227 lines
7.6 KiB
TypeScript
227 lines
7.6 KiB
TypeScript
import assert from "node:assert/strict";
|
|
import { readFileSync } from "node:fs";
|
|
import { join } from "node:path";
|
|
import test from "node:test";
|
|
|
|
const schemaSource = readFileSync(
|
|
join(process.cwd(), "convex", "schema.ts"),
|
|
"utf8",
|
|
);
|
|
|
|
type ExactSetEquality<A, B> = [
|
|
Exclude<A, B>,
|
|
] extends [never]
|
|
? [Exclude<B, A>] extends [never]
|
|
? true
|
|
: false
|
|
: false;
|
|
|
|
type AssertPageSpeedStrategy = "mobile" | "desktop";
|
|
type AssertPageSpeedResultStatus = "succeeded" | "failed";
|
|
type AssertPageSpeedErrorType =
|
|
| "quota"
|
|
| "timeout"
|
|
| "unavailable"
|
|
| "invalid_url"
|
|
| "api_error"
|
|
| "unknown";
|
|
|
|
type PageSpeedStrategyParity = ExactSetEquality<
|
|
AssertPageSpeedStrategy,
|
|
("mobile" | "desktop")
|
|
>;
|
|
type PageSpeedResultStatusParity = ExactSetEquality<
|
|
AssertPageSpeedResultStatus,
|
|
"succeeded" | "failed"
|
|
>;
|
|
type PageSpeedErrorTypeParity = ExactSetEquality<
|
|
AssertPageSpeedErrorType,
|
|
"quota" | "timeout" | "unavailable" | "invalid_url" | "api_error" | "unknown"
|
|
>;
|
|
|
|
const _assertPageSpeedStrategyParity: PageSpeedStrategyParity = true;
|
|
const _assertPageSpeedResultStatusParity: PageSpeedResultStatusParity = true;
|
|
const _assertPageSpeedErrorTypeParity: PageSpeedErrorTypeParity = true;
|
|
|
|
function extractTableSection(tableName: string) {
|
|
const marker = `${tableName}: defineTable({`;
|
|
const markerIndex = schemaSource.indexOf(marker);
|
|
assert.notEqual(
|
|
markerIndex,
|
|
-1,
|
|
`Expected schema table definition for ${tableName}.`,
|
|
);
|
|
|
|
const objectStart = schemaSource.indexOf("{", markerIndex);
|
|
let depth = 0;
|
|
let objectEnd = -1;
|
|
|
|
for (let i = objectStart; i < schemaSource.length; i += 1) {
|
|
if (schemaSource[i] === "{") {
|
|
depth += 1;
|
|
} else if (schemaSource[i] === "}") {
|
|
depth -= 1;
|
|
if (depth === 0) {
|
|
objectEnd = i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
assert.notEqual(objectEnd, -1, `Could not parse schema object for ${tableName}.`);
|
|
|
|
const remainder = schemaSource.slice(objectEnd + 1);
|
|
const nextTableMatch = remainder.match(/^\s*[a-zA-Z_][\w]*:\s*defineTable\(/m);
|
|
|
|
const sectionEnd =
|
|
nextTableMatch === null ? schemaSource.length : objectEnd + 1 + nextTableMatch.index!;
|
|
const section = schemaSource.slice(markerIndex, sectionEnd);
|
|
const objectBlock = schemaSource.slice(markerIndex, objectEnd + 1);
|
|
|
|
return { section, objectBlock };
|
|
}
|
|
|
|
function assertHas(pattern: RegExp, source: string, message: string) {
|
|
assert.equal(pattern.test(source), true, message);
|
|
}
|
|
|
|
test("PageSpeed validator unions are declared", () => {
|
|
assert.equal(_assertPageSpeedStrategyParity, true);
|
|
assert.equal(_assertPageSpeedResultStatusParity, true);
|
|
assert.equal(_assertPageSpeedErrorTypeParity, true);
|
|
|
|
assertHas(
|
|
/const\s+pageSpeedStrategy\s*=\s*v\.union\(\s*[\s\S]*v\.literal\(\s*["']mobile["']\s*\)\s*,\s*[\s\S]*v\.literal\(\s*["']desktop["']\s*\)[\s\S]*\)/,
|
|
schemaSource,
|
|
"Schema should define pageSpeedStrategy union with mobile and desktop.",
|
|
);
|
|
assertHas(
|
|
/const\s+pageSpeedResultStatus\s*=\s*v\.union\(\s*[\s\S]*v\.literal\(\s*["']succeeded["']\s*\)\s*,\s*[\s\S]*v\.literal\(\s*["']failed["']\s*\)[\s\S]*\)/,
|
|
schemaSource,
|
|
"Schema should define pageSpeedResultStatus union with succeeded and failed.",
|
|
);
|
|
assertHas(
|
|
/const\s+pageSpeedErrorType\s*=\s*v\.union\(\s*[\s\S]*v\.literal\(\s*["']quota["']\s*\)\s*,\s*[\s\S]*v\.literal\(\s*["']timeout["']\s*\)\s*,\s*[\s\S]*v\.literal\(\s*["']unavailable["']\s*\)\s*,\s*[\s\S]*v\.literal\(\s*["']invalid_url["']\s*\)\s*,\s*[\s\S]*v\.literal\(\s*["']api_error["']\s*\)\s*,\s*[\s\S]*v\.literal\(\s*["']unknown["']\s*\)[\s\S]*\)/,
|
|
schemaSource,
|
|
"Schema should define pageSpeedErrorType union with all declared values.",
|
|
);
|
|
});
|
|
|
|
test("pageSpeedResults table has contract fields and indexes", () => {
|
|
const { section, objectBlock } = extractTableSection("pageSpeedResults");
|
|
|
|
assertHas(
|
|
/leadId:\s*v\.id\(["']leads["']\)/,
|
|
objectBlock,
|
|
"pageSpeedResults.leadId should be required lead id.",
|
|
);
|
|
assertHas(
|
|
/auditId:\s*v\.optional\(\s*v\.id\(["']audits["']\)\s*\)/,
|
|
objectBlock,
|
|
"pageSpeedResults.auditId should be optional audit id.",
|
|
);
|
|
assertHas(
|
|
/runId:\s*v\.optional\(\s*v\.id\(["']agentRuns["']\)\s*\)/,
|
|
objectBlock,
|
|
"pageSpeedResults.runId should be optional run id.",
|
|
);
|
|
assertHas(
|
|
/strategy:\s*pageSpeedStrategy/,
|
|
objectBlock,
|
|
"pageSpeedResults.strategy should use pageSpeedStrategy validator.",
|
|
);
|
|
assertHas(
|
|
/status:\s*pageSpeedResultStatus/,
|
|
objectBlock,
|
|
"pageSpeedResults.status should use pageSpeedResultStatus validator.",
|
|
);
|
|
assertHas(
|
|
/sourceUrl:\s*v\.string\(\)/,
|
|
objectBlock,
|
|
"pageSpeedResults.sourceUrl should be required.",
|
|
);
|
|
assertHas(
|
|
/finalUrl:\s*v\.optional\(\s*v\.string\(\)\s*\)/,
|
|
objectBlock,
|
|
"pageSpeedResults.finalUrl should be optional string.",
|
|
);
|
|
assertHas(
|
|
/rawStorageId:\s*v\.optional\(\s*v\.id\(["']_storage["']\)\s*\)/,
|
|
objectBlock,
|
|
"pageSpeedResults.rawStorageId should be optional storage id.",
|
|
);
|
|
assertHas(
|
|
/errorType:\s*v\.optional\(\s*pageSpeedErrorType\s*\)/,
|
|
objectBlock,
|
|
"pageSpeedResults.errorType should be optional error type.",
|
|
);
|
|
assertHas(
|
|
/errorSummary:\s*v\.optional\(\s*v\.string\(\)\s*\)/,
|
|
objectBlock,
|
|
"pageSpeedResults.errorSummary should be optional.",
|
|
);
|
|
assertHas(
|
|
/fetchedAt:\s*v\.number\(\)/,
|
|
objectBlock,
|
|
"pageSpeedResults.fetchedAt should be required.",
|
|
);
|
|
assertHas(
|
|
/createdAt:\s*v\.number\(\)/,
|
|
objectBlock,
|
|
"pageSpeedResults.createdAt should be required.",
|
|
);
|
|
assertHas(
|
|
/scores:\s*v\.optional\(\s*v\.object\([\s\S]*?performance:\s*v\.optional\(v\.number\(\)\)[\s\S]*?accessibility:\s*v\.optional\(v\.number\(\)\)[\s\S]*?bestPractices:\s*v\.optional\(v\.number\(\)\)[\s\S]*?seo:\s*v\.optional\(v\.number\(\)\)[\s\S]*?\)\s*\)/,
|
|
objectBlock,
|
|
"pageSpeedResults.normalized.scores should include expected keys.",
|
|
);
|
|
assertHas(
|
|
/metrics:\s*v\.optional\(\s*v\.object\([\s\S]*?firstContentfulPaintMs:\s*v\.optional\(v\.number\(\)\)[\s\S]*?largestContentfulPaintMs:\s*v\.optional\(v\.number\(\)\)[\s\S]*?cumulativeLayoutShift:\s*v\.optional\(v\.number\(\)\)[\s\S]*?totalBlockingTimeMs:\s*v\.optional\(v\.number\(\)\)[\s\S]*?speedIndexMs:\s*v\.optional\(v\.number\(\)\)[\s\S]*?\)\s*\)/,
|
|
objectBlock,
|
|
"pageSpeedResults.normalized.metrics should include expected keys.",
|
|
);
|
|
assertHas(
|
|
/opportunities:\s*v\.optional\(\s*v\.array\(v\.string\(\)\)\s*\)/,
|
|
objectBlock,
|
|
"pageSpeedResults.normalized.opportunities should be optional string array.",
|
|
);
|
|
assertHas(
|
|
/implications:\s*v\.optional\(\s*v\.array\(v\.string\(\)\)\s*\)/,
|
|
objectBlock,
|
|
"pageSpeedResults.normalized.implications should be optional string array.",
|
|
);
|
|
|
|
assertHas(
|
|
/index\("by_leadId",\s*\["leadId"\]\)/,
|
|
section,
|
|
"pageSpeedResults should have by_leadId index.",
|
|
);
|
|
assertHas(
|
|
/index\("by_runId",\s*\["runId"\]\)/,
|
|
section,
|
|
"pageSpeedResults should have by_runId index.",
|
|
);
|
|
assertHas(
|
|
/index\("by_auditId",\s*\["auditId"\]\)/,
|
|
section,
|
|
"pageSpeedResults should have by_auditId index.",
|
|
);
|
|
assertHas(
|
|
/index\("by_leadId_and_strategy",\s*\["leadId",\s*"strategy"\]\)/,
|
|
section,
|
|
"pageSpeedResults should have by_leadId_and_strategy index.",
|
|
);
|
|
});
|
|
|
|
test("audits should not include public raw PageSpeed/Lighthouse JSON fields", () => {
|
|
const { objectBlock } = extractTableSection("audits");
|
|
const hasPublicRawJson = /raw.*pagespeed|pagespeed.*raw|raw.*lighthouse|lighthouse.*raw/i.test(
|
|
objectBlock,
|
|
);
|
|
assert.equal(
|
|
hasPublicRawJson,
|
|
false,
|
|
"audits should not expose raw PageSpeed/Lighthouse JSON fields.",
|
|
);
|
|
});
|