@elench/testkit 0.1.83 → 0.1.84

package/lib/config/discovery.test.mjs

@@ -1,276 +0,0 @@
-import fs from "fs";
-import os from "os";
-import path from "path";
-import { afterEach, describe, expect, it } from "vitest";
-import { discoverProject, discoverSuites } from "./discovery.mjs";
-
-const cleanups = [];
-
-afterEach(() => {
-  while (cleanups.length > 0) {
-    cleanups.pop()();
-  }
-});
-
-describe("filesystem-discovery", () => {
-  it("discovers colocated __testkit__ suites by service root", () => {
-    const productDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-discovery-"));
-    cleanups.push(() => fs.rmSync(productDir, { recursive: true, force: true }));
-
-    writeFile(productDir, "src/api/routes/__testkit__/auth/me.int.testkit.ts");
-    writeFile(productDir, "src/api/routes/__testkit__/health/ready.int.testkit.ts");
-    writeFile(productDir, "src/api/routes/__testkit__/journeys/smoke.scenario.testkit.ts");
-    writeFile(productDir, "frontend/app/__testkit__/homepage/homepage.pw.testkit.ts");
-
-    const project = discoverProject(productDir, {
-      api: {
-        local: {
-          cwd: ".",
-        },
-      },
-      frontend: {
-        local: {
-          cwd: "frontend",
-        },
-      },
-    });
-
-    const suites = project.suitesByService;
-    expect(suites.api.integration).toEqual([
-      {
-        name: "auth",
-        files: ["src/api/routes/__testkit__/auth/me.int.testkit.ts"],
-        framework: "k6",
-      },
-      {
-        name: "health",
-        files: ["src/api/routes/__testkit__/health/ready.int.testkit.ts"],
-        framework: "k6",
-      },
-    ]);
-    expect(suites.api.scenario).toEqual([
-      {
-        name: "journeys",
-        files: ["src/api/routes/__testkit__/journeys/smoke.scenario.testkit.ts"],
-        framework: "k6",
-      },
-    ]);
-    expect(suites.frontend.e2e).toEqual([
-      {
-        name: "homepage",
-        files: ["frontend/app/__testkit__/homepage/homepage.pw.testkit.ts"],
-        framework: "playwright",
-      },
-    ]);
-    expect(project.files).toEqual([
-      {
-        serviceName: "api",
-        type: "integration",
-        framework: "k6",
-        suiteName: "auth",
-        suitePath: ["src", "api", "routes", "auth"],
-        filePath: "src/api/routes/__testkit__/auth/me.int.testkit.ts",
-      },
-      {
-        serviceName: "api",
-        type: "integration",
-        framework: "k6",
-        suiteName: "health",
-        suitePath: ["src", "api", "routes", "health"],
-        filePath: "src/api/routes/__testkit__/health/ready.int.testkit.ts",
-      },
-      {
-        serviceName: "api",
-        type: "scenario",
-        framework: "k6",
-        suiteName: "journeys",
-        suitePath: ["src", "api", "routes", "journeys"],
-        filePath: "src/api/routes/__testkit__/journeys/smoke.scenario.testkit.ts",
-      },
-      {
-        serviceName: "frontend",
-        type: "e2e",
-        framework: "playwright",
-        suiteName: "homepage",
-        suitePath: ["app", "homepage"],
-        filePath: "frontend/app/__testkit__/homepage/homepage.pw.testkit.ts",
-      },
-    ]);
-    expect(project.diagnostics).toEqual([]);
-  });
-
-  it("infers the suite from the directory that owns __testkit__", () => {
-    const productDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-discovery-"));
-    cleanups.push(() => fs.rmSync(productDir, { recursive: true, force: true }));
-
-    writeFile(productDir, "src/services/search/__testkit__/query/validation.int.testkit.ts");
-
-    const project = discoverProject(productDir, {
-      api: {
-        local: {
-          cwd: ".",
-        },
-      },
-    });
-    expect(project.services.api).toMatchObject({
-      name: "api",
-      inferredLocalCwd: ".",
-    });
-    expect(project.suitesByService.api.integration[0]).toMatchObject({
-      name: "query",
-      files: ["src/services/search/__testkit__/query/validation.int.testkit.ts"],
-      framework: "k6",
-    });
-  });
-
-  it("prefers the deepest matching service root", () => {
-    const productDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-discovery-"));
-    cleanups.push(() => fs.rmSync(productDir, { recursive: true, force: true }));
-
-    writeFile(productDir, "frontend/app/__testkit__/billing/lifecycle.pw.testkit.ts");
-
-    const project = discoverProject(productDir, {
-      app: {
-        local: {
-          cwd: ".",
-        },
-      },
-      frontend: {
-        local: {
-          cwd: "frontend",
-        },
-      },
-    });
-
-    expect(project.suitesByService.app).toBeUndefined();
-    expect(project.suitesByService.frontend.e2e[0]).toMatchObject({
-      name: "billing",
-      files: ["frontend/app/__testkit__/billing/lifecycle.pw.testkit.ts"],
-      framework: "playwright",
-    });
-  });
-
-  it("fails on legacy files outside __testkit__", () => {
-    const productDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-discovery-"));
-    cleanups.push(() => fs.rmSync(productDir, { recursive: true, force: true }));
-
-    writeFile(productDir, "tests/api/integration/health.int.testkit.ts");
-
-    expect(() =>
-      discoverSuites(productDir, {
-        api: {
-          local: {
-            cwd: ".",
-          },
-        },
-      })
-    ).toThrow("Legacy test files outside __testkit__");
-  });
-
-  it("reports legacy files in non-strict mode", () => {
-    const productDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-discovery-"));
-    cleanups.push(() => fs.rmSync(productDir, { recursive: true, force: true }));
-
-    writeFile(productDir, "src/api/routes/__testkit__/health/ready.int.testkit.ts");
-    writeFile(productDir, "tests/api/integration/health.int.testkit.ts");
-
-    const project = discoverProject(
-      productDir,
-      {
-        api: {
-          local: {
-            cwd: ".",
-          },
-        },
-      },
-      {
-        strict: false,
-      }
-    );
-
-    expect(project.suitesByService.api.integration).toEqual([
-      {
-        name: "health",
-        files: ["src/api/routes/__testkit__/health/ready.int.testkit.ts"],
-        framework: "k6",
-      },
-    ]);
-    expect(project.diagnostics).toEqual([
-      {
-        code: "legacy_path",
-        severity: "error",
-        message: "Legacy test file outside __testkit__: tests/api/integration/health.int.testkit.ts",
-        path: "tests/api/integration/health.int.testkit.ts",
-      },
-    ]);
-  });
-
-  it("does not treat nested coverage source directories as generated output", () => {
-    const productDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-discovery-"));
-    cleanups.push(() => fs.rmSync(productDir, { recursive: true, force: true }));
-
-    writeFile(productDir, "app/coverage/__testkit__/coverage-map.pw.testkit.ts");
-
-    const project = discoverProject(productDir, {
-      web: {
-        local: {
-          cwd: ".",
-        },
-        discovery: {
-          roots: ["app"],
-        },
-      },
-    });
-
-    expect(project.files).toEqual([
-      {
-        serviceName: "web",
-        type: "e2e",
-        framework: "playwright",
-        suiteName: "coverage",
-        suitePath: ["coverage"],
-        filePath: "app/coverage/__testkit__/coverage-map.pw.testkit.ts",
-      },
-    ]);
-  });
-
-  it("supports repo-level and service-level discovery excludes", () => {
-    const productDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-discovery-"));
-    cleanups.push(() => fs.rmSync(productDir, { recursive: true, force: true }));
-
-    writeFile(productDir, "coverage/__testkit__/noise/noise.pw.testkit.ts");
-    writeFile(productDir, "app/generated/__testkit__/noise/noise.pw.testkit.ts");
-    writeFile(productDir, "app/coverage/__testkit__/coverage-map.pw.testkit.ts");
-
-    const project = discoverProject(
-      productDir,
-      {
-        web: {
-          local: {
-            cwd: ".",
-          },
-          discovery: {
-            roots: ["app"],
-            exclude: ["app/generated"],
-          },
-        },
-      },
-      {
-        discovery: {
-          exclude: ["coverage"],
-        },
-      }
-    );
-
-    expect(project.files.map((entry) => entry.filePath)).toEqual([
-      "app/coverage/__testkit__/coverage-map.pw.testkit.ts",
-    ]);
-  });
-
-});
-
-function writeFile(productDir, relativePath, content = "export {};\n") {
-  const absolutePath = path.join(productDir, relativePath);
-  fs.mkdirSync(path.dirname(absolutePath), { recursive: true });
-  fs.writeFileSync(absolutePath, content);
-}

