@elench/testkit 0.1.83 → 0.1.85

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/runtime-src/k6/http-checks.test.mjs

@@ -1,120 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-const mockCheck = vi.fn((value, checks) =>
-  Object.values(checks).every((predicate) => predicate(value))
-);
-const mockGroup = vi.fn((name, fn) => fn());
-
-vi.mock("k6", () => ({
-  check: mockCheck,
-  group: mockGroup,
-}));
-
-vi.mock("k6/http", () => ({
-  default: {
-    del: vi.fn(),
-    file: vi.fn(),
-    get: vi.fn(),
-    patch: vi.fn(),
-    post: vi.fn(),
-    put: vi.fn(),
-  },
-}));
-
-vi.mock("k6/metrics", () => ({
-  Rate: class {
-    add() {}
-  },
-}));
-
-const { runAuthGateChecks, runPaginationChecks } = await import("./http-checks.js");
-
-function makeJsonResponse(status, body) {
-  return {
-    status,
-    body: JSON.stringify(body),
-    headers: { "content-type": "application/json" },
-  };
-}
-
-describe("runtime http checks", () => {
-  beforeEach(() => {
-    mockCheck.mockClear();
-    mockGroup.mockClear();
-  });
-
-  it("executes auth-gate checks across configured methods", () => {
-    const rawReq = vi.fn((method, path, body) => {
-      return makeJsonResponse(401, {
-        error: {
-          code: "UNAUTHORIZED",
-          message: `${method} ${path} requires auth`,
-        },
-        body,
-      });
-    });
-
-    runAuthGateChecks(rawReq, "sessions", {
-      get: ["/api/v1/sessions"],
-      post: [["/api/v1/sessions", { name: "draft" }]],
-      validateGetErrorShape: true,
-    });
-
-    expect(rawReq.mock.calls).toEqual([
-      ["GET", "/api/v1/sessions", undefined],
-      ["POST", "/api/v1/sessions", { name: "draft" }],
-    ]);
-    expect(mockGroup).toHaveBeenCalledWith(
-      "sessions GET endpoints return 401 without auth",
-      expect.any(Function)
-    );
-    expect(mockGroup).toHaveBeenCalledWith(
-      "sessions POST endpoints return 401 without auth",
-      expect.any(Function)
-    );
-  });
-
-  it("executes default and audit-log pagination abuse cases", () => {
-    const requested = [];
-    const req = {
-      get: vi.fn((url) => {
-        requested.push(url);
-        const expects400 =
-          url.includes("limit=-1") ||
-          url.includes("limit=abc") ||
-          url.includes("offset=-1") ||
-          url.includes("offset=1.5") ||
-          url.includes("limit=Infinity") ||
-          url.includes("limit=NaN") ||
-          url.includes("offset=NaN") ||
-          url.endsWith("limit=") ||
-          url.endsWith("offset=");
-
-        if (expects400) {
-          return makeJsonResponse(400, {
-            error: {
-              code: "VALIDATION_ERROR",
-              message: "invalid pagination",
-            },
-          });
-        }
-
-        return makeJsonResponse(200, {
-          data: [],
-          pagination: {
-            limit: 25,
-            offset: 0,
-          },
-        });
-      }),
-    };
-
-    runPaginationChecks(req, "/api/v1/audit-logs", { auditLogsExtra: true });
-
-    expect(requested).toHaveLength(13);
-    expect(requested).toContain("/api/v1/audit-logs?limit=-1");
-    expect(requested).toContain("/api/v1/audit-logs?offset=1.5");
-    expect(requested).toContain("/api/v1/audit-logs?limit=Infinity");
-    expect(requested).toContain("/api/v1/audit-logs?limit=0x10");
-  });
-});

package/lib/runtime-src/k6/http.test.mjs

