@elench/testkit 0.1.82 → 0.1.84

package/lib/runner/template.test.mjs

@@ -1,272 +0,0 @@
-import fs from "fs";
-import os from "os";
-import path from "path";
-import { describe, expect, it } from "vitest";
-import {
-  buildExecutionEnv,
-  buildPlaywrightEnv,
-  buildPortMap,
-  buildTaskExecutionEnv,
-  finalizeString,
-  normalizeSocketHost,
-  numericPortFromUrl,
-  resolveRuntimeInstanceConfigs,
-  resolveServiceStateDir,
-  resolveTemplateString,
-  rewriteUrlPort,
-  socketFromUrl,
-} from "./template.mjs";
-
-function makeRuntimeConfig(name, local, extras = {}) {
-  return {
-    name,
-    stateDir: extras.stateDir,
-    runtimeId: extras.runtimeId,
-    productDir: extras.productDir || process.cwd(),
-    testkit: {
-      local,
-      runtime: extras.runtime || {
-        instances: 1,
-        maxConcurrentTasks: Infinity,
-        prepare: {
-          inputs: [],
-          steps: [],
-        },
-      },
-      envFiles: extras.envFiles || [],
-      serviceEnv: extras.serviceEnv || {},
-      databaseFrom: extras.databaseFrom,
-      database: extras.database,
-      templateContext: extras.templateContext,
-    },
-  };
-}
-
-describe("runner-template", () => {
-  it("builds port maps and detects collisions", () => {
-    const configs = [
-      makeRuntimeConfig("api", { port: 3000, baseUrl: "http://127.0.0.1:{port}" }),
-      makeRuntimeConfig("frontend", { port: 3001, baseUrl: "http://127.0.0.1:{port}" }),
-    ];
-
-    expect([...buildPortMap(configs, "runtime-2").entries()]).toEqual([
-      ["api", 3100],
-      ["frontend", 3101],
-    ]);
-    expect([...buildPortMap(configs, "runtime-1", { index: 1, stride: 2 }).entries()]).toEqual([
-      ["api", 3200],
-      ["frontend", 3201],
-    ]);
-
-    expect(() =>
-      buildPortMap(
-        [
-          makeRuntimeConfig("api", { port: 3000, baseUrl: "http://127.0.0.1:{port}" }),
-          makeRuntimeConfig("other", { port: 3000, baseUrl: "http://127.0.0.1:{port}" }),
-        ],
-        "runtime-1",
-        { index: 0, stride: 2 }
-      )
-    ).toThrow("Runtime port collision");
-  });
-
-  it("resolves template strings and URL rewrites", () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-template-"));
-    const apiStateDir = path.join(tmpDir, "api");
-    fs.mkdirSync(apiStateDir, { recursive: true });
-    fs.writeFileSync(
-      path.join(apiStateDir, "database_url"),
-      "postgres://testkit:testkit@127.0.0.1:55432/runtime_db"
-    );
-
-    const context = {
-      runtimeId: "runtime-2",
-      serviceName: "frontend",
-      serviceStateDir: "/tmp/state",
-      portMap: new Map([
-        ["frontend", 3200],
-        ["api", 3100],
-      ]),
-      baseUrlByService: new Map([["api", "http://127.0.0.1:3100"]]),
-      readyUrlByService: new Map([["api", "http://127.0.0.1:3100/health"]]),
-      stateDirByService: new Map([["api", apiStateDir]]),
-      urlMappings: [["http://api:3000", "http://127.0.0.1:3100"]],
-      leaseId: "lease-1",
-      leaseDir: "/tmp/lease-1",
-    };
-
-    expect(resolveTemplateString("{runtime}:{service}:{lease}", context)).toBe(
-      "runtime-2:frontend:lease-1"
-    );
-    expect(resolveTemplateString("{prepareDir}", { ...context, prepareDir: "/tmp/prepare-1" })).toBe(
-      "/tmp/prepare-1"
-    );
-    expect(resolveTemplateString("{baseUrl:api}", context)).toBe("http://127.0.0.1:3100");
-    expect(resolveTemplateString("{dbHost:api}:{dbPort:api}/{dbName:api}", context)).toBe(
-      "127.0.0.1:55432/runtime_db"
-    );
-    expect(finalizeString("API={baseUrl:api} OLD=http://api:3000", context)).toBe(
-      "API=http://127.0.0.1:3100 OLD=http://127.0.0.1:3100"
-    );
-    expect(rewriteUrlPort("http://127.0.0.1:3000/health", 3200)).toBe(
-      "http://127.0.0.1:3200/health"
-    );
-  });
-
-  it("builds runtime configs and execution env", () => {
-    const runtimeDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-runtime-"));
-    const api = makeRuntimeConfig(
-      "api",
-      {
-        cwd: ".",
-        start: "npm run api",
-        port: 3000,
-        baseUrl: "http://127.0.0.1:{port}",
-        readyUrl: "http://127.0.0.1:{port}/health",
-        env: {
-          PORT: "{port}",
-        },
-      },
-      {
-        serviceEnv: {
-          API_KEY: "secret",
-        },
-      }
-    );
-    const frontend = makeRuntimeConfig("frontend", {
-      cwd: "frontend",
-      start: "npm run web",
-      port: 3001,
-      baseUrl: "http://127.0.0.1:{port}",
-      readyUrl: "http://127.0.0.1:{port}",
-      env: {
-        NEXT_PUBLIC_API_URL: "{baseUrl:api}",
-        API_DB_HOST: "{dbHost:api}",
-      },
-    });
-
-    const resolved = resolveRuntimeInstanceConfigs([api, frontend], "runtime-2", runtimeDir, {
-      graphDirName: "api__frontend",
-      portNamespaceIndex: 0,
-      portNamespaceStride: 2,
-    });
-    expect(resolved[0].testkit.local.port).toBe(3100);
-    expect(resolved[0].runtimeLabel).toBe("api__frontend/runtime-2");
-    expect(resolveServiceStateDir(runtimeDir, api)).toBe(`${runtimeDir}/services/api`);
-    expect(resolved[0].testkit.prepareDir).toBe(`${runtimeDir}/services/api/prepared`);
-
-    fs.mkdirSync(path.join(runtimeDir, "services", "api"), { recursive: true });
-    fs.writeFileSync(
-      path.join(runtimeDir, "services", "api", "database_url"),
-      "postgres://testkit:testkit@127.0.0.1:55432/runtime_db"
-    );
-
-    expect(
-      buildExecutionEnv(
-        resolved[1],
-        { DATABASE_URL: "gone" },
-        {
-          PATH: "/usr/bin",
-        }
-      )
-    ).toEqual({
-      PATH: "/usr/bin",
-      NEXT_PUBLIC_API_URL: "http://127.0.0.1:3100",
-      API_DB_HOST: "127.0.0.1",
-      TESTKIT_ACTIVE: "1",
-      TESTKIT_RUNTIME_ID: "runtime-2",
-    });
-
-    expect(
-      buildTaskExecutionEnv(
-        resolved[1],
-        {
-          leaseId: "lease-1",
-          leaseDir: "/tmp/lease-1",
-        },
-        {},
-        {}
-      )
-    ).toMatchObject({
-      TESTKIT_RUNTIME_ID: "runtime-2",
-      TESTKIT_LEASE_ID: "lease-1",
-      TESTKIT_LEASE_DIR: "/tmp/lease-1",
-    });
-    expect(finalizeString(".next-testkit/{runtimeId}/dist", resolved[1].testkit.templateContext)).toBe(
-      ".next-testkit/runtime-2/dist"
-    );
-
-    expect(
-      buildPlaywrightEnv(
-        { runtimeId: "runtime-1", testkit: { serviceEnv: {}, templateContext: {} } },
-        "http://localhost:3000",
-        { leaseId: "lease-2", leaseDir: "/tmp/lease-2" },
-        {}
-      )
-    ).toMatchObject({
-      BASE_URL: "http://localhost:3000",
-      TESTKIT_RUNTIME_ID: "runtime-1",
-      TESTKIT_LEASE_ID: "lease-2",
-      PLAYWRIGHT_HTML_OPEN: "never",
-    });
-  });
-
-  it("finalizes runtime.prepare templates with prepareDir", () => {
-    const runtimeDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-runtime-prepare-"));
-    const api = makeRuntimeConfig(
-      "api",
-      {
-        cwd: ".",
-        start: "npm run api",
-        port: 3000,
-        baseUrl: "http://127.0.0.1:{port}",
-        readyUrl: "http://127.0.0.1:{port}/health",
-        env: {},
-      },
-      {
-        runtime: {
-          instances: 1,
-          maxConcurrentTasks: 2,
-          prepare: {
-            inputs: ["src/{service}.ts"],
-            steps: [
-              {
-                kind: "command",
-                cmd: "node scripts/prepare.mjs {prepareDir}",
-                cwd: ".",
-                inputs: ["src/{service}.ts"],
-              },
-            ],
-          },
-        },
-      }
-    );
-
-    const [resolved] = resolveRuntimeInstanceConfigs([api], "runtime-1", runtimeDir, {
-      graphDirName: "api",
-      portNamespaceIndex: 0,
-      portNamespaceStride: 1,
-    });
-
-    expect(resolved.testkit.runtime.prepare).toEqual({
-      inputs: ["src/api.ts"],
-      steps: [
-        {
-          kind: "command",
-          cmd: `node scripts/prepare.mjs ${runtimeDir}/services/api/prepared`,
-          cwd: ".",
-          inputs: ["src/api.ts"],
-        },
-      ],
-    });
-  });
-
-  it("parses runtime sockets", () => {
-    expect(numericPortFromUrl("http://localhost:3000")).toBe(3000);
-    expect(socketFromUrl("http://localhost:3000")).toEqual({
-      host: "127.0.0.1",
-      port: 3000,
-    });
-    expect(normalizeSocketHost("[::1]")).toBe("::1");
-  });
-});

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");
-  });
-});