@elench/testkit 0.1.83 → 0.1.85

package/lib/discovery/path-policy.test.mjs

@@ -1,65 +0,0 @@
-import fs from "fs";
-import os from "os";
-import path from "path";
-import { afterEach, describe, expect, it } from "vitest";
-import {
-  mergeDiscoveryConfigs,
-  normalizeDiscoveryConfig,
-  resolveDiscoveryRoots,
-  shouldExcludeDiscoveryPath,
-} from "./path-policy.mjs";
-
-const cleanups = [];
-
-afterEach(() => {
-  while (cleanups.length > 0) {
-    cleanups.pop()();
-  }
-});
-
-describe("discovery path policy", () => {
-  it("normalizes roots and excludes as relative paths", () => {
-    expect(
-      normalizeDiscoveryConfig({
-        roots: ["./app/", "src/app"],
-        exclude: ["./coverage/", "dist"],
-      })
-    ).toEqual({
-      roots: ["app", "src/app"],
-      exclude: ["coverage", "dist"],
-    });
-  });
-
-  it("merges excludes without losing later roots", () => {
-    expect(
-      mergeDiscoveryConfigs(
-        { roots: ["src"], exclude: ["coverage"] },
-        { exclude: ["dist"] },
-        { roots: ["app"], exclude: ["test-results"] }
-      )
-    ).toEqual({
-      roots: ["app"],
-      exclude: ["coverage", "dist", "test-results"],
-    });
-  });
-
-  it("treats exclude paths as path prefixes rather than bare directory names", () => {
-    expect(shouldExcludeDiscoveryPath("coverage", ["coverage"])).toBe(true);
-    expect(shouldExcludeDiscoveryPath("coverage/report/index.html", ["coverage"])).toBe(true);
-    expect(shouldExcludeDiscoveryPath("app/coverage", ["coverage"])).toBe(false);
-    expect(shouldExcludeDiscoveryPath("src/app/coverage", ["coverage"])).toBe(false);
-  });
-
-  it("resolves only existing discovery roots", () => {
-    const productDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-discovery-roots-"));
-    cleanups.push(() => fs.rmSync(productDir, { recursive: true, force: true }));
-    fs.mkdirSync(path.join(productDir, "app"), { recursive: true });
-    fs.mkdirSync(path.join(productDir, "src", "app"), { recursive: true });
-
-    const roots = resolveDiscoveryRoots(productDir, ["app", "missing", "src/app"]);
-    expect(roots).toEqual([
-      path.join(productDir, "app"),
-      path.join(productDir, "src", "app"),
-    ]);
-  });
-});

package/lib/drizzle/index.test.mjs

