af8cc7b29c
Correct the velocity baseline to reflect an empty quarantine ledger and cover that report-only path. - Update the published test velocity baseline quarantine totals, buckets, trend row, and #leads summary to zero. - Add a regression test that regenerates the report from an empty live quarantine ledger without measuring lanes. - Assert deletion-due and bucket rows stay zero and stale nonzero quarantine text is removed. Files changed: docs/test-velocity-baseline.md | 10 ++-- scripts/__tests__/test-velocity-baseline.test.mjs | 72 ++++++++++++++++++++++- 2 files changed, 76 insertions(+), 6 deletions(-) Fusion-Task-Id: FN-7079 Fusion-Task-Lineage: d641adc3-f991-4d95-bcb2-7b20bbfeb0bb
377 lines
13 KiB
JavaScript
377 lines
13 KiB
JavaScript
import { describe, it } from "node:test";
|
|
import assert from "node:assert/strict";
|
|
import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
|
|
import { tmpdir } from "node:os";
|
|
import path from "node:path";
|
|
|
|
import {
|
|
main,
|
|
measureCommands,
|
|
readQuarantineCount,
|
|
renderReport,
|
|
timingSnapshotNotes,
|
|
topSlowestFiles,
|
|
} from "../test-velocity-baseline.mjs";
|
|
|
|
function nullStream() {
|
|
return { write() {} };
|
|
}
|
|
|
|
function tempRoot() {
|
|
return mkdtempSync(path.join(tmpdir(), "fusion-test-velocity-"));
|
|
}
|
|
|
|
function makeTimings(count = 25) {
|
|
const files = {};
|
|
for (let index = 0; index < count; index += 1) {
|
|
files[`packages/a/src/__tests__/case-${String(index).padStart(2, "0")}.test.ts`] = 100 + index;
|
|
}
|
|
files["packages/a/src/__tests__/tie-z.test.ts"] = 500;
|
|
files["packages/a/src/__tests__/tie-a.test.ts"] = 500;
|
|
return {
|
|
packages: {
|
|
"@pkg/b": {
|
|
files: {
|
|
"packages/b/src/__tests__/winner.test.ts": 1000,
|
|
},
|
|
},
|
|
"@pkg/a": { files },
|
|
},
|
|
};
|
|
}
|
|
|
|
function writeJson(rootDir, relativePath, value) {
|
|
const fullPath = path.join(rootDir, relativePath);
|
|
mkdirSync(path.dirname(fullPath), { recursive: true });
|
|
writeFileSync(fullPath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
|
|
}
|
|
|
|
describe("topSlowestFiles", () => {
|
|
it("returns exactly 20 rows in descending duration order with package attribution and stable ties", () => {
|
|
const rows = topSlowestFiles(makeTimings(), 20);
|
|
|
|
assert.equal(rows.length, 20);
|
|
assert.deepEqual(rows[0], {
|
|
file: "packages/b/src/__tests__/winner.test.ts",
|
|
ms: 1000,
|
|
package: "@pkg/b",
|
|
});
|
|
assert.deepEqual(rows.slice(1, 3).map((row) => row.file), [
|
|
"packages/a/src/__tests__/tie-a.test.ts",
|
|
"packages/a/src/__tests__/tie-z.test.ts",
|
|
]);
|
|
assert.ok(rows.every((row, index) => index === 0 || rows[index - 1].ms >= row.ms));
|
|
assert.equal(rows[1].package, "@pkg/a");
|
|
});
|
|
});
|
|
|
|
describe("timingSnapshotNotes", () => {
|
|
it("warns when slowest-file rows are stale or point at missing paths", () => {
|
|
const rootDir = tempRoot();
|
|
try {
|
|
const notes = timingSnapshotNotes({
|
|
rootDir,
|
|
now: new Date("2026-06-23T12:00:00.000Z"),
|
|
timingSnapshotCapturedAt: "2026-06-03T12:00:00.000Z",
|
|
slowest: [
|
|
{ file: "packages/engine/src/__tests__/renamed.test.ts", package: "@fusion/engine", ms: 13_900 },
|
|
],
|
|
});
|
|
|
|
assert.equal(notes.length, 2);
|
|
assert.match(notes[0], /20 days old/);
|
|
assert.match(notes[1], /renamed\.test\.ts/);
|
|
assert.match(notes[1], /Refresh scripts\/test-timings\.json/);
|
|
} finally {
|
|
rmSync(rootDir, { recursive: true, force: true });
|
|
}
|
|
});
|
|
});
|
|
|
|
describe("readQuarantineCount", () => {
|
|
it("counts entries by age bucket and flags deletion-due quarantines after 14 days", () => {
|
|
const result = readQuarantineCount(
|
|
{
|
|
entries: [
|
|
{ file: "fresh.test.ts", quarantinedAt: "2026-06-15" },
|
|
{ file: "warning.test.ts", quarantinedAt: "2026-06-08" },
|
|
{ file: "due.test.ts", quarantinedAt: "2026-06-01" },
|
|
{ file: "unknown.test.ts", quarantinedAt: "not-a-date" },
|
|
],
|
|
},
|
|
{ now: new Date("2026-06-17T12:00:00.000Z") },
|
|
);
|
|
|
|
assert.equal(result.total, 4);
|
|
assert.deepEqual(result.byAgeBucket, {
|
|
"0-6d": 1,
|
|
"7-13d": 1,
|
|
deletionDue: 1,
|
|
unknown: 1,
|
|
});
|
|
assert.deepEqual(result.deletionDueEntries, [
|
|
{ file: "due.test.ts", quarantinedAt: "2026-06-01", ageDays: 16 },
|
|
]);
|
|
});
|
|
});
|
|
|
|
describe("measureCommands", () => {
|
|
it("runs the build preflight before measured lanes and excludes setup time from lane ms", async () => {
|
|
const calls = [];
|
|
let built = false;
|
|
const result = await measureCommands({
|
|
timeoutMs: 10_000,
|
|
cwd: "/repo",
|
|
stdout: nullStream(),
|
|
stderr: nullStream(),
|
|
commandRunner: async (measurement) => {
|
|
calls.push(measurement.command === "pnpm" ? `pnpm ${measurement.args.join(" ")}` : measurement.label);
|
|
if (measurement.args[0] === "build") {
|
|
built = true;
|
|
return { ms: 50_000, failure: null };
|
|
}
|
|
if (measurement.args[0] === "smoke:boot") {
|
|
assert.equal(built, true, "boot smoke should only run after the build preflight creates CLI dist");
|
|
return { ms: 406, failure: null };
|
|
}
|
|
if (measurement.args[0] === "test") return { ms: 7_300, failure: null };
|
|
return { ms: 12_000, failure: null };
|
|
},
|
|
});
|
|
|
|
assert.deepEqual(calls, ["pnpm build", "pnpm test:gate", "pnpm smoke:boot", "pnpm test"]);
|
|
assert.equal(result.bootSmokeMs, 406);
|
|
assert.equal(result.testMs, 7_300);
|
|
assert.deepEqual(result.measurementFailures, []);
|
|
});
|
|
|
|
it("records preflight failure instead of silently attributing missing build output to boot smoke", async () => {
|
|
const calls = [];
|
|
const result = await measureCommands({
|
|
timeoutMs: 10_000,
|
|
cwd: "/repo",
|
|
stdout: nullStream(),
|
|
stderr: nullStream(),
|
|
commandRunner: async (measurement) => {
|
|
calls.push(`pnpm ${measurement.args.join(" ")}`);
|
|
return {
|
|
ms: null,
|
|
failure: { label: measurement.label, status: "exit 1 after 400ms" },
|
|
};
|
|
},
|
|
});
|
|
|
|
assert.deepEqual(calls, ["pnpm build"]);
|
|
assert.equal(result.gateMs, undefined);
|
|
assert.equal(result.bootSmokeMs, undefined);
|
|
assert.equal(result.testMs, undefined);
|
|
assert.deepEqual(result.measurementFailures, [
|
|
{ label: "Build preflight (`pnpm build`)", status: "exit 1 after 400ms" },
|
|
]);
|
|
});
|
|
|
|
it("honors --skip-build-preflight-style opt out while still measuring lanes", async () => {
|
|
const calls = [];
|
|
const result = await measureCommands({
|
|
timeoutMs: 10_000,
|
|
cwd: "/repo",
|
|
stdout: nullStream(),
|
|
stderr: nullStream(),
|
|
skipBuildPreflight: true,
|
|
commandRunner: async (measurement) => {
|
|
calls.push(`pnpm ${measurement.args.join(" ")}`);
|
|
return { ms: 100 + calls.length, failure: null };
|
|
},
|
|
});
|
|
|
|
assert.deepEqual(calls, ["pnpm test:gate", "pnpm smoke:boot", "pnpm test"]);
|
|
assert.equal(result.gateMs, 101);
|
|
assert.equal(result.bootSmokeMs, 102);
|
|
assert.equal(result.testMs, 103);
|
|
});
|
|
});
|
|
|
|
describe("main", () => {
|
|
it("keeps report-only regeneration cheap by invoking neither preflight nor suites", async () => {
|
|
const rootDir = tempRoot();
|
|
try {
|
|
const exitCode = await main([], {
|
|
rootDir,
|
|
stdout: nullStream(),
|
|
stderr: nullStream(),
|
|
now: new Date("2026-06-21T12:00:00.000Z"),
|
|
commandRunner: async (measurement) => {
|
|
throw new Error(`unexpected command: ${measurement.label}`);
|
|
},
|
|
});
|
|
|
|
assert.equal(exitCode, 0);
|
|
const report = readFileSync(path.join(rootDir, "docs/test-velocity-baseline.md"), "utf8");
|
|
assert.match(report, /Report-only regeneration is cheap and does not run any suite/);
|
|
} finally {
|
|
rmSync(rootDir, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
it("renders zero quarantine figures from an empty live ledger in report-only mode", async () => {
|
|
const rootDir = tempRoot();
|
|
try {
|
|
writeJson(rootDir, "scripts/lib/test-quarantine.json", { entries: [] });
|
|
writeJson(rootDir, "scripts/test-velocity-history.json", {
|
|
entries: [
|
|
{
|
|
capturedAt: "2026-06-18T12:00:00.000Z",
|
|
gateMs: 10_000,
|
|
bootSmokeMs: 20_000,
|
|
testMs: 30_000,
|
|
quarantineCount: 0,
|
|
slowestTop20: [{ file: "packages/a/src/__tests__/slow.test.ts", package: "@pkg/a", ms: 9_000 }],
|
|
measurementFailures: [],
|
|
},
|
|
{
|
|
capturedAt: "2026-06-25T12:00:00.000Z",
|
|
gateMs: 7_000,
|
|
bootSmokeMs: 18_000,
|
|
testMs: 25_000,
|
|
quarantineCount: 0,
|
|
slowestTop20: [{ file: "packages/a/src/__tests__/slow.test.ts", package: "@pkg/a", ms: 9_000 }],
|
|
measurementFailures: [],
|
|
},
|
|
],
|
|
});
|
|
mkdirSync(path.join(rootDir, "docs"), { recursive: true });
|
|
writeFileSync(
|
|
path.join(rootDir, "docs/test-velocity-baseline.md"),
|
|
"| Quarantine / flake count | 3 | +3 |\n| 0-6 days | 3 |\nquarantine ledger 3 (+3)\n",
|
|
"utf8",
|
|
);
|
|
|
|
const exitCode = await main(["--write-report"], {
|
|
rootDir,
|
|
stdout: nullStream(),
|
|
stderr: nullStream(),
|
|
now: new Date("2026-06-26T12:00:00.000Z"),
|
|
commandRunner: async (measurement) => {
|
|
throw new Error(`unexpected command: ${measurement.label}`);
|
|
},
|
|
});
|
|
|
|
assert.equal(exitCode, 0);
|
|
const report = readFileSync(path.join(rootDir, "docs/test-velocity-baseline.md"), "utf8");
|
|
assert.match(report, /\| Quarantine \/ flake count \| 0 \| 0 \|/);
|
|
assert.match(report, /\| Deletion-due quarantines \| 0 \| n\/a \|/);
|
|
assert.match(report, /\| 0-6 days \| 0 \|/);
|
|
assert.match(report, /\| 7-13 days \| 0 \|/);
|
|
assert.match(report, /\| deletion due \(>=14 days\) \| 0 \|/);
|
|
assert.match(report, /\| unknown\/future \| 0 \|/);
|
|
assert.match(report, /\| — \| — \| — \|/);
|
|
assert.match(report, /\| Latest \| 2026-06-25T12:00:00\.000Z \| 7\.0s \| 18\.0s \| 25\.0s \| 0 \|/);
|
|
assert.match(report, /\| Delta \| — \| -3\.0s \| -2\.0s \| -5\.0s \| 0 \|/);
|
|
assert.match(report, /quarantine ledger 0 \(0\)/);
|
|
assert.match(report, /Deletion-due quarantines: 0\./);
|
|
assert.doesNotMatch(report, /\| Quarantine \/ flake count \| [1-9]/);
|
|
assert.doesNotMatch(report, /\| (?:0-6 days|7-13 days|deletion due \(>=14 days\)|unknown\/future) \| [1-9]/);
|
|
assert.doesNotMatch(report, /quarantine ledger [1-9]/);
|
|
} finally {
|
|
rmSync(rootDir, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
it("honors --skip-build-preflight while still measuring lanes", async () => {
|
|
const rootDir = tempRoot();
|
|
const calls = [];
|
|
try {
|
|
const exitCode = await main(["--measure", "--write-report", "--skip-build-preflight"], {
|
|
rootDir,
|
|
stdout: nullStream(),
|
|
stderr: nullStream(),
|
|
now: new Date("2026-06-21T12:00:00.000Z"),
|
|
commandRunner: async (measurement) => {
|
|
calls.push(`pnpm ${measurement.args.join(" ")}`);
|
|
return { ms: 1_000 * calls.length, failure: null };
|
|
},
|
|
});
|
|
|
|
assert.equal(exitCode, 0);
|
|
assert.deepEqual(calls, ["pnpm test:gate", "pnpm smoke:boot", "pnpm test"]);
|
|
const report = readFileSync(path.join(rootDir, "docs/test-velocity-baseline.md"), "utf8");
|
|
assert.match(report, /Boot smoke wall-time \(`pnpm smoke:boot`\) \| 2\.0s/);
|
|
} finally {
|
|
rmSync(rootDir, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
it("records preflight failure in the generated measurement failures section", async () => {
|
|
const rootDir = tempRoot();
|
|
try {
|
|
const exitCode = await main(["--measure", "--write-report"], {
|
|
rootDir,
|
|
stdout: nullStream(),
|
|
stderr: nullStream(),
|
|
now: new Date("2026-06-21T12:00:00.000Z"),
|
|
commandRunner: async (measurement) => ({
|
|
ms: null,
|
|
failure: { label: measurement.label, status: "exit 2 after 1.0s" },
|
|
}),
|
|
});
|
|
|
|
assert.equal(exitCode, 0);
|
|
const report = readFileSync(path.join(rootDir, "docs/test-velocity-baseline.md"), "utf8");
|
|
assert.match(report, /- Build preflight \(`pnpm build`\): exit 2 after 1\.0s/);
|
|
assert.doesNotMatch(report, /Boot smoke \(`pnpm smoke:boot`\):/);
|
|
} finally {
|
|
rmSync(rootDir, { recursive: true, force: true });
|
|
}
|
|
});
|
|
});
|
|
|
|
describe("renderReport", () => {
|
|
it("includes metrics, slowest rows, quarantine count, and previous-run deltas", () => {
|
|
const report = renderReport({
|
|
gateMs: 12_000,
|
|
bootSmokeMs: 2_000,
|
|
testMs: 45_000,
|
|
capturedAt: "2026-06-17T12:00:00.000Z",
|
|
previous: {
|
|
capturedAt: "2026-06-10T12:00:00.000Z",
|
|
gateMs: 10_000,
|
|
bootSmokeMs: 3_000,
|
|
testMs: 50_000,
|
|
quarantineCount: 3,
|
|
},
|
|
slowest: [
|
|
{ file: "packages/a/src/__tests__/slow.test.ts", package: "@pkg/a", ms: 3210 },
|
|
],
|
|
quarantine: {
|
|
total: 2,
|
|
byAgeBucket: { "0-6d": 1, "7-13d": 1, deletionDue: 0, unknown: 0 },
|
|
deletionDueEntries: [],
|
|
deletionDueCount: 0,
|
|
},
|
|
});
|
|
|
|
assert.match(report, /\| Merge gate wall-time \(`pnpm test:gate`\) \| 12\.0s \| \+2\.0s \|/);
|
|
assert.match(report, /\| Boot smoke wall-time \(`pnpm smoke:boot`\) \| 2\.0s \| -1\.0s \|/);
|
|
assert.match(report, /\| Changed-only test wall-time \(`pnpm test`\) \| 45\.0s \| -5\.0s \|/);
|
|
assert.match(report, /\| Quarantine \/ flake count \| 2 \| -1 \|/);
|
|
assert.match(report, /`packages\/a\/src\/__tests__\/slow\.test\.ts` \| @pkg\/a \| 3\.2s/);
|
|
assert.match(report, /FN-6612 weekly test velocity: gate 12\.0s \(\+2\.0s\)/);
|
|
assert.match(report, /## Timing snapshot notes/);
|
|
assert.match(report, /No stale or missing timing metadata detected/);
|
|
});
|
|
|
|
it("renders seed-baseline trend placeholders when there is no previous entry", () => {
|
|
const report = renderReport({
|
|
gateMs: 1_000,
|
|
bootSmokeMs: null,
|
|
testMs: 2_000,
|
|
capturedAt: "2026-06-17T12:00:00.000Z",
|
|
slowest: [],
|
|
quarantine: { total: 0, byAgeBucket: {}, deletionDueEntries: [], deletionDueCount: 0 },
|
|
});
|
|
|
|
assert.match(report, /\| Previous \| _\(seed baseline\)_ \| — \| — \| — \| — \|/);
|
|
assert.match(report, /\| Delta \| — \| n\/a \| n\/a \| n\/a \| n\/a \|/);
|
|
});
|
|
});
|