@elench/testkit 0.1.17 → 0.1.19

package/lib/runtime-src/k6/dal-suite.js

@@ -0,0 +1,33 @@
+import { defaultOptions } from "./checks.js";
+import { createDalContext, openDb } from "./dal.js";
+
+export function defineDalSuite(configOrRun, maybeRun) {
+  const { config, run } = normalizeSuiteArgs(configOrRun, maybeRun);
+  const db = config.db || openDb();
+  const dal = createDalContext(db);
+
+  return {
+    options: config.options || defaultOptions,
+    setup() {
+      if (typeof config.setup !== "function") return null;
+      return config.setup({ db, dal });
+    },
+    exec(setupData) {
+      return run({
+        db,
+        dal,
+        setupData,
+      });
+    },
+  };
+}
+
+function normalizeSuiteArgs(configOrRun, maybeRun) {
+  if (typeof configOrRun === "function") {
+    return { config: {}, run: configOrRun };
+  }
+  if (typeof maybeRun !== "function") {
+    throw new Error("suite factory requires a run callback");
+  }
+  return { config: configOrRun || {}, run: maybeRun };
+}

package/lib/runtime-src/k6/dal.js

@@ -0,0 +1,32 @@
+import sql from "k6/x/sql";
+import driver from "k6/x/sql/driver/postgres";
+import {
+  allMatch,
+  contains,
+  defaultOptions,
+  isSorted,
+} from "./checks.js";
+
+export { allMatch, contains, defaultOptions, isSorted };
+
+export function openDb() {
+  const url = __ENV.DATABASE_URL;
+  if (!url) {
+    throw new Error("DATABASE_URL env var required");
+  }
+  return sql.open(driver, url);
+}
+
+export function truncate(db, ...tables) {
+  if (tables.length === 0) return;
+  db.exec(`TRUNCATE ${tables.join(", ")} CASCADE`);
+}
+
+export function createDalContext(db = openDb()) {
+  return {
+    db,
+    truncate(...tables) {
+      return truncate(db, ...tables);
+    },
+  };
+}

package/lib/runtime-src/k6/http.js