@@ -1,33 +0,0 @@
-import fs from "fs";
-import os from "os";
-import path from "path";
-import { describe, expect, it } from "vitest";
-import { defineConfig } from "./index.mjs";
-
-describe("testkit drizzle defineConfig", () => {
-  it("loads dotenv files before returning config", () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-drizzle-"));
-    fs.writeFileSync(path.join(tmpDir, ".env"), "DATABASE_URL=postgres://user:pass@127.0.0.1:5432/app\n");
-    const env = {};
-
-    const config = defineConfig({ dialect: "postgresql" }, { cwd: tmpDir, env });
-
-    expect(config).toEqual({ dialect: "postgresql" });
-    expect(env.DATABASE_URL).toContain("127.0.0.1");
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it("enforces local database urls during managed runs by default", () => {
-    expect(() =>
-      defineConfig(
-        { dialect: "postgresql" },
-        {
-          env: {
-            TESTKIT_ACTIVE: "1",
-            DATABASE_URL: "postgres://user:pass@db.example.com:5432/app",
-          },
-        }
-      )
-    ).toThrow("testkit runs require a local PostgreSQL DATABASE_URL");
-  });
-});

package/lib/env/index.test.mjs

@@ -1,82 +0,0 @@
-import fs from "fs";
-import os from "os";
-import path from "path";
-import { describe, expect, it } from "vitest";
-import {
-  assertLocalDatabaseUrl,
-  isManagedRuntime,
-  loadDotenvFiles,
-  shouldLoadDotenv,
-} from "./index.mjs";
-
-describe("testkit env helpers", () => {
-  it("detects managed runtimes", () => {
-    expect(isManagedRuntime({ TESTKIT_ACTIVE: "1" })).toBe(true);
-    expect(isManagedRuntime({ TESTKIT_ACTIVE: "0" })).toBe(false);
-  });
-
-  it("only loads dotenv when not production and not managed", () => {
-    expect(shouldLoadDotenv({ NODE_ENV: "development" })).toBe(true);
-    expect(shouldLoadDotenv({ NODE_ENV: "production" })).toBe(false);
-    expect(shouldLoadDotenv({ NODE_ENV: "development", TESTKIT_ACTIVE: "1" })).toBe(false);
-  });
-
-  it("loads dotenv files in order and respects override by default", () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-env-"));
-    fs.writeFileSync(path.join(tmpDir, ".env"), "FOO=base\nBAR=base\n");
-    fs.writeFileSync(path.join(tmpDir, ".env.local"), "BAR=local\nBAZ=local\n");
-    const env = {};
-
-    const result = loadDotenvFiles({ cwd: tmpDir, env });
-
-    expect(result.loaded).toHaveLength(2);
-    expect(env).toEqual({
-      FOO: "base",
-      BAR: "local",
-      BAZ: "local",
-    });
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it("supports non-overriding dotenv loads", () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-env-"));
-    fs.writeFileSync(path.join(tmpDir, ".env"), "FOO=base\n");
-    const env = { FOO: "preset" };
-
-    loadDotenvFiles({ cwd: tmpDir, env, override: false });
-
-    expect(env.FOO).toBe("preset");
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it("skips dotenv loading when managed unless explicitly overridden", () => {
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "testkit-env-"));
-    fs.writeFileSync(path.join(tmpDir, ".env"), "FOO=base\n");
-    const env = { TESTKIT_ACTIVE: "1" };
-
-    const skipped = loadDotenvFiles({ cwd: tmpDir, env });
-    expect(skipped.loaded).toEqual([]);
-    expect(env.FOO).toBeUndefined();
-
-    const forced = loadDotenvFiles({ cwd: tmpDir, env, onlyWhenAllowed: false });
-    expect(forced.loaded).toHaveLength(1);
-    expect(env.FOO).toBe("base");
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  it("enforces local postgres urls during managed runs", () => {
-    expect(() =>
-      assertLocalDatabaseUrl(
-        { TESTKIT_ACTIVE: "1", DATABASE_URL: "postgres://user:pass@db.example.com:5432/app" },
-        "drizzle.config.ts"
-      )
-    ).toThrow("drizzle.config.ts testkit runs require a local PostgreSQL DATABASE_URL.");
-
-    expect(() =>
-      assertLocalDatabaseUrl(
-        { TESTKIT_ACTIVE: "1", DATABASE_URL: "postgres://user:pass@127.0.0.1:5432/app" },
-        "drizzle.config.ts"
-      )
-    ).not.toThrow();
-  });
-});

package/lib/history/index.test.mjs

@@ -1,115 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { buildHistoryTestId, createEmptyHistory, summarizeHistoryForFiles, updateHistoryFromRunArtifact } from "./index.mjs";
-
-describe("test history", () => {
-  it("tracks first seen and pass/fail counters across runs", () => {
-    const history = createEmptyHistory();
-    const first = updateHistoryFromRunArtifact(
-      history,
-      {
-        generatedAt: "2026-04-30T10:00:00.000Z",
-        services: [
-          {
-            name: "api",
-            suites: [
-              {
-                name: "routes",
-                type: "int",
-                framework: "default",
-                files: [
-                  {
-                    path: "src/api/routes/__testkit__/health.int.testkit.ts",
-                    status: "passed",
-                    durationMs: 2000,
-                  },
-                ],
-              },
-            ],
-          },
-        ],
-      }
-    );
-    const second = updateHistoryFromRunArtifact(
-      first,
-      {
-        generatedAt: "2026-05-01T10:00:00.000Z",
-        services: [
-          {
-            name: "api",
-            suites: [
-              {
-                name: "routes",
-                type: "int",
-                framework: "default",
-                files: [
-                  {
-                    path: "src/api/routes/__testkit__/health.int.testkit.ts",
-                    status: "failed",
-                    durationMs: 4000,
-                  },
-                ],
-              },
-            ],
-          },
-        ],
-      }
-    );
-
-    const id = buildHistoryTestId("api", "int", "src/api/routes/__testkit__/health.int.testkit.ts");
-    expect(second.tests[id]).toMatchObject({
-      firstSeenAt: "2026-04-30T10:00:00.000Z",
-      lastSeenAt: "2026-05-01T10:00:00.000Z",
-      lastRunAt: "2026-05-01T10:00:00.000Z",
-      runCount: 2,
-      passCount: 1,
-      failCount: 1,
-      skipCount: 0,
-      avgDurationMs: 3000,
-      lastStatus: "failed",
-    });
-  });
-
-  it("summarizes history for discovery file entries", () => {
-    const history = {
-      version: 1,
-      tests: {
-        [buildHistoryTestId("api", "int", "src/api/routes/__testkit__/health.int.testkit.ts")]: {
-          id: buildHistoryTestId("api", "int", "src/api/routes/__testkit__/health.int.testkit.ts"),
-          path: "src/api/routes/__testkit__/health.int.testkit.ts",
-          service: "api",
-          suiteName: "routes",
-          selectionType: "int",
-          framework: "k6",
-          firstSeenAt: "2026-04-30T10:00:00.000Z",
-          lastSeenAt: "2026-05-01T10:00:00.000Z",
-          lastRunAt: "2026-05-01T10:00:00.000Z",
-          runCount: 2,
-          passCount: 1,
-          failCount: 1,
-          skipCount: 0,
-          notRunCount: 0,
-          avgDurationMs: 3000,
-          durationCount: 2,
-          lastStatus: "failed",
-        },
-      },
-    };
-
-    const summaries = summarizeHistoryForFiles(history, [
-      {
-        id: buildHistoryTestId("api", "int", "src/api/routes/__testkit__/health.int.testkit.ts"),
-        service: "api",
-        selectionType: "int",
-        path: "src/api/routes/__testkit__/health.int.testkit.ts",
-      },
-    ]);
-
-    expect(summaries.get(buildHistoryTestId("api", "int", "src/api/routes/__testkit__/health.int.testkit.ts"))).toMatchObject({
-      runCount: 2,
-      passCount: 1,
-      failCount: 1,
-      avgDurationMs: 3000,
-      lastStatus: "failed",
-    });
-  });
-});

package/lib/package.test.mjs

@@ -1,59 +0,0 @@
-import fs from "fs";
-import path from "path";
-import { fileURLToPath } from "url";
-import { describe, expect, it } from "vitest";
-
-const rootDir = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
-const packageJsonPath = path.join(rootDir, "package.json");
-const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
-
-describe("package metadata", () => {
-  it("ships first-party type declarations for the public exports", () => {
-    expect(packageJson.types).toBe("./lib/index.d.ts");
-    expect(packageJson.exports["."]).toEqual({
-      types: "./lib/index.d.ts",
-      default: "./lib/index.mjs",
-    });
-    expect(packageJson.exports["./config"]).toEqual({
-      types: "./lib/config-api/index.d.ts",
-      default: "./lib/config-api/index.mjs",
-    });
-    expect(packageJson.exports["./drizzle"]).toEqual({
-      types: "./lib/drizzle/index.d.ts",
-      default: "./lib/drizzle/index.mjs",
-    });
-    expect(packageJson.exports["./env"]).toEqual({
-      types: "./lib/env/index.d.ts",
-      default: "./lib/env/index.mjs",
-    });
-    expect(packageJson.exports["./playwright"]).toEqual({
-      types: "./lib/playwright/index.d.ts",
-      default: "./lib/playwright/index.mjs",
-    });
-    expect(packageJson.exports["./runtime"]).toEqual({
-      types: "./lib/runtime/index.d.ts",
-      default: "./lib/runtime/index.mjs",
-    });
-    expect(packageJson.exports["./vitest"]).toEqual({
-      types: "./lib/vitest/index.d.ts",
-      default: "./lib/vitest/index.mjs",
-    });
-    expect(packageJson.exports["./discovery"]).toEqual({
-      types: "./lib/discovery/index.d.ts",
-      default: "./lib/discovery/index.mjs",
-    });
-    expect(packageJson.exports["./regressions"]).toEqual({
-      types: "./lib/regressions/index.d.ts",
-      default: "./lib/regressions/index.mjs",
-    });
-    expect(fs.existsSync(path.join(rootDir, "lib", "index.d.ts"))).toBe(true);
-    expect(fs.existsSync(path.join(rootDir, "lib", "config-api", "index.d.ts"))).toBe(true);
-    expect(fs.existsSync(path.join(rootDir, "lib", "drizzle", "index.d.ts"))).toBe(true);
-    expect(fs.existsSync(path.join(rootDir, "lib", "env", "index.d.ts"))).toBe(true);
-    expect(fs.existsSync(path.join(rootDir, "lib", "playwright", "index.d.ts"))).toBe(true);
-    expect(fs.existsSync(path.join(rootDir, "lib", "runtime", "index.d.ts"))).toBe(true);
-    expect(fs.existsSync(path.join(rootDir, "lib", "vitest", "index.d.ts"))).toBe(true);
-    expect(fs.existsSync(path.join(rootDir, "lib", "discovery", "index.d.ts"))).toBe(true);
-    expect(fs.existsSync(path.join(rootDir, "lib", "regressions", "index.d.ts"))).toBe(true);
-  });
-});

package/lib/playwright/index.test.mjs

@@ -1,43 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { defineConfig } from "./index.mjs";
-
-describe("testkit playwright defineConfig", () => {
-  it("derives timeouts from the managed file-timeout env", () => {
-    const config = defineConfig(
-      {
-        use: {
-          trace: "on-first-retry",
-        },
-      },
-      {
-        env: {
-          TESTKIT_INTERNAL_FILE_TIMEOUT_SECONDS: "45",
-        },
-      }
-    );
-
-    expect(config.timeout).toBe(45_000);
-    expect(config.expect.timeout).toBe(45_000);
-    expect(config.use.actionTimeout).toBe(45_000);
-    expect(config.use.trace).toBe("on-first-retry");
-  });
-
-  it("disables webServer during managed runs and respects BASE_URL", () => {
-    const config = defineConfig(
-      {
-        webServer: [{ command: "npm run dev" }],
-        use: {},
-      },
-      {
-        env: {
-          TESTKIT_ACTIVE: "1",
-          TESTKIT_MANAGED_SERVERS: "1",
-          BASE_URL: "http://127.0.0.1:3000",
-        },
-      }
-    );
-
-    expect(config.webServer).toBeUndefined();
-    expect(config.use.baseURL).toBe("http://127.0.0.1:3000");
-  });
-});