문제
capability 제거 드릴의 fixture도 test:unit을 돈다. 앞 커밋들이 더한 가드
테스트 두 개가 그 안에서 실패했다.
- removal-fixture.test.ts: 문서 테스트 파일과 드릴 스크립트를 이름으로 읽는데,
fixture는 문서 테스트를 지우고(02-06) 드릴은 자기 스크립트를 지운다.
browser-file-storage·realtime 드릴이 이 두 건으로 `test` 검사에서 실패했다.
- feature-scaffold-drill: 제거 드릴이 자기 capability 명령을 계약에서 빼면,
scaffold 드릴 제외 목록의 그 스크립트가 "merge 단계에 없음"으로 실패한다.
고른 방법
- 문서 테스트는 "문서가 있는 곳에만 있다"를 단언한다(저장소: 둘 다 있음,
capability fixture: 둘 다 없음).
- 드릴 목록은 scripts/test-*.ts 중 removal-fixture.ts를 import하는 파일로 찾고,
sample·scaffold 드릴이 그 안에 있는지 확인한다.
- 제외 목록이 낡았다는 판정은 계약에 있으나 merge 단계 밖인 명령에만 한다.
계약에서 아예 빠진 명령(제거 드릴이 정리한 capability)은 낡은 것이 아니다.
위험·한계
- 계약에서 지운 스크립트의 제외 항목이 저장소에 남아도 이 검사는 알리지
않는다. 남아도 아무 명령을 숨기지 않는다.
검증
- 수정 전 snapshot(0edc3fc)에서 test:browser-file-storage-removal,
test:realtime-removal 모두 이 두 테스트로 exit 1(ENOENT).
- 수정 뒤 removal-fixture·feature-scaffold-drill 18건 통과, eslint·tsc 통과.
Refs: docs/reviews/2026-11-03-maturity-review/02-adapters-browser-files-cache.md 02-06
Refs: docs/reviews/2026-11-03-maturity-review/12-guardrails-ci.md 12-02
144 lines
6.2 KiB
TypeScript
144 lines
6.2 KiB
TypeScript
import { spawnSync } from "node:child_process";
|
|
|
|
import type { CiGateContract } from "../contracts/ci-gates.ts";
|
|
import { classifyGateStepResult, type GateStepExpectation } from "./ci-step-result.ts";
|
|
import { FIXTURE_PNPM_ENVIRONMENT } from "./fixture-node-modules.ts";
|
|
import type { RemovalCheck } from "./removal-fixture.ts";
|
|
|
|
/**
|
|
* 1103/12-02. test:feature-scaffold proves that a feature from
|
|
* `create:feature` passes the merge gates. It ran a hand-kept list of 15
|
|
* commands while the merge stage has 88, so a template change that broke a
|
|
* generated feature in any other merge command passed FE-GATE-020.
|
|
*
|
|
* The drill now runs the merge stage of the copy's config/ci/gates.json, in
|
|
* stage order, each command once. A command added to the merge stage runs here
|
|
* unless this list names it, with the reason it cannot run in the drill.
|
|
*/
|
|
const BROWSER =
|
|
"needs Playwright browsers. FE-GATE-020 runs in a merge job without them " +
|
|
"(merge_gate matrix browser: false). The generated routes in the browser " +
|
|
"gates are reviewed as 1103/12-01 and 12-03.";
|
|
const DRILL =
|
|
"a removal drill copies the repository again. The drill runs the generated " +
|
|
"feature's own removal instead (feature-removal).";
|
|
|
|
export const SCAFFOLD_DRILL_EXCLUDED_SCRIPTS: Readonly<Record<string, string>> = Object.freeze({
|
|
"verify:lockfile":
|
|
"runs pnpm install, which writes into the node_modules the copy links from " +
|
|
"the repository (scripts/lib/fixture-node-modules.ts).",
|
|
"test:e2e": BROWSER,
|
|
"test:browser-capabilities": BROWSER,
|
|
"verify:browser-capability-evidence": `reads the test:browser-capabilities results; ${BROWSER}`,
|
|
"test:storybook": BROWSER,
|
|
"test:visual": BROWSER,
|
|
"check:test-evidence:browser": `reads the browser gates' results; ${BROWSER}`,
|
|
"test:a11y": BROWSER,
|
|
"test:system":
|
|
"needs the CI runner's bubblewrap, systemd and cgroup v2 " +
|
|
"(scripts/check-system-test-prerequisites.ts). It tests the provider " +
|
|
"sandbox, which a feature does not reach.",
|
|
"test:sample-removal": DRILL,
|
|
"test:feature-scaffold": "is this drill.",
|
|
"test:optional-recipe-removal": DRILL,
|
|
"test:browser-file-storage-removal": DRILL,
|
|
"test:realtime-removal": DRILL,
|
|
});
|
|
|
|
export type ScaffoldDrillCommand = Readonly<{
|
|
/** `<gate>:<command id>`, the check's name in the drill report. */
|
|
name: string;
|
|
script: string;
|
|
args: readonly string[];
|
|
expectation: GateStepExpectation;
|
|
}>;
|
|
|
|
type ContractShape = Pick<CiGateContract, "commands" | "gates" | "stages">;
|
|
|
|
export function scaffoldDrillCommands(
|
|
contract: ContractShape,
|
|
excluded: Readonly<Record<string, string>> = SCAFFOLD_DRILL_EXCLUDED_SCRIPTS,
|
|
): readonly ScaffoldDrillCommand[] {
|
|
const merge = contract.stages.find(({ id }) => id === "merge");
|
|
if (!merge) throw new TypeError("the CI contract has no merge stage");
|
|
const commands = new Map(contract.commands.map((command) => [command.id, command]));
|
|
const mergeScripts = new Set<string>();
|
|
const seen = new Set<string>();
|
|
const selected: ScaffoldDrillCommand[] = [];
|
|
for (const gateId of merge.gateIds) {
|
|
const gate = contract.gates.find(({ id }) => id === gateId);
|
|
if (!gate) throw new TypeError(`the merge stage names an undefined gate: ${gateId}`);
|
|
for (const commandId of gate.commandIds) {
|
|
const command = commands.get(commandId);
|
|
if (!command) throw new TypeError(`${gateId} names an undefined command: ${commandId}`);
|
|
mergeScripts.add(command.script);
|
|
if (seen.has(commandId) || Object.hasOwn(excluded, command.script)) continue;
|
|
seen.add(commandId);
|
|
selected.push(Object.freeze({
|
|
name: `${gateId}:${commandId}`,
|
|
script: command.script,
|
|
args: Object.freeze([...(command.args ?? [])]),
|
|
expectation: command.expect === "pass"
|
|
? Object.freeze({ kind: "pass" as const })
|
|
: Object.freeze({
|
|
kind: "fail" as const,
|
|
expectedExitCode: command.expectedExitCode ?? 1,
|
|
expectedDiagnosticId: command.expectedDiagnosticId ?? "",
|
|
}),
|
|
}));
|
|
}
|
|
}
|
|
// An exclusion for a command that moved out of the merge stage would hide
|
|
// nothing today and silently drop it if it came back. A command the contract
|
|
// no longer has at all (a removal drill pruned its capability) is not stale.
|
|
const contractScripts = new Set(contract.commands.map(({ script }) => script));
|
|
const stale = Object.keys(excluded).filter(
|
|
(script) => contractScripts.has(script) && !mergeScripts.has(script),
|
|
);
|
|
if (stale.length > 0) {
|
|
throw new TypeError(
|
|
`the scaffold drill excludes scripts the contract runs outside the merge stage: ${stale.join(", ")}`,
|
|
);
|
|
}
|
|
return Object.freeze(selected);
|
|
}
|
|
|
|
/**
|
|
* Runs one merge command in the fixture. A negative fixture command passes
|
|
* only with its registered exit code and diagnostic, as in run-ci-gate.ts.
|
|
*/
|
|
export function runScaffoldDrillCommand(
|
|
command: ScaffoldDrillCommand,
|
|
root: string,
|
|
pnpmCli: string,
|
|
): RemovalCheck {
|
|
const capture = command.expectation.kind === "fail";
|
|
const result = spawnSync(process.execPath, [pnpmCli, command.script, ...command.args], {
|
|
cwd: root,
|
|
encoding: "utf8",
|
|
stdio: capture ? "pipe" : "inherit",
|
|
maxBuffer: 64 * 1024 * 1024,
|
|
env: { ...process.env, ...FIXTURE_PNPM_ENVIRONMENT },
|
|
});
|
|
if (capture) {
|
|
process.stdout.write(result.stdout ?? "");
|
|
process.stderr.write(result.stderr ?? "");
|
|
}
|
|
const classification = classifyGateStepResult(command.expectation, {
|
|
status: result.status,
|
|
signal: result.signal,
|
|
stdout: result.stdout ?? "",
|
|
stderr: result.stderr ?? "",
|
|
...(result.error ? { error: { code: (result.error as NodeJS.ErrnoException).code } } : {}),
|
|
});
|
|
if (classification.expectationMet) return { name: command.name, passed: true };
|
|
const invocation = `corepack pnpm ${[command.script, ...command.args].join(" ")}`;
|
|
return {
|
|
name: command.name,
|
|
passed: false,
|
|
failure: command.expectation.kind === "fail"
|
|
? `${invocation}: ${classification.kind}, expected exit ${command.expectation.expectedExitCode} with ${JSON.stringify(command.expectation.expectedDiagnosticId)}, got exit ${result.status ?? result.signal}`
|
|
: `${invocation} exited ${result.status ?? result.signal ?? "on a spawn error"}`,
|
|
};
|
|
}
|