@@ -0,0 +1,134 @@
+import http from "k6/http";
+import { defaultOptions } from "./checks.js";
+
+export { defaultOptions };
+
+export function getEnv() {
+  const BASE = __ENV.BASE_URL;
+  const MACHINE_ID = __ENV.MACHINE_ID;
+
+  if (!BASE) {
+    throw new Error("BASE_URL env var required");
+  }
+
+  const routeParams = MACHINE_ID ? { "fly-force-instance-id": MACHINE_ID } : {};
+  return { BASE, MACHINE_ID, routeParams };
+}
+
+export function createHttpClient(config) {
+  const {
+    baseUrl,
+    routeHeaders = {},
+    defaultHeaders = { "Content-Type": "application/json" },
+    getHeaders = null,
+    getRawHeaders = null,
+  } = config;
+
+  if (!baseUrl) {
+    throw new Error("baseUrl is required");
+  }
+
+  function buildHeaders(builder, setupData, extraHeaders = {}) {
+    return {
+      ...defaultHeaders,
+      ...safeHeaders(builder, setupData),
+      ...routeHeaders,
+      ...extraHeaders,
+    };
+  }
+
+  function request(method, path, setupData, body, extraHeaders = {}) {
+    const url = `${baseUrl}${path}`;
+    const headers = buildHeaders(getHeaders, setupData, extraHeaders);
+    return runHttpRequest(method, url, body, headers);
+  }
+
+  function raw(method, path, body, extraHeaders = {}) {
+    const url = `${baseUrl}${path}`;
+    const headers = buildHeaders(getRawHeaders, null, extraHeaders);
+    return runHttpRequest(method, url, body, headers);
+  }
+
+  function getWithHeaders(path, setupData, extraHeaders = {}) {
+    return http.get(`${baseUrl}${path}`, {
+      headers: buildHeaders(getHeaders, setupData, extraHeaders),
+    });
+  }
+
+  return {
+    request,
+    raw,
+    get(path, setupData, extraHeaders = {}) {
+      return request("GET", path, setupData, null, extraHeaders);
+    },
+    put(path, setupData, body, extraHeaders = {}) {
+      return request("PUT", path, setupData, body, extraHeaders);
+    },
+    post(path, setupData, body, extraHeaders = {}) {
+      return request("POST", path, setupData, body, extraHeaders);
+    },
+    patch(path, setupData, body, extraHeaders = {}) {
+      return request("PATCH", path, setupData, body, extraHeaders);
+    },
+    delete(path, setupData, extraHeaders = {}) {
+      return request("DELETE", path, setupData, null, extraHeaders);
+    },
+    rawGet(path, extraHeaders = {}) {
+      return raw("GET", path, null, extraHeaders);
+    },
+    rawPost(path, body, extraHeaders = {}) {
+      return raw("POST", path, body, extraHeaders);
+    },
+    rawPut(path, body, extraHeaders = {}) {
+      return raw("PUT", path, body, extraHeaders);
+    },
+    rawPatch(path, body, extraHeaders = {}) {
+      return raw("PATCH", path, body, extraHeaders);
+    },
+    rawDelete(path, extraHeaders = {}) {
+      return raw("DELETE", path, null, extraHeaders);
+    },
+    getWithHeaders,
+  };
+}
+
+export function makeReq(baseUrl, routeHeaders = {}, getHeaders = null) {
+  return createHttpClient({
+    baseUrl,
+    routeHeaders,
+    getHeaders,
+  }).request;
+}
+
+export function makeRawReq(baseUrl, routeHeaders = {}, getRawHeaders = null) {
+  return createHttpClient({
+    baseUrl,
+    routeHeaders,
+    getRawHeaders,
+  }).raw;
+}
+
+export function makeGetWithHeaders(baseUrl, routeHeaders = {}, getHeaders = null) {
+  return createHttpClient({
+    baseUrl,
+    routeHeaders,
+    getHeaders,
+  }).getWithHeaders;
+}
+
+function runHttpRequest(method, url, body, headers) {
+  const options = { headers };
+
+  if (method === "GET") return http.get(url, options);
+  if (method === "PUT") return http.put(url, JSON.stringify(body), options);
+  if (method === "POST") return http.post(url, JSON.stringify(body), options);
+  if (method === "PATCH") return http.patch(url, JSON.stringify(body), options);
+  if (method === "DELETE") return http.del(url, null, options);
+
+  throw new Error(`unsupported method: ${method}`);
+}
+
+function safeHeaders(builder, setupData) {
+  if (typeof builder !== "function") return {};
+  return builder(setupData) || {};
+}

package/lib/runtime-src/k6/suite.js

@@ -0,0 +1,55 @@
+import { defaultOptions } from "./checks.js";
+import { createHttpClient, getEnv } from "./http.js";
+
+export function defineHttpSuite(configOrRun, maybeRun) {
+  const { config, run } = normalizeSuiteArgs(configOrRun, maybeRun);
+  const env = config.env || getEnv();
+  const auth = config.auth || null;
+
+  const client = createHttpClient({
+    baseUrl: env.BASE,
+    routeHeaders: env.routeParams,
+    getHeaders(setupData) {
+      return {
+        ...callHeaders(auth?.headers, setupData, env),
+        ...callHeaders(config.headers, setupData, env),
+      };
+    },
+    getRawHeaders(setupData) {
+      return callHeaders(config.rawHeaders, setupData, env);
+    },
+  });
+
+  return {
+    options: config.options || defaultOptions,
+    setup() {
+      if (typeof auth?.setup !== "function") return null;
+      return auth.setup({ env });
+    },
+    exec(setupData) {
+      return run({
+        env,
+        req: client.request,
+        rawReq: client.raw,
+        getWithHeaders: client.getWithHeaders,
+        setupData,
+        session: setupData,
+      });
+    },
+  };
+}
+
+function normalizeSuiteArgs(configOrRun, maybeRun) {
+  if (typeof configOrRun === "function") {
+    return { config: {}, run: configOrRun };
+  }
+  if (typeof maybeRun !== "function") {
+    throw new Error("suite factory requires a run callback");
+  }
+  return { config: configOrRun || {}, run: maybeRun };
+}
+
+function callHeaders(builder, setupData, env) {
+  if (typeof builder !== "function") return {};
+  return builder(setupData, { env }) || {};
+}

