@elench/testkit 0.1.65 → 0.1.67

package/lib/known-failures/github.mjs

@@ -1,10 +1,18 @@
-import fs from "fs";
-import path from "path";
-import { execFile } from "child_process";
-import { promisify } from "util";
 import { findMatchingKnownFailureEntries } from "./index.mjs";
-
-const execFileAsync = promisify(execFile);
+import {
+  applyStaleCacheFallback,
+  loadIssueCache,
+  mergeIssuesByRepo,
+  resolveIssueCache,
+  updateIssueCache,
+  writeIssueCache,
+} from "./github-cache.mjs";
+import {
+  createDefaultGitHubIssueTransport,
+  fetchIssuesByRepo,
+  parseGitHubRepoSlug,
+} from "./github-transport.mjs";
+export { parseGitHubRepoSlug } from "./github-transport.mjs";
 const DEFAULT_CACHE_TTL_SECONDS = 15 * 60;
 const CACHE_SCHEMA_VERSION = 1;
 const CACHE_PATH = [".testkit", "known-failures", "github-issues-cache.json"];
@@ -60,7 +68,7 @@ export async function validateKnownFailureIssues({
   const issueNumbersByRepo = groupIssueNumbersByRepo(document.entries);
   const repoSlug = gitMetadata?.repoSlug || null;
   const remoteUrl = gitMetadata?.remoteUrl || null;
-  const cache = loadIssueCache(productDir);
+  const cache = loadIssueCache(productDir, CACHE_PATH, CACHE_SCHEMA_VERSION);
   const cacheResolution = resolveIssueCache(cache, issueNumbersByRepo, normalizedConfig, now);
   const availabilityFindings = [];
   let issuesByRepo = cacheResolution.issuesByRepo;
@@ -71,8 +79,8 @@ export async function validateKnownFailureIssues({
       try {
         const fetchedIssues = await fetchIssuesByRepo(client, cacheResolution.missingByRepo);
         issuesByRepo = mergeIssuesByRepo(issuesByRepo, fetchedIssues);
-        updateIssueCache(cache, fetchedIssues, now);
-        writeIssueCache(productDir, cache);
+        updateIssueCache(cache, fetchedIssues, now, CACHE_SCHEMA_VERSION);
+        writeIssueCache(productDir, CACHE_PATH, cache);
       } catch (error) {
         issuesByRepo = applyStaleCacheFallback(
           issuesByRepo,
@@ -191,167 +199,6 @@ export function buildKnownFailureIssueValidationSummaryLines(result) {
   ];
 }
 
-export function parseGitHubRepoSlug(remoteUrl) {
-  const normalized = normalizeOptionalString(remoteUrl);
-  if (!normalized) return null;
-
-  let match = normalized.match(/^https:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?$/i);
-  if (match) return `${match[1]}/${match[2]}`;
-
-  match = normalized.match(/^git@github\.com:([^/]+)\/([^/]+?)(?:\.git)?$/i);
-  if (match) return `${match[1]}/${match[2]}`;
-
-  match = normalized.match(/^ssh:\/\/git@github\.com\/([^/]+)\/([^/]+?)(?:\.git)?$/i);
-  if (match) return `${match[1]}/${match[2]}`;
-
-  return null;
-}
-
-async function createDefaultGitHubIssueTransport() {
-  const token = process.env.GH_TOKEN || process.env.GITHUB_TOKEN || null;
-  if (token) {
-    return {
-      type: "token",
-      async fetchRepoIssues(repo, numbers) {
-        return fetchRepoIssuesViaToken(repo, numbers, token);
-      },
-    };
-  }
-
-  try {
-    await execFileAsync("gh", ["auth", "status"], {
-      encoding: "utf8",
-      env: process.env,
-      maxBuffer: 1024 * 1024,
-    });
-    return {
-      type: "gh",
-      async fetchRepoIssues(repo, numbers) {
-        return fetchRepoIssuesViaGh(repo, numbers);
-      },
-    };
-  } catch {
-    return null;
-  }
-}
-
-async function fetchIssuesByRepo(client, issueNumbersByRepo) {
-  const issuesByRepo = new Map();
-
-  for (const [repo, numbers] of issueNumbersByRepo.entries()) {
-    const issueMap = new Map();
-    const chunks = chunkValues(numbers, 40);
-    for (const chunk of chunks) {
-      const fetched = await client.fetchRepoIssues(repo, chunk);
-      for (const [number, issue] of fetched.entries()) {
-        issueMap.set(number, issue);
-      }
-    }
-    issuesByRepo.set(repo, issueMap);
-  }
-
-  return issuesByRepo;
-}
-
-async function fetchRepoIssuesViaToken(repo, numbers, token) {
-  const query = buildIssueQuery(repo, numbers);
-  const response = await fetch("https://api.github.com/graphql", {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Accept: "application/vnd.github+json",
-      Authorization: `Bearer ${token}`,
-      "X-GitHub-Api-Version": "2022-11-28",
-    },
-    body: JSON.stringify({ query }),
-  });
-
-  const payload = await response.json().catch(() => null);
-  if (!response.ok) {
-    throw new Error(
-      `GitHub GraphQL request failed with ${response.status}${
-        payload?.message ? `: ${payload.message}` : ""
-      }`
-    );
-  }
-  if (Array.isArray(payload?.errors) && payload.errors.length > 0) {
-    throw new Error(payload.errors.map((error) => error.message).join("; "));
-  }
-  return normalizeGraphqlIssuesResponse(repo, numbers, payload?.data);
-}
-
-async function fetchRepoIssuesViaGh(repo, numbers) {
-  const query = buildIssueQuery(repo, numbers);
-  const { stdout } = await execFileAsync(
-    "gh",
-    ["api", "graphql", "-f", `query=${query}`],
-    {
-      encoding: "utf8",
-      env: process.env,
-      maxBuffer: 1024 * 1024,
-    }
-  );
-  const payload = JSON.parse(stdout);
-  if (Array.isArray(payload?.errors) && payload.errors.length > 0) {
-    throw new Error(payload.errors.map((error) => error.message).join("; "));
-  }
-  return normalizeGraphqlIssuesResponse(repo, numbers, payload?.data);
-}
-
-function buildIssueQuery(repo, numbers) {
-  const [owner, name] = repo.split("/");
-  return `
-    query TestkitKnownFailureIssues {
-      repository(owner: ${JSON.stringify(owner)}, name: ${JSON.stringify(name)}) {
-        ${numbers
-          .map(
-            (number) => `
-          issue_${number}: issue(number: ${number}) {
-            number
-            title
-            state
-            url
-          }
-        `
-          )
-          .join("\n")}
-      }
-    }
-  `;
-}
-
-function normalizeGraphqlIssuesResponse(repo, numbers, data) {
-  const map = new Map();
-  const repository = data?.repository || null;
-  for (const number of numbers) {
-    const issue = repository?.[`issue_${number}`] || null;
-    if (!issue) {
-      map.set(number, {
-        repo,
-        number,
-        exists: false,
-        title: null,
-        state: null,
-        url: null,
-        checkedAt: null,
-        source: "github",
-      });
-      continue;
-    }
-
-    map.set(number, {
-      repo,
-      number: issue.number,
-      exists: true,
-      title: normalizeOptionalString(issue.title),
-      state: normalizeOptionalString(issue.state),
-      url: normalizeOptionalString(issue.url),
-      checkedAt: null,
-      source: "github",
-    });
-  }
-  return map;
-}
 
 function collectObservedKnownFailureEntries(document, runArtifact, statusArtifact) {
   const observedTests = collectObservedTests(runArtifact, statusArtifact);
@@ -583,161 +430,6 @@ function buildIssueValidationSummary(entries, globalFindings) {
   };
 }
 
-function loadIssueCache(productDir) {
-  const filePath = getIssueCachePath(productDir);
-  if (!fs.existsSync(filePath)) {
-    return {
-      schemaVersion: CACHE_SCHEMA_VERSION,
-      entries: {},
-    };
-  }
-
-  try {
-    const parsed = JSON.parse(fs.readFileSync(filePath, "utf8"));
-    if (parsed?.schemaVersion !== CACHE_SCHEMA_VERSION || typeof parsed.entries !== "object") {
-      return {
-        schemaVersion: CACHE_SCHEMA_VERSION,
-        entries: {},
-      };
-    }
-    return parsed;
-  } catch {
-    return {
-      schemaVersion: CACHE_SCHEMA_VERSION,
-      entries: {},
-    };
-  }
-}
-
-function resolveIssueCache(cache, issueNumbersByRepo, config, now) {
-  const issuesByRepo = new Map();
-  const missingByRepo = new Map();
-  const staleByRepo = new Map();
-  const ttlMs = config.cacheTtlSeconds * 1000;
-
-  for (const [repo, numbers] of issueNumbersByRepo.entries()) {
-    const cachedIssues = new Map();
-    const missing = [];
-    const stale = [];
-
-    for (const number of numbers) {
-      const key = buildIssueCacheKey(repo, number);
-      const cached = cache.entries[key];
-      if (!cached) {
-        missing.push(number);
-        continue;
-      }
-
-      const checkedAt = Date.parse(cached.checkedAt);
-      const normalized = {
-        repo,
-        number,
-        exists: Boolean(cached.exists),
-        title: normalizeOptionalString(cached.title),
-        state: normalizeOptionalString(cached.state),
-        url: normalizeOptionalString(cached.url),
-        checkedAt: cached.checkedAt || null,
-        source: "cache",
-      };
-
-      if (!Number.isFinite(checkedAt) || now - checkedAt > ttlMs) {
-        stale.push(number);
-        cachedIssues.set(number, normalized);
-        continue;
-      }
-
-      cachedIssues.set(number, normalized);
-    }
-
-    issuesByRepo.set(repo, cachedIssues);
-    if (missing.length > 0 || stale.length > 0) {
-      missingByRepo.set(repo, [...new Set([...missing, ...stale])].sort((a, b) => a - b));
-    }
-    if (stale.length > 0) {
-      staleByRepo.set(repo, stale.sort((a, b) => a - b));
-    }
-  }
-
-  return {
-    issuesByRepo,
-    missingByRepo,
-    staleByRepo,
-  };
-}
-
-function updateIssueCache(cache, issuesByRepo, now) {
-  cache.schemaVersion = CACHE_SCHEMA_VERSION;
-  cache.entries = cache.entries || {};
-  const checkedAt = new Date(now).toISOString();
-
-  for (const [repo, issues] of issuesByRepo.entries()) {
-    for (const [number, issue] of issues.entries()) {
-      issue.checkedAt = checkedAt;
-      cache.entries[buildIssueCacheKey(repo, number)] = {
-        exists: issue.exists,
-        title: issue.title,
-        state: issue.state,
-        url: issue.url,
-        checkedAt,
-      };
-    }
-  }
-}
-
-function writeIssueCache(productDir, cache) {
-  const filePath = getIssueCachePath(productDir);
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-  fs.writeFileSync(filePath, `${JSON.stringify(cache, null, 2)}\n`);
-}
-
-function getIssueCachePath(productDir) {
-  return path.join(productDir, ...CACHE_PATH);
-}
-
-function applyStaleCacheFallback(issuesByRepo, staleByRepo, findings) {
-  let usedStale = false;
-  for (const [repo, numbers] of staleByRepo.entries()) {
-    const issues = issuesByRepo.get(repo);
-    if (!issues) continue;
-    for (const number of numbers) {
-      if (issues.has(number)) {
-        usedStale = true;
-      }
-    }
-  }
-  if (usedStale) {
-    findings.push({
-      code: "used_stale_cache",
-      severity: "warning",
-      message: "Used stale cached GitHub issue metadata because fresh validation failed",
-    });
-  }
-  return issuesByRepo;
-}
-
-function mergeIssuesByRepo(left, right) {
-  const merged = new Map();
-  for (const [repo, issues] of left.entries()) {
-    merged.set(repo, new Map(issues.entries()));
-  }
-
-  for (const [repo, issues] of right.entries()) {
-    if (!merged.has(repo)) {
-      merged.set(repo, new Map());
-    }
-    const mergedIssues = merged.get(repo);
-    for (const [number, issue] of issues.entries()) {
-      mergedIssues.set(number, issue);
-    }
-  }
-
-  return merged;
-}
-
-function buildIssueCacheKey(repo, number) {
-  return `${repo}#${number}`;
-}
-
 function normalizeIssueState(value) {
   const normalized = normalizeOptionalString(value);
   if (!normalized) return null;

package/lib/runner/default-runtime-runner.mjs

@@ -2,7 +2,7 @@ import fs from "fs";
 import path from "path";
 import { execa } from "execa";
 import { bundleK6File } from "../bundler/index.mjs";
-import { resolveK6Binary } from "../config/index.mjs";
+import { resolveK6Binary } from "../config/binaries.mjs";
 import {
   buildFileTimeoutEnv,
   formatFileTimeoutBudgetError,
@@ -16,6 +16,7 @@ import { collectFailureDetailsFromRuntimeArtifacts } from "./failure-details.mjs
 import { RUNTIME_ARTIFACT_MARKER } from "../runtime-src/k6/artifacts.js";
 import { readDatabaseUrl } from "./state-io.mjs";
 import { buildTaskExecutionEnv } from "./template.mjs";
+import { registerManagedProcess, unregisterManagedProcess } from "./managed-processes.mjs";
 import { killChildProcess } from "./processes.mjs";
 
 export async function runHttpK6Task(targetConfig, task, lifecycle, lease, reporter = null) {
@@ -105,21 +106,14 @@ export async function runDefaultRuntimeTask(
       forceKillAfterDelay: 5_000,
     }
   );
-  lifecycle.registerProcess(subprocess, () => {
-    killChildProcess(subprocess, "SIGINT");
-  });
-  if (lifecycle.isStopRequested()) {
-    const interruptSubprocess = () => killChildProcess(subprocess, "SIGINT");
-    if (subprocess.pid) interruptSubprocess();
-    else subprocess.once?.("spawn", interruptSubprocess);
-  }
+  registerManagedProcess(lifecycle, subprocess, "SIGINT");
   reporter?.taskStarted?.(task, targetConfig);
   let result;
   let timedOut;
   try {
     ({ result, timedOut } = await settleSubprocess(subprocess, fileTimeoutSeconds));
   } finally {
-    lifecycle.unregisterProcess(subprocess.pid);
+    unregisterManagedProcess(lifecycle, subprocess);
   }
 
   const stdout = parseDefaultRuntimeOutput(result.stdout || "");

package/lib/runner/execution-config.mjs

@@ -1,85 +1,14 @@
-import {
+export {
+  DATABASE_BINDINGS,
   DEFAULT_FILE_TIMEOUT_SECONDS,
-  normalizeFileTimeoutSeconds,
+  buildRuntimeIds,
+  normalizeDatabaseBinding,
+  normalizeExecutionConfig,
+  normalizeRuntimeInstances,
+  normalizeRuntimeMaxConcurrentTasks,
   parseFileTimeoutOption,
-} from "../shared/file-timeout.mjs";
-
-export const DATABASE_BINDINGS = new Set(["shared", "per-runtime"]);
-
-export { DEFAULT_FILE_TIMEOUT_SECONDS, parseFileTimeoutOption };
-
-export function parseWorkersOption(value) {
-  return parsePositiveInteger(value, "--workers");
-}
-
-export function parseRuntimeInstancesOption(value, label = "runtime.instances") {
-  return parsePositiveInteger(value, label);
-}
-
-export function normalizeRuntimeInstances(value, label = "runtime.instances") {
-  return normalizePositiveInteger(value, label);
-}
-
-export function parseRuntimeMaxConcurrentTasksOption(
-  value,
-  label = "runtime.maxConcurrentTasks"
-) {
-  return parsePositiveInteger(value, label);
-}
-
-export function normalizeRuntimeMaxConcurrentTasks(
-  value,
-  label = "runtime.maxConcurrentTasks"
-) {
-  if (value === undefined || value === null) {
-    return Number.POSITIVE_INFINITY;
-  }
-  return normalizePositiveInteger(value, label);
-}
-
-export function normalizeDatabaseBinding(value, label = "database.binding") {
-  const normalized = String(value || "").trim();
-  if (!DATABASE_BINDINGS.has(normalized)) {
-    throw new Error(
-      `Invalid ${label} value "${value}". Expected one of: shared, per-runtime.`
-    );
-  }
-  return normalized;
-}
-
-export function resolveExecutionConfig({ cli = {}, repo = {} } = {}) {
-  return normalizeExecutionConfig({
-    workers: cli.workers ?? repo.workers ?? 1,
-    fileTimeoutSeconds:
-      cli.fileTimeoutSeconds ?? repo.fileTimeoutSeconds ?? DEFAULT_FILE_TIMEOUT_SECONDS,
-  });
-}
-
-export function normalizeExecutionConfig(input = {}) {
-  return {
-    workers: normalizePositiveInteger(input.workers ?? 1, "execution.workers"),
-    fileTimeoutSeconds: normalizeFileTimeoutSeconds(
-      input.fileTimeoutSeconds ?? DEFAULT_FILE_TIMEOUT_SECONDS
-    ),
-  };
-}
-
-export function buildRuntimeIds(count) {
-  return Array.from({ length: count }, (_unused, index) => `runtime-${index + 1}`);
-}
-
-function parsePositiveInteger(value, label) {
-  const parsed = Number.parseInt(String(value), 10);
-  if (!Number.isInteger(parsed) || parsed <= 0) {
-    throw new Error(`Invalid ${label} value "${value}". Expected a positive integer.`);
-  }
-  return parsed;
-}
-
-function normalizePositiveInteger(value, label) {
-  const parsed = Number(value);
-  if (!Number.isInteger(parsed) || parsed <= 0) {
-    throw new Error(`${label} must be a positive integer.`);
-  }
-  return parsed;
-}
+  parseRuntimeInstancesOption,
+  parseRuntimeMaxConcurrentTasksOption,
+  parseWorkersOption,
+  resolveExecutionConfig,
+} from "../shared/execution-schema.mjs";

package/lib/runner/live-run.mjs

@@ -0,0 +1,45 @@
+import { finalizeServiceResult, summarizeDbBackend } from "./results.mjs";
+import { buildLiveRunArtifact } from "./reporting.mjs";
+import { writeLiveRunArtifact } from "./artifacts.mjs";
+
+export function createLiveSnapshotWriter({
+  productDir,
+  configs,
+  trackers,
+  startedAt,
+  execution,
+  workerState,
+  selection,
+  metadata,
+  logRegistry,
+  setupRegistry,
+}) {
+  return () => {
+    const now = Date.now();
+    const partialResults = configs.map((config) => finalizeServiceResult(trackers.get(config.name), startedAt, now));
+    writeLiveRunArtifact(
+      productDir,
+      buildLiveRunArtifact({
+        productDir,
+        results: partialResults,
+        startedAt,
+        updatedAt: now,
+        execution,
+        workerCount: workerState.workerCount,
+        runtimeInstanceCount: workerState.runtimeInstanceCount,
+        runtimeStats: workerState.runtimeStats,
+        typeValues: selection.typeValues,
+        suiteSelectors: selection.suiteSelectors,
+        fileNames: selection.fileNames,
+        shard: selection.shard,
+        serviceFilter: selection.serviceFilter,
+        scenarioSeed: selection.scenarioSeed,
+        metadata,
+        summarizeDbBackend,
+        serviceLogs: logRegistry.listServiceLogs(),
+        setupLogs: logRegistry.listSetupLogs(),
+        setupOperations: setupRegistry.listOperations(),
+      })
+    );
+  };
+}

package/lib/runner/managed-processes.mjs

@@ -0,0 +1,29 @@
+import { killChildProcess } from "./processes.mjs";
+
+export function registerManagedProcess(lifecycle, subprocess, signal = "SIGINT") {
+  lifecycle.registerProcess(subprocess, () => {
+    killChildProcess(subprocess, signal);
+  });
+  if (lifecycle.isStopRequested()) {
+    interruptManagedProcess(subprocess, signal);
+  }
+}
+
+export function unregisterManagedProcess(lifecycle, subprocess) {
+  lifecycle.unregisterProcess(subprocess.pid);
+}
+
+export function registerManagedService(lifecycle, config, child, cwd, signal = "SIGTERM") {
+  lifecycle.registerService(config, child, cwd, () => {
+    killChildProcess(child, signal);
+  });
+  if (lifecycle.isStopRequested()) {
+    interruptManagedProcess(child, signal);
+  }
+}
+
+function interruptManagedProcess(subprocess, signal) {
+  const interruptSubprocess = () => killChildProcess(subprocess, signal);
+  if (subprocess.pid) interruptSubprocess();
+  else subprocess.once?.("spawn", interruptSubprocess);
+}