@elench/testkit 0.1.83 → 0.1.84

package/lib/coverage/routing.test.mjs

@@ -1,36 +0,0 @@
-import path from "path";
-import { describe, expect, it } from "vitest";
-import {
-  inferApiRoutesFromTestFile,
-  inferOwnerDirectoryFromTestFile,
-  inferPageRouteFromTestFile,
-  pathMatchesOwner,
-} from "./routing.mjs";
-
-describe("coverage routing helpers", () => {
-  it("infers page ownership routes from colocated __testkit__ files", () => {
-    const serviceRoot = "/repo";
-    const nextAppRoot = path.join(serviceRoot, "src", "app");
-
-    expect(
-      inferPageRouteFromTestFile("src/app/campaigns/[campaignId]/__testkit__/details.pw.testkit.ts", nextAppRoot, serviceRoot)
-    ).toBe("/campaigns/[campaignId]");
-  });
-
-  it("infers API routes from colocated __testkit__ files", () => {
-    const serviceRoot = "/repo";
-    const nextAppRoot = path.join(serviceRoot, "src", "app");
-
-    expect(
-      inferApiRoutesFromTestFile("src/app/api/campaigns/__testkit__/create.int.testkit.ts", nextAppRoot, serviceRoot)
-    ).toEqual(["/campaigns"]);
-  });
-
-  it("matches nested ownership directories for DAL evidence", () => {
-    expect(inferOwnerDirectoryFromTestFile("src/backend/data/campaigns/__testkit__/save.dal.testkit.ts")).toBe(
-      "src/backend/data/campaigns"
-    );
-    expect(pathMatchesOwner("src/backend/data/campaigns/index.ts", "src/backend/data/campaigns")).toBe(true);
-    expect(pathMatchesOwner("src/backend/data/other/index.ts", "src/backend/data/campaigns")).toBe(false);
-  });
-});

package/lib/coverage/shared.test.mjs

@@ -1,72 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  DYNAMIC_SEGMENT_TOKEN,
-  dedupeTargets,
-  findMatchingApiRouteEntry,
-  findMatchingRouteValue,
-  modulePathKey,
-  pageLabelFromRoute,
-  routePatternMatchesCandidate,
-  toApiRequestPath,
-  toSelectionType,
-} from "./shared.mjs";
-
-describe("coverage shared helpers", () => {
-  it("builds readable page labels from routes", () => {
-    expect(pageLabelFromRoute("/")).toBe("Home");
-    expect(pageLabelFromRoute("/campaigns/[campaignId]")).toBe("Campaigns CampaignId");
-  });
-
-  it("collapses index modules into stable module path keys", () => {
-    expect(modulePathKey("src/backend/server/campaigns/index.ts")).toBe("src/backend/server/campaigns");
-    expect(modulePathKey("src/backend/server/campaigns.ts")).toBe("src/backend/server/campaigns");
-  });
-
-  it("dedupes overlay targets by kind and value", () => {
-    expect(
-      dedupeTargets([
-        { kind: "testId", value: "save-button", confidence: "high" },
-        { kind: "testId", value: "save-button", confidence: "medium" },
-        { kind: "text", value: "Save", confidence: "medium" },
-      ])
-    ).toEqual([
-      { kind: "testId", value: "save-button", confidence: "high" },
-      { kind: "text", value: "Save", confidence: "medium" },
-    ]);
-  });
-
-  it("normalizes request paths and selection types", () => {
-    expect(toApiRequestPath("/campaigns")).toBe("/api/campaigns");
-    expect(toSelectionType("integration", "http")).toBe("int");
-    expect(toSelectionType("ui", "playwright")).toBe("pw");
-  });
-
-  it("matches dynamic API route patterns against concrete and template-like request paths", () => {
-    expect(routePatternMatchesCandidate("/api/projects/[projectId]/overview", "/api/projects/123/overview")).toBe(true);
-    expect(
-      routePatternMatchesCandidate(
-        "/api/projects/[projectId]/events",
-        `/api/projects/${DYNAMIC_SEGMENT_TOKEN}/events`
-      )
-    ).toBe(true);
-    expect(routePatternMatchesCandidate("/api/projects/[projectId]/events", "/api/projects/123/stats")).toBe(false);
-  });
-
-  it("prefers the most specific matching API route entry", () => {
-    const routeEntry = findMatchingApiRouteEntry("GET", "/api/projects/123/events", [
-      { method: "GET", requestPath: "/api/projects/[projectId]" },
-      { method: "GET", requestPath: "/api/projects/[projectId]/events" },
-    ]);
-
-    expect(routeEntry).toEqual({
-      method: "GET",
-      requestPath: "/api/projects/[projectId]/events",
-    });
-  });
-
-  it("matches dynamic page routes against discovered route patterns", () => {
-    expect(
-      findMatchingRouteValue(`/projects/${DYNAMIC_SEGMENT_TOKEN}`, ["/projects/[projectId]", "/projects"])
-    ).toBe("/projects/[projectId]");
-  });
-});

