From c6d7f43ab9889bb779365f1867db720a0b6b6479 Mon Sep 17 00:00:00 2001 From: DongHyeonka Date: Thu, 12 Nov 2026 23:19:28 +0900 Subject: [PATCH] =?UTF-8?q?perf(e2e):=20fixture=20build=EB=A5=BC=20?= =?UTF-8?q?=EB=B8=8C=EB=9D=BC=EC=9A=B0=EC=A0=80=20project=EB=A7=88?= =?UTF-8?q?=EB=8B=A4=EA=B0=80=20=EC=95=84=EB=8B=88=EB=9D=BC=20run=EC=97=90?= =?UTF-8?q?=20=ED=95=9C=20=EB=B2=88=20=EB=A7=8C=EB=93=A0=EB=8B=A4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 문제: fixture spec 여섯(old-tab-chunk-recovery, generated-feature, preload-use, boot-module-failure, service-worker-update·recovery)이 beforeAll에서 저장소를 복사해 vite build를 동기로 돈다. chromium· firefox·webkit project가 그 hook을 따로 돌아, e2e 한 번에 같은 build를 세 번(약 9 build × 3) 만든다. 그 build는 옆 worker의 브라우저와 CPU를 다툰다. FE-GATE-008이 가끔 떨어진 firefox 시험(runner run 127, desktop p5·fea-v8: `old-tab-chunk-recovery`·`app-shell`·`accessibility`의 첫 goto 뒤 요소 없음)은 이 build가 도는 구간과 겹쳤다. 다만 아래 6회 실행에서 고치기 전·후 모두 재현되지 않아, 이것이 원인이라고는 확정하지 못했다. 고른 방법: e2e 설정의 global setup이 run마다 공유 폴더를 만들고 (`SHARED_FIXTURE_BUILD_ROOT`), `prepareFixtureBuilds`와 `prepareServiceWorkerBuilds`가 key마다 처음 닿은 worker만 build한다. 나머지 worker는 그 결과를 기다려 쓴다(`mkdir` 잠금, 결과 JSON을 rename으로 공개, 실패는 `.failed`로 전한다). 같은 key를 다른 정의로 부르면 거절한다. build는 엔진과 무관하고 시험이 build 폴더에 쓰는 곳은 없다(edit는 build 전에만 돈다). global teardown이 폴더를 지운다. - old-tab spec은 edit 안에서 정하던 기능 목록을 build 뒤에 root에서도 읽는다. 다른 project의 build를 쓴 worker는 edit를 돌지 않는다. - 공유 폴더가 없으면(Vitest 시험, 다른 Playwright 설정) 예전처럼 호출마다 자기 사본을 만든다. - 버린 대안: expect timeout 늘리기·worker 줄이기(규칙 밖), fixture spec을 한 브라우저만 돌리기(브라우저별 계약이 줄어든다). 위험·한계: build를 기다리는 worker는 자기 hook timeout(180~300초) 안에서 기다린다. build한 worker가 죽으면 기다리는 쪽은 그 timeout으로 실패한다. 2026-11-01 리뷰의 R-1(두 helper 중복 정리)은 하지 않았다. 검증(desktop, `taskset -c 0-5` + worker 6으로 runner 모양, 같은 세션에서 고치기 전·후 번갈아 3회): e2e 전체 벽시계 172/150/141 → 123/141/113초 (중앙값 150 → 123초), 6회 모두 183개 통과. 공유 시험 6개 통과, check:types·eslint rc=0. 로그 /tmp/claude-gates/w2fe2-e2eab/, w2fe2-shared1/. --- playwright.config.ts | 3 + tests/e2e/old-tab-chunk-recovery.spec.ts | 17 ++- tests/e2e/service-worker-recovery.spec.ts | 1 + tests/e2e/service-worker-update.spec.ts | 1 + tests/e2e/support/e2e-global-setup.ts | 10 ++ tests/e2e/support/fixture-builds.ts | 59 +++++---- tests/e2e/support/service-worker-builds.ts | 76 ++++++------ tests/e2e/support/shared-fixture-builds.ts | 135 +++++++++++++++++++++ tests/unit/shared-fixture-builds.test.ts | 115 ++++++++++++++++++ 9 files changed, 348 insertions(+), 69 deletions(-) create mode 100644 tests/e2e/support/e2e-global-setup.ts create mode 100644 tests/e2e/support/shared-fixture-builds.ts create mode 100644 tests/unit/shared-fixture-builds.test.ts diff --git a/playwright.config.ts b/playwright.config.ts index 1ea46419..67a39b6e 100644 --- a/playwright.config.ts +++ b/playwright.config.ts @@ -21,6 +21,9 @@ const origin = `http://127.0.0.1:${port}`; export default defineConfig({ testDir: "./tests/e2e", + // Fixture specs build a repository copy once for the run, not once per + // browser project (tests/e2e/support/shared-fixture-builds.ts). + globalSetup: "./tests/e2e/support/e2e-global-setup.ts", forbidOnly: true, outputDir: testRunPath("artifacts/tests/e2e/results"), reporter: [ diff --git a/tests/e2e/old-tab-chunk-recovery.spec.ts b/tests/e2e/old-tab-chunk-recovery.spec.ts index 36dc61d1..81ec3e5f 100644 --- a/tests/e2e/old-tab-chunk-recovery.spec.ts +++ b/tests/e2e/old-tab-chunk-recovery.spec.ts @@ -57,6 +57,14 @@ const PLATFORM: ChunkRoute = Object.freeze({ }); /** The generated feature's list, read from build A's copy. */ let featureList: ChunkRoute | undefined; +function readFeatureList(root: string): ChunkRoute { + const { list, messages } = generatedFeature(root); + return Object.freeze({ + ...list, + navigationLabel: messages["ko-KR"][`route.${list.routeId}.navigation`]!, + title: messages["ko-KR"][`route.${list.routeId}.title`]!, + }); +} function FEATURE(): ChunkRoute { if (!featureList) throw new Error("Fixture builds were not prepared."); return featureList; @@ -110,12 +118,7 @@ test.beforeAll(async () => { name: "a", edit: async (root) => { await addGeneratedFeature(root); - const { list, messages } = generatedFeature(root); - featureList = Object.freeze({ - ...list, - navigationLabel: messages["ko-KR"][`route.${list.routeId}.navigation`]!, - title: messages["ko-KR"][`route.${list.routeId}.title`]!, - }); + featureList = readFeatureList(root); }, }, { @@ -131,6 +134,8 @@ test.beforeAll(async () => { }, }, ]); + // A worker that reused another browser project's builds ran no edit. + featureList ??= readFeatureList(builds.root); }); test.afterAll(async () => { diff --git a/tests/e2e/service-worker-recovery.spec.ts b/tests/e2e/service-worker-recovery.spec.ts index 5867f933..400ec503 100644 --- a/tests/e2e/service-worker-recovery.spec.ts +++ b/tests/e2e/service-worker-recovery.spec.ts @@ -35,6 +35,7 @@ let builds: ServiceWorkerBuilds | undefined; test.beforeAll(async () => { test.setTimeout(180_000); builds = await prepareServiceWorkerBuilds({ + key: "recovery", async beforeBuild(name, root) { if (name === "a") { await replaceOnce( diff --git a/tests/e2e/service-worker-update.spec.ts b/tests/e2e/service-worker-update.spec.ts index 3562825f..bdc55e10 100644 --- a/tests/e2e/service-worker-update.spec.ts +++ b/tests/e2e/service-worker-update.spec.ts @@ -61,6 +61,7 @@ const CHANGED_ROUTE_SOURCE = test.beforeAll(async () => { test.setTimeout(180_000); builds = await prepareServiceWorkerBuilds({ + key: "update", beforeBuild: async (name, root) => { if (name !== "b") return; await appendFile( diff --git a/tests/e2e/support/e2e-global-setup.ts b/tests/e2e/support/e2e-global-setup.ts new file mode 100644 index 00000000..dcd36649 --- /dev/null +++ b/tests/e2e/support/e2e-global-setup.ts @@ -0,0 +1,10 @@ +import { startSharedFixtureBuilds } from "./shared-fixture-builds.ts"; + +/** + * The e2e run's global setup: one shared fixture build root for every browser + * project (shared-fixture-builds.ts). The returned function is the global + * teardown that removes it. + */ +export default async function globalSetup(): Promise<() => Promise> { + return startSharedFixtureBuilds(); +} diff --git a/tests/e2e/support/fixture-builds.ts b/tests/e2e/support/fixture-builds.ts index 0a70a059..23a95e3f 100644 --- a/tests/e2e/support/fixture-builds.ts +++ b/tests/e2e/support/fixture-builds.ts @@ -1,11 +1,11 @@ import { spawnSync } from "node:child_process"; -import { cp, mkdtemp, readFile, rename, rm, writeFile } from "node:fs/promises"; -import { tmpdir } from "node:os"; +import { cp, readFile, rename, rm, writeFile } from "node:fs/promises"; import path from "node:path"; import { localBuildEnvironment } from "../../../scripts/lib/build-environment.ts"; import { linkFixtureNodeModules } from "../../../scripts/lib/fixture-node-modules.ts"; import { selectRepositoryPaths } from "../../../scripts/lib/repository-layout.ts"; +import { sharedFixtureBuild } from "./shared-fixture-builds.ts"; /** * Real production builds of an edited temp copy of the repository, in the @@ -29,6 +29,8 @@ export type FixtureBuild = Readonly<{ export type FixtureBuilds = Readonly<{ root: string; dist: Readonly>; + /** One copy for the whole e2e run (shared-fixture-builds.ts); the run removes it. */ + shared: boolean; }>; /** Replaces the one occurrence of `search` in `file` of the copy. */ @@ -67,32 +69,37 @@ export async function prepareFixtureBuilds( prefix: string, builds: readonly FixtureBuild[], ): Promise> { - const root = await mkdtemp(path.join(tmpdir(), `${prefix}-`)); - try { - await cp(repoRoot, root, { - recursive: true, - filter: (source) => - !skipped.has(path.relative(repoRoot, source).split(path.sep)[0]!), - }); - await linkFixtureNodeModules(root, repoRoot); - const dist = {} as Record; - for (const build of builds) { - await build.edit?.(root); - const buildId = `${prefix}-${build.name}`; - run(root, "scripts/generate-product-feature-index.ts", buildId, build.env); - run(root, "scripts/build-frontend.ts", buildId, build.env); - dist[build.name] = path.join(root, `dist-${build.name}`); - await rename(path.join(root, "dist"), dist[build.name]); - } - return { root, dist }; - } catch (error) { - await rm(root, { recursive: true, force: true }); - throw error; - } + // An edit's source text names the build (two specs never share a prefix). + const fingerprint = JSON.stringify( + builds.map((build) => [build.name, build.env ?? {}, build.edit?.toString() ?? ""]), + ); + const { root, value, shared } = await sharedFixtureBuild( + `fixture-${prefix}`, + fingerprint, + async (root) => { + await cp(repoRoot, root, { + recursive: true, + filter: (source) => + !skipped.has(path.relative(repoRoot, source).split(path.sep)[0]!), + }); + await linkFixtureNodeModules(root, repoRoot); + const dist = {} as Record; + for (const build of builds) { + await build.edit?.(root); + const buildId = `${prefix}-${build.name}`; + run(root, "scripts/generate-product-feature-index.ts", buildId, build.env); + run(root, "scripts/build-frontend.ts", buildId, build.env); + dist[build.name] = path.join(root, `dist-${build.name}`); + await rename(path.join(root, "dist"), dist[build.name]); + } + return dist; + }, + ); + return { root, dist: value, shared }; } export async function removeFixtureBuilds( - builds: Readonly<{ root: string }> | undefined, + builds: Readonly<{ root: string; shared: boolean }> | undefined, ): Promise { - if (builds) await rm(builds.root, { recursive: true, force: true }); + if (builds && !builds.shared) await rm(builds.root, { recursive: true, force: true }); } diff --git a/tests/e2e/support/service-worker-builds.ts b/tests/e2e/support/service-worker-builds.ts index 156a23fd..c96b1961 100644 --- a/tests/e2e/support/service-worker-builds.ts +++ b/tests/e2e/support/service-worker-builds.ts @@ -2,7 +2,6 @@ import { spawnSync } from "node:child_process"; import { existsSync } from "node:fs"; import { cp, - mkdtemp, readFile, rename, rm, @@ -10,7 +9,6 @@ import { } from "node:fs/promises"; import { createServer, type Server } from "node:http"; import type { AddressInfo } from "node:net"; -import { tmpdir } from "node:os"; import path from "node:path"; import { pathToFileURL } from "node:url"; import { gzipSync } from "node:zlib"; @@ -20,6 +18,7 @@ import { localBuildEnvironment } from "../../../scripts/lib/build-environment.ts import { linkFixtureNodeModules } from "../../../scripts/lib/fixture-node-modules.ts"; import { selectRepositoryPaths } from "../../../scripts/lib/repository-layout.ts"; import type { StaticAssetManifestV1 } from "../../../src/contracts/service-worker.ts"; +import { sharedFixtureBuild } from "./shared-fixture-builds.ts"; /** * R3-6 test helper: two real production builds with the Service Worker on, @@ -66,6 +65,8 @@ export type ServiceWorkerBuilds = Readonly<{ dist: Readonly>; /** Sorted URLs of each build's generated precache list (premise 3). */ precached: Readonly>; + /** One copy for the whole e2e run (shared-fixture-builds.ts); the run removes it. */ + shared: boolean; }>; const SELECTION_FILE = "src/features/product-capabilities.ts"; @@ -183,52 +184,53 @@ function run(cwd: string, script: string, buildId: string): void { /** * `beforeBuild` edits the temp copy right before build `name` (06-03: a * broken worker A, then a `REMOVE_REGISTRATION` release B). Edits persist - * into the later build. + * into the later build. `key` names this pair of builds in the e2e run + * (shared-fixture-builds.ts); each spec passes its own. */ export async function prepareServiceWorkerBuilds( options: Readonly<{ + key: string; beforeBuild?: (name: BuildName, root: string) => Promise; - }> = {}, + }>, ): Promise { - const root = await mkdtemp(path.join(tmpdir(), "ca-sw-builds-")); - try { - await cp(repoRoot, root, { - recursive: true, - filter: (source) => - !skipped.has(path.relative(repoRoot, source).split(path.sep)[0]!), - }); - await linkFixtureNodeModules(root, repoRoot); - await turnOnServiceWorker(root); - const hostFile = path.join(root, "src/bootstrap/register-service-worker.ts"); - await replaceOnce( - hostFile, - "export function createServiceWorkerRuntimeHost(", - "function createServiceWorkerRuntimeHostUnobserved(", - ); - await writeFile(hostFile, (await readFile(hostFile, "utf8")) + HOST_PROBE); + const { root, value, shared } = await sharedFixtureBuild( + `sw-${options.key}`, + options.beforeBuild?.toString() ?? "", + async (root) => { + await cp(repoRoot, root, { + recursive: true, + filter: (source) => + !skipped.has(path.relative(repoRoot, source).split(path.sep)[0]!), + }); + await linkFixtureNodeModules(root, repoRoot); + await turnOnServiceWorker(root); + const hostFile = path.join(root, "src/bootstrap/register-service-worker.ts"); + await replaceOnce( + hostFile, + "export function createServiceWorkerRuntimeHost(", + "function createServiceWorkerRuntimeHostUnobserved(", + ); + await writeFile(hostFile, (await readFile(hostFile, "utf8")) + HOST_PROBE); - const dist = { a: path.join(root, "dist-a"), b: path.join(root, "dist-b") }; - const precached: Record = { a: [], b: [] }; - for (const name of ["a", "b"] as const) { - await options.beforeBuild?.(name, root); - run(root, "scripts/generate-product-feature-index.ts", `sw-e2e-${name}`); - run(root, "scripts/build-frontend.ts", `sw-e2e-${name}`); - await rename(path.join(root, "dist"), dist[name]); - precached[name] = await precachedUrls(root, name); - } - return { root, dist, precached }; - } catch (error) { - // The spec never receives `root` from a failed setup, so afterAll cannot - // remove it. - await rm(root, { recursive: true, force: true }); - throw error; - } + const dist = { a: path.join(root, "dist-a"), b: path.join(root, "dist-b") }; + const precached: Record = { a: [], b: [] }; + for (const name of ["a", "b"] as const) { + await options.beforeBuild?.(name, root); + run(root, "scripts/generate-product-feature-index.ts", `sw-e2e-${name}`); + run(root, "scripts/build-frontend.ts", `sw-e2e-${name}`); + await rename(path.join(root, "dist"), dist[name]); + precached[name] = await precachedUrls(root, name); + } + return { dist, precached }; + }, + ); + return { root, ...value, shared }; } export async function removeServiceWorkerBuilds( builds: ServiceWorkerBuilds | undefined, ): Promise { - if (builds) await rm(builds.root, { recursive: true, force: true }); + if (builds && !builds.shared) await rm(builds.root, { recursive: true, force: true }); } export type AssetHeaders = Readonly<{ diff --git a/tests/e2e/support/shared-fixture-builds.ts b/tests/e2e/support/shared-fixture-builds.ts new file mode 100644 index 00000000..4f59564d --- /dev/null +++ b/tests/e2e/support/shared-fixture-builds.ts @@ -0,0 +1,135 @@ +import { mkdir, mkdtemp, readFile, rename, rm, writeFile } from "node:fs/promises"; +import { tmpdir } from "node:os"; +import path from "node:path"; + +/** + * One fixture build per Playwright run instead of one per browser project. + * + * The fixture specs build a copy of the repository in `beforeAll`, and every + * browser project runs that hook again: one e2e run made the same builds + * three times, synchronously, while the other workers drove browsers. Those + * builds took the CPU from the browsers next to them, and Firefox's first + * render in a test then missed its 5 s expectation (FE-GATE-008, desktop and + * runner). Builds are the same for every engine and no test writes into them. + * + * With `SHARED_FIXTURE_BUILD_ROOT` set (the e2e config's global setup sets it + * for the run), the first worker that needs `key` builds it under that root and + * the others wait for it and reuse it; the global teardown removes the root. + * Unset (a Vitest test, another config), every call builds its own copy in a + * new temp folder as before. + */ +export const SHARED_FIXTURE_BUILD_ROOT_VARIABLE = "SHARED_FIXTURE_BUILD_ROOT"; + +const POLL_MS = 200; +const KEY = /^[a-z0-9][a-z0-9-]{0,63}$/u; + +export type SharedFixtureBuild = Readonly<{ + /** The folder `create` built into. */ + root: string; + value: Value; + /** Owned by the run (not removable by the spec) when true. */ + shared: boolean; +}>; + +type BuildRecord = Readonly<{ fingerprint: string; value: unknown }>; + +function hasCode(error: unknown, code: string): boolean { + return typeof error === "object" && error !== null && "code" in error && error.code === code; +} + +async function readRecord(file: string): Promise { + try { + return JSON.parse(await readFile(file, "utf8")) as BuildRecord; + } catch (error) { + if (hasCode(error, "ENOENT")) return undefined; + throw error; + } +} + +async function readFailure(file: string): Promise { + try { + return await readFile(file, "utf8"); + } catch (error) { + if (hasCode(error, "ENOENT")) return undefined; + throw error; + } +} + +/** + * `create(root)` fills the empty folder `root` and returns a JSON value that + * describes it (paths under `root`). `fingerprint` names what `create` builds; + * a second caller of the same `key` with another fingerprint is refused. + */ +export async function sharedFixtureBuild( + key: string, + fingerprint: string, + create: (root: string) => Promise, + environment: NodeJS.ProcessEnv = process.env, +): Promise> { + if (!KEY.test(key)) throw new Error(`Invalid fixture build key: ${key}`); + const sharedRoot = environment[SHARED_FIXTURE_BUILD_ROOT_VARIABLE]; + if (!sharedRoot) { + const root = await mkdtemp(path.join(tmpdir(), `${key}-`)); + try { + return { root, value: await create(root), shared: false }; + } catch (error) { + await rm(root, { recursive: true, force: true }); + throw error; + } + } + + const root = path.join(sharedRoot, key); + const recordFile = `${root}.json`; + const failureFile = `${root}.failed`; + let owner = true; + try { + await mkdir(root); + } catch (error) { + if (!hasCode(error, "EEXIST")) throw error; + owner = false; + } + + if (owner) { + let value: Value; + try { + value = await create(root); + } catch (error) { + await writeFile(failureFile, String(error instanceof Error ? error.stack : error)); + throw error; + } + const temporary = `${recordFile}.${process.pid}.tmp`; + await writeFile(temporary, JSON.stringify({ fingerprint, value })); + await rename(temporary, recordFile); + return { root, value, shared: true }; + } + + // Another worker builds `key`; the spec's own hook timeout bounds this wait. + for (;;) { + const record = await readRecord(recordFile); + if (record) { + if (record.fingerprint !== fingerprint) { + throw new Error( + `Fixture build ${key} was built from another definition in this run.`, + ); + } + return { root, value: record.value as Value, shared: true }; + } + const failure = await readFailure(failureFile); + if (failure !== undefined) { + throw new Error(`Fixture build ${key} failed in another worker:\n${failure}`); + } + await new Promise((resolve) => setTimeout(resolve, POLL_MS)); + } +} + +/** The e2e config's global setup: a shared root for this run, and its teardown. */ +export async function startSharedFixtureBuilds( + environment: NodeJS.ProcessEnv = process.env, +): Promise<() => Promise> { + const root = await mkdtemp(path.join(tmpdir(), "e2e-fixture-builds-")); + environment[SHARED_FIXTURE_BUILD_ROOT_VARIABLE] = root; + return async () => { + delete environment[SHARED_FIXTURE_BUILD_ROOT_VARIABLE]; + await rm(root, { recursive: true, force: true }); + }; +} diff --git a/tests/unit/shared-fixture-builds.test.ts b/tests/unit/shared-fixture-builds.test.ts new file mode 100644 index 00000000..210071d1 --- /dev/null +++ b/tests/unit/shared-fixture-builds.test.ts @@ -0,0 +1,115 @@ +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 { + 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); + }); + + it("fails the waiting callers with the builder's failure", async () => { + const environment = await sharedEnvironment(); + const owner = sharedFixtureBuild( + "fixture-c", + "same", + async () => { + await new Promise((resolve) => setTimeout(resolve, 50)); + throw new Error("vite build exited 1"); + }, + environment, + ); + 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" }); + }); +});