import { existsSync } from "node:fs"; import { mkdir, mkdtemp, readdir, readFile, rm, writeFile } from "node:fs/promises"; import { tmpdir } from "node:os"; import path from "node:path"; import { parseAsync } from "@babel/core"; import { afterEach, describe, expect, it } from "vitest"; import { loadCiGateContract } from "../../scripts/contracts/ci-gates.ts"; import { assertNoRuntimeImports, pruneRemovalFixtureCiContract, REMOVAL_FIXTURE_COPY_TARGETS, REMOVAL_FIXTURE_DOCUMENT_TARGETS, REMOVAL_FIXTURE_DOCUMENT_TESTS, removalFixtureExcludedTests, removeRuntimeDependentTests, renderRemovalJunit, runtimeImportGraph, } from "../../scripts/lib/removal-fixture.ts"; const temporaryRoots: string[] = []; afterEach(async () => { await Promise.all( temporaryRoots.splice(0).map((root) => rm(root, { recursive: true, force: true })), ); }); it("rejects an empty scanned module universe", async () => { const root = await mkdtemp(path.join(tmpdir(), "removal-fixture-empty-modules-")); temporaryRoots.push(root); await expect(runtimeImportGraph(root, ["src/runtime"])).rejects.toThrow( /scanned module universe is empty/i, ); }); it("rejects a runtime removal scan that discovers no dependent tests", async () => { const root = await mkdtemp(path.join(tmpdir(), "removal-fixture-zero-dependent-tests-")); temporaryRoots.push(root); await mkdir(path.join(root, "src/runtime"), { recursive: true }); await mkdir(path.join(root, "tests"), { recursive: true }); await writeFile(path.join(root, "src/runtime/index.ts"), "export const runtime = true;\n"); await writeFile(path.join(root, "tests/unrelated.test.ts"), "export const unrelated = true;\n"); await expect(removeRuntimeDependentTests(root, ["src/runtime"])).rejects.toThrow( /no runtime-dependent tests discovered/i, ); }); it("allows zero runtime imports after the runtime has been removed", async () => { const root = await mkdtemp(path.join(tmpdir(), "removal-fixture-post-removal-")); temporaryRoots.push(root); await mkdir(path.join(root, "tests"), { recursive: true }); await writeFile(path.join(root, "tests/unrelated.test.ts"), "export const unrelated = true;\n"); await expect( assertNoRuntimeImports(root, ["src/runtime"], "fixture runtime"), ).resolves.toBeUndefined(); }); async function copyCiContract(prefix: string): Promise { const root = await mkdtemp(path.join(tmpdir(), prefix)); temporaryRoots.push(root); await mkdir(path.join(root, "config/ci"), { recursive: true }); for (const file of ["config/ci/gates.json", "package.json"]) { await writeFile(path.join(root, file), await readFile(file)); } return root; } it("prunes removed command and evidence references and loads the reduced contract", async () => { const root = await copyCiContract("removal-fixture-contract-"); // A command with evidence of its own, as a removed sample's tests had. Not // one a removal drill deletes: this test also runs inside those copies // (test:recipes is gone in the optional-recipe removal copy). await pruneRemovalFixtureCiContract({ root, removedScripts: new Set(["test:integration"]), removedEvidencePathFragments: ["integration.xml"], }); const contract = await loadCiGateContract(root); expect(contract.commands.some(({ script }) => script === "test:integration")).toBe(false); expect(contract.artifacts.some(({ path }) => path.includes("integration.xml"))).toBe(false); expect(contract.gates.some(({ commandIds }) => commandIds.includes("test-integration"))).toBe(false); expect(contract.gates.some(({ evidenceArtifactIds }) => evidenceArtifactIds.includes("artifact-artifacts-tests-integration-xml") )).toBe(false); const packageDocument = JSON.parse(await readFile(path.join(root, "package.json"), "utf8")) as { scripts: Record; }; expect(packageDocument.scripts["check:ci"]).not.toMatch(/reduced/u); }); // 1103/16-02. A product feature owns no CI script, so its removal prunes // nothing, and the contract still loads. it("loads a removal that prunes no CI script", async () => { const root = await copyCiContract("removal-fixture-no-scripts-"); await pruneRemovalFixtureCiContract({ root, removedScripts: new Set(), removedEvidencePathFragments: [], }); await expect(loadCiGateContract(root)).resolves.toBeDefined(); }); it("rejects pruning that leaves a reduced gate without commands", async () => { const root = await copyCiContract("removal-fixture-empty-gate-"); await expect(pruneRemovalFixtureCiContract({ root, removedScripts: new Set(["test:runtime-schema"]), removedEvidencePathFragments: ["runtime-schema.xml"], })).rejects.toThrow(/commandIds|too small|at least 1/i); }); type BabelOptions = NonNullable[1]>; type BabelParserPlugin = NonNullable["plugins"]>[number]; type SyntaxNode = { type: string } & Record; /** * 1106/12-01. The document paths the code of `source` spells out: string and * template literal parts that are a document target (README.md, CHANGELOG.md, * docs) or a path under one. Comments are not code. */ async function documentsNamedInCode(file: string, source: string): Promise { const plugins: BabelParserPlugin[] = [["typescript", { dts: false }]]; const tree = (await parseAsync(source, { filename: file, babelrc: false, configFile: false, sourceType: "module", parserOpts: { plugins }, })) as unknown as SyntaxNode | null; if (!tree) throw new Error(`cannot parse ${file}`); const strings: string[] = []; const visit = (node: SyntaxNode): void => { const literal = node["value"]; if (node.type === "StringLiteral" && typeof literal === "string") strings.push(literal); if (node.type === "TemplateElement") { const cooked = (literal as { cooked?: unknown } | undefined)?.cooked; if (typeof cooked === "string") strings.push(cooked); } for (const [key, value] of Object.entries(node)) { if (key === "comments" || key.endsWith("Comments")) continue; for (const child of Array.isArray(value) ? value : [value]) { if (child && typeof child === "object" && typeof (child as SyntaxNode).type === "string") { visit(child as SyntaxNode); } } } }; visit(tree); return strings.filter((value) => REMOVAL_FIXTURE_DOCUMENT_TARGETS.some( (target) => value === target || value.startsWith(`${target}/`), ), ); } // 1103/02-06. Three FE-GATE-020 drills copied the repository without its // documents and still ran the tests that read them, so each failed its `test` // check on ENOENT whatever it removed. Only the sample drill excluded them. describe("document tests in a removal fixture", () => { it("leaves the document tests out exactly when the documents are not copied", () => { expect(removalFixtureExcludedTests(REMOVAL_FIXTURE_COPY_TARGETS)) .toEqual(REMOVAL_FIXTURE_DOCUMENT_TESTS); expect(removalFixtureExcludedTests([ ...REMOVAL_FIXTURE_COPY_TARGETS, ...REMOVAL_FIXTURE_DOCUMENT_TARGETS, ])).toEqual([]); }); // This file also runs inside the capability fixtures, which hold neither // the documents nor these tests; the two go together. it("names tests that read the documents, present exactly where the documents are", async () => { const documentsPresent = REMOVAL_FIXTURE_DOCUMENT_TARGETS.every((target) => existsSync(target)); for (const test of REMOVAL_FIXTURE_DOCUMENT_TESTS) { expect(existsSync(test), test).toBe(documentsPresent); if (documentsPresent) { // 1106/12-01. Named in its code, not in a comment. A comment naming // the contract document let backend-contract-pin.test.ts on the list, // and its fourteen checks of config and code left those drills with // the one that read the document. expect(await documentsNamedInCode(test, await readFile(test, "utf8")), test).not.toEqual([]); } } }); it("counts a document named in code, not one named in a comment", async () => { const commentOnly = [ "// Reads docs/architecture/a.md (README.md, CHANGELOG.md).", "/** docs/manual/b.md */", 'const pin = JSON.parse(readFileSync("config/pin.json", "utf8"));', "readFileSync(pin.document);", ].join("\n"); expect(await documentsNamedInCode("comment-only.test.ts", commentOnly)).toEqual([]); const reads = [ 'readFileSync("CHANGELOG.md", "utf8");', "const name: string = 'a';", "readFileSync(`docs/manual/${name}.md`, 'utf8');", 'z.string().startsWith("docs/");', 'const notADocument = "src/docs/x.ts";', ].join("\n"); expect((await documentsNamedInCode("reads.test.ts", reads)).sort()).toEqual([ "CHANGELOG.md", "docs/", "docs/manual/", ]); }); it("is the only exclusion list: every drill prepares its fixture through it", async () => { const drills: string[] = []; for (const name of await readdir("scripts")) { if (!/^test-.*\.ts$/u.test(name)) continue; const source = await readFile(path.join("scripts", name), "utf8"); if (!source.includes("./lib/removal-fixture.ts")) continue; drills.push(name); expect(source, name).toContain("prepareRemovalFixture("); for (const test of REMOVAL_FIXTURE_DOCUMENT_TESTS) { expect(source, name).not.toContain(test); } } expect(drills).toEqual(expect.arrayContaining(["test-sample-removal.ts", "test-feature-scaffold.ts"])); }); }); describe("release evidence fixture copy", () => { it("keeps the release evidence and leaves the regenerated trees behind", async () => { const { copyReleaseEvidenceTree, RELEASE_EVIDENCE_REGENERATED_TREES } = await import("../../scripts/lib/removal-fixture.ts"); const { RELEASE_CANDIDATE_EVIDENCE_PATHS } = await import( "../../scripts/lib/release-candidate.ts" ); const { access, readdir } = await import("node:fs/promises"); // The source is a fake checkout, not process.cwd(): release evidence is // git-ignored, so a fresh clone has none of it and the copy would be // checked against nothing. const source = await mkdtemp(path.join(tmpdir(), "release-evidence-source-")); const target = await mkdtemp(path.join(tmpdir(), "release-evidence-target-")); temporaryRoots.push(source, target); const evidencePaths = RELEASE_CANDIDATE_EVIDENCE_PATHS.filter((evidence) => evidence.startsWith("artifacts/") ); expect(evidencePaths.length).toBeGreaterThan(0); for (const relative of [ ...evidencePaths, ...RELEASE_EVIDENCE_REGENERATED_TREES.map((tree) => `${tree}/trace.zip`), ]) { await mkdir(path.dirname(path.join(source, relative)), { recursive: true }); await writeFile(path.join(source, relative), "{}\n"); } await copyReleaseEvidenceTree(source, target); // Every release artifact has to survive the copy; a fixture missing one // cannot build a candidate at all, and every provider suite then fails // while constructing its own fixture. for (const evidence of evidencePaths) { await expect(access(path.join(target, evidence)), evidence).resolves.toBeUndefined(); } // The regenerated trees are why this is a filter and not a plain copy: they // are tens of megabytes of traces and coverage HTML. They still exist, // because the repository inventory expects the directories. for (const tree of RELEASE_EVIDENCE_REGENERATED_TREES) { await expect(readdir(path.join(target, tree)), tree).resolves.toEqual([]); } }); }); describe("removal JUnit report (14-08)", () => { it("counts every failure and gives each check its own cause", () => { const xml = renderRemovalJunit("sample-feature-removal", [ { name: "typecheck", passed: false, failure: "corepack pnpm check:types exited 2" }, { name: "architecture", passed: true }, { name: "build", passed: false, failure: "corepack pnpm build exited 1" }, { name: "fixture-id-residue", passed: false, failure: "residue: tests/a.test.ts, tests/&c.ts", }, ]); expect(xml).toContain('tests="4" failures="3"'); expect(xml).toContain( '', ); expect(xml).toContain(''); expect(xml).toContain( '', ); expect(xml).toContain( 'message="residue: tests/a.test.ts, tests/<b>&c.ts"', ); expect(xml.match(/residue:/gu)).toHaveLength(1); }); });