@elench/testkit 0.1.43 → 0.1.45

package/lib/runner/triage.mjs

@@ -1,35 +1,10 @@
-import fs from "fs";
-import path from "path";
+import {
+  buildKnownFailureFileIdentity,
+  findMatchingKnownFailureEntries,
+  loadKnownFailuresConfig,
+} from "../known-failures/index.mjs";
 
-const CLASSIFICATIONS = new Set([
-  "expected_failure",
-  "infra",
-  "product_bug",
-  "stale_test",
-  "test_bug",
-]);
-const STATES = new Set(["closed", "open"]);
-
-export function loadKnownFailuresConfig(productDir, config) {
-  const relativePath = config?.knownFailuresFile;
-  if (!relativePath) return null;
-
-  const absolutePath = path.resolve(productDir, relativePath);
-  if (!fs.existsSync(absolutePath)) {
-    throw new Error(`Known failures file not found: ${relativePath}`);
-  }
-
-  let parsed;
-  try {
-    parsed = JSON.parse(fs.readFileSync(absolutePath, "utf8"));
-  } catch (error) {
-    throw new Error(
-      `Could not parse known failures file ${relativePath}: ${formatErrorMessage(error)}`
-    );
-  }
-
-  return normalizeKnownFailuresDocument(parsed, relativePath);
-}
+export { loadKnownFailuresConfig };
 
 export function applyKnownFailuresToArtifacts(runArtifact, statusArtifact, knownFailures) {
   if (!knownFailures) return { runArtifact, statusArtifact };
@@ -39,7 +14,7 @@ export function applyKnownFailuresToArtifacts(runArtifact, statusArtifact, known
   const fileSummaries = new Map();
 
   for (const entry of [...runEntries, ...statusEntries]) {
-    const key = buildFileIdentity(entry.service, entry.type, entry.path);
+    const key = buildKnownFailureFileIdentity(entry.service, entry.type, entry.path);
     if (!fileSummaries.has(key)) {
       fileSummaries.set(key, {
         service: entry.service,
@@ -55,22 +30,25 @@ export function applyKnownFailuresToArtifacts(runArtifact, statusArtifact, known
   const matchesByFileKey = new Map();
   const matchedByFailedEntryIds = new Set();
 
-  for (const entry of knownFailures.entries) {
-    for (const fileSummary of fileSummaries.values()) {
-      if (!matchesKnownFailureEntry(entry, fileSummary)) continue;
-      const fileKey = buildFileIdentity(fileSummary.service, fileSummary.type, fileSummary.path);
-      if (!matchesByFileKey.has(fileKey)) {
-        matchesByFileKey.set(fileKey, []);
-      }
-      matchesByFileKey.get(fileKey).push(toArtifactTriageEntry(entry));
-      if (fileSummary.status === "failed") {
+  for (const fileSummary of fileSummaries.values()) {
+    const matches = findMatchingKnownFailureEntries(knownFailures, fileSummary);
+    if (matches.length === 0) continue;
+
+    const fileKey = buildKnownFailureFileIdentity(
+      fileSummary.service,
+      fileSummary.type,
+      fileSummary.path
+    );
+    matchesByFileKey.set(fileKey, matches.map((entry) => toArtifactTriageEntry(entry)));
+    if (fileSummary.status === "failed") {
+      for (const entry of matches) {
         matchedByFailedEntryIds.add(entry.id);
       }
     }
   }
 
   for (const entry of [...runEntries, ...statusEntries]) {
-    const fileKey = buildFileIdentity(entry.service, entry.type, entry.path);
+    const fileKey = buildKnownFailureFileIdentity(entry.service, entry.type, entry.path);
     const matches = matchesByFileKey.get(fileKey) || [];
     if (matches.length === 0) {
       if (entry.status === "failed") {
@@ -102,129 +80,6 @@ export function applyKnownFailuresToArtifacts(runArtifact, statusArtifact, known
   return { runArtifact, statusArtifact };
 }
 
-export function normalizeKnownFailuresDocument(document, relativePath = "known failures file") {
-  if (!document || typeof document !== "object") {
-    throw new Error(`${relativePath} must contain a JSON object`);
-  }
-  if (document.schemaVersion !== 1) {
-    throw new Error(`${relativePath} schemaVersion must be 1`);
-  }
-  if (!Array.isArray(document.entries)) {
-    throw new Error(`${relativePath} entries must be an array`);
-  }
-
-  const ids = new Set();
-  const entries = document.entries.map((entry, index) => {
-    const normalized = normalizeKnownFailureEntry(entry, `${relativePath} entries[${index}]`);
-    if (ids.has(normalized.id)) {
-      throw new Error(`${relativePath} has duplicate entry id "${normalized.id}"`);
-    }
-    ids.add(normalized.id);
-    return normalized;
-  });
-
-  return {
-    schemaVersion: 1,
-    issueRepo: normalizeOptionalString(document.issueRepo),
-    entries,
-  };
-}
-
-function normalizeKnownFailureEntry(entry, label) {
-  if (!entry || typeof entry !== "object") {
-    throw new Error(`${label} must be an object`);
-  }
-
-  const id = requireNonEmptyString(entry.id, `${label}.id`);
-  const title = requireNonEmptyString(entry.title, `${label}.title`);
-  const classification = requireEnumValue(
-    entry.classification,
-    CLASSIFICATIONS,
-    `${label}.classification`
-  );
-  const state = requireEnumValue(entry.state, STATES, `${label}.state`);
-  const description = requireNonEmptyString(entry.description, `${label}.description`);
-  const whyFailing = requireNonEmptyString(entry.whyFailing, `${label}.whyFailing`);
-  const lastReviewedAt = requireNonEmptyString(entry.lastReviewedAt, `${label}.lastReviewedAt`);
-  if (!Array.isArray(entry.matches) || entry.matches.length === 0) {
-    throw new Error(`${label}.matches must be a non-empty array`);
-  }
-
-  return {
-    id,
-    title,
-    classification,
-    state,
-    issue: normalizeKnownFailureIssue(entry.issue, `${label}.issue`),
-    description,
-    whyFailing,
-    lastReviewedAt,
-    matches: entry.matches.map((match, index) =>
-      normalizeKnownFailureMatch(match, `${label}.matches[${index}]`)
-    ),
-  };
-}
-
-function normalizeKnownFailureIssue(issue, label) {
-  if (!issue || typeof issue !== "object") {
-    throw new Error(`${label} must be an object`);
-  }
-
-  const repo = requireNonEmptyString(issue.repo, `${label}.repo`);
-  const number = issue.number;
-  if (!Number.isInteger(number) || number <= 0) {
-    throw new Error(`${label}.number must be a positive integer`);
-  }
-  const url = requireNonEmptyString(issue.url, `${label}.url`);
-
-  return { repo, number, url };
-}
-
-function normalizeKnownFailureMatch(match, label) {
-  if (!match || typeof match !== "object") {
-    throw new Error(`${label} must be an object`);
-  }
-
-  const pathValue = requireNonEmptyString(match.path, `${label}.path`);
-  const normalized = {
-    path: pathValue,
-  };
-
-  const service = normalizeOptionalString(match.service);
-  if (service) normalized.service = service;
-
-  const type = normalizeOptionalString(match.type);
-  if (type) normalized.type = type;
-
-  const failureKey = normalizeOptionalString(match.failureKey);
-  if (failureKey) normalized.failureKey = failureKey;
-
-  const errorIncludes = normalizeOptionalString(match.errorIncludes);
-  if (errorIncludes) normalized.errorIncludes = errorIncludes;
-
-  return normalized;
-}
-
-function matchesKnownFailureEntry(entry, fileSummary) {
-  return entry.matches.some((match) => matchesKnownFailureMatch(match, fileSummary));
-}
-
-function matchesKnownFailureMatch(match, fileSummary) {
-  if (match.service && match.service !== fileSummary.service) return false;
-  if (match.type && match.type !== fileSummary.type) return false;
-  if (match.path !== fileSummary.path) return false;
-  if (match.failureKey) {
-    const failureKeys = Array.isArray(fileSummary.failureDetails)
-      ? fileSummary.failureDetails.map((detail) => detail.key)
-      : [];
-    if (!failureKeys.includes(match.failureKey)) return false;
-  }
-  if (match.errorIncludes && !String(fileSummary.error || "").includes(match.errorIncludes)) {
-    return false;
-  }
-  return true;
-}
-
 function toArtifactTriageEntry(entry) {
   return {
     id: entry.id,
@@ -297,34 +152,3 @@ function setEntryTriage(entry, triage) {
   }
   entry.triage = triage;
 }
-
-function buildFileIdentity(service, type, filePath) {
-  return `${service}::${type}::${filePath}`;
-}
-
-function requireNonEmptyString(value, label) {
-  const normalized = normalizeOptionalString(value);
-  if (!normalized) {
-    throw new Error(`${label} must be a non-empty string`);
-  }
-  return normalized;
-}
-
-function requireEnumValue(value, allowed, label) {
-  const normalized = requireNonEmptyString(value, label);
-  if (!allowed.has(normalized)) {
-    throw new Error(`${label} must be one of: ${[...allowed].sort().join(", ")}`);
-  }
-  return normalized;
-}
-
-function normalizeOptionalString(value) {
-  if (typeof value !== "string") return null;
-  const normalized = value.trim();
-  return normalized.length > 0 ? normalized : null;
-}
-
-function formatErrorMessage(error) {
-  if (error instanceof Error) return error.message;
-  return String(error);
-}

package/lib/runner/triage.test.mjs

@@ -1,8 +1,6 @@
 import { describe, expect, it } from "vitest";
-import {
-  applyKnownFailuresToArtifacts,
-  normalizeKnownFailuresDocument,
-} from "./triage.mjs";
+import { normalizeKnownFailuresDocument } from "../known-failures/index.mjs";
+import { applyKnownFailuresToArtifacts } from "./triage.mjs";
 
 describe("runner triage", () => {
   it("matches exact failure keys and enriches both artifacts", () => {

package/lib/setup/index.d.ts

@@ -59,6 +59,12 @@ export interface TestkitExecutionConfig {
   fileTimeoutSeconds?: number;
 }
 
+export interface KnownFailureIssueValidationConfig {
+  provider?: "github";
+  mode?: "off" | "warn" | "error";
+  cacheTtlSeconds?: number;
+}
+
 export interface ServiceConfig {
   database?: LocalDatabaseConfig;
   databaseFrom?: string;
@@ -92,6 +98,7 @@ export interface TestkitSetup {
   };
   reporting?: {
     knownFailuresFile?: string;
+    issueValidation?: KnownFailureIssueValidationConfig;
   };
   services?: Record<string, ServiceConfig>;
   telemetry?: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elench/testkit",
-  "version": "0.1.43",
+  "version": "0.1.45",
   "description": "CLI for discovering and running local HTTP, DAL, and Playwright test suites",
   "type": "module",
   "types": "./lib/index.d.ts",
@@ -17,6 +17,10 @@
       "types": "./lib/runtime/index.d.ts",
       "default": "./lib/runtime/index.mjs"
     },
+    "./known-failures": {
+      "types": "./lib/known-failures/index.d.ts",
+      "default": "./lib/known-failures/index.mjs"
+    },
     "./package.json": "./package.json"
   },
   "bin": {