@@ -1,205 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-
-const mockHttp = {
-  del: vi.fn(),
-  file: vi.fn((data, filename, contentType) => ({
-    __testkitFile: true,
-    contentType,
-    data,
-    filename,
-  })),
-  get: vi.fn(),
-  patch: vi.fn(),
-  post: vi.fn(),
-  put: vi.fn(),
-};
-
-vi.mock("k6/http", () => ({
-  default: mockHttp,
-}));
-
-vi.mock("k6", () => ({
-  check: vi.fn((value, checks) =>
-    Object.values(checks).every((predicate) => predicate(value))
-  ),
-  group: vi.fn((name, fn) => fn()),
-}));
-
-vi.mock("k6/metrics", () => ({
-  Rate: class {
-    add() {}
-  },
-}));
-
-const { createHttpClient } = await import("./http.js");
-
-function makeResponse(status = 200, body = { ok: true }) {
-  return {
-    status,
-    body: JSON.stringify(body),
-    headers: { "content-type": "application/json" },
-  };
-}
-
-function makeSessionBundle() {
-  return {
-    primaryActor: "userA",
-    actors: {
-      userA: {
-        actorIndex: 0,
-        actorName: "userA",
-        email: "testkit+fixture.user-a@example.test",
-        jwt: "jwt-user-a",
-        organizationId: "org-alpha",
-        organizationKey: "primary",
-        organizationName: "Primary Org",
-        session: {
-          jwt: "jwt-user-a",
-          organizationId: "org-alpha",
-        },
-      },
-      userB: {
-        actorIndex: 1,
-        actorName: "userB",
-        email: "testkit+fixture.user-b@example.test",
-        jwt: "jwt-user-b",
-        organizationId: "org-beta",
-        organizationKey: "secondary",
-        organizationName: "Secondary Org",
-        session: {
-          jwt: "jwt-user-b",
-          organizationId: "org-beta",
-        },
-      },
-    },
-  };
-}
-
-describe("runtime http client", () => {
-  beforeEach(() => {
-    globalThis.__ENV = { TESTKIT_RUNTIME_ID: "unit" };
-    mockHttp.del.mockReset();
-    mockHttp.file.mockClear();
-    mockHttp.get.mockReset();
-    mockHttp.patch.mockReset();
-    mockHttp.post.mockReset();
-    mockHttp.put.mockReset();
-
-    mockHttp.get.mockImplementation(() => makeResponse());
-    mockHttp.post.mockImplementation(() => makeResponse(201));
-    mockHttp.put.mockImplementation(() => makeResponse());
-    mockHttp.patch.mockImplementation(() => makeResponse());
-    mockHttp.del.mockImplementation(() => makeResponse(204));
-  });
-
-  it("resolves actor-aware auth headers and raw headers", () => {
-    const client = createHttpClient({
-      baseUrl: "http://api.test",
-      defaultActor: "userA",
-      routeHeaders: { "x-route": "route-a" },
-      sessionBundle: makeSessionBundle(),
-      getHeaders({ actor }) {
-        return actor?.jwt
-          ? {
-              Authorization: `Bearer ${actor.jwt}`,
-              "Content-Type": "application/json",
-              "X-Organization-Id": actor.organizationId,
-            }
-          : {};
-      },
-      getRawHeaders({ actor }) {
-        return actor?.organizationId
-          ? {
-              "X-Organization-Id": actor.organizationId,
-            }
-          : {
-              "X-Testkit-Mode": "raw",
-            };
-      },
-    });
-
-    expect(client.headers({ "X-Test": "1" })).toEqual({
-      "Content-Type": "application/json",
-      Authorization: "Bearer jwt-user-a",
-      "X-Organization-Id": "org-alpha",
-      "x-route": "route-a",
-      "X-Test": "1",
-    });
-
-    expect(client.raw.headers()).toEqual({
-      "Content-Type": "application/json",
-      "X-Testkit-Mode": "raw",
-      "x-route": "route-a",
-    });
-
-    expect(client.raw.as("userB").headers({ "X-Trace": "secondary" })).toEqual({
-      "Content-Type": "application/json",
-      "X-Organization-Id": "org-beta",
-      "x-route": "route-a",
-      "X-Trace": "secondary",
-    });
-
-    client.as("userB").rawReq.get("/api/v1/context", { "X-Test": "1" });
-
-    expect(mockHttp.get).toHaveBeenCalledWith("http://api.test/api/v1/context", {
-      headers: expect.objectContaining({
-        "Content-Type": "application/json",
-        "X-Organization-Id": "org-beta",
-        "x-route": "route-a",
-        "X-Test": "1",
-        "x-request-id": expect.stringContaining("tk_unit_exec_"),
-      }),
-    });
-  });
-
-  it("builds multipart requests without forcing json content type", () => {
-    const client = createHttpClient({
-      baseUrl: "http://api.test",
-      defaultActor: "userA",
-      sessionBundle: makeSessionBundle(),
-      getHeaders({ actor }) {
-        return actor?.jwt
-          ? {
-              Authorization: `Bearer ${actor.jwt}`,
-              "Content-Type": "application/json",
-              "X-Organization-Id": actor.organizationId,
-            }
-          : {};
-      },
-    });
-
-    client.multipart.post("/api/v1/uploads", {
-      fields: { name: "fixture-upload" },
-      files: [
-        {
-          field: "file",
-          data: "hello world",
-          filename: "fixture.txt",
-          contentType: "text/plain",
-        },
-      ],
-    });
-
-    expect(mockHttp.file).toHaveBeenCalledWith("hello world", "fixture.txt", "text/plain");
-    expect(mockHttp.post).toHaveBeenCalledWith(
-      "http://api.test/api/v1/uploads",
-      {
-        file: {
-          __testkitFile: true,
-          contentType: "text/plain",
-          data: "hello world",
-          filename: "fixture.txt",
-        },
-        name: "fixture-upload",
-      },
-      {
-        headers: expect.objectContaining({
-          Authorization: "Bearer jwt-user-a",
-          "X-Organization-Id": "org-alpha",
-          "x-request-id": expect.stringContaining("tk_unit_exec_"),
-        }),
-      }
-    );
-    expect(mockHttp.post.mock.calls[0][2].headers["Content-Type"]).toBeUndefined();
-  });
-});

