Files
clean-architecture-frontend…/tests/unit/v8-coverage-counter-semantics.test.ts
T
DongHyeonka 543518ad2a
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
fix(coverage): coverage 대상 패턴을 저장소 루트에 고정한다
문제: 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/.
2026-11-12 22:03:08 +09:00

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));
});