@elench/testkit 0.1.83 → 0.1.85

package/lib/shared/build-config.test.mjs

@@ -1,132 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  buildConfigToPrepare,
-  compiledEntryFromBuild,
-  normalizeBuildConfig,
-} from "./build-config.mjs";
-
-describe("shared build config helpers", () => {
-  it("normalizes tsc build config and derives prepare steps", () => {
-    const build = normalizeBuildConfig(
-      {
-        kind: "tsc",
-        entry: "src/server.ts",
-        outDir: "dist",
-      },
-      "runtime.build"
-    );
-
-    expect(build).toEqual({
-      kind: "tsc",
-      cwd: null,
-      entry: "src/server.ts",
-      tsconfig: "tsconfig.json",
-      outDir: "dist",
-      inputs: [],
-    });
-    expect(compiledEntryFromBuild(build)).toBe("dist/server.js");
-    expect(buildConfigToPrepare(build)).toEqual({
-      inputs: ["tsconfig.json", "package.json", "src"],
-      steps: [
-        {
-          kind: "command",
-          cmd: './node_modules/.bin/tsc -p tsconfig.json --outDir "{prepareDir}/dist"',
-          cwd: undefined,
-          inputs: [],
-        },
-      ],
-    });
-  });
-
-  it("normalizes script and steps builds", () => {
-    expect(
-      normalizeBuildConfig(
-        {
-          kind: "script",
-          script: "npm run build",
-          cwd: "frontend",
-          inputs: ["frontend/package.json"],
-        },
-        "runtime.build"
-      )
-    ).toEqual({
-      kind: "script",
-      script: "npm run build",
-      cwd: "frontend",
-      inputs: ["frontend/package.json"],
-    });
-
-    expect(
-      normalizeBuildConfig(
-        {
-          kind: "next",
-          cwd: "frontend",
-        },
-        "runtime.build"
-      )
-    ).toEqual({
-      kind: "next",
-      cwd: "frontend",
-      distDir: "dist",
-      tsconfig: "tsconfig.json",
-      inputs: [],
-    });
-
-    expect(
-      normalizeBuildConfig(
-        {
-          kind: "steps",
-          inputs: ["scripts/prepare.mjs"],
-          steps: [{ kind: "command", run: "node scripts/prepare.mjs" }],
-        },
-        "runtime.build"
-      )
-    ).toEqual({
-      kind: "steps",
-      inputs: ["scripts/prepare.mjs"],
-      steps: [
-        {
-          kind: "command",
-          cmd: "node scripts/prepare.mjs",
-          cwd: null,
-          inputs: [],
-        },
-      ],
-    });
-
-    expect(
-      buildConfigToPrepare({
-        kind: "next",
-        cwd: "frontend",
-        distDir: "dist",
-        tsconfig: "tsconfig.json",
-        inputs: [],
-      })
-    ).toEqual({
-      inputs: [
-        "frontend/tsconfig.json",
-        "frontend/package.json",
-        "frontend/src",
-        "frontend/app",
-        "frontend/public",
-        "frontend/next.config.js",
-        "frontend/next.config.mjs",
-        "frontend/next.config.ts",
-      ],
-      steps: [
-        {
-          kind: "module",
-          specifier: "@elench/testkit/config/next-runtime-tsconfig#writeNextRuntimeTsconfig",
-          cwd: "frontend",
-          inputs: [],
-        },
-        {
-          kind: "command",
-          cmd: "./node_modules/.bin/next build",
-          cwd: "frontend",
-          inputs: [],
-        },
-      ],
-    });
-  });
-});

package/lib/shared/configured-steps.test.mjs

