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 / self-tests and removal drills (pull_request) Canceled after 0s
문제: `tests/unit/shared-fixture-builds.test.ts`의 「fails the waiting callers with the builder's failure」가 runner run 235(PR #44, FE-GATE-020 scaffold 사본의 test:coverage)에서 실패했다. 시험은 먼저 부른 호출이 잠금을 잡는다고 가정했다. 그러나 잠금은 key 폴더의 `mkdir`이고, 먼저 끝난 `mkdir`이 주인이 된다. 두 번째 호출(waiter)이 먼저 잡아 빌드했고, 먼저 부른 owner는 기다리는 쪽이 되어 그 성공(`{}`)을 받았다. 구현은 맞고 시험의 가정이 틀렸다(r9-fe 넘김). 고친 것: owner의 builder가 시작될 때(곧 owner가 잠금을 잡았을 때) 알리고, 그 뒤에 waiter를 부른다. 버린 대안: 두 호출에 같은 실패 builder를 주고 결과를 순서 없이 비교하기. 「기다리는 쪽이 빌드한 쪽의 실패를 받는다」를 누가 어느 쪽인지 모른 채 보게 된다. 검증(desktop): 첫 `mkdir`만 30ms 늦추는 일회용 시험에서 옛 시험은 runner와 같은 「promise resolved instead of rejecting」으로 실패하고(RED), 새 시험은 통과했다. 실제 파일 3회 6개 통과, eslint rc=0.
126 lines
4.5 KiB
TypeScript
126 lines
4.5 KiB
TypeScript
import { access, mkdtemp, rm, writeFile } from "node:fs/promises";
|
|
import { tmpdir } from "node:os";
|
|
import path from "node:path";
|
|
|
|
import { afterEach, describe, expect, it } from "vitest";
|
|
|
|
import {
|
|
SHARED_FIXTURE_BUILD_ROOT_VARIABLE,
|
|
sharedFixtureBuild,
|
|
startSharedFixtureBuilds,
|
|
} from "../e2e/support/shared-fixture-builds.ts";
|
|
|
|
const roots: string[] = [];
|
|
|
|
afterEach(async () => {
|
|
await Promise.all(
|
|
roots.splice(0).map((root) => rm(root, { recursive: true, force: true })),
|
|
);
|
|
});
|
|
|
|
async function sharedEnvironment(): Promise<NodeJS.ProcessEnv> {
|
|
const root = await mkdtemp(path.join(tmpdir(), "shared-builds-test-"));
|
|
roots.push(root);
|
|
return { [SHARED_FIXTURE_BUILD_ROOT_VARIABLE]: root };
|
|
}
|
|
|
|
describe("one fixture build per e2e run", () => {
|
|
it("builds a key once and hands every caller the same copy", async () => {
|
|
const environment = await sharedEnvironment();
|
|
let builds = 0;
|
|
const create = async (root: string) => {
|
|
builds += 1;
|
|
await new Promise((resolve) => setTimeout(resolve, 50));
|
|
await writeFile(path.join(root, "dist.txt"), "built");
|
|
return { dist: path.join(root, "dist.txt") };
|
|
};
|
|
|
|
const results = await Promise.all(
|
|
[1, 2, 3].map(() => sharedFixtureBuild("fixture-a", "same", create, environment)),
|
|
);
|
|
|
|
expect(builds).toBe(1);
|
|
expect(new Set(results.map((result) => result.root)).size).toBe(1);
|
|
for (const result of results) {
|
|
expect(result.shared).toBe(true);
|
|
expect(result.value).toEqual({ dist: path.join(result.root, "dist.txt") });
|
|
}
|
|
await access(results[0]!.value.dist);
|
|
});
|
|
|
|
it("refuses a second definition under the same key", async () => {
|
|
const environment = await sharedEnvironment();
|
|
await sharedFixtureBuild("fixture-b", "first", async () => ({}), environment);
|
|
|
|
await expect(
|
|
sharedFixtureBuild("fixture-b", "second", async () => ({}), environment),
|
|
).rejects.toThrow(/fixture-b was built from another definition/u);
|
|
});
|
|
|
|
// The key's folder is the lock, and the call whose mkdir finishes first owns
|
|
// it, not the one made first: runner run 235 let the second call build and
|
|
// the first wait for its success. The waiter starts once the owner's
|
|
// builder runs, that is once the owner holds the lock.
|
|
it("fails the waiting callers with the builder's failure", async () => {
|
|
const environment = await sharedEnvironment();
|
|
let building!: () => void;
|
|
const ownerBuilds = new Promise<void>((resolve) => {
|
|
building = resolve;
|
|
});
|
|
const owner = sharedFixtureBuild(
|
|
"fixture-c",
|
|
"same",
|
|
async () => {
|
|
building();
|
|
await new Promise((resolve) => setTimeout(resolve, 50));
|
|
throw new Error("vite build exited 1");
|
|
},
|
|
environment,
|
|
);
|
|
await ownerBuilds;
|
|
const waiter = sharedFixtureBuild("fixture-c", "same", async () => ({}), environment);
|
|
|
|
await expect(owner).rejects.toThrow(/vite build exited 1/u);
|
|
await expect(waiter).rejects.toThrow(
|
|
/fixture-c failed in another worker:[\s\S]*vite build exited 1/u,
|
|
);
|
|
});
|
|
|
|
it("builds a private copy and removes it on failure without a shared root", async () => {
|
|
const result = await sharedFixtureBuild("fixture-d", "x", async (root) => root, {});
|
|
roots.push(result.root);
|
|
expect(result).toMatchObject({ shared: false, value: result.root });
|
|
expect(path.dirname(result.root)).toBe(tmpdir());
|
|
|
|
let failedRoot = "";
|
|
await expect(
|
|
sharedFixtureBuild("fixture-d", "x", async (root) => {
|
|
failedRoot = root;
|
|
throw new Error("broken copy");
|
|
}, {}),
|
|
).rejects.toThrow(/broken copy/u);
|
|
await expect(access(failedRoot)).rejects.toMatchObject({ code: "ENOENT" });
|
|
});
|
|
|
|
it("refuses a key that is not one lower-case path segment", async () => {
|
|
for (const key of ["", "../x", "a/b", "Fixture", `a${"b".repeat(64)}`]) {
|
|
await expect(sharedFixtureBuild(key, "x", async () => ({}), {})).rejects.toThrow(
|
|
/Invalid fixture build key/u,
|
|
);
|
|
}
|
|
});
|
|
|
|
it("gives the run a root and removes it with the teardown", async () => {
|
|
const environment: NodeJS.ProcessEnv = {};
|
|
const teardown = await startSharedFixtureBuilds(environment);
|
|
const root = environment[SHARED_FIXTURE_BUILD_ROOT_VARIABLE];
|
|
expect(root).toBeTruthy();
|
|
await sharedFixtureBuild("fixture-e", "x", async () => ({}), environment);
|
|
|
|
await teardown();
|
|
|
|
expect(environment[SHARED_FIXTURE_BUILD_ROOT_VARIABLE]).toBeUndefined();
|
|
await expect(access(root!)).rejects.toMatchObject({ code: "ENOENT" });
|
|
});
|
|
});
|