package/lib/config/env.test.mjs

@@ -1,40 +0,0 @@
-import fs from "fs";
-import os from "os";
-import path from "path";
-import { afterEach, describe, expect, it } from "vitest";
-import { inferEnvFiles, parseDotenvString } from "./env.mjs";
-
-const cleanups = [];
-
-afterEach(() => {
-  while (cleanups.length > 0) {
-    cleanups.pop()();
-  }
-});
-
-describe("config env helpers", () => {
-  it("parses dotenv content with comments and quoted values", () => {
-    expect(
-      parseDotenvString(`
-        # comment
-        FOO=bar
-        BAR="quoted value"
-        BAZ='single quoted'
-      `)
-    ).toEqual({
-      FOO: "bar",
-      BAR: "quoted value",
-      BAZ: "single quoted",
-    });
-  });
-
-  it("infers env files from service cwd and root", () => {
-    const productDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-env-"));
-    cleanups.push(() => fs.rmSync(productDir, { recursive: true, force: true }));
-    fs.mkdirSync(path.join(productDir, "apps", "web"), { recursive: true });
-    fs.writeFileSync(path.join(productDir, ".env"), "ROOT=1\n");
-    fs.writeFileSync(path.join(productDir, "apps", "web", ".env.testkit"), "WEB=1\n");
-
-    expect(inferEnvFiles(productDir, {}, { cwd: "apps/web" })).toEqual(["apps/web/.env.testkit", ".env"]);
-  });
-});