package/lib/telemetry/index.mjs

@@ -0,0 +1,43 @@
+export async function uploadTelemetryArtifact(telemetry, artifact) {
+  if (!telemetry?.enabled) return { skipped: true, reason: "disabled" };
+  if (process.env.TESTKIT_TELEMETRY === "0") {
+    return { skipped: true, reason: "disabled-by-env" };
+  }
+  if (!telemetry.endpoint) {
+    return { skipped: true, reason: "missing-endpoint" };
+  }
+  if (!telemetry.tokenEnv) {
+    return { skipped: true, reason: "missing-token-env" };
+  }
+
+  const token = process.env[telemetry.tokenEnv];
+  if (!token) {
+    return { skipped: true, reason: "missing-token" };
+  }
+
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), telemetry.timeoutMs || 3_000);
+
+  try {
+    const response = await fetch(telemetry.endpoint, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(artifact),
+      signal: controller.signal,
+    });
+
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      throw new Error(
+        `telemetry upload failed with ${response.status}${body ? `: ${body.trim()}` : ""}`
+      );
+    }
+
+    return { skipped: false, ok: true };
+  } finally {
+    clearTimeout(timeout);
+  }
+}

package/lib/timing/index.mjs

@@ -0,0 +1,73 @@
+import path from "path";
+
+export function createEmptyTimings() {
+  return {
+    version: 1,
+    files: {},
+  };
+}
+
+export function normalizeTimings(parsed) {
+  return {
+    version: 1,
+    files: parsed?.files && typeof parsed.files === "object" ? parsed.files : {},
+  };
+}
+
+export function applyTimingUpdates(timings, updates, updatedAt = new Date().toISOString()) {
+  const next = {
+    version: 1,
+    files: { ...timings.files },
+  };
+
+  for (const update of updates) {
+    const existing = next.files[update.key];
+    if (!existing) {
+      next.files[update.key] = {
+        durationMs: Math.max(1, Math.round(update.durationMs)),
+        runs: 1,
+        updatedAt,
+      };
+      continue;
+    }
+
+    const runs = Number(existing.runs || 0) + 1;
+    const durationMs = Math.max(
+      1,
+      Math.round(((existing.durationMs || update.durationMs) * (runs - 1) + update.durationMs) / runs)
+    );
+    next.files[update.key] = {
+      durationMs,
+      runs,
+      updatedAt,
+    };
+  }
+
+  return next;
+}
+
+export function estimateTaskDuration(timings, timingKey, suite) {
+  const cached = timings.files[timingKey];
+  if (cached?.durationMs) return cached.durationMs;
+
+  const base =
+    suite.framework === "playwright"
+      ? 20_000
+      : suite.type === "dal"
+        ? 4_000
+        : 8_000;
+  return Math.max(1_000, Math.round((base * suite.weight) / Math.max(1, suite.files.length)));
+}
+
+export function buildTimingKey(serviceName, suite, file) {
+  return [
+    serviceName,
+    suite.framework,
+    suite.type,
+    normalizePathSeparators(file),
+  ].join("|");
+}
+
+function normalizePathSeparators(filePath) {
+  return filePath.split(path.sep).join("/");
+}

package/lib/timing/index.test.mjs

@@ -0,0 +1,64 @@
+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/package.json