@@ -1,102 +0,0 @@
-import fs from "fs";
-import os from "os";
-import path from "path";
-import { afterEach, describe, expect, it } from "vitest";
-import {
-  collectConfiguredInputs,
-  finalizeConfiguredStep,
-  isBareModuleSpecifier,
-  normalizeConfiguredStep,
-  parseModuleSpecifier,
-  validateConfiguredCollection,
-} from "./configured-steps.mjs";
-
-const tempDirs = [];
-
-afterEach(() => {
-  for (const dir of tempDirs.splice(0)) {
-    fs.rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-describe("shared configured steps", () => {
-  it("normalizes and finalizes configured steps", () => {
-    const normalized = normalizeConfiguredStep(
-      { kind: "module", target: "./seed.mjs#run", cwd: "db", inputs: ["schema.sql"] },
-      'Service "api" database.template.seed[0]'
-    );
-
-    expect(normalized).toEqual({
-      kind: "module",
-      specifier: "./seed.mjs#run",
-      cwd: "db",
-      inputs: ["schema.sql"],
-    });
-    expect(parseModuleSpecifier(normalized.specifier)).toEqual({
-      modulePath: "./seed.mjs",
-      exportName: "run",
-    });
-    expect(finalizeConfiguredStep(normalized, (value) => value.toUpperCase())).toEqual({
-      kind: "module",
-      specifier: "./SEED.MJS#RUN",
-      cwd: "DB",
-      inputs: ["SCHEMA.SQL"],
-    });
-  });
-
-  it("collects and validates configured input paths", () => {
-    const productDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-configured-steps-"));
-    tempDirs.push(productDir);
-    fs.mkdirSync(path.join(productDir, "db"), { recursive: true });
-    fs.writeFileSync(path.join(productDir, "db", "schema.sql"), "-- schema\n");
-    fs.writeFileSync(path.join(productDir, "db", "seed.mjs"), "export default async function run() {}\n");
-
-    const collection = {
-      inputs: ["db/schema.sql"],
-      steps: [
-        { kind: "sql-file", path: "schema.sql", cwd: "db", inputs: [] },
-        { kind: "module", target: "./seed.mjs#run", cwd: "db", inputs: [] },
-      ],
-    };
-
-    expect(collectConfiguredInputs(productDir, collection)).toEqual([
-      path.join(productDir, "db", "schema.sql"),
-      path.join(productDir, "db", "seed.mjs"),
-    ]);
-    expect(() =>
-      validateConfiguredCollection({
-        productDir,
-        label: 'Service "api" runtime.prepare',
-        ...collection,
-      })
-    ).not.toThrow();
-  });
-
-  it("treats bare module specifiers as modules, not product-relative file paths", () => {
-    const productDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-configured-steps-"));
-    tempDirs.push(productDir);
-    fs.mkdirSync(path.join(productDir, "frontend"), { recursive: true });
-
-    const collection = {
-      inputs: [],
-      steps: [
-        {
-          kind: "module",
-          target: "@elench/testkit/config/next-runtime-tsconfig#writeNextRuntimeTsconfig",
-          cwd: "frontend",
-          inputs: [],
-        },
-      ],
-    };
-
-    expect(isBareModuleSpecifier("@elench/testkit/config/next-runtime-tsconfig")).toBe(true);
-    expect(collectConfiguredInputs(productDir, collection)).toEqual([]);
-    expect(() =>
-      validateConfiguredCollection({
-        productDir,
-        label: 'Service "frontend" runtime.prepare',
-        ...collection,
-      })
-    ).not.toThrow();
-  });
-});

package/lib/shared/execution-schema.test.mjs

@@ -1,26 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  normalizeDatabaseBinding,
-  normalizeExecutionConfig,
-  normalizeRuntimeMaxConcurrentTasks,
-  resolveExecutionConfig,
-} from "./execution-schema.mjs";
-
-describe("shared execution schema", () => {
-  it("normalizes execution config and repo/cli overrides", () => {
-    expect(normalizeExecutionConfig({ workers: 2, fileTimeoutSeconds: 30 })).toEqual({
-      workers: 2,
-      fileTimeoutSeconds: 30,
-    });
-    expect(resolveExecutionConfig({ cli: { workers: 3 }, repo: { workers: 2, fileTimeoutSeconds: 45 } })).toEqual({
-      workers: 3,
-      fileTimeoutSeconds: 45,
-    });
-  });
-
-  it("validates runtime concurrency and database binding", () => {
-    expect(normalizeRuntimeMaxConcurrentTasks(undefined)).toBe(Number.POSITIVE_INFINITY);
-    expect(normalizeDatabaseBinding("shared")).toBe("shared");
-    expect(() => normalizeDatabaseBinding("legacy")).toThrow('Invalid database.binding value "legacy"');
-  });
-});

package/lib/shared/file-timeout.test.mjs

@@ -1,64 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  buildFileTimeoutEnv,
-  DEFAULT_FILE_TIMEOUT_SECONDS,
-  formatFileTimeoutBudgetError,
-  formatWaitForTimeoutError,
-  normalizeFileTimeoutSeconds,
-  normalizeWaitIntervalSeconds,
-  parseFileTimeoutOption,
-  readFileTimeoutBudget,
-  remainingFileTimeoutMs,
-  remainingFileTimeoutSeconds,
-} from "./file-timeout.mjs";
-
-describe("file-timeout", () => {
-  it("normalizes positive file timeout values", () => {
-    expect(parseFileTimeoutOption("45")).toBe(45);
-    expect(normalizeFileTimeoutSeconds(DEFAULT_FILE_TIMEOUT_SECONDS)).toBe(60);
-    expect(() => parseFileTimeoutOption("0")).toThrow(
-      'Invalid --file-timeout-seconds value "0"'
-    );
-    expect(() => normalizeFileTimeoutSeconds(0)).toThrow(
-      "execution.fileTimeoutSeconds must be a positive integer."
-    );
-  });
-
-  it("builds and reads runtime timeout budget env", () => {
-    const env = buildFileTimeoutEnv(45, 1_000);
-    expect(env).toEqual({
-      TESTKIT_INTERNAL_FILE_TIMEOUT_SECONDS: "45",
-      TESTKIT_INTERNAL_FILE_DEADLINE_MS: "46000",
-    });
-
-    expect(readFileTimeoutBudget(env)).toEqual({
-      fileTimeoutSeconds: 45,
-      deadlineMs: 46_000,
-    });
-  });
-
-  it("computes remaining file timeout budget", () => {
-    const budget = {
-      fileTimeoutSeconds: 45,
-      deadlineMs: 46_000,
-    };
-
-    expect(remainingFileTimeoutMs(budget, 40_000)).toBe(6_000);
-    expect(remainingFileTimeoutMs(budget, 47_000)).toBe(0);
-    expect(remainingFileTimeoutSeconds(budget, 44_500)).toBe(1.5);
-  });
-
-  it("normalizes wait intervals and timeout errors", () => {
-    expect(normalizeWaitIntervalSeconds()).toBe(0.25);
-    expect(normalizeWaitIntervalSeconds(0.5)).toBe(0.5);
-    expect(() => normalizeWaitIntervalSeconds(0)).toThrow(
-      "waitFor intervalSeconds must be a positive number."
-    );
-    expect(formatWaitForTimeoutError("cron worker pickup", 60)).toBe(
-      "Timed out waiting for cron worker pickup before the 60s test file timeout"
-    );
-    expect(formatFileTimeoutBudgetError(60)).toBe(
-      "Default runtime exceeded the 60s test file timeout"
-    );
-  });
-});

package/lib/shared/test-context.test.mjs

@@ -1,43 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { buildTestNamespace, readTestkitContext } from "./test-context.mjs";
-
-describe("buildTestNamespace", () => {
-  it("prefers the lease id when present", () => {
-    expect(buildTestNamespace({ runtimeId: "runtime-2", leaseId: "lease-4" })).toBe("lease-4");
-  });
-
-  it("falls back to the runtime id", () => {
-    expect(buildTestNamespace({ runtimeId: "runtime-2" })).toBe("runtime-2");
-  });
-
-  it("normalizes unsafe characters", () => {
-    expect(buildTestNamespace({ leaseId: " Lease 4 / Weird " })).toBe("lease-4-weird");
-  });
-
-  it("falls back to standalone when no runtime identifiers exist", () => {
-    expect(buildTestNamespace({})).toBe("standalone");
-  });
-});
-
-describe("readTestkitContext", () => {
-  it("reads active state and normalized identifiers", () => {
-    expect(
-      readTestkitContext({
-        TESTKIT_ACTIVE: "1",
-        TESTKIT_RUNTIME_ID: "Runtime 2",
-        TESTKIT_LEASE_ID: "Lease 3",
-      })
-    ).toEqual({
-      active: true,
-      runtimeId: "runtime-2",
-      leaseId: "lease-3",
-      namespace: "lease-3",
-      rawEnv: {
-        TESTKIT_ACTIVE: "1",
-        TESTKIT_RUNTIME_ID: "Runtime 2",
-        TESTKIT_LEASE_ID: "Lease 3",
-      },
-    });
-  });
-});

package/lib/timing/index.test.mjs

@@ -1,64 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  applyTimingUpdates,
-  buildTimingKey,
-  createEmptyTimings,
-  estimateTaskDuration,
-  normalizeTimings,
-} from "./index.mjs";
-
-describe("timings", () => {
-  it("creates and normalizes empty timing structures", () => {
-    expect(createEmptyTimings()).toEqual({ version: 1, files: {} });
-    expect(normalizeTimings({})).toEqual({ version: 1, files: {} });
-  });
-
-  it("applies rolling timing updates", () => {
-    const next = applyTimingUpdates(
-      {
-        version: 1,
-        files: {
-          "api|k6|integration|a.js": {
-            durationMs: 1000,
-            runs: 1,
-            updatedAt: "2020-01-01T00:00:00.000Z",
-          },
-        },
-      },
-      [{ key: "api|k6|integration|a.js", durationMs: 3000 }],
-      "2020-01-02T00:00:00.000Z"
-    );
-
-    expect(next.files["api|k6|integration|a.js"]).toEqual({
-      durationMs: 2000,
-      runs: 2,
-      updatedAt: "2020-01-02T00:00:00.000Z",
-    });
-  });
-
-  it("estimates task durations and builds timing keys", () => {
-    expect(
-      estimateTaskDuration(
-        { files: { key: { durationMs: 3210 } } },
-        "key",
-        { framework: "k6", type: "integration", weight: 1, files: ["a.js"] }
-      )
-    ).toBe(3210);
-
-    expect(
-      estimateTaskDuration(
-        { files: {} },
-        "key",
-        { framework: "playwright", type: "e2e", weight: 2, files: ["a.js", "b.js"] }
-      )
-    ).toBe(20000);
-
-    expect(
-      buildTimingKey(
-        "api",
-        { framework: "k6", type: "integration" },
-        "tests/health.js"
-      )
-    ).toBe("api|k6|integration|tests/health.js");
-  });
-});