package/lib/runtime-src/shared/http-parsing.test.mjs

@@ -1,69 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  extractCookie,
-  getSseEventData,
-  parseJsonBody,
-  parseSseEvents,
-} from "./http-parsing.mjs";
-import {
-  deriveDeterministicIp,
-  extractErrorMessageFromBody,
-  hasStandardErrorShape,
-} from "./error-body.mjs";
-
-describe("runtime shared parsing", () => {
-  it("extracts cookies from set-cookie headers", () => {
-    const response = {
-      headers: {
-        "set-cookie": [
-          "fixture_session=jwt-primary; Path=/",
-          "fixture_refresh=refresh-primary; Path=/",
-        ],
-      },
-    };
-
-    expect(extractCookie(response, "fixture_session")).toBe("jwt-primary");
-    expect(extractCookie(response, "fixture_refresh")).toBe("refresh-primary");
-    expect(extractCookie(response, "missing")).toBeNull();
-  });
-
-  it("parses JSON response bodies", () => {
-    expect(parseJsonBody({ body: "{\"ok\":true}" })).toEqual({ ok: true });
-  });
-
-  it("parses SSE events and extracts typed event data", () => {
-    const body = [
-      "event: progress",
-      "data: {\"step\":1}",
-      "",
-      "event: complete",
-      "data: {\"success\":true}",
-      "",
-    ].join("\n");
-
-    expect(parseSseEvents(body)).toEqual([
-      { event: "progress", data: { step: 1 } },
-      { event: "complete", data: { success: true } },
-    ]);
-    expect(getSseEventData(body, "complete")).toEqual({ success: true });
-  });
-});
-
-describe("runtime shared error helpers", () => {
-  it("extracts human-readable error messages", () => {
-    expect(extractErrorMessageFromBody({ error: "bad request" })).toBe("bad request");
-    expect(extractErrorMessageFromBody({ error: { message: "nested" } })).toBe("nested");
-    expect(extractErrorMessageFromBody({ message: "top-level" })).toBe("top-level");
-    expect(extractErrorMessageFromBody({ ok: true })).toBeNull();
-  });
-
-  it("detects the standard structured error shape", () => {
-    expect(hasStandardErrorShape({ error: { code: "BAD", message: "boom" } })).toBe(true);
-    expect(hasStandardErrorShape({ error: { message: "boom" } })).toBe(false);
-  });
-
-  it("derives deterministic test-network IPs", () => {
-    expect(deriveDeterministicIp("bourne", 1)).toBe(deriveDeterministicIp("bourne", 1));
-    expect(deriveDeterministicIp("bourne", 1)).not.toBe(deriveDeterministicIp("bourne", 2));
-  });
-});