@@ -1,20 +1,35 @@
 {
   "name": "@elench/testkit",
-  "version": "0.1.17",
+  "version": "0.1.19",
   "description": "CLI for running manifest-defined local test suites across k6 and Playwright",
   "type": "module",
+  "exports": {
+    ".": "./lib/index.mjs",
+    "./k6": "./lib/k6/index.mjs",
+    "./k6/*": "./lib/k6/*.mjs",
+    "./package.json": "./package.json"
+  },
   "bin": {
     "testkit": "bin/testkit.mjs"
   },
+  "scripts": {
+    "test": "vitest run",
+    "test:unit": "vitest run lib",
+    "test:integration": "vitest run test/integration",
+    "test:system": "vitest run test/system --passWithNoTests"
+  },
   "files": [
     "bin/",
     "lib/",
-    "infra/neon-up.sh",
-    "infra/neon-down.sh",
     "vendor/"
   ],
+  "devDependencies": {
+    "@playwright/test": "^1.52.0",
+    "vitest": "^3.2.4"
+  },
   "dependencies": {
     "cac": "^6.7.14",
+    "esbuild": "^0.25.11",
     "execa": "^9.5.0"
   },
   "engines": {

package/infra/neon-down.sh

@@ -1,18 +0,0 @@
-#!/usr/bin/env bash
-# Deletes the ephemeral Neon branch from .state/
-# Requires: NEON_API_KEY, NEON_PROJECT_ID
-set -eo pipefail
-
-STATE_DIR="${STATE_DIR:-.state}"
-NEON_API="https://console.neon.tech/api/v2/projects/$NEON_PROJECT_ID"
-
-if [ ! -f "$STATE_DIR/neon_branch_id" ]; then
-  echo "No Neon branch to clean up"
-  exit 0
-fi
-
-BRANCH_ID=$(cat "$STATE_DIR/neon_branch_id")
-echo "Deleting Neon branch: $BRANCH_ID"
-curl -s -X DELETE "$NEON_API/branches/$BRANCH_ID" \
-  -H "Authorization: Bearer $NEON_API_KEY" > /dev/null
-echo "Neon branch deleted"

package/infra/neon-up.sh

@@ -1,124 +0,0 @@
-#!/usr/bin/env bash
-# Ensures a persistent Neon test branch exists and resets its data.
-# Creates the branch on first run; truncates tables on subsequent runs.
-# Requires: NEON_API_KEY, NEON_PROJECT_ID
-set -eo pipefail
-
-STATE_DIR="${STATE_DIR:-.state}"
-NEON_DB_NAME="${NEON_DB_NAME:-neondb}"
-BRANCH_NAME="${NEON_BRANCH_NAME:-testkit}"
-NEON_API="https://console.neon.tech/api/v2/projects/$NEON_PROJECT_ID"
-
-mkdir -p "$STATE_DIR"
-
-# ── 1. Check state file ──────────────────────────────────────────────────
-BRANCH_ID=""
-if [ -f "$STATE_DIR/neon_branch_id" ]; then
-  STORED_ID=$(cat "$STATE_DIR/neon_branch_id")
-  if curl -sf "$NEON_API/branches/$STORED_ID" \
-       -H "Authorization: Bearer $NEON_API_KEY" >/dev/null 2>&1; then
-    BRANCH_ID="$STORED_ID"
-    echo "Neon branch exists: $BRANCH_ID"
-  else
-    echo "Stored branch $STORED_ID gone — will discover or create"
-    rm -f "$STATE_DIR/neon_branch_id"
-  fi
-fi
-
-# ── 2. Discover existing branch by name ──────────────────────────────────
-if [ -z "$BRANCH_ID" ]; then
-  EXISTING_ID=$(curl -sf "$NEON_API/branches" \
-    -H "Authorization: Bearer $NEON_API_KEY" \
-    | jq -r --arg name "$BRANCH_NAME" '.branches[] | select(.name == $name) | .id' | head -1)
-
-  if [ -n "$EXISTING_ID" ] && [ "$EXISTING_ID" != "null" ]; then
-    BRANCH_ID="$EXISTING_ID"
-    echo "$BRANCH_ID" > "$STATE_DIR/neon_branch_id"
-    echo "Discovered existing Neon branch '$BRANCH_NAME': $BRANCH_ID"
-  fi
-fi
-
-# ── 3. Create branch if needed ───────────────────────────────────────────
-if [ -z "$BRANCH_ID" ]; then
-  echo "Creating Neon branch: $BRANCH_NAME"
-  RESPONSE=$(curl -sf -X POST "$NEON_API/branches" \
-    -H "Authorization: Bearer $NEON_API_KEY" \
-    -H "Content-Type: application/json" \
-    -d "{
-      \"branch\": { \"name\": \"$BRANCH_NAME\" },
-      \"endpoints\": [{ \"type\": \"read_write\", \"suspend_timeout_seconds\": 300 }]
-    }")
-
-  BRANCH_ID=$(echo "$RESPONSE" | jq -r '.branch.id')
-  if [ -z "$BRANCH_ID" ] || [ "$BRANCH_ID" = "null" ]; then
-    # Create failed — may be a 409 race (another parallel service created it).
-    # Re-discover by name before giving up.
-    BRANCH_ID=$(curl -sf "$NEON_API/branches" \
-      -H "Authorization: Bearer $NEON_API_KEY" \
-      | jq -r --arg name "$BRANCH_NAME" '.branches[] | select(.name == $name) | .id' | head -1)
-
-    if [ -z "$BRANCH_ID" ] || [ "$BRANCH_ID" = "null" ]; then
-      echo "ERROR: Failed to create or discover branch '$BRANCH_NAME'"
-      exit 1
-    fi
-    echo "Branch created by another process — discovered: $BRANCH_ID"
-  fi
-  echo "$BRANCH_ID" > "$STATE_DIR/neon_branch_id"
-
-  ENDPOINT_ID=$(echo "$RESPONSE" | jq -r '.endpoints[0].id')
-  if [ -n "$ENDPOINT_ID" ] && [ "$ENDPOINT_ID" != "null" ]; then
-    echo "Waiting for endpoint $ENDPOINT_ID to become active..."
-    for i in $(seq 1 30); do
-      EP_STATE=$(curl -sf "$NEON_API/endpoints/$ENDPOINT_ID" \
-        -H "Authorization: Bearer $NEON_API_KEY" \
-        | jq -r '.endpoint.current_state')
-      if [ "$EP_STATE" = "active" ] || [ "$EP_STATE" = "idle" ]; then
-        echo "Endpoint ready (state: $EP_STATE)"
-        break
-      fi
-      if [ "$i" -eq 30 ]; then
-        echo "WARNING: Endpoint still '$EP_STATE' after 30s"
-      fi
-      sleep 1
-    done
-  fi
-fi
-
-# ── Get connection URI ───────────────────────────────────────────────────
-CONN_URI=$(curl -sf "$NEON_API/connection_uri?branch_id=$BRANCH_ID&database_name=$NEON_DB_NAME&role_name=neondb_owner" \
-  -H "Authorization: Bearer $NEON_API_KEY" \
-  | jq -r '.uri')
-
-if [ -z "$CONN_URI" ] || [ "$CONN_URI" = "null" ]; then
-  echo "ERROR: Failed to get connection URI"
-  exit 1
-fi
-echo "$CONN_URI" > "$STATE_DIR/database_url"
-
-# ── Reset test data ─────────────────────────────────────────────────────
-NEON_RESET="${NEON_RESET:-true}"
-if [ "$NEON_RESET" = "false" ]; then
-  echo "Reset disabled — keeping fork data"
-elif command -v psql &>/dev/null; then
-  echo "Resetting test data..."
-  psql "$CONN_URI" -q -c "
-    DO \$\$
-    DECLARE r RECORD;
-    BEGIN
-      FOR r IN (
-        SELECT tablename FROM pg_tables
-        WHERE schemaname = 'public'
-        AND tablename NOT LIKE '%migration%'
-        AND tablename NOT LIKE 'goose_%'
-        AND tablename NOT LIKE 'drizzle_%'
-      ) LOOP
-        EXECUTE 'TRUNCATE TABLE public.' || quote_ident(r.tablename) || ' CASCADE';
-      END LOOP;
-    END \$\$;
-  " 2>/dev/null && echo "Tables truncated" || echo "First run — no tables to reset"
-else
-  echo "WARNING: psql not available — skipping data reset"
-fi
-
-echo "Neon branch ready: $BRANCH_ID"
-echo "Database URL saved to $STATE_DIR/database_url"