package/lib/toolchains/index.test.mjs

@@ -1,168 +0,0 @@
-import fs from "fs";
-import os from "os";
-import path from "path";
-import { execa } from "execa";
-import { afterEach, describe, expect, it } from "vitest";
-import {
-  applyToolchainEnv,
-  normalizeRuntimeToolchain,
-  normalizeToolchainRegistry,
-  resolveConfiguredToolchain,
-} from "./index.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;
-}
-
-function writeJson(filePath, value) {
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-  fs.writeFileSync(filePath, JSON.stringify(value, null, 2));
-}
-
-describe("toolchains", () => {
-  it("normalizes named toolchain profiles and runtime references", () => {
-    const registry = normalizeToolchainRegistry({
-      frontend: {
-        cwd: "frontend",
-        install: "download",
-        node: "20.19.5",
-      },
-    });
-
-    expect(normalizeRuntimeToolchain("frontend", "Service \"web\" runtime.toolchain", registry)).toEqual(
-      expect.objectContaining({
-        kind: "node",
-        cwd: "frontend",
-        install: "download",
-        node: "20.19.5",
-        refName: "frontend",
-      })
-    );
-  });
-
-  it("fails clearly when host versions do not satisfy a require-host toolchain", async () => {
-    const productDir = makeTempDir("testkit-toolchain-host-");
-    writeJson(path.join(productDir, "package.json"), {
-      name: "toolchain-host-product",
-      engines: {
-        node: ">=20.19.5 <21",
-        npm: ">=10.8.2 <11",
-      },
-    });
-
-    const config = {
-      name: "frontend",
-      productDir,
-      testkit: {
-        runtime: {
-          toolchain: {
-            kind: "node",
-            cwd: ".",
-            detect: "auto",
-            install: "require-host",
-          },
-        },
-      },
-    };
-
-    await expect(
-      resolveConfiguredToolchain(config, {
-        hostNodeVersion: "18.19.0",
-        hostNpmVersion: "10.8.2",
-      })
-    ).rejects.toThrow("requires Node >=20.19.5 <21");
-  });
-
-  it("provisions a downloaded Node toolchain from a deterministic range minimum", async () => {
-    const productDir = makeTempDir("testkit-toolchain-download-");
-    writeJson(path.join(productDir, "package.json"), {
-      name: "toolchain-download-product",
-      engines: {
-        node: ">=20.19.5 <21",
-        npm: ">=10.8.2 <11",
-      },
-    });
-
-    const archiveBuffer = await buildFakeNodeArchive();
-    const config = {
-      name: "frontend",
-      productDir,
-      testkit: {
-        runtime: {
-          toolchain: {
-            kind: "node",
-            cwd: ".",
-            detect: "auto",
-            install: "download",
-          },
-        },
-      },
-    };
-
-    const resolved = await resolveConfiguredToolchain(config, {
-      fetchImpl: async () => ({
-        ok: true,
-        status: 200,
-        arrayBuffer: async () => archiveBuffer,
-      }),
-    });
-
-    expect(resolved).toMatchObject({
-      kind: "node",
-      install: "download",
-      nodeVersion: "20.19.5",
-      npmVersion: "10.8.2",
-      nodeSource: "package.json#engines.node",
-      npmSource: "package.json#engines.npm",
-    });
-    expect(fs.existsSync(resolved.nodeExecutable)).toBe(true);
-    expect(applyToolchainEnv({ PATH: "/usr/bin" }, resolved).PATH).toContain(
-      path.dirname(resolved.nodeExecutable)
-    );
-  });
-});
-
-async function buildFakeNodeArchive() {
-  const root = makeTempDir("testkit-node-archive-root-");
-  const platform = process.platform === "darwin" ? "darwin" : process.platform;
-  const arch = process.arch;
-  const bundleDir = path.join(root, `node-v20.19.5-${platform}-${arch}`);
-  const binDir = path.join(bundleDir, "bin");
-  fs.mkdirSync(binDir, { recursive: true });
-
-  fs.writeFileSync(
-    path.join(binDir, "node"),
-    [
-      "#!/usr/bin/env bash",
-      'if [[ \"$1\" == *\"template-step-module-runner.mjs\" ]]; then',
-      "  shift",
-      "  exec node \"$@\"",
-      "fi",
-      'if [[ \"$1\" == *\"npm-cli.js\" ]]; then',
-      "  shift",
-      "  exec node \"$@\"",
-      "fi",
-      "exec node \"$@\"",
-    ].join("\n"),
-    { mode: 0o755 }
-  );
-  fs.writeFileSync(
-    path.join(binDir, "npm"),
-    ['#!/usr/bin/env bash', 'echo "10.8.2"'].join("\n"),
-    { mode: 0o755 }
-  );
-
-  const archivePath = path.join(root, "node-v20.19.5-linux-x64.tar.gz");
-  await execa("tar", ["-czf", archivePath, "-C", root, path.basename(bundleDir)]);
-  return fs.readFileSync(archivePath);
-}

package/lib/vitest/index.test.mjs

@@ -1,20 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { defineConfig, testkitExcludes } from "./index.mjs";
-
-describe("testkit vitest defineConfig", () => {
-  it("appends testkit suite excludes", () => {
-    const config = defineConfig({
-      test: {
-        exclude: ["dist"],
-      },
-    });
-
-    expect(config.test.exclude).toEqual(
-      expect.arrayContaining(["dist", "**/*.int.testkit.ts", "**/*.pw.testkit.ts"])
-    );
-  });
-
-  it("exports the default testkit excludes", () => {
-    expect(testkitExcludes()).toContain("**/*.scenario.testkit.ts");
-  });
-});