feat: Ford legacy support, EMEX browser pooling, collapsible sidebar
- Add PL24 Ford legacy service for fordt_parts architecture - Refactor EMEX to use persistent browser pool instead of per-call instances - Make vehicle decode resilient: fallback to PL24 when Corgi doesn't recognize VIN - Add collapsible sidebar with persistent user preference - Improve brand access guard and categories service - Add debug/test scripts for VIN e2e testing Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
This commit is contained in:
Sase Dev
921
scripts/vin-e2e-test.js
Normal file
921
scripts/vin-e2e-test.js
Normal file
@@ -0,0 +1,921 @@
|
||||
#!/usr/bin/env node
|
||||
/**
|
||||
* VIN End-to-End Test Script
|
||||
*
|
||||
* Tests each VIN through the sase.tr dashboard:
|
||||
* 1. Login as admin
|
||||
* 2. Search VIN on /dashboard/search
|
||||
* 3. Check if VIN resolves (PL24 / EMEX / failed)
|
||||
* 4. Click first categories, verify schema + OEM parts load
|
||||
* 5. Verify DB records (vehicles, categories, parts, schema_pics)
|
||||
* 6. Verify MinIO image storage
|
||||
* 7. Generate a full report
|
||||
*
|
||||
* Usage: node scripts/vin-e2e-test.js [--headless] [--vin VIN1,VIN2,...] [--delay 5000]
|
||||
*/
|
||||
|
||||
const { chromium } = require("playwright");
|
||||
const fs = require("fs");
|
||||
const path = require("path");
|
||||
const { execSync } = require("child_process");
|
||||
|
||||
// ── Config ──────────────────────────────────────────────
|
||||
const CONFIG = {
|
||||
webUrl: "http://localhost:3000",
|
||||
apiUrl: "http://localhost:4000/api",
|
||||
email: "admin@sase.tr",
|
||||
password: "Sase2026",
|
||||
dbUrl:
|
||||
"postgresql://sase:vlii9wcMK0dcXD0A8zYdHx4wQp3XUQ7@127.0.0.1:5432/sase",
|
||||
minioPublicUrl: "https://storage.sase.tr/sase-schemas",
|
||||
headless: true,
|
||||
delayBetweenVins: 8000, // ms between VIN searches (rate limit protection)
|
||||
navigationTimeout: 120000, // 2 min
|
||||
actionTimeout: 60000, // 1 min
|
||||
categoryClickDelay: 5000, // ms after clicking a category
|
||||
maxCategoriesToTest: 3, // how many categories to click per VIN
|
||||
};
|
||||
|
||||
// ── Known-brand VINs (primary test set) ─────────────────
|
||||
const KNOWN_BRAND_VINS = [
|
||||
{ brand: "Renault", vin: "VF1C066MC19290416" },
|
||||
{ brand: "Porsche", vin: "WP1ZZZ92ZCLA29834" },
|
||||
{ brand: "Subaru", vin: "JF1GD9LF37G069905" },
|
||||
{ brand: "Mercedes", vin: "WDB2020181A148652" },
|
||||
{ brand: "Honda", vin: "NLAFC5650HW030691" },
|
||||
{ brand: "Mazda", vin: "JMZDKFWSA10182289" },
|
||||
{ brand: "Ford", vin: "NM0GXXTTPGAG07617" },
|
||||
{ brand: "Volvo", vin: "YV1AS985691096540" },
|
||||
{ brand: "Kia", vin: "TMAJ3812HGJ226161" },
|
||||
{ brand: "BMW", vin: "WBALZ72090DY98841" },
|
||||
{ brand: "Mitsubishi", vin: "JMBSNCS3A4U004435" },
|
||||
{ brand: "Suzuki", vin: "TSMLYD21S00268458" },
|
||||
{ brand: "Scania", vin: "XLER4X20005217616" },
|
||||
{ brand: "Nissan", vin: "SJNFCAJ10U1242901" },
|
||||
{ brand: "MAN", vin: "WMAH12ZZ04M393187" },
|
||||
{ brand: "Land Rover", vin: "SALLNABA8YA563459" },
|
||||
];
|
||||
|
||||
// ── Parse CLI args ──────────────────────────────────────
|
||||
function parseArgs() {
|
||||
const args = process.argv.slice(2);
|
||||
const opts = { ...CONFIG };
|
||||
|
||||
for (let i = 0; i < args.length; i++) {
|
||||
if (args[i] === "--headless") opts.headless = true;
|
||||
if (args[i] === "--headed") opts.headless = false;
|
||||
if (args[i] === "--vin" && args[i + 1]) {
|
||||
opts.filterVins = args[++i].split(",").map((v) => v.trim().toUpperCase());
|
||||
}
|
||||
if (args[i] === "--delay" && args[i + 1]) {
|
||||
opts.delayBetweenVins = parseInt(args[++i], 10);
|
||||
}
|
||||
if (args[i] === "--max-categories" && args[i + 1]) {
|
||||
opts.maxCategoriesToTest = parseInt(args[++i], 10);
|
||||
}
|
||||
}
|
||||
|
||||
return opts;
|
||||
}
|
||||
|
||||
// ── Helpers ─────────────────────────────────────────────
|
||||
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
|
||||
|
||||
function timestamp() {
|
||||
return new Date().toISOString().replace("T", " ").substring(0, 19);
|
||||
}
|
||||
|
||||
function log(msg) {
|
||||
console.log(`[${timestamp()}] ${msg}`);
|
||||
}
|
||||
|
||||
function logSection(title) {
|
||||
console.log(`\n${"═".repeat(70)}`);
|
||||
console.log(` ${title}`);
|
||||
console.log(`${"═".repeat(70)}`);
|
||||
}
|
||||
|
||||
// ── Database helper (uses psql CLI) ─────────────────────
|
||||
class DbChecker {
|
||||
constructor(connectionString) {
|
||||
this.connStr = connectionString;
|
||||
this.available = false;
|
||||
}
|
||||
|
||||
async connect() {
|
||||
try {
|
||||
this._query("SELECT 1");
|
||||
this.available = true;
|
||||
log("DB connected via psql");
|
||||
} catch (err) {
|
||||
log(`DB connection failed: ${err.message}`);
|
||||
this.available = false;
|
||||
}
|
||||
}
|
||||
|
||||
async close() {
|
||||
// psql is stateless, nothing to close
|
||||
}
|
||||
|
||||
_query(sql) {
|
||||
const escaped = sql.replace(/"/g, '\\"');
|
||||
const result = execSync(
|
||||
`psql "${this.connStr}" -t -A -F '|' -c "${escaped}"`,
|
||||
{ encoding: "utf-8", timeout: 15000 },
|
||||
).trim();
|
||||
if (!result) return [];
|
||||
return result.split("\n").filter(Boolean).map((row) => row.split("|"));
|
||||
}
|
||||
|
||||
_esc(val) {
|
||||
return String(val).replace(/'/g, "''");
|
||||
}
|
||||
|
||||
async getVehicle(vin) {
|
||||
const rows = this._query(
|
||||
`SELECT id, vin, brand_name, model, year, engine, source, raw_data IS NOT NULL AS has_raw_data FROM vehicles WHERE vin = '${this._esc(vin.toUpperCase())}' ORDER BY updated_at DESC LIMIT 1`,
|
||||
);
|
||||
if (rows.length === 0 || !rows[0][0]) return null;
|
||||
const r = rows[0];
|
||||
return {
|
||||
id: r[0], vin: r[1], brand_name: r[2], model: r[3],
|
||||
year: r[4], engine: r[5], source: r[6], has_raw_data: r[7] === "t",
|
||||
};
|
||||
}
|
||||
|
||||
async getCategoryCount(vehicleId) {
|
||||
const rows = this._query(
|
||||
`SELECT count(*) FROM categories WHERE vehicle_id = '${this._esc(vehicleId)}'`,
|
||||
);
|
||||
return parseInt(rows[0]?.[0] || "0", 10);
|
||||
}
|
||||
|
||||
async getTopCategories(vehicleId, limit = 5) {
|
||||
const rows = this._query(
|
||||
`SELECT id, name, name_original, source, link_path IS NOT NULL FROM categories WHERE vehicle_id = '${this._esc(vehicleId)}' AND parent_id IS NULL ORDER BY created_at LIMIT ${limit}`,
|
||||
);
|
||||
return rows.filter((r) => r[0]).map((r) => ({
|
||||
id: r[0], name: r[1], name_original: r[2], source: r[3], has_link: r[4] === "t",
|
||||
}));
|
||||
}
|
||||
|
||||
async getPartsCount(vehicleId) {
|
||||
const rows = this._query(
|
||||
`SELECT count(*) FROM parts WHERE vehicle_id = '${this._esc(vehicleId)}'`,
|
||||
);
|
||||
return parseInt(rows[0]?.[0] || "0", 10);
|
||||
}
|
||||
|
||||
async getPartsForCategory(categoryId) {
|
||||
const rows = this._query(
|
||||
`SELECT id, oem_code, name, position, hotspot_index FROM parts WHERE category_id = '${this._esc(categoryId)}' ORDER BY position LIMIT 20`,
|
||||
);
|
||||
return rows.filter((r) => r[0]).map((r) => ({
|
||||
id: r[0], oem_code: r[1], name: r[2], position: r[3], hotspot_index: r[4],
|
||||
}));
|
||||
}
|
||||
|
||||
async getSchemaPics(categoryId) {
|
||||
const rows = this._query(
|
||||
`SELECT id, image_url, source, hotspots IS NOT NULL FROM schema_pics WHERE category_id = '${this._esc(categoryId)}'`,
|
||||
);
|
||||
return rows.filter((r) => r[0]).map((r) => ({
|
||||
id: r[0], image_url: r[1], source: r[2], has_hotspots: r[3] === "t",
|
||||
}));
|
||||
}
|
||||
|
||||
async getLeafCategories(vehicleId, limit = 5) {
|
||||
const rows = this._query(
|
||||
`SELECT c.id, c.name, c.source, c.link_path FROM categories c WHERE c.vehicle_id = '${this._esc(vehicleId)}' AND NOT EXISTS (SELECT 1 FROM categories c2 WHERE c2.parent_id = c.id) AND c.link_path IS NOT NULL ORDER BY c.created_at LIMIT ${limit}`,
|
||||
);
|
||||
return rows.filter((r) => r[0]).map((r) => ({
|
||||
id: r[0], name: r[1], source: r[2], link_path: r[3],
|
||||
}));
|
||||
}
|
||||
}
|
||||
|
||||
// ── MinIO check ─────────────────────────────────────────
|
||||
async function checkMinioImage(imageUrl) {
|
||||
if (!imageUrl) return { exists: false, reason: "no URL" };
|
||||
try {
|
||||
const resp = await fetch(imageUrl, { method: "HEAD", signal: AbortSignal.timeout(10000) });
|
||||
return {
|
||||
exists: resp.ok,
|
||||
status: resp.status,
|
||||
contentType: resp.headers.get("content-type"),
|
||||
size: resp.headers.get("content-length"),
|
||||
};
|
||||
} catch (err) {
|
||||
return { exists: false, reason: err.message };
|
||||
}
|
||||
}
|
||||
|
||||
// ── Main test runner ────────────────────────────────────
|
||||
async function main() {
|
||||
const opts = parseArgs();
|
||||
const report = {
|
||||
startedAt: new Date().toISOString(),
|
||||
config: {
|
||||
headless: opts.headless,
|
||||
delayBetweenVins: opts.delayBetweenVins,
|
||||
maxCategoriesToTest: opts.maxCategoriesToTest,
|
||||
},
|
||||
results: [],
|
||||
summary: { total: 0, resolved: 0, failed: 0, errors: 0 },
|
||||
};
|
||||
|
||||
// Decide which VINs to test
|
||||
let vinList = KNOWN_BRAND_VINS;
|
||||
if (opts.filterVins) {
|
||||
vinList = opts.filterVins.map((vin) => {
|
||||
const known = KNOWN_BRAND_VINS.find((v) => v.vin === vin);
|
||||
return known || { brand: "Unknown", vin };
|
||||
});
|
||||
}
|
||||
|
||||
logSection("VIN E2E TEST - STARTING");
|
||||
log(`Testing ${vinList.length} VINs`);
|
||||
log(`Headless: ${opts.headless}, Delay: ${opts.delayBetweenVins}ms`);
|
||||
|
||||
// ── Launch browser ────────────────────────────────────
|
||||
const browser = await chromium.launch({
|
||||
headless: opts.headless,
|
||||
args: ["--no-sandbox", "--disable-setuid-sandbox"],
|
||||
});
|
||||
|
||||
const context = await browser.newContext({
|
||||
viewport: { width: 1440, height: 900 },
|
||||
ignoreHTTPSErrors: true,
|
||||
});
|
||||
|
||||
context.setDefaultTimeout(opts.actionTimeout);
|
||||
context.setDefaultNavigationTimeout(opts.navigationTimeout);
|
||||
|
||||
const page = await context.newPage();
|
||||
|
||||
// ── Connect to DB ─────────────────────────────────────
|
||||
const db = new DbChecker(opts.dbUrl);
|
||||
try {
|
||||
await db.connect();
|
||||
} catch (err) {
|
||||
log(`WARNING: Could not connect to DB: ${err.message}`);
|
||||
log("DB checks will be skipped.");
|
||||
}
|
||||
|
||||
// ── Login ─────────────────────────────────────────────
|
||||
logSection("LOGIN");
|
||||
try {
|
||||
log("Navigating to login page...");
|
||||
await page.goto(`${opts.webUrl}/login`, {
|
||||
waitUntil: "networkidle",
|
||||
timeout: opts.navigationTimeout,
|
||||
});
|
||||
|
||||
// Fill login form
|
||||
await page.fill('#email', opts.email);
|
||||
await page.fill('#password', opts.password);
|
||||
await sleep(500);
|
||||
|
||||
// Submit
|
||||
await page.click('button[type="submit"]');
|
||||
log("Login form submitted, waiting for redirect...");
|
||||
|
||||
// Wait for dashboard
|
||||
await page.waitForURL("**/dashboard**", {
|
||||
timeout: opts.navigationTimeout,
|
||||
});
|
||||
log("Login successful - on dashboard");
|
||||
} catch (err) {
|
||||
log(`LOGIN FAILED: ${err.message}`);
|
||||
// Try API login fallback
|
||||
log("Trying API login fallback...");
|
||||
try {
|
||||
const loginResp = await page.request.post(
|
||||
`${opts.apiUrl}/auth/sign-in/email`,
|
||||
{
|
||||
data: { email: opts.email, password: opts.password },
|
||||
},
|
||||
);
|
||||
if (loginResp.ok()) {
|
||||
log("API login successful, navigating to dashboard...");
|
||||
await page.goto(`${opts.webUrl}/dashboard`, {
|
||||
waitUntil: "networkidle",
|
||||
});
|
||||
} else {
|
||||
throw new Error(`API login failed: ${loginResp.status()}`);
|
||||
}
|
||||
} catch (err2) {
|
||||
log(`FATAL: Could not login: ${err2.message}`);
|
||||
await browser.close();
|
||||
process.exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
// ── Test each VIN ─────────────────────────────────────
|
||||
for (let i = 0; i < vinList.length; i++) {
|
||||
const { brand, vin } = vinList[i];
|
||||
const vinUpper = vin.toUpperCase();
|
||||
const result = {
|
||||
index: i + 1,
|
||||
brand,
|
||||
vin: vinUpper,
|
||||
resolved: false,
|
||||
platform: null,
|
||||
vehicleInfo: null,
|
||||
categoriesLoaded: false,
|
||||
categoryCount: 0,
|
||||
categoryTests: [],
|
||||
dbChecks: {},
|
||||
errors: [],
|
||||
timing: {},
|
||||
};
|
||||
|
||||
logSection(`[${i + 1}/${vinList.length}] ${brand}: ${vinUpper}`);
|
||||
|
||||
try {
|
||||
// ── Navigate to search page ───────────────────────
|
||||
log("Navigating to search page...");
|
||||
await page.goto(`${opts.webUrl}/dashboard/search`, {
|
||||
waitUntil: "networkidle",
|
||||
timeout: opts.navigationTimeout,
|
||||
});
|
||||
await sleep(1000);
|
||||
|
||||
// ── Enter VIN ─────────────────────────────────────
|
||||
log("Entering VIN...");
|
||||
const vinInput = page.locator(
|
||||
'input[placeholder*="VIN"], input.font-mono',
|
||||
);
|
||||
await vinInput.fill("");
|
||||
await sleep(300);
|
||||
await vinInput.fill(vinUpper);
|
||||
await sleep(500);
|
||||
|
||||
// ── Click search button ───────────────────────────
|
||||
const searchBtn = page.locator('button[type="submit"]');
|
||||
const startTime = Date.now();
|
||||
|
||||
// Intercept API responses
|
||||
const decodeResponsePromise = page.waitForResponse(
|
||||
(resp) =>
|
||||
resp.url().includes("/vehicles/decode") && resp.request().method() === "POST",
|
||||
{ timeout: opts.navigationTimeout },
|
||||
);
|
||||
|
||||
await searchBtn.click();
|
||||
log("Search submitted, waiting for decode response...");
|
||||
|
||||
// Wait for decode response
|
||||
let decodeResp;
|
||||
try {
|
||||
decodeResp = await decodeResponsePromise;
|
||||
result.timing.decodeMs = Date.now() - startTime;
|
||||
log(`Decode response: ${decodeResp.status()} (${result.timing.decodeMs}ms)`);
|
||||
|
||||
if (decodeResp.ok()) {
|
||||
const rawBody = await decodeResp.json();
|
||||
// API wraps in { data: {...} } envelope
|
||||
const body = rawBody?.data || rawBody;
|
||||
result.resolved = true;
|
||||
result.vehicleInfo = {
|
||||
id: body.id,
|
||||
brandName: body.brandName,
|
||||
model: body.model,
|
||||
year: body.year,
|
||||
source: body.source,
|
||||
};
|
||||
result.platform = body.source;
|
||||
log(
|
||||
`RESOLVED via ${body.source || "?"}: ${body.brandName || "?"} ${body.model || ""} ${body.year || ""} (id: ${body.id})`,
|
||||
);
|
||||
} else {
|
||||
const errBody = await decodeResp.text();
|
||||
result.errors.push(`Decode HTTP ${decodeResp.status()}: ${errBody.substring(0, 200)}`);
|
||||
log(`FAILED: HTTP ${decodeResp.status()}`);
|
||||
}
|
||||
} catch (err) {
|
||||
result.errors.push(`Decode timeout/error: ${err.message}`);
|
||||
log(`DECODE ERROR: ${err.message}`);
|
||||
}
|
||||
|
||||
// ── If resolved, check vehicle page ───────────────
|
||||
if (result.resolved && result.vehicleInfo?.id) {
|
||||
const vehicleId = result.vehicleInfo.id;
|
||||
|
||||
// Wait for navigation to vehicle page
|
||||
try {
|
||||
await page.waitForURL(`**/vehicles/${vehicleId}**`, {
|
||||
timeout: 15000,
|
||||
});
|
||||
log("On vehicle detail page");
|
||||
} catch {
|
||||
// Might already be there or URL slightly different
|
||||
log("Navigating to vehicle page manually...");
|
||||
await page.goto(
|
||||
`${opts.webUrl}/dashboard/vehicles/${vehicleId}`,
|
||||
{ waitUntil: "networkidle", timeout: opts.navigationTimeout },
|
||||
);
|
||||
}
|
||||
|
||||
// ── Wait for category tree to load ──────────────
|
||||
log("Waiting for categories to load...");
|
||||
const catTreeStart = Date.now();
|
||||
|
||||
try {
|
||||
// Wait for category tree API response
|
||||
const catResp = await page.waitForResponse(
|
||||
(resp) =>
|
||||
resp.url().includes(`/categories/tree/${vehicleId}`) &&
|
||||
resp.request().method() === "GET",
|
||||
{ timeout: opts.navigationTimeout },
|
||||
);
|
||||
|
||||
result.timing.categoryTreeMs = Date.now() - catTreeStart;
|
||||
|
||||
if (catResp.ok()) {
|
||||
const catRaw = await catResp.json();
|
||||
const catTree = catRaw?.data || catRaw;
|
||||
result.categoriesLoaded = true;
|
||||
result.categoryCount = Array.isArray(catTree)
|
||||
? catTree.length
|
||||
: 0;
|
||||
log(
|
||||
`Categories loaded: ${result.categoryCount} top-level (${result.timing.categoryTreeMs}ms)`,
|
||||
);
|
||||
} else {
|
||||
result.errors.push(
|
||||
`Category tree HTTP ${catResp.status()}`,
|
||||
);
|
||||
log(`Category tree failed: ${catResp.status()}`);
|
||||
}
|
||||
} catch (err) {
|
||||
// Maybe already loaded from cache
|
||||
log(`Category tree wait: ${err.message} - checking page content...`);
|
||||
await sleep(3000);
|
||||
}
|
||||
|
||||
// ── Check categories are visible on page ────────
|
||||
await sleep(2000);
|
||||
|
||||
// Look for category elements (cards or tree nodes)
|
||||
const categoryElements = await page
|
||||
.locator('[class*="cursor-pointer"], a[href*="/categories/"]')
|
||||
.count();
|
||||
if (categoryElements > 0) {
|
||||
result.categoriesLoaded = true;
|
||||
log(`Found ${categoryElements} clickable category elements on page`);
|
||||
}
|
||||
|
||||
// ── Click first categories and test parts/schema ─
|
||||
if (result.categoriesLoaded && result.categoryCount > 0) {
|
||||
const categoriesToTest = Math.min(
|
||||
opts.maxCategoriesToTest,
|
||||
result.categoryCount,
|
||||
);
|
||||
|
||||
for (let ci = 0; ci < categoriesToTest; ci++) {
|
||||
const catTest = {
|
||||
index: ci,
|
||||
name: null,
|
||||
clicked: false,
|
||||
partsLoaded: false,
|
||||
partsCount: 0,
|
||||
schemaLoaded: false,
|
||||
schemaImageUrl: null,
|
||||
minioCheck: null,
|
||||
dbParts: [],
|
||||
dbSchema: [],
|
||||
errors: [],
|
||||
};
|
||||
|
||||
try {
|
||||
// Navigate back to vehicle page for each category test
|
||||
if (ci > 0) {
|
||||
await page.goto(
|
||||
`${opts.webUrl}/dashboard/vehicles/${vehicleId}`,
|
||||
{
|
||||
waitUntil: "networkidle",
|
||||
timeout: opts.navigationTimeout,
|
||||
},
|
||||
);
|
||||
await sleep(2000);
|
||||
}
|
||||
|
||||
// Click the category card (first available link to categories)
|
||||
const catLinks = page.locator(
|
||||
'a[href*="/categories/"]',
|
||||
);
|
||||
const catLinkCount = await catLinks.count();
|
||||
|
||||
if (catLinkCount > ci) {
|
||||
const catLink = catLinks.nth(ci);
|
||||
catTest.name =
|
||||
(await catLink.textContent())?.trim() || `Category ${ci}`;
|
||||
log(
|
||||
` Clicking category ${ci + 1}: "${catTest.name}"...`,
|
||||
);
|
||||
|
||||
// Listen for parts API response
|
||||
const partsResponsePromise = page.waitForResponse(
|
||||
(resp) =>
|
||||
resp.url().includes("/categories/") &&
|
||||
resp.url().includes("/vehicles/") &&
|
||||
resp.request().method() === "GET",
|
||||
{ timeout: opts.navigationTimeout },
|
||||
);
|
||||
|
||||
await catLink.click();
|
||||
catTest.clicked = true;
|
||||
|
||||
// Wait for parts response
|
||||
try {
|
||||
const partsResp = await partsResponsePromise;
|
||||
|
||||
if (partsResp.ok()) {
|
||||
const partsRaw = await partsResp.json();
|
||||
const partsData = partsRaw?.data || partsRaw;
|
||||
catTest.partsLoaded = true;
|
||||
catTest.partsCount =
|
||||
partsData?.parts?.length || 0;
|
||||
|
||||
if (
|
||||
partsData?.schemaPics &&
|
||||
partsData.schemaPics.length > 0
|
||||
) {
|
||||
catTest.schemaLoaded = true;
|
||||
catTest.schemaImageUrl =
|
||||
partsData.schemaPics[0]?.imageUrl || null;
|
||||
}
|
||||
|
||||
log(
|
||||
` Parts: ${catTest.partsCount}, Schema: ${catTest.schemaLoaded ? "YES" : "NO"}`,
|
||||
);
|
||||
|
||||
// ── Check MinIO image ───────────────
|
||||
if (catTest.schemaImageUrl) {
|
||||
catTest.minioCheck = await checkMinioImage(
|
||||
catTest.schemaImageUrl,
|
||||
);
|
||||
log(
|
||||
` MinIO image: ${catTest.minioCheck.exists ? "OK" : "MISSING"} (${catTest.schemaImageUrl})`,
|
||||
);
|
||||
}
|
||||
} else {
|
||||
catTest.errors.push(
|
||||
`Parts HTTP ${partsResp.status()}`,
|
||||
);
|
||||
}
|
||||
} catch (err) {
|
||||
catTest.errors.push(
|
||||
`Parts timeout: ${err.message}`,
|
||||
);
|
||||
log(` Parts error: ${err.message}`);
|
||||
}
|
||||
} else {
|
||||
// No direct category links - try clicking grid cards
|
||||
const gridCards = page.locator(
|
||||
".grid button, .grid [role='button']",
|
||||
);
|
||||
const cardCount = await gridCards.count();
|
||||
|
||||
if (cardCount > ci) {
|
||||
const card = gridCards.nth(ci);
|
||||
catTest.name =
|
||||
(await card.textContent())?.trim()?.substring(0, 50) ||
|
||||
`Card ${ci}`;
|
||||
log(` Clicking grid card ${ci + 1}: "${catTest.name}"...`);
|
||||
await card.click();
|
||||
catTest.clicked = true;
|
||||
await sleep(opts.categoryClickDelay);
|
||||
|
||||
// After clicking a parent, look for leaf links
|
||||
const leafLinks = page.locator(
|
||||
'a[href*="/categories/"]',
|
||||
);
|
||||
const leafCount = await leafLinks.count();
|
||||
if (leafCount > 0) {
|
||||
log(
|
||||
` Drilled down - found ${leafCount} sub-categories`,
|
||||
);
|
||||
const firstLeaf = leafLinks.first();
|
||||
catTest.name +=
|
||||
" > " +
|
||||
((await firstLeaf.textContent())?.trim() || "sub");
|
||||
|
||||
const subPartsPromise = page.waitForResponse(
|
||||
(resp) =>
|
||||
resp.url().includes("/categories/") &&
|
||||
resp.url().includes("/vehicles/") &&
|
||||
resp.request().method() === "GET",
|
||||
{ timeout: opts.navigationTimeout },
|
||||
);
|
||||
|
||||
await firstLeaf.click();
|
||||
try {
|
||||
const subResp = await subPartsPromise;
|
||||
if (subResp.ok()) {
|
||||
const subRaw = await subResp.json();
|
||||
const subData = subRaw?.data || subRaw;
|
||||
catTest.partsLoaded = true;
|
||||
catTest.partsCount =
|
||||
subData?.parts?.length || 0;
|
||||
if (
|
||||
subData?.schemaPics?.length > 0
|
||||
) {
|
||||
catTest.schemaLoaded = true;
|
||||
catTest.schemaImageUrl =
|
||||
subData.schemaPics[0]?.imageUrl;
|
||||
}
|
||||
log(
|
||||
` Sub-category parts: ${catTest.partsCount}, Schema: ${catTest.schemaLoaded}`,
|
||||
);
|
||||
}
|
||||
} catch (err) {
|
||||
catTest.errors.push(
|
||||
`Sub parts timeout: ${err.message}`,
|
||||
);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
catTest.errors.push("No clickable categories found");
|
||||
log(" No clickable categories found on page");
|
||||
}
|
||||
}
|
||||
} catch (err) {
|
||||
catTest.errors.push(`Category test error: ${err.message}`);
|
||||
log(` Category test error: ${err.message}`);
|
||||
}
|
||||
|
||||
result.categoryTests.push(catTest);
|
||||
await sleep(opts.categoryClickDelay);
|
||||
}
|
||||
}
|
||||
|
||||
// ── DB verification ─────────────────────────────
|
||||
if (db.available) {
|
||||
log("Running DB checks...");
|
||||
try {
|
||||
const dbVehicle = await db.getVehicle(vinUpper);
|
||||
if (dbVehicle) {
|
||||
result.dbChecks.vehicle = {
|
||||
found: true,
|
||||
id: dbVehicle.id,
|
||||
brandName: dbVehicle.brand_name,
|
||||
model: dbVehicle.model,
|
||||
year: dbVehicle.year,
|
||||
source: dbVehicle.source,
|
||||
hasRawData: dbVehicle.has_raw_data,
|
||||
};
|
||||
|
||||
const catCount = await db.getCategoryCount(dbVehicle.id);
|
||||
result.dbChecks.categories = {
|
||||
count: catCount,
|
||||
};
|
||||
|
||||
const topCats = await db.getTopCategories(dbVehicle.id);
|
||||
result.dbChecks.topCategories = topCats.map((c) => ({
|
||||
id: c.id,
|
||||
name: c.name,
|
||||
source: c.source,
|
||||
hasLink: c.has_link,
|
||||
}));
|
||||
|
||||
const partsCount = await db.getPartsCount(dbVehicle.id);
|
||||
result.dbChecks.partsCount = partsCount;
|
||||
|
||||
// Check leaf categories for schema pics
|
||||
const leaves = await db.getLeafCategories(
|
||||
dbVehicle.id,
|
||||
3,
|
||||
);
|
||||
result.dbChecks.leafCategorySchemas = [];
|
||||
for (const leaf of leaves) {
|
||||
const schemas = await db.getSchemaPics(leaf.id);
|
||||
const parts = await db.getPartsForCategory(leaf.id);
|
||||
result.dbChecks.leafCategorySchemas.push({
|
||||
categoryId: leaf.id,
|
||||
name: leaf.name,
|
||||
source: leaf.source,
|
||||
schemaCount: schemas.length,
|
||||
partsCount: parts.length,
|
||||
schemaUrls: schemas.map((s) => s.image_url),
|
||||
hasHotspots: schemas.some((s) => s.has_hotspots),
|
||||
});
|
||||
}
|
||||
|
||||
log(
|
||||
` DB: vehicle=${result.dbChecks.vehicle.found}, categories=${catCount}, parts=${partsCount}`,
|
||||
);
|
||||
} else {
|
||||
result.dbChecks.vehicle = { found: false };
|
||||
log(" DB: vehicle NOT FOUND");
|
||||
}
|
||||
} catch (err) {
|
||||
result.dbChecks.error = err.message;
|
||||
log(` DB check error: ${err.message}`);
|
||||
}
|
||||
}
|
||||
}
|
||||
} catch (err) {
|
||||
result.errors.push(`VIN test error: ${err.message}`);
|
||||
log(`ERROR: ${err.message}`);
|
||||
}
|
||||
|
||||
// Update summary
|
||||
report.results.push(result);
|
||||
report.summary.total++;
|
||||
if (result.resolved) report.summary.resolved++;
|
||||
else if (result.errors.length > 0) report.summary.errors++;
|
||||
else report.summary.failed++;
|
||||
|
||||
// ── Delay before next VIN ───────────────────────────
|
||||
if (i < vinList.length - 1) {
|
||||
log(`Waiting ${opts.delayBetweenVins}ms before next VIN...`);
|
||||
await sleep(opts.delayBetweenVins);
|
||||
}
|
||||
}
|
||||
|
||||
// ── Generate report ───────────────────────────────────
|
||||
report.finishedAt = new Date().toISOString();
|
||||
|
||||
logSection("REPORT SUMMARY");
|
||||
console.log(`Total: ${report.summary.total}`);
|
||||
console.log(`Resolved: ${report.summary.resolved}`);
|
||||
console.log(`Failed: ${report.summary.failed}`);
|
||||
console.log(`Errors: ${report.summary.errors}`);
|
||||
|
||||
console.log("\nPer-VIN Results:");
|
||||
console.log(
|
||||
"─".repeat(90),
|
||||
);
|
||||
console.log(
|
||||
`${"Brand".padEnd(15)} ${"VIN".padEnd(20)} ${"Status".padEnd(10)} ${"Platform".padEnd(8)} ${"Cats".padEnd(6)} ${"Parts".padEnd(6)} ${"Schema".padEnd(8)} DB`,
|
||||
);
|
||||
console.log(
|
||||
"─".repeat(90),
|
||||
);
|
||||
|
||||
for (const r of report.results) {
|
||||
const status = r.resolved ? "OK" : "FAIL";
|
||||
const platform = r.platform || "-";
|
||||
const cats = r.categoryCount || 0;
|
||||
const partsTotal = r.categoryTests.reduce(
|
||||
(s, t) => s + t.partsCount,
|
||||
0,
|
||||
);
|
||||
const schemaOk = r.categoryTests.some((t) => t.schemaLoaded)
|
||||
? "YES"
|
||||
: "NO";
|
||||
const dbOk = r.dbChecks?.vehicle?.found ? "OK" : "NO";
|
||||
|
||||
console.log(
|
||||
`${r.brand.padEnd(15)} ${r.vin.padEnd(20)} ${status.padEnd(10)} ${platform.padEnd(8)} ${String(cats).padEnd(6)} ${String(partsTotal).padEnd(6)} ${schemaOk.padEnd(8)} ${dbOk}`,
|
||||
);
|
||||
|
||||
if (r.errors.length > 0) {
|
||||
for (const err of r.errors) {
|
||||
console.log(` └─ ERROR: ${err}`);
|
||||
}
|
||||
}
|
||||
|
||||
for (const ct of r.categoryTests) {
|
||||
if (ct.errors.length > 0) {
|
||||
for (const err of ct.errors) {
|
||||
console.log(` └─ CAT "${ct.name}": ${err}`);
|
||||
}
|
||||
}
|
||||
if (ct.minioCheck && !ct.minioCheck.exists) {
|
||||
console.log(
|
||||
` └─ MINIO MISSING: ${ct.schemaImageUrl} (${ct.minioCheck.reason || ct.minioCheck.status})`,
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ── Platform breakdown ────────────────────────────────
|
||||
console.log(`\n${"─".repeat(50)}`);
|
||||
console.log("Platform Breakdown:");
|
||||
const platformCounts = {};
|
||||
for (const r of report.results) {
|
||||
const p = r.platform || "unresolved";
|
||||
platformCounts[p] = (platformCounts[p] || 0) + 1;
|
||||
}
|
||||
for (const [p, count] of Object.entries(platformCounts)) {
|
||||
console.log(` ${p}: ${count}`);
|
||||
}
|
||||
|
||||
// ── DB Summary ────────────────────────────────────────
|
||||
console.log(`\n${"─".repeat(50)}`);
|
||||
console.log("DB Storage Summary:");
|
||||
let totalDbCats = 0;
|
||||
let totalDbParts = 0;
|
||||
let totalDbSchemas = 0;
|
||||
for (const r of report.results) {
|
||||
if (r.dbChecks?.categories) totalDbCats += r.dbChecks.categories.count;
|
||||
if (r.dbChecks?.partsCount) totalDbParts += r.dbChecks.partsCount;
|
||||
if (r.dbChecks?.leafCategorySchemas) {
|
||||
totalDbSchemas += r.dbChecks.leafCategorySchemas.reduce(
|
||||
(s, l) => s + l.schemaCount,
|
||||
0,
|
||||
);
|
||||
}
|
||||
}
|
||||
console.log(` Total categories in DB: ${totalDbCats}`);
|
||||
console.log(` Total parts in DB: ${totalDbParts}`);
|
||||
console.log(` Total schema pics in DB: ${totalDbSchemas}`);
|
||||
|
||||
// ── MinIO Summary ─────────────────────────────────────
|
||||
console.log(`\n${"─".repeat(50)}`);
|
||||
console.log("MinIO Storage Summary:");
|
||||
let minioOk = 0;
|
||||
let minioFail = 0;
|
||||
for (const r of report.results) {
|
||||
for (const ct of r.categoryTests) {
|
||||
if (ct.minioCheck) {
|
||||
if (ct.minioCheck.exists) minioOk++;
|
||||
else minioFail++;
|
||||
}
|
||||
}
|
||||
}
|
||||
console.log(` Images accessible: ${minioOk}`);
|
||||
console.log(` Images missing: ${minioFail}`);
|
||||
|
||||
// ── Save report ───────────────────────────────────────
|
||||
const reportPath = path.join(
|
||||
__dirname,
|
||||
`vin-e2e-report-${Date.now()}.json`,
|
||||
);
|
||||
fs.writeFileSync(reportPath, JSON.stringify(report, null, 2));
|
||||
log(`\nFull report saved to: ${reportPath}`);
|
||||
|
||||
// Also save a human-readable markdown report
|
||||
const mdPath = path.join(
|
||||
__dirname,
|
||||
`vin-e2e-report-${Date.now()}.md`,
|
||||
);
|
||||
let md = `# VIN E2E Test Report\n\n`;
|
||||
md += `**Date:** ${report.startedAt}\n`;
|
||||
md += `**Total:** ${report.summary.total} | **Resolved:** ${report.summary.resolved} | **Failed:** ${report.summary.failed} | **Errors:** ${report.summary.errors}\n\n`;
|
||||
md += `## Results\n\n`;
|
||||
md += `| # | Brand | VIN | Status | Platform | Categories | Parts | Schema | DB | MinIO |\n`;
|
||||
md += `|---|-------|-----|--------|----------|------------|-------|--------|----|-------|\n`;
|
||||
|
||||
for (const r of report.results) {
|
||||
const status = r.resolved ? "OK" : "FAIL";
|
||||
const platform = r.platform || "-";
|
||||
const cats = r.categoryCount || 0;
|
||||
const partsTotal = r.categoryTests.reduce(
|
||||
(s, t) => s + t.partsCount,
|
||||
0,
|
||||
);
|
||||
const schemaOk = r.categoryTests.some((t) => t.schemaLoaded)
|
||||
? "YES"
|
||||
: "NO";
|
||||
const dbOk = r.dbChecks?.vehicle?.found ? "OK" : "-";
|
||||
const minioStatus = r.categoryTests.some(
|
||||
(t) => t.minioCheck?.exists,
|
||||
)
|
||||
? "OK"
|
||||
: r.categoryTests.some((t) => t.minioCheck)
|
||||
? "FAIL"
|
||||
: "-";
|
||||
|
||||
md += `| ${r.index} | ${r.brand} | \`${r.vin}\` | ${status} | ${platform} | ${cats} | ${partsTotal} | ${schemaOk} | ${dbOk} | ${minioStatus} |\n`;
|
||||
}
|
||||
|
||||
md += `\n## Errors\n\n`;
|
||||
for (const r of report.results) {
|
||||
if (r.errors.length > 0) {
|
||||
md += `### ${r.brand} (\`${r.vin}\`)\n`;
|
||||
for (const err of r.errors) {
|
||||
md += `- ${err}\n`;
|
||||
}
|
||||
md += `\n`;
|
||||
}
|
||||
}
|
||||
|
||||
md += `## Platform Breakdown\n\n`;
|
||||
for (const [p, count] of Object.entries(platformCounts)) {
|
||||
md += `- **${p}**: ${count}\n`;
|
||||
}
|
||||
|
||||
md += `\n## DB Storage\n\n`;
|
||||
md += `- Categories: ${totalDbCats}\n`;
|
||||
md += `- Parts: ${totalDbParts}\n`;
|
||||
md += `- Schema images: ${totalDbSchemas}\n`;
|
||||
|
||||
fs.writeFileSync(mdPath, md);
|
||||
log(`Markdown report saved to: ${mdPath}`);
|
||||
|
||||
// ── Cleanup ───────────────────────────────────────────
|
||||
await db.close().catch(() => {});
|
||||
await browser.close();
|
||||
|
||||
log("Done!");
|
||||
process.exit(report.summary.errors > 0 ? 1 : 0);
|
||||
}
|
||||
|
||||
main().catch((err) => {
|
||||
console.error("FATAL:", err);
|
||||
process.exit(1);
|
||||
});
|
||||
Reference in New Issue
Block a user