package/lib/config/index.test.mjs

@@ -1,44 +0,0 @@
-import fs from "fs";
-import path from "path";
-import os from "os";
-import { afterEach, describe, expect, it } from "vitest";
-import { resolveDalBinary, resolveK6Binary } from "./index.mjs";
-
-const originalK6Bin = process.env.TESTKIT_K6_BIN;
-
-afterEach(() => {
-  if (originalK6Bin === undefined) {
-    delete process.env.TESTKIT_K6_BIN;
-  } else {
-    process.env.TESTKIT_K6_BIN = originalK6Bin;
-  }
-});
-
-describe("config-index", () => {
-  it("resolves the bundled k6 binary from the package root", () => {
-    const binaryPath = resolveK6Binary();
-    expect(path.basename(binaryPath)).toBe("k6");
-    expect(fs.existsSync(binaryPath)).toBe(true);
-  });
-
-  it("keeps resolveDalBinary aligned with the shared k6 resolver", () => {
-    expect(resolveDalBinary()).toBe(resolveK6Binary());
-  });
-
-  it("uses TESTKIT_K6_BIN when provided with a relative path", () => {
-    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-k6-"));
-    const binPath = path.join(tempDir, "k6-custom");
-    fs.writeFileSync(binPath, "#!/usr/bin/env bash\nexit 0\n");
-    process.env.TESTKIT_K6_BIN = path.relative(process.cwd(), binPath);
-
-    expect(resolveK6Binary()).toBe(binPath);
-  });
-
-  it("throws a clear error when TESTKIT_K6_BIN points at a missing path", () => {
-    process.env.TESTKIT_K6_BIN = "./definitely-missing-k6-bin";
-
-    expect(() => resolveK6Binary()).toThrow(
-      /TESTKIT_K6_BIN points to a missing file/
-    );
-  });
-});

package/lib/config/paths.test.mjs

@@ -1,27 +0,0 @@
-import fs from "fs";
-import os from "os";
-import path from "path";
-import { afterEach, describe, expect, it } from "vitest";
-import { normalizePath, resolveProductDir, resolveServiceCwd } from "./paths.mjs";
-
-const cleanups = [];
-
-afterEach(() => {
-  while (cleanups.length > 0) {
-    cleanups.pop()();
-  }
-});
-
-describe("config path helpers", () => {
-  it("normalizes repo-relative paths consistently", () => {
-    expect(normalizePath("./src/app/page.tsx")).toBe("src/app/page.tsx");
-  });
-
-  it("resolves product and service directories", () => {
-    const productDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-paths-"));
-    cleanups.push(() => fs.rmSync(productDir, { recursive: true, force: true }));
-
-    expect(resolveProductDir(productDir, ".")).toBe(productDir);
-    expect(resolveServiceCwd(productDir, "apps/web")).toBe(path.join(productDir, "apps", "web"));
-  });
-});

package/lib/config/runtime.test.mjs

