752 lines
25 KiB
TypeScript
752 lines
25 KiB
TypeScript
import assert from "node:assert/strict";
|
|
import { existsSync, readFileSync } from "node:fs";
|
|
import path from "node:path";
|
|
import test from "node:test";
|
|
import ts from "typescript";
|
|
|
|
const convexConfigPath = path.join(process.cwd(), "convex.json");
|
|
const convexConfigSource = readFileSync(convexConfigPath, "utf8");
|
|
|
|
const websiteEnrichmentPath = path.join(
|
|
process.cwd(),
|
|
"convex/websiteEnrichment.ts",
|
|
);
|
|
const actionPath = path.join(process.cwd(), "convex/websiteEnrichmentAction.ts");
|
|
|
|
const websiteEnrichmentSource = readFileSync(websiteEnrichmentPath, "utf8");
|
|
const actionSource = readFileSync(actionPath, "utf8");
|
|
|
|
const websiteEnrichmentSourceFile = ts.createSourceFile(
|
|
"websiteEnrichment.ts",
|
|
websiteEnrichmentSource,
|
|
ts.ScriptTarget.ES2022,
|
|
true,
|
|
ts.ScriptKind.TS,
|
|
);
|
|
const actionSourceFile = ts.createSourceFile(
|
|
"websiteEnrichmentAction.ts",
|
|
actionSource,
|
|
ts.ScriptTarget.ES2022,
|
|
true,
|
|
ts.ScriptKind.TS,
|
|
);
|
|
|
|
function getExportedConstNames(file: ts.SourceFile) {
|
|
const names = new Set<string>();
|
|
|
|
const visit = (node: ts.Node) => {
|
|
if (ts.isVariableStatement(node)) {
|
|
const isExported = node.modifiers?.some(
|
|
(mod) => mod.kind === ts.SyntaxKind.ExportKeyword,
|
|
);
|
|
|
|
if (!isExported) {
|
|
ts.forEachChild(node, visit);
|
|
return;
|
|
}
|
|
|
|
const isConst = node.declarationList.flags & ts.NodeFlags.Const;
|
|
|
|
if (!isConst) {
|
|
ts.forEachChild(node, visit);
|
|
return;
|
|
}
|
|
|
|
for (const declaration of node.declarationList.declarations) {
|
|
if (ts.isIdentifier(declaration.name)) {
|
|
names.add(declaration.name.text);
|
|
}
|
|
}
|
|
}
|
|
|
|
ts.forEachChild(node, visit);
|
|
};
|
|
|
|
ts.forEachChild(file, visit);
|
|
return names;
|
|
}
|
|
|
|
function hasPattern(source: string, pattern: RegExp) {
|
|
return pattern.test(source);
|
|
}
|
|
|
|
function extractExportSource(source: string, name: string) {
|
|
const marker = `export const ${name} = `;
|
|
const declarationIndex = source.indexOf(marker);
|
|
assert.notEqual(declarationIndex, -1, `Expected declaration for ${name}`);
|
|
|
|
const openBraceIndex = source.indexOf("{", declarationIndex);
|
|
let depth = 0;
|
|
let end = -1;
|
|
|
|
for (let index = openBraceIndex; index < source.length; index += 1) {
|
|
const char = source[index];
|
|
if (char === "{") {
|
|
depth += 1;
|
|
} else if (char === "}") {
|
|
depth -= 1;
|
|
if (depth === 0) {
|
|
end = index;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
assert.notEqual(end, -1, `Expected balanced braces for ${name}`);
|
|
return source.slice(openBraceIndex, end + 1);
|
|
}
|
|
|
|
test("website enrichment mutation module exists and has runtime assertions", () => {
|
|
assert.equal(
|
|
existsSync(websiteEnrichmentPath),
|
|
true,
|
|
"websiteEnrichment.ts should be present",
|
|
);
|
|
|
|
assert.equal(
|
|
hasPattern(websiteEnrichmentSource, /^"use node";/m),
|
|
false,
|
|
"websiteEnrichment.ts should not declare a Node runtime",
|
|
);
|
|
});
|
|
|
|
test("website enrichment action module exists and uses Node runtime", () => {
|
|
assert.equal(
|
|
existsSync(actionPath),
|
|
true,
|
|
"websiteEnrichmentAction.ts should be present",
|
|
);
|
|
|
|
assert.equal(
|
|
hasPattern(actionSource, /^"use node";/m),
|
|
true,
|
|
"websiteEnrichmentAction.ts should declare Node runtime",
|
|
);
|
|
});
|
|
|
|
test("module exports are split across mutations and action", () => {
|
|
const mutationExports = getExportedConstNames(websiteEnrichmentSourceFile);
|
|
const actionExports = getExportedConstNames(actionSourceFile);
|
|
|
|
const requiredMutationExports = [
|
|
"queueLeadEnrichment",
|
|
"startLeadEnrichmentRun",
|
|
"persistLeadEnrichmentResult",
|
|
"finishLeadEnrichmentRun",
|
|
"patchLeadFromWebsiteEnrichment",
|
|
];
|
|
const requiredActionExports = ["processLeadEnrichment"];
|
|
|
|
for (const exportName of requiredMutationExports) {
|
|
assert.equal(
|
|
mutationExports.has(exportName),
|
|
true,
|
|
`Expected mutation export in websiteEnrichment.ts: ${exportName}`,
|
|
);
|
|
}
|
|
|
|
for (const exportName of requiredActionExports) {
|
|
assert.equal(
|
|
actionExports.has(exportName),
|
|
true,
|
|
`Expected action export in websiteEnrichmentAction.ts: ${exportName}`,
|
|
);
|
|
}
|
|
});
|
|
|
|
test("queueLeadEnrichment schedules internal.websiteEnrichmentAction.processLeadEnrichment", () => {
|
|
assert.equal(
|
|
hasPattern(
|
|
websiteEnrichmentSource,
|
|
/queueLeadEnrichment\s*=\s*internalMutation\([\s\S]*?ctx\.scheduler\.runAfter\(\s*0,\s*internal\.websiteEnrichmentAction\.processLeadEnrichment/,
|
|
),
|
|
true,
|
|
"Queue mutation should schedule action with runAfter(0, internal.websiteEnrichmentAction.processLeadEnrichment)",
|
|
);
|
|
});
|
|
|
|
test("queueLeadEnrichment uses lead-aware run index and does not use fixed-size .take(50) windows", () => {
|
|
const queueBodyMatch = websiteEnrichmentSource.match(
|
|
/export const queueLeadEnrichment[\s\S]*?(?=\nexport const startLeadEnrichmentRun)/,
|
|
);
|
|
assert.equal(
|
|
queueBodyMatch !== null,
|
|
true,
|
|
"queueLeadEnrichment block should be parseable for source assertions",
|
|
);
|
|
|
|
const queueBody = queueBodyMatch?.[0] ?? "";
|
|
assert.equal(
|
|
hasPattern(
|
|
queueBody,
|
|
/withIndex\("by_type_and_status_and_leadId"[\s\S]*?eq\("type",\s*"website_enrichment"\)[\s\S]*?eq\("status",\s*"pending"\)[\s\S]*?eq\("leadId",\s*args\.leadId\)/,
|
|
),
|
|
true,
|
|
"Queue dedupe for pending runs should use direct type+status+leadId index.",
|
|
);
|
|
assert.equal(
|
|
hasPattern(
|
|
queueBody,
|
|
/withIndex\("by_type_and_status_and_leadId"[\s\S]*?eq\("type",\s*"website_enrichment"\)[\s\S]*?eq\("status",\s*"running"\)[\s\S]*?eq\("leadId",\s*args\.leadId\)/,
|
|
),
|
|
true,
|
|
"Queue dedupe for running runs should use direct type+status+leadId index.",
|
|
);
|
|
assert.equal(hasPattern(queueBody, /take\(50\)/), false, "No fixed-size .take(50) window in dedupe queries.");
|
|
});
|
|
|
|
test("website enrichment action uses Chromium desktop/mobile devices and runtime Playwright import", () => {
|
|
assert.equal(
|
|
hasPattern(
|
|
actionSource,
|
|
/import\s+type\s+\{[^\n]*BrowserContext[^\n]*\}\s+from\s+["']playwright-core["']/,
|
|
),
|
|
true,
|
|
"Action should import BrowserContext type for typed helper signatures",
|
|
);
|
|
assert.equal(
|
|
hasPattern(actionSource, /loadPlaywrightModules\(\)/),
|
|
true,
|
|
"Action should load Playwright at runtime from inside action",
|
|
);
|
|
assert.equal(
|
|
hasPattern(actionSource, /import\("playwright-core"\)/),
|
|
true,
|
|
"Action should use a dynamic import for playwright-core that Convex can detect as an external package",
|
|
);
|
|
assert.equal(
|
|
hasPattern(actionSource, /import\("@sparticuz\/chromium-min"\)/),
|
|
true,
|
|
"Action should use a dynamic import for @sparticuz/chromium-min as the lightweight browser package",
|
|
);
|
|
assert.equal(
|
|
hasPattern(actionSource, /TASK8_BROWSER_ASSET_URL/),
|
|
true,
|
|
"Action should reference TASK8_BROWSER_ASSET_URL when loading browser assets",
|
|
);
|
|
assert.equal(
|
|
hasPattern(
|
|
actionSource,
|
|
/TASK8_BROWSER_ASSET_URL[\s\S]{0,240}(throw|Error|required|missing|not configured|configured|konfiguriert|setze)/i,
|
|
),
|
|
true,
|
|
"Action should surface a clear error when the browser asset URL is not configured",
|
|
);
|
|
assert.equal(
|
|
hasPattern(actionSource, /import\("@sparticuz\/chromium"\)/),
|
|
false,
|
|
"Action should not import the oversized @sparticuz/chromium package",
|
|
);
|
|
const externalPackages = JSON.parse(convexConfigSource).node?.externalPackages;
|
|
assert.equal(Array.isArray(externalPackages), true, "convex.json should define node.externalPackages");
|
|
assert.equal(
|
|
externalPackages?.includes("playwright-core"),
|
|
true,
|
|
"convex.json must include playwright-core in externalPackages",
|
|
);
|
|
assert.equal(
|
|
externalPackages?.includes("@sparticuz/chromium-min"),
|
|
true,
|
|
"convex.json should include @sparticuz/chromium-min for browser runtime",
|
|
);
|
|
assert.equal(
|
|
externalPackages?.includes("@sparticuz/chromium"),
|
|
false,
|
|
"convex.json should not include the oversized @sparticuz/chromium package",
|
|
);
|
|
assert.equal(
|
|
hasPattern(actionSource, /serverlessChromium/),
|
|
true,
|
|
"Runtime bootstrap should still use a serverless Chromium wrapper object for launch config",
|
|
);
|
|
assert.equal(
|
|
hasPattern(actionSource, /devices\["Desktop Chrome"\]/),
|
|
true,
|
|
"Desktop context should use Playwright Desktop Chrome device profile",
|
|
);
|
|
assert.equal(
|
|
hasPattern(actionSource, /devices\["iPhone 11"\]/),
|
|
true,
|
|
"Mobile context should use Playwright iPhone 11 device profile",
|
|
);
|
|
});
|
|
|
|
test("website enrichment action invalidates stale @sparticuz/chromium-min cache when source changes", () => {
|
|
assert.equal(
|
|
hasPattern(actionSource, /CHROMIUM_SOURCE_MARKER_FILE/),
|
|
true,
|
|
"Action should declare a temporary marker file path for Chromium executable source cache tracking.",
|
|
);
|
|
assert.equal(
|
|
hasPattern(
|
|
actionSource,
|
|
/tmpdir\(\)/,
|
|
),
|
|
true,
|
|
"Action should derive temporary cache paths from os.tmpdir().",
|
|
);
|
|
assert.equal(
|
|
hasPattern(actionSource, /getChromiumSourceMarker\(/),
|
|
true,
|
|
"Action should hash executable sources into a stable marker.",
|
|
);
|
|
assert.equal(
|
|
hasPattern(actionSource, /clearChromiumCacheForSourceMismatch\(/),
|
|
true,
|
|
"Action should centralize cache invalidation in a dedicated helper.",
|
|
);
|
|
assert.equal(
|
|
hasPattern(
|
|
actionSource,
|
|
/rm\(CHROMIUM_EXECUTABLE_PATH,\s*\{ force: true, recursive: true \}\),/,
|
|
),
|
|
true,
|
|
"Action should remove /tmp/chromium when executable source changes.",
|
|
);
|
|
assert.equal(
|
|
hasPattern(
|
|
actionSource,
|
|
/rm\(CHROMIUM_PACK_PATH,\s*\{ force: true, recursive: true \}\),/,
|
|
),
|
|
true,
|
|
"Action should remove /tmp/chromium-pack when executable source changes.",
|
|
);
|
|
assert.equal(
|
|
hasPattern(
|
|
actionSource,
|
|
/clearChromiumCacheForSourceMismatch\(executableSource\)[\s\S]*?chromium\.executablePath\(executableSource\)/,
|
|
),
|
|
true,
|
|
"Action should clear stale cache before resolving Chromium executable path.",
|
|
);
|
|
assert.equal(
|
|
hasPattern(
|
|
actionSource,
|
|
/writeFile\([\s\S]*?CHROMIUM_SOURCE_MARKER_FILE,[\s\S]*?getChromiumSourceMarker\(executableSource\)/,
|
|
),
|
|
true,
|
|
"Action should persist the source marker after executable path resolution.",
|
|
);
|
|
});
|
|
|
|
test("website enrichment action prepares Chromium AL2023 shared libraries for Convex runtime", () => {
|
|
const hasChromiumHelpers =
|
|
(hasPattern(actionSource, /inflate/) &&
|
|
hasPattern(actionSource, /setupLambdaEnvironment/)) ||
|
|
hasPattern(actionSource, /LD_LIBRARY_PATH/);
|
|
assert.equal(
|
|
hasChromiumHelpers,
|
|
true,
|
|
"Action should explicitly prepare chromium-min runtime environment for AL2023 shared libraries to avoid `/tmp/chromium: error while loading shared libraries: libnspr4.so` (inflate/setupLambdaEnvironment or LD_LIBRARY_PATH).",
|
|
);
|
|
|
|
const hasAl2023LibPath =
|
|
hasPattern(
|
|
actionSource,
|
|
/path\.join\(\s*tmpdir\(\),\s*["']al2023["'],\s*["']lib["']\s*\)/,
|
|
) ||
|
|
(hasPattern(actionSource, /LD_LIBRARY_PATH/) &&
|
|
hasPattern(actionSource, /al2023\/lib/));
|
|
|
|
const referencesRuntimeArchive = hasPattern(actionSource, /al2023\.tar\.br/);
|
|
const referencesPackPath = hasPattern(
|
|
actionSource,
|
|
/CHROMIUM_PACK_PATH/,
|
|
);
|
|
assert.equal(
|
|
referencesRuntimeArchive && referencesPackPath && hasAl2023LibPath,
|
|
true,
|
|
"Action should reference al2023.tar.br, track CHROMIUM_PACK_PATH, and ensure /tmp/al2023/lib is prepared for Convex launch.",
|
|
);
|
|
|
|
const executableIndex = actionSource.indexOf(
|
|
"resolveChromiumExecutablePath(",
|
|
actionSource.indexOf("export const processLeadEnrichment"),
|
|
);
|
|
const launchIndex = actionSource.indexOf("chromium.launch({");
|
|
const hasSetupIndex = Math.max(
|
|
actionSource.indexOf("setupLambdaEnvironment("),
|
|
actionSource.indexOf("LD_LIBRARY_PATH"),
|
|
actionSource.indexOf("path.join(tmpdir(), \"al2023\", \"lib\")"),
|
|
);
|
|
assert.equal(
|
|
executableIndex >= 0 &&
|
|
hasSetupIndex > executableIndex &&
|
|
hasSetupIndex < launchIndex,
|
|
true,
|
|
"Executable resolution and AL2023 shared-library setup should happen before chromium launch in the action runtime path.",
|
|
);
|
|
});
|
|
|
|
test("processLeadEnrichment wraps Playwright bootstrap in protected try/catch", () => {
|
|
assert.equal(
|
|
hasPattern(
|
|
actionSource,
|
|
/try\s*\{[\s\S]*?const \{ playwrightCore, serverlessChromium \}\s*=[\s\S]*?loadPlaywrightModules\(\)[\s\S]*?const executablePath = await withActionTimeout\([\s\S]*?resolveChromiumExecutablePath\(\s*serverlessChromium\s*\)[\s\S]*?browser = await withActionTimeout\([\s\S]*?playwrightCore\.chromium\.launch\([\s\S]*?executablePath,[\s\S]*?desktopContext = await withActionTimeout\([\s\S]*?browser\.newContext\([\s\S]*?mobileContext = await withActionTimeout\([\s\S]*?browser\.newContext\(/,
|
|
),
|
|
true,
|
|
"Playwright runtime bootstrap should use resolveChromiumExecutablePath() inside the action's try/catch-protected block",
|
|
);
|
|
assert.equal(
|
|
hasPattern(
|
|
actionSource,
|
|
/catch\s*\(error\)\s*\{[\s\S]*?finishLeadEnrichmentRun[\s\S]*?runs\.appendEvent[\s\S]*?patchLeadFromWebsiteEnrichment/,
|
|
),
|
|
true,
|
|
"Bootstrap failures should be handled by finish + error event + lead patch in catch",
|
|
);
|
|
});
|
|
|
|
test("persistence caps candidates and links before writing", () => {
|
|
assert.equal(
|
|
hasPattern(actionSource, /MAX_PERSISTED_LINKS\s*=\s*120/),
|
|
true,
|
|
"Action should define MAX_PERSISTED_LINKS with value 120.",
|
|
);
|
|
assert.equal(
|
|
hasPattern(actionSource, /MAX_PERSISTED_EMAIL_CANDIDATES\s*=\s*40/),
|
|
true,
|
|
"Action should define MAX_PERSISTED_EMAIL_CANDIDATES with value 40.",
|
|
);
|
|
assert.equal(
|
|
hasPattern(
|
|
actionSource,
|
|
/deduplicateCrawlLinks\(allLinks\)[\s\S]*?slice\([\s\S]*?MAX_PERSISTED_LINKS/,
|
|
),
|
|
true,
|
|
"Action should dedupe and cap link persistence at MAX_PERSISTED_LINKS.",
|
|
);
|
|
assert.equal(
|
|
hasPattern(
|
|
actionSource,
|
|
/validCandidates\.slice\([\s\S]*?MAX_PERSISTED_EMAIL_CANDIDATES/,
|
|
),
|
|
true,
|
|
"Action should cap candidate persistence at MAX_PERSISTED_EMAIL_CANDIDATES.",
|
|
);
|
|
});
|
|
|
|
test("website enrichment process stores homepage screenshots in Convex storage as PNG", () => {
|
|
assert.equal(
|
|
hasPattern(actionSource, /ctx\.storage\.store\(/),
|
|
true,
|
|
"Action should store screenshot blobs via ctx.storage.store",
|
|
);
|
|
assert.equal(
|
|
hasPattern(
|
|
actionSource,
|
|
/new\s+Blob\(\[[\s\S]*?SCREENSHOT_MIME_TYPE/,
|
|
),
|
|
true,
|
|
"Action should wrap screenshots in Blob with image/png MIME type",
|
|
);
|
|
});
|
|
|
|
test("startLeadEnrichmentRun marks missing website lead with contact status reason", () => {
|
|
assert.equal(
|
|
hasPattern(
|
|
websiteEnrichmentSource,
|
|
/if \(!lead\.websiteUrl\)\s*\{[\s\S]*?status:\s*"failed"[\s\S]*?contactStatusReason:\s*"Website-URL fehlt für das Website-Enrichment\."/,
|
|
),
|
|
true,
|
|
"Missing websiteUrl should set a specific contactStatusReason on the lead",
|
|
);
|
|
});
|
|
|
|
test("website enrichment persistence inserts all required evidence table rows", () => {
|
|
const expectedTables = [
|
|
"websiteCrawlPages",
|
|
"websiteCrawlLinks",
|
|
"websiteEmailCandidates",
|
|
"websiteCrawlScreenshots",
|
|
"websiteTechnicalChecks",
|
|
] as const;
|
|
|
|
for (const tableName of expectedTables) {
|
|
assert.equal(
|
|
hasPattern(
|
|
websiteEnrichmentSource,
|
|
new RegExp(`ctx\\.db\\.insert\\(["']${tableName}["']`, "s"),
|
|
),
|
|
true,
|
|
`persistLeadEnrichmentResult should insert into ${tableName}`,
|
|
);
|
|
}
|
|
});
|
|
|
|
test("website enrichment flow uses TASK-7 email selection helper for lead patching", () => {
|
|
assert.equal(
|
|
hasPattern(
|
|
actionSource,
|
|
/getUsableContactEmailFromEntries\([\s\S]*?\)/,
|
|
),
|
|
true,
|
|
"Action should call getUsableContactEmailFromEntries",
|
|
);
|
|
assert.equal(
|
|
hasPattern(
|
|
actionSource,
|
|
/runMutation\(\s*internal\.websiteEnrichment\.patchLeadFromWebsiteEnrichment[\s\S]*?\{[\s\S]*?email:\s*usable\.email/,
|
|
),
|
|
true,
|
|
"Action should patch lead from usable email result",
|
|
);
|
|
assert.equal(
|
|
hasPattern(
|
|
actionSource,
|
|
/currentContactStatus\s*:\s*started\.lead\.contactStatus/,
|
|
),
|
|
true,
|
|
"Action should pass lead contact status to patchLeadFromWebsiteEnrichment",
|
|
);
|
|
assert.equal(
|
|
hasPattern(websiteEnrichmentSource, /args\.currentContactStatus\s*===\s*\"missing_contact\"/),
|
|
true,
|
|
"Lead patch mutation should only set new status for missing_contact",
|
|
);
|
|
});
|
|
|
|
test("failure handling marks run as failed and writes lead-facing reason", () => {
|
|
assert.equal(
|
|
hasPattern(
|
|
actionSource,
|
|
/runMutation\(\s*internal\.websiteEnrichment\.finishLeadEnrichmentRun[\s\S]*?status:\s*"failed"/,
|
|
),
|
|
true,
|
|
"Action should persist failed run state on fatal crawl errors",
|
|
);
|
|
assert.equal(
|
|
hasPattern(
|
|
actionSource,
|
|
/runMutation\(\s*api\.runs\.appendEvent[\s\S]*?level:\s*"error"[\s\S]*?message:\s*"Website-Enrichment fehlgeschlagen/,
|
|
),
|
|
true,
|
|
"Action should append a visible error event on failure",
|
|
);
|
|
assert.equal(
|
|
hasPattern(
|
|
actionSource,
|
|
/contactStatusReason:\s*`Website-Enrichment fehlgeschlagen:\s*\$\{errorSummary\}`/,
|
|
),
|
|
true,
|
|
"Action should patch the lead with an actionable failure reason",
|
|
);
|
|
assert.equal(
|
|
hasPattern(
|
|
actionSource,
|
|
/contactStatusReason:\s*"Website-Enrichment fehlgeschlagen: Ungültige Website-URL\."/,
|
|
),
|
|
true,
|
|
"Invalid-url failure should also update lead contact status reason",
|
|
);
|
|
});
|
|
|
|
test("website enrichment enforces TASK-8 crawler limits and runtime timeboxes", () => {
|
|
assert.equal(
|
|
hasPattern(actionSource, /TASK8_CRAWL_TIMEOUT_MS/g),
|
|
true,
|
|
"TASK8_CRAWL_TIMEOUT_MS environment override should be used",
|
|
);
|
|
assert.equal(
|
|
hasPattern(actionSource, /DEFAULT_CRAWL_TIMEOUT_MS\s*=\s*60_000/),
|
|
true,
|
|
"Default crawl timeout should be 60s",
|
|
);
|
|
assert.equal(
|
|
hasPattern(actionSource, /DEFAULT_CRAWL_MAX_PAGES\s*=\s*5/),
|
|
true,
|
|
"Default max crawl page count should be 5",
|
|
);
|
|
});
|
|
|
|
test("website enrichment guards long browser work before Convex action runtime aborts", () => {
|
|
assert.equal(
|
|
hasPattern(actionSource, /DEFAULT_ACTION_BUDGET_MS\s*=\s*120_000/),
|
|
true,
|
|
"Action should keep an overall runtime budget below the observed Convex abort window.",
|
|
);
|
|
assert.equal(
|
|
hasPattern(actionSource, /TASK8_ACTION_BUDGET_MS/),
|
|
true,
|
|
"Action runtime budget should be configurable for manual tuning.",
|
|
);
|
|
assert.equal(
|
|
hasPattern(actionSource, /function actionBudgetMs\(\)/),
|
|
true,
|
|
"Action should resolve a bounded runtime budget.",
|
|
);
|
|
assert.equal(
|
|
hasPattern(actionSource, /function remainingActionBudgetMs\(/),
|
|
true,
|
|
"Action should calculate remaining runtime before long awaits.",
|
|
);
|
|
assert.equal(
|
|
hasPattern(actionSource, /async function withActionTimeout/),
|
|
true,
|
|
"Action should wrap long promises so JS catch runs before Convex kills the runtime.",
|
|
);
|
|
|
|
const processBody = extractExportSource(actionSource, "processLeadEnrichment");
|
|
assert.equal(
|
|
hasPattern(processBody, /const actionStartedAt = Date\.now\(\)/),
|
|
true,
|
|
"processLeadEnrichment should track action start time.",
|
|
);
|
|
assert.equal(
|
|
hasPattern(processBody, /const actionBudget = actionBudgetMs\(\)/),
|
|
true,
|
|
"processLeadEnrichment should resolve the action budget once.",
|
|
);
|
|
|
|
const guardedPatterns = [
|
|
/withActionTimeout\([\s\S]*loadPlaywrightModules\(\)/,
|
|
/withActionTimeout\([\s\S]*resolveChromiumExecutablePath\(/,
|
|
/withActionTimeout\([\s\S]*prepareChromiumSharedLibraries\(/,
|
|
/withActionTimeout\([\s\S]*playwrightCore\.chromium\.launch\(/,
|
|
/withActionTimeout\([\s\S]*crawlPage\(\s*desktopContext,\s*rootUrl/,
|
|
/withActionTimeout\([\s\S]*captureHomepageScreenshot\(/,
|
|
];
|
|
|
|
for (const pattern of guardedPatterns) {
|
|
assert.equal(
|
|
hasPattern(processBody, pattern),
|
|
true,
|
|
`Expected long await to be guarded by withActionTimeout: ${pattern}`,
|
|
);
|
|
}
|
|
|
|
assert.equal(
|
|
hasPattern(processBody, /Math\.min\(\s*timeoutMs,\s*remainingActionBudgetMs\(/),
|
|
true,
|
|
"Per-page crawl timeout should be capped by remaining action budget.",
|
|
);
|
|
assert.equal(
|
|
hasPattern(
|
|
processBody,
|
|
/desktopContext\.request\.get\([\s\S]*timeout:\s*Math\.min\([\s\S]*remainingActionBudgetMs\(/,
|
|
),
|
|
true,
|
|
"Internal link checks should cap request timeouts by remaining action budget.",
|
|
);
|
|
});
|
|
|
|
test("processLeadEnrichment schedules PageSpeed audit jobs after successful enrichment", () => {
|
|
const processBody = extractExportSource(actionSource, "processLeadEnrichment");
|
|
const persistIndex = processBody.indexOf(
|
|
"internal.websiteEnrichment.persistLeadEnrichmentResult",
|
|
);
|
|
const queueIndex = processBody.indexOf(
|
|
"internal.pageSpeed.queueLeadPageSpeedAudit",
|
|
persistIndex,
|
|
);
|
|
const finishIndex = processBody.indexOf(
|
|
"internal.websiteEnrichment.finishLeadEnrichmentRun",
|
|
persistIndex,
|
|
);
|
|
|
|
assert.notEqual(queueIndex, -1, "processLeadEnrichment should queue PageSpeed audits");
|
|
assert.notEqual(persistIndex, -1, "processLeadEnrichment should persist website enrichment result");
|
|
assert.notEqual(finishIndex, -1, "processLeadEnrichment should finish enrichment run");
|
|
assert.equal(
|
|
hasPattern(
|
|
processBody,
|
|
/runMutation\(\s*internal\.pageSpeed\.queueLeadPageSpeedAudit[\s\S]*leadId:\s*started\.lead\._id[\s\S]*parentRunId:\s*runId[\s\S]*\)/,
|
|
),
|
|
true,
|
|
"Queue call should pass lead ID and parent run ID",
|
|
);
|
|
|
|
assert.equal(queueIndex > persistIndex, true, "PageSpeed queueing should happen after persistence");
|
|
assert.equal(queueIndex < finishIndex, true, "PageSpeed queueing should happen before success finish");
|
|
});
|
|
|
|
test("processLeadEnrichment records warning on PageSpeed queue failure and continues", () => {
|
|
const processBody = extractExportSource(actionSource, "processLeadEnrichment");
|
|
|
|
assert.equal(
|
|
hasPattern(
|
|
processBody,
|
|
/try\s*\{[\s\S]*internal\.pageSpeed\.queueLeadPageSpeedAudit[\s\S]*\}\s*catch\s*\([^)]*\)\s*\{[\s\S]*api\.runs\.appendEvent[\s\S]*level:\s*"warning"/,
|
|
),
|
|
true,
|
|
"Queueing PageSpeed should be wrapped in warning-safe try/catch",
|
|
);
|
|
assert.equal(
|
|
hasPattern(
|
|
processBody,
|
|
/PageSpeed-Analyse konnte nicht in die Warteschlange gesetzt werden\./,
|
|
),
|
|
true,
|
|
"Warning event should describe queue failure",
|
|
);
|
|
});
|
|
|
|
test("processLeadEnrichment regression: queue PageSpeed on invalid URL failure when started lead exists", () => {
|
|
const processBody = extractExportSource(actionSource, "processLeadEnrichment");
|
|
const invalidUrlStart = processBody.indexOf("if (!rootUrl)");
|
|
assert.notEqual(invalidUrlStart, -1, "Invalid URL guard should exist");
|
|
|
|
const invalidUrlReturnNull = processBody.indexOf("return null;", invalidUrlStart);
|
|
assert.notEqual(
|
|
invalidUrlReturnNull,
|
|
-1,
|
|
"Invalid URL branch should return null",
|
|
);
|
|
|
|
const queueCallInInvalidUrl = processBody.indexOf(
|
|
"internal.pageSpeed.queueLeadPageSpeedAudit",
|
|
invalidUrlStart,
|
|
);
|
|
assert.equal(
|
|
queueCallInInvalidUrl > invalidUrlStart && queueCallInInvalidUrl < invalidUrlReturnNull,
|
|
true,
|
|
"Invalid URL failure path should queue PageSpeed before returning.",
|
|
);
|
|
const invalidUrlBranch = processBody.slice(invalidUrlStart, invalidUrlReturnNull);
|
|
assert.equal(
|
|
hasPattern(
|
|
invalidUrlBranch,
|
|
/leadId:\s*started\.lead\._id[\s\S]*?parentRunId:\s*runId/,
|
|
),
|
|
true,
|
|
"Invalid URL queue payload should use started.lead._id and parentRunId runId.",
|
|
);
|
|
});
|
|
|
|
test("processLeadEnrichment regression: queue PageSpeed in fatal catch path with started lead", () => {
|
|
const processBody = extractExportSource(actionSource, "processLeadEnrichment");
|
|
const outerCatchStart = processBody.lastIndexOf("catch (error)");
|
|
assert.notEqual(outerCatchStart, -1, "Outer catch block should exist");
|
|
|
|
const startedGuard = processBody.indexOf("if (started)", outerCatchStart);
|
|
assert.notEqual(startedGuard, -1, "Outer catch should guard lead patch by started check.");
|
|
|
|
const catchReturnNull = processBody.indexOf("return null;", outerCatchStart);
|
|
assert.notEqual(
|
|
catchReturnNull,
|
|
-1,
|
|
"Outer catch should return null on unrecoverable errors.",
|
|
);
|
|
|
|
const queueCallInCatch = processBody.indexOf(
|
|
"internal.pageSpeed.queueLeadPageSpeedAudit",
|
|
outerCatchStart,
|
|
);
|
|
assert.equal(
|
|
queueCallInCatch > outerCatchStart &&
|
|
queueCallInCatch > startedGuard &&
|
|
queueCallInCatch < catchReturnNull,
|
|
true,
|
|
"Fatal catch path should queue PageSpeed before returning, while started lead exists.",
|
|
);
|
|
const catchBlock = processBody.slice(outerCatchStart, catchReturnNull);
|
|
assert.equal(
|
|
hasPattern(
|
|
catchBlock,
|
|
/leadId:\s*started\.lead\._id[\s\S]*?parentRunId:\s*runId/,
|
|
),
|
|
true,
|
|
"Catch-path PageSpeed queue payload should use started.lead._id and parentRunId runId.",
|
|
);
|
|
});
|