package/lib/database/fingerprint.test.mjs

@@ -1,99 +0,0 @@
-import crypto from "crypto";
-import fs from "fs";
-import os from "os";
-import path from "path";
-import { afterEach, describe, expect, it } from "vitest";
-import {
-  appendFileToHash,
-  appendInputToHash,
-  computeTemplateFingerprint,
-} from "./fingerprint.mjs";
-
-const tempDirs = [];
-
-afterEach(() => {
-  for (const dir of tempDirs.splice(0)) {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-function mkTempDir() {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-db-fingerprint-"));
-  tempDirs.push(dir);
-  return dir;
-}
-
-describe("database-fingerprint", () => {
-  it("hashes files, directories, and missing paths deterministically", () => {
-    const productDir = mkTempDir();
-    fs.mkdirSync(path.join(productDir, "schema"), { recursive: true });
-    fs.writeFileSync(path.join(productDir, "schema", "001.sql"), "select 1;\n");
-    fs.mkdirSync(path.join(productDir, ".testkit", "ignored"), { recursive: true });
-    fs.writeFileSync(path.join(productDir, ".testkit", "ignored", "skip.sql"), "skip");
-
-    const hashA = crypto.createHash("sha256");
-    appendInputToHash(hashA, productDir, "schema");
-    appendInputToHash(hashA, productDir, "missing");
-    const digestA = hashA.digest("hex");
-
-    const hashB = crypto.createHash("sha256");
-    appendInputToHash(hashB, productDir, "schema");
-    appendInputToHash(hashB, productDir, "missing");
-    const digestB = hashB.digest("hex");
-
-    expect(digestA).toBe(digestB);
-  });
-
-  it("hashes file contents and missing files", () => {
-    const productDir = mkTempDir();
-    const filePath = path.join(productDir, "a.txt");
-    fs.writeFileSync(filePath, "alpha");
-
-    const present = crypto.createHash("sha256");
-    appendFileToHash(present, productDir, filePath);
-    const presentDigest = present.digest("hex");
-
-    const missing = crypto.createHash("sha256");
-    appendFileToHash(missing, productDir, path.join(productDir, "missing.txt"));
-    const missingDigest = missing.digest("hex");
-
-    expect(presentDigest).not.toBe(missingDigest);
-  });
-
-  it("computes template fingerprints from config inputs and env files", async () => {
-    const productDir = mkTempDir();
-    fs.mkdirSync(path.join(productDir, "schema"), { recursive: true });
-    fs.writeFileSync(path.join(productDir, "schema", "001.sql"), "select 1;\n");
-    fs.writeFileSync(path.join(productDir, ".env.testkit"), "TOKEN=alpha\n");
-
-    const config = {
-      productDir,
-      testkit: {
-        database: {
-          provider: "local",
-          selectedBackend: "local",
-          template: {
-            inputs: ["schema"],
-            migrate: [
-              {
-                kind: "command",
-                cmd: "npm run migrate",
-                cwd: ".",
-                inputs: [],
-              },
-            ],
-            seed: [],
-            verify: [],
-          },
-        },
-        envFiles: [".env.testkit"],
-      },
-    };
-
-    const first = await computeTemplateFingerprint(config);
-    fs.writeFileSync(path.join(productDir, ".env.testkit"), "TOKEN=beta\n");
-    const second = await computeTemplateFingerprint(config);
-
-    expect(first).not.toBe(second);
-  });
-});

package/lib/database/index.test.mjs

@@ -1,95 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  dropDatabaseWithForceOrDrain,
-  waitForDatabaseConnectionsToDrain,
-} from "./index.mjs";
-
-describe("database lifecycle helpers", () => {
-  it("uses DROP DATABASE ... WITH (FORCE) when supported", async () => {
-    const calls = [];
-
-    await dropDatabaseWithForceOrDrain(
-      { containerName: "pg", password: "pw", user: "user" },
-      "demo",
-      {
-        async runAdminQuery(_infra, args) {
-          calls.push(args);
-          return "";
-        },
-      }
-    );
-
-    expect(calls).toEqual([["-c", 'DROP DATABASE IF EXISTS "demo" WITH (FORCE)']]);
-  });
-
-  it("falls back to draining connections when forced drop is unsupported", async () => {
-    const calls = [];
-    const counts = ["2", "0"];
-
-    await dropDatabaseWithForceOrDrain(
-      { containerName: "pg", password: "pw", user: "user" },
-      "demo",
-      {
-        async runAdminQuery(_infra, args) {
-          calls.push(args);
-          if (args[1] === 'DROP DATABASE IF EXISTS "demo" WITH (FORCE)') {
-            const error = new Error('syntax error at or near "WITH"');
-            error.stderr = 'ERROR: syntax error at or near "WITH"';
-            throw error;
-          }
-          if (args[0] === "-tAc") {
-            return counts.shift() || "0";
-          }
-          return "";
-        },
-        async databaseExists() {
-          return true;
-        },
-        async sleep() {},
-      }
-    );
-
-    expect(calls).toEqual([
-      ["-c", 'DROP DATABASE IF EXISTS "demo" WITH (FORCE)'],
-      ["-c", 'ALTER DATABASE "demo" WITH ALLOW_CONNECTIONS false'],
-      [
-        "-c",
-        "SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE datname = 'demo' AND pid <> pg_backend_pid();",
-      ],
-      [
-        "-tAc",
-        "SELECT COUNT(*) FROM pg_stat_activity WHERE datname = 'demo' AND pid <> pg_backend_pid();",
-      ],
-      [
-        "-c",
-        "SELECT pg_terminate_backend(pid) FROM pg_stat_activity WHERE datname = 'demo' AND pid <> pg_backend_pid();",
-      ],
-      [
-        "-tAc",
-        "SELECT COUNT(*) FROM pg_stat_activity WHERE datname = 'demo' AND pid <> pg_backend_pid();",
-      ],
-      ["-c", 'DROP DATABASE IF EXISTS "demo"'],
-    ]);
-  });
-
-  it("times out clearly while waiting for lingering connections to drain", async () => {
-    let now = 0;
-    await expect(() =>
-      waitForDatabaseConnectionsToDrain(
-        { containerName: "pg", password: "pw", user: "user" },
-        "demo",
-        {
-          async runAdminQuery(_infra, args) {
-            if (args[0] === "-tAc") return "1";
-            return "";
-          },
-          async sleep() {
-            now += 10;
-          },
-          now: () => now,
-          timeoutMs: 20,
-        }
-      )
-    ).rejects.toThrow(/Timed out waiting for database "demo" connections to close/);
-  });
-});

package/lib/database/naming.test.mjs

@@ -1,39 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  buildContainerName,
-  buildDatabaseUrl,
-  buildRuntimeDatabaseName,
-  buildTemplateDatabaseName,
-  escapeIdentifier,
-  escapeSqlLiteral,
-  slugSegment,
-} from "./naming.mjs";
-
-describe("database-naming", () => {
-  it("builds deterministic names and URLs", () => {
-    expect(buildContainerName("/tmp/My Product")).toMatch(/^testkit_pg_my_product_/);
-    expect(buildTemplateDatabaseName("api", "1234567890abcdef1234")).toBe(
-      "tk_tpl_api_1234567890abcdef"
-    );
-    expect(buildRuntimeDatabaseName("api", "/tmp/state", "abcdef1234567890")).toMatch(
-      /^tk_api_[a-f0-9]{10}_abcdef123456$/
-    );
-    expect(
-      buildDatabaseUrl(
-        {
-          user: "a user",
-          password: "p@ss word",
-          host: "127.0.0.1",
-          port: 5432,
-        },
-        "dbname"
-      )
-    ).toContain("postgresql://a%20user:p%40ss%20word@127.0.0.1:5432/dbname");
-  });
-
-  it("escapes identifiers and literals", () => {
-    expect(slugSegment("My API")).toBe("my_api");
-    expect(escapeIdentifier('bad"name')).toBe('bad""name');
-    expect(escapeSqlLiteral("it's")).toBe("it''s");
-  });
-});

package/lib/database/state.test.mjs

@@ -1,66 +0,0 @@
-import fs from "fs";
-import os from "os";
-import path from "path";
-import { afterEach, describe, expect, it } from "vitest";
-import {
-  getLocalInfraDir,
-  getLocalLocksDir,
-  getLocalServiceCacheDir,
-  hasRemainingLocalArtifacts,
-  readStateValue,
-  visitDirs,
-} from "./state.mjs";
-
-const tempDirs = [];
-
-afterEach(() => {
-  for (const dir of tempDirs.splice(0)) {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-function mkTempDir() {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-db-state-"));
-  tempDirs.push(dir);
-  return dir;
-}
-
-describe("database-state", () => {
-  it("builds local state paths", () => {
-    expect(getLocalInfraDir("/tmp/product")).toBe("/tmp/product/.testkit/_infra/local-postgres");
-    expect(getLocalLocksDir("/tmp/product")).toBe("/tmp/product/.testkit/_infra/local-postgres/locks");
-    expect(getLocalServiceCacheDir("/tmp/product", "api")).toBe("/tmp/product/.testkit/_dbcache/api");
-  });
-
-  it("reads state values and visits directories", () => {
-    const productDir = mkTempDir();
-    const aDir = path.join(productDir, "a");
-    const bDir = path.join(aDir, "b");
-    fs.mkdirSync(bDir, { recursive: true });
-    fs.writeFileSync(path.join(aDir, "value"), " hello \n");
-
-    const visited = [];
-    visitDirs(productDir, (dir) => visited.push(path.relative(productDir, dir)));
-
-    expect(visited).toEqual(["a", path.join("a", "b")]);
-    expect(readStateValue(path.join(aDir, "value"))).toBe("hello");
-    expect(readStateValue(path.join(aDir, "missing"))).toBeNull();
-  });
-
-  it("detects remaining local artifacts", () => {
-    const productDir = mkTempDir();
-    const runtimeDir = path.join(productDir, ".testkit", "api");
-    fs.mkdirSync(runtimeDir, { recursive: true });
-    fs.writeFileSync(path.join(runtimeDir, "database_backend"), "local");
-
-    expect(hasRemainingLocalArtifacts(productDir, readStateValue)).toBe(true);
-
-    fs.rmSync(path.join(productDir, ".testkit"), { recursive: true, force: true });
-    fs.mkdirSync(path.join(productDir, ".testkit", "_dbcache", "api"), { recursive: true });
-
-    expect(hasRemainingLocalArtifacts(productDir, readStateValue)).toBe(true);
-
-    fs.rmSync(path.join(productDir, ".testkit"), { recursive: true, force: true });
-    expect(hasRemainingLocalArtifacts(productDir, readStateValue)).toBe(false);
-  });
-});

package/lib/database/template-steps.test.mjs

@@ -1,43 +0,0 @@
-import fs from "fs";
-import os from "os";
-import path from "path";
-import { afterEach, describe, expect, it } from "vitest";
-import { sanitizeSnapshotFile } from "./template-steps.mjs";
-
-const tempDirs = [];
-
-afterEach(() => {
-  while (tempDirs.length > 0) {
-    fs.rmSync(tempDirs.pop(), { recursive: true, force: true });
-  }
-});
-
-function makeTempDir(prefix) {
-  const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-  tempDirs.push(dir);
-  return dir;
-}
-
-describe("template snapshot sanitization", () => {
-  it("removes volatile pg_dump control lines", () => {
-    const dir = makeTempDir("testkit-template-snapshot-");
-    const filePath = path.join(dir, "schema.sql");
-    fs.writeFileSync(
-      filePath,
-      [
-        "SET statement_timeout = 0;",
-        "SET transaction_timeout = 0;",
-        "\\restrict abc123",
-        "CREATE TABLE public.widgets (id integer);",
-        "\\unrestrict abc123",
-        "",
-      ].join("\n")
-    );
-
-    sanitizeSnapshotFile(filePath);
-
-    expect(fs.readFileSync(filePath, "utf8")).toBe(
-      ["SET statement_timeout = 0;", "CREATE TABLE public.widgets (id integer);", ""].join("\n")
-    );
-  });
-});

package/lib/discovery/file-metadata.test.mjs

@@ -1,51 +0,0 @@
-import fs from "fs";
-import os from "os";
-import path from "path";
-import { afterEach, describe, expect, it } from "vitest";
-import { readTestFileMetadata } from "./file-metadata.mjs";
-
-const tempDirs = [];
-
-afterEach(() => {
-  for (const dir of tempDirs.splice(0)) {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-describe("test file metadata", () => {
-  it("reads exported testkit metadata from object literals and helper calls", () => {
-    const productDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-file-meta-"));
-    tempDirs.push(productDir);
-    fs.mkdirSync(path.join(productDir, "__testkit__"), { recursive: true });
-    fs.writeFileSync(
-      path.join(productDir, "__testkit__", "billing.int.testkit.ts"),
-      [
-        'import { defineFile } from "@elench/testkit/config";',
-        'export const testkit = defineFile({',
-        '  skip: "Billing is stubbed locally",',
-        '  locks: ["background-workers", "background-workers"],',
-        "});",
-      ].join("\n")
-    );
-
-    expect(readTestFileMetadata(productDir, "__testkit__/billing.int.testkit.ts")).toEqual({
-      skipReason: "Billing is stubbed locally",
-      locks: ["background-workers"],
-    });
-  });
-
-  it("returns empty metadata when no export is present", () => {
-    const productDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-file-meta-"));
-    tempDirs.push(productDir);
-    fs.mkdirSync(path.join(productDir, "__testkit__"), { recursive: true });
-    fs.writeFileSync(
-      path.join(productDir, "__testkit__", "health.int.testkit.ts"),
-      "export default {};\n"
-    );
-
-    expect(readTestFileMetadata(productDir, "__testkit__/health.int.testkit.ts")).toEqual({
-      skipReason: null,
-      locks: [],
-    });
-  });
-});

package/lib/discovery/index.test.mjs

@@ -1,182 +0,0 @@
-import fs from "fs";
-import os from "os";
-import path from "path";
-import { afterEach, describe, expect, it } from "vitest";
-import { discoverTests } from "./index.mjs";
-import { buildHistoryTestId, saveHistory } from "../history/index.mjs";
-
-const cleanups = [];
-
-afterEach(() => {
-  while (cleanups.length > 0) {
-    cleanups.pop()();
-  }
-});
-
-describe("public discovery", () => {
-  it("returns resolved suites/files with human labels and persisted history", async () => {
-    const productDir = createProduct();
-    writeFile(
-      productDir,
-      "testkit.config.ts",
-      `
-        import { defineConfig } from "@elench/testkit/config";
-
-        export default defineConfig({
-          services: {
-            api: {
-              local: {
-                cwd: ".",
-                start: "node server.js",
-                baseUrl: "http://127.0.0.1:3000",
-                readyUrl: "http://127.0.0.1:3000"
-              }
-            },
-            frontend: {
-              local: {
-                cwd: "frontend",
-                start: "node server.js",
-                baseUrl: "http://127.0.0.1:3001",
-                readyUrl: "http://127.0.0.1:3001"
-              },
-              dependsOn: ["api"]
-            }
-          }
-        });
-      `
-    );
-    writeFile(
-      productDir,
-      "src/api/routes/__testkit__/agent-configs-auth-gate.int.testkit.ts",
-      [
-        'import { defineFile } from "@elench/testkit/config";',
-        'export const testkit = defineFile({ locks: ["route-lock"] });',
-        "export {};",
-      ].join("\n")
-    );
-    writeFile(
-      productDir,
-      "frontend/src/app/login/__testkit__/auth.pw.testkit.ts",
-      [
-        'import { defineFile } from "@elench/testkit/config";',
-        'export const testkit = defineFile({ skip: "Auth is stubbed locally" });',
-        "export {};",
-      ].join("\n")
-    );
-
-    saveHistory(productDir, {
-      version: 1,
-      tests: {
-        [buildHistoryTestId("api", "int", "src/api/routes/__testkit__/agent-configs-auth-gate.int.testkit.ts")]: {
-          id: buildHistoryTestId("api", "int", "src/api/routes/__testkit__/agent-configs-auth-gate.int.testkit.ts"),
-          path: "src/api/routes/__testkit__/agent-configs-auth-gate.int.testkit.ts",
-          service: "api",
-          suiteName: "routes",
-          selectionType: "int",
-          framework: "k6",
-          firstSeenAt: "2026-04-01T00:00:00.000Z",
-          lastSeenAt: "2026-04-02T00:00:00.000Z",
-          lastRunAt: "2026-04-02T00:00:00.000Z",
-          runCount: 4,
-          passCount: 3,
-          failCount: 1,
-          skipCount: 0,
-          notRunCount: 0,
-          avgDurationMs: 2500,
-          durationCount: 4,
-          lastStatus: "passed",
-        },
-      },
-    });
-
-    const result = await discoverTests({ dir: productDir });
-    expect(result.summary).toMatchObject({
-      services: 2,
-      suites: 2,
-      files: 2,
-      activeFiles: 1,
-      skippedFiles: 1,
-      byType: {
-        int: 1,
-        pw: 1,
-      },
-    });
-    expect(result.history.available).toBe(true);
-    expect(result.services.map((entry) => entry.name)).toEqual(["api", "frontend"]);
-
-    const apiFile = result.files.find((entry) => entry.service === "api");
-    expect(apiFile).toMatchObject({
-      displayName: "Agent Configs Auth Gate",
-      suiteName: "routes",
-      groupLabel: "Routes",
-      selectionType: "int",
-      skipped: false,
-      locks: ["route-lock"],
-    });
-    expect(apiFile.history).toMatchObject({
-      firstSeenAt: "2026-04-01T00:00:00.000Z",
-      runCount: 4,
-      passCount: 3,
-      failCount: 1,
-      avgDurationMs: 2500,
-    });
-
-    const frontendFile = result.files.find((entry) => entry.service === "frontend");
-    expect(frontendFile).toMatchObject({
-      displayName: "Auth",
-      selectionType: "pw",
-      skipped: true,
-      skipReason: "Auth is stubbed locally",
-      dependsOn: ["api"],
-    });
-  });
-
-  it("reports legacy discovery diagnostics without failing in report mode", async () => {
-    const productDir = createProduct();
-    writeFile(
-      productDir,
-      "testkit.config.ts",
-      `
-        import { defineConfig } from "@elench/testkit/config";
-
-        export default defineConfig({
-          services: {
-            api: {
-              local: {
-                cwd: ".",
-                start: "node server.js",
-                baseUrl: "http://127.0.0.1:3000",
-                readyUrl: "http://127.0.0.1:3000"
-              }
-            }
-          }
-        });
-      `
-    );
-    writeFile(productDir, "src/api/routes/__testkit__/health/health.int.testkit.ts");
-    writeFile(productDir, "tests/api/integration/legacy.int.testkit.ts");
-
-    const result = await discoverTests({ dir: productDir, diagnostics: "report" });
-    expect(result.files).toHaveLength(1);
-    expect(result.diagnostics).toEqual(
-      expect.arrayContaining([
-        expect.objectContaining({
-          code: "legacy_path",
-          path: "tests/api/integration/legacy.int.testkit.ts",
-        }),
-      ])
-    );
-  });
-});
-
-function createProduct() {
-  const productDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-discovery-public-"));
-  cleanups.push(() => fs.rmSync(productDir, { recursive: true, force: true }));
-  return productDir;
-}
-
-function writeFile(productDir, relativePath, contents = "export {};\n") {
-  const absolutePath = path.join(productDir, relativePath);
-  fs.mkdirSync(path.dirname(absolutePath), { recursive: true });
-  fs.writeFileSync(absolutePath, contents);
-}