@@ -1,82 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  normalizeBrowserServiceConfig,
-  normalizeRuntimeConfig,
-  normalizeRuntimePrepareConfig,
-  normalizeTemplateLifecycleStep,
-  normalizeTemplateStepInputs,
-  normalizeTemplateInputs,
-  parseModuleSpecifier,
-} from "./runtime.mjs";
-
-describe("config runtime helpers", () => {
-  it("normalizes template inputs and steps", () => {
-    expect(normalizeTemplateInputs(["foo.sql", "bar.sql"], "Service \"web\" database.template")).toEqual([
-      "foo.sql",
-      "bar.sql",
-    ]);
-    expect(
-      normalizeRuntimePrepareConfig(
-        {
-          inputs: ["fixtures/users.json"],
-          steps: [{ kind: "module", target: "./scripts/setup.mjs#run", inputs: ["fixtures/users.json"] }],
-        },
-        "web"
-      )
-    ).toEqual({
-      inputs: ["fixtures/users.json"],
-      steps: [
-        {
-          kind: "module",
-          specifier: "./scripts/setup.mjs#run",
-          cwd: null,
-          inputs: ["fixtures/users.json"],
-        },
-      ],
-    });
-  });
-
-  it("validates browser origins and module specifiers", () => {
-    expect(normalizeBrowserServiceConfig({ origins: ["http://localhost:3000"] }, "web")).toEqual({
-      origins: ["http://localhost:3000"],
-    });
-    expect(parseModuleSpecifier("./script.mjs#seed")).toEqual({
-      modulePath: "./script.mjs",
-      exportName: "seed",
-    });
-  });
-
-  it("folds declarative runtime.build into runtime.prepare", () => {
-    expect(
-      normalizeRuntimeConfig(
-        {
-          build: {
-            kind: "tsc",
-            entry: "src/server.ts",
-          },
-        },
-        "api",
-        {}
-      )
-    ).toMatchObject({
-      build: {
-        kind: "tsc",
-        entry: "src/server.ts",
-        tsconfig: "tsconfig.json",
-        outDir: "dist",
-      },
-      prepare: {
-        inputs: ["tsconfig.json", "package.json", "src"],
-      },
-    });
-  });
-
-  it("rejects malformed lifecycle steps and empty step inputs", () => {
-    expect(() => normalizeTemplateLifecycleStep({ kind: "module" }, "runtime.prepare.steps[0]")).toThrow(
-      /target must be a non-empty string/
-    );
-    expect(() => normalizeTemplateStepInputs([""], "runtime.prepare.steps[0]")).toThrow(
-      /must be a non-empty string/
-    );
-  });
-});

package/lib/config/skip-config.test.mjs

@@ -1,63 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  normalizeRequirementLocks,
-  normalizeServiceRequirements,
-  normalizeSkipConfig,
-  normalizeSkipReason,
-} from "./skip-config.mjs";
-
-const suites = {
-  integration: [
-    {
-      name: "health",
-      framework: "k6",
-      files: ["app/api/health/__testkit__/health.int.testkit.ts"],
-    },
-  ],
-  playwright: [
-    {
-      name: "campaigns",
-      framework: "playwright",
-      files: ["app/campaigns/__testkit__/campaigns.pw.testkit.ts"],
-    },
-  ],
-};
-
-describe("config skip helpers", () => {
-  it("normalizes skip reasons and requirement locks", () => {
-    expect(normalizeSkipReason("flaky on CI", "skip.files[0]")).toBe("flaky on CI");
-    expect(normalizeRequirementLocks(["db", "db", "redis"], "locks")).toEqual(["db", "redis"]);
-  });
-
-  it("normalizes skip config against discovered suites and files", () => {
-    const result = normalizeSkipConfig(
-      {
-        files: [{ path: "app/campaigns/__testkit__/campaigns.pw.testkit.ts", reason: "manual only" }],
-        suites: [{ selector: "pw:campaigns", reason: "broken locally" }],
-      },
-      { name: "web", suites }
-    );
-
-    expect(result.files).toHaveLength(1);
-    expect(result.suites).toHaveLength(1);
-  });
-
-  it("normalizes typed service requirements", () => {
-    const result = normalizeServiceRequirements(
-      {
-        suites: [{ selector: "int:health", locks: ["db"] }],
-        files: [{ path: "app/campaigns/__testkit__/campaigns.pw.testkit.ts", locks: ["browser", "browser"] }],
-      },
-      { name: "web", suites }
-    );
-
-    expect(result.suites[0]).toMatchObject({
-      selector: expect.objectContaining({ raw: "int:health" }),
-      locks: ["db"],
-    });
-    expect(result.files[0]).toMatchObject({
-      path: "app/campaigns/__testkit__/campaigns.pw.testkit.ts",
-      locks: ["browser"],
-    });
-  });
-});