frontend-quality-gates / merge / static checks (pull_request) Canceled after 0s
frontend-quality-gates / merge / tests (pull_request) Canceled after 0s
frontend-quality-gates / merge / browser tests (pull_request) Canceled after 0s
frontend-quality-gates / FE-GATE-014 / config-compatibility (pull_request) Canceled after 0s
frontend-quality-gates / FE-GATE-028 / manual-accessibility-review (pull_request) Canceled after 0s
frontend-quality-gates / FE-GATE-026 / lab-performance (pull_request) Canceled after 0s
frontend-quality-gates / FE-GATE-015 / immutable-release-candidate (pull_request) Canceled after 0s
frontend-quality-gates / external-vulnerability-provider (pull_request) Canceled after 0s
frontend-quality-gates / external-provenance-provider (pull_request) Canceled after 0s
frontend-quality-gates / promote-verified-immutable-candidate (pull_request) Canceled after 0s
frontend-quality-gates / deploy-promoted-release (pull_request) Canceled after 0s
frontend-quality-gates / FE-GATE-019 / hosting-header (pull_request) Canceled after 0s
frontend-quality-gates / FE-GATE-021 / runbook-boot-config (pull_request) Canceled after 0s
frontend-quality-gates / FE-GATE-022 / runbook-chunk-mismatch (pull_request) Canceled after 0s
frontend-quality-gates / FE-GATE-023 / runbook-api-degradation (pull_request) Canceled after 0s
frontend-quality-gates / FE-GATE-024 / runbook-telemetry (pull_request) Canceled after 0s
frontend-quality-gates / FE-GATE-025 / runbook-release-rollback (pull_request) Canceled after 0s
frontend-quality-gates / FE-GATE-018 / field-web-vitals (pull_request) Canceled after 0s
frontend-quality-gates / FE-GATE-017 / diagram-review (pull_request) Canceled after 0s
frontend-quality-gates / main / checker self-tests (pull_request) Canceled after 0s
문제: vitest는 coverage include·exclude를 모듈의 절대 경로에 picomatch
`contains: true`로 맞춘다. 그래서 `src/**/*.{ts,tsx}`가 경로 어디에서나
맞는다. checkout이 이름이 `src`로 끝나는 폴더(`~/work/app-src/`)에
있으면 `vite.config.ts`·`scripts/**` 같은 루트 파일이 coverage에 들어가
risk-coverage가 저장소 목록 밖의 행으로 실패한다(tech-log 동기화 때
desktop에서 본 일). CI 경로에는 `src`가 없어 runner에서는 안 보였다.
고른 방법: `scripts/lib/coverage-scope.ts`의 `rootAnchoredGlobs`가
패턴 앞에 루트를 붙인다. 루트는 vitest의 glob 라이브러리(tinyglobby
0.2)가 cwd를 escape하는 식 그대로 escape해, 괄호 같은 glob 문자가 든
루트도 자기 자신에만 맞고 안 불린 파일 glob도 `src/...`로 풀린다.
`vitest.config.ts`와 `check:v8-coverage-counter-semantics`의 자식
설정이 이 함수를 쓴다.
- 막는 시험: counter-semantics 검사가 fixture를
`checkout (copy)-src/` 아래로 복사하고, fixture 시험이 `src/` 밖
모듈(`outside-src.ts`)도 불러온다. 고정이 빠지면 그 모듈이 행으로
들어와 행 집합 검사가 실패한다. 이 검사는 test:coverage 첫 단계에서
이미 자식 vitest를 띄우므로 프로세스가 늘지 않는다. 단위 시험은
repo 설정의 모든 패턴이 루트로 시작하는지와 escape를 본다.
- 버린 대안: picomatch로 vitest의 판정을 흉내 내는 단위 시험. 직접
의존성이 아니고, vitest가 옵션을 바꾸면 거짓 통과한다.
위험·한계: Windows 루트는 `/`로 바꾼 뒤 같은 식으로 escape한다.
올바른 Windows 경로에서는 tinyglobby의 Windows escape와 결과가 같다고
보았지만 Windows에서 돌려 보지는 않았다.
검증(desktop): coverage-scope·v8-coverage-counter-semantics 시험 통과,
check:v8-coverage-counter-semantics rc=0. 변이: 자식 설정을 예전
`["src/**/*.ts"]`로 되돌리면 같은 검사가 `additional: outside-src.ts`로
rc=1. check:types·eslint rc=0. 로그 /tmp/claude-gates/w2fe2-cov1/.
247 lines
8.0 KiB
TypeScript
247 lines
8.0 KiB
TypeScript
import { execFile } from "node:child_process";
|
|
import {
|
|
access,
|
|
mkdtemp,
|
|
readFile,
|
|
rm,
|
|
} from "node:fs/promises";
|
|
import { tmpdir } from "node:os";
|
|
import path from "node:path";
|
|
import { promisify } from "node:util";
|
|
|
|
import { afterEach, describe, expect, it } from "vitest";
|
|
|
|
import {
|
|
assertV8CoverageCounterSemantics,
|
|
checkV8CoverageCounterSemantics,
|
|
} from "../../scripts/lib/v8-coverage-counter-semantics.ts";
|
|
import { rootAnchoredGlobs } from "../../scripts/lib/coverage-scope.ts";
|
|
import { childProcessTimeout } from "../helpers/child-process-timeout.ts";
|
|
|
|
const roots: string[] = [];
|
|
const execFileAsync = promisify(execFile);
|
|
const zeroCounter = Object.freeze({
|
|
total: 0,
|
|
covered: 0,
|
|
skipped: 0,
|
|
pct: 100,
|
|
});
|
|
const zeroMetrics = Object.freeze({
|
|
lines: zeroCounter,
|
|
statements: zeroCounter,
|
|
functions: zeroCounter,
|
|
branches: zeroCounter,
|
|
});
|
|
const counterlessPaths = Object.freeze([
|
|
"src/import-empty.ts",
|
|
"src/import-side-effect.ts",
|
|
"src/import-type-empty.ts",
|
|
"src/import-value.ts",
|
|
"src/reexport-named.ts",
|
|
"src/reexport-star.ts",
|
|
"src/type-only.ts",
|
|
]);
|
|
|
|
function fixtureSummary(root: string): Record<string, unknown> {
|
|
return Object.fromEntries([
|
|
[
|
|
"total",
|
|
{
|
|
lines: { total: 1, covered: 1, skipped: 0, pct: 100 },
|
|
statements: { total: 1, covered: 1, skipped: 0, pct: 100 },
|
|
functions: zeroCounter,
|
|
branches: zeroCounter,
|
|
},
|
|
],
|
|
[
|
|
path.join(root, "src/runtime.ts"),
|
|
{
|
|
lines: { total: 1, covered: 1, skipped: 0, pct: 100 },
|
|
statements: { total: 1, covered: 1, skipped: 0, pct: 100 },
|
|
functions: zeroCounter,
|
|
branches: zeroCounter,
|
|
},
|
|
],
|
|
...counterlessPaths.map((modulePath) => [path.join(root, modulePath), zeroMetrics]),
|
|
]);
|
|
}
|
|
|
|
async function captureFailure(operation: Promise<unknown>): Promise<Error> {
|
|
try {
|
|
await operation;
|
|
} catch (error) {
|
|
if (error instanceof Error) return error;
|
|
throw error;
|
|
}
|
|
throw new Error("expected operation to fail");
|
|
}
|
|
|
|
afterEach(async () => {
|
|
await Promise.all(
|
|
roots.splice(0).map((root) => rm(root, { recursive: true, force: true })),
|
|
);
|
|
});
|
|
|
|
describe("V8 coverage counter semantics", () => {
|
|
it("accepts one counter-bearing row and seven exact counterless rows", () => {
|
|
const root = "/owned-fixture";
|
|
|
|
expect(assertV8CoverageCounterSemantics(fixtureSummary(root), root)).toEqual({
|
|
counterBearingModules: ["src/runtime.ts"],
|
|
counterlessModules: counterlessPaths,
|
|
});
|
|
});
|
|
|
|
it("rejects a missing or additional producer row", () => {
|
|
const root = "/owned-fixture";
|
|
const missing = fixtureSummary(root);
|
|
delete missing[path.join(root, "src/import-empty.ts")];
|
|
expect(() => assertV8CoverageCounterSemantics(missing, root)).toThrow(
|
|
/row set.*missing.*import-empty/u,
|
|
);
|
|
|
|
const additional = fixtureSummary(root);
|
|
additional[path.join(root, "src/unexpected.ts")] = zeroMetrics;
|
|
expect(() => assertV8CoverageCounterSemantics(additional, root)).toThrow(
|
|
/row set.*additional.*unexpected/u,
|
|
);
|
|
});
|
|
|
|
it("rejects counterless nonzero and runtime all-zero drift", () => {
|
|
const root = "/owned-fixture";
|
|
const counterlessDrift = fixtureSummary(root);
|
|
counterlessDrift[path.join(root, "src/import-value.ts")] = {
|
|
...zeroMetrics,
|
|
lines: { total: 1, covered: 1, skipped: 0, pct: 100 },
|
|
};
|
|
expect(() =>
|
|
assertV8CoverageCounterSemantics(counterlessDrift, root),
|
|
).toThrow(/counterless.*exact all-zero.*import-value/u);
|
|
|
|
const runtimeDrift = fixtureSummary(root);
|
|
runtimeDrift[path.join(root, "src/runtime.ts")] = zeroMetrics;
|
|
expect(() => assertV8CoverageCounterSemantics(runtimeDrift, root)).toThrow(
|
|
/runtime.*counter-bearing/u,
|
|
);
|
|
});
|
|
|
|
it("rejects producer percentages that do not exactly match their counts", () => {
|
|
const root = "/owned-fixture";
|
|
const totalDrift = fixtureSummary(root);
|
|
totalDrift["total"] = {
|
|
...totalDrift["total"] as Record<string, unknown>,
|
|
lines: { total: 1, covered: 1, skipped: 0, pct: -500 },
|
|
};
|
|
expect(() => assertV8CoverageCounterSemantics(totalDrift, root)).toThrow(
|
|
/total\.lines.*invalid coverage counters/u,
|
|
);
|
|
|
|
const runtimeDrift = fixtureSummary(root);
|
|
runtimeDrift[path.join(root, "src/runtime.ts")] = {
|
|
...runtimeDrift[path.join(root, "src/runtime.ts")] as Record<
|
|
string,
|
|
unknown
|
|
>,
|
|
lines: { total: 1, covered: 1, skipped: 0, pct: 99.99 },
|
|
};
|
|
expect(() => assertV8CoverageCounterSemantics(runtimeDrift, root)).toThrow(
|
|
/runtime.*lines.*invalid coverage counters/u,
|
|
);
|
|
});
|
|
|
|
it("bounds child diagnostics and cleans its owned root on child exit", async () => {
|
|
const ownedRoot = await mkdtemp(path.join(tmpdir(), "v8-counter-exit-"));
|
|
roots.push(ownedRoot);
|
|
const childFailure = Object.assign(new Error("child exit 1"), {
|
|
stdout: "o".repeat(20_000),
|
|
stderr: "e".repeat(20_000),
|
|
});
|
|
|
|
const failure = await captureFailure(
|
|
checkV8CoverageCounterSemantics({
|
|
repositoryRoot: process.cwd(),
|
|
createOwnedRoot: async () => ownedRoot,
|
|
runVitest: async () => Promise.reject(childFailure),
|
|
}),
|
|
);
|
|
|
|
expect(failure.message).toMatch(/child Vitest failed/u);
|
|
expect(failure.message).toMatch(/truncated/u);
|
|
expect(failure.message.length).toBeLessThan(5_000);
|
|
await expect(access(ownedRoot)).rejects.toMatchObject({ code: "ENOENT" });
|
|
});
|
|
|
|
it("fails closed on a missing summary and cleans its owned root", async () => {
|
|
const ownedRoot = await mkdtemp(path.join(tmpdir(), "v8-counter-summary-"));
|
|
roots.push(ownedRoot);
|
|
|
|
await expect(
|
|
checkV8CoverageCounterSemantics({
|
|
repositoryRoot: process.cwd(),
|
|
createOwnedRoot: async () => ownedRoot,
|
|
runVitest: async () => ({ stdout: "", stderr: "" }),
|
|
}),
|
|
).rejects.toThrow(/coverage summary is missing/u);
|
|
await expect(access(ownedRoot)).rejects.toMatchObject({ code: "ENOENT" });
|
|
});
|
|
|
|
it("copies the fixture under a src-suffixed folder with root-anchored patterns", async () => {
|
|
const ownedRoot = await mkdtemp(path.join(tmpdir(), "v8-counter-scope-"));
|
|
roots.push(ownedRoot);
|
|
let child: { fixtureRoot: string; config: string } | undefined;
|
|
|
|
await expect(
|
|
checkV8CoverageCounterSemantics({
|
|
repositoryRoot: process.cwd(),
|
|
createOwnedRoot: async () => ownedRoot,
|
|
runVitest: async (input) => {
|
|
child = {
|
|
fixtureRoot: input.fixtureRoot,
|
|
config: await readFile(input.configPath, "utf8"),
|
|
};
|
|
await access(path.join(input.fixtureRoot, "outside-src.ts"));
|
|
return { stdout: "", stderr: "" };
|
|
},
|
|
}),
|
|
).rejects.toThrow(/coverage summary is missing/u);
|
|
|
|
expect(child?.fixtureRoot.startsWith(`${ownedRoot}${path.sep}`)).toBe(true);
|
|
expect(path.basename(child?.fixtureRoot ?? "")).toMatch(/[()].*src$/u);
|
|
const config = JSON.parse(
|
|
(child?.config ?? "").replace(/^export default /u, "").replace(/;\s*$/u, ""),
|
|
) as { test: { coverage: { include: string[] } } };
|
|
expect(config.test.coverage.include).toEqual(
|
|
rootAnchoredGlobs(child?.fixtureRoot ?? "", ["src/**/*.ts"]),
|
|
);
|
|
});
|
|
|
|
it("keeps the child fixture outside main Vitest discovery", async () => {
|
|
const outputRoot = await mkdtemp(path.join(tmpdir(), "v8-counter-list-"));
|
|
roots.push(outputRoot);
|
|
const outputPath = path.join(outputRoot, "listed.json");
|
|
await execFileAsync(
|
|
process.execPath,
|
|
[
|
|
path.join(process.cwd(), "node_modules/vitest/vitest.mjs"),
|
|
"list",
|
|
"tests/fixtures/v8-coverage-counter-semantics",
|
|
"--config",
|
|
path.join(process.cwd(), "vitest.config.ts"),
|
|
"--filesOnly",
|
|
"--passWithNoTests",
|
|
"--json",
|
|
outputPath,
|
|
"--no-color",
|
|
],
|
|
{
|
|
cwd: process.cwd(),
|
|
encoding: "utf8",
|
|
timeout: 30_000,
|
|
maxBuffer: 256 * 1024,
|
|
},
|
|
);
|
|
|
|
expect(JSON.parse(await readFile(outputPath, "utf8"))).toEqual([]);
|
|
}, childProcessTimeout(1_104));
|
|
});
|