@elench/testkit 0.1.80 → 0.1.81

package/lib/known-failures/index.d.ts

@@ -1,192 +0,0 @@
-export type KnownFailureClassification =
-  | "expected_failure"
-  | "infra"
-  | "product_bug"
-  | "stale_test"
-  | "test_bug";
-
-export type KnownFailureState = "closed" | "open";
-
-export interface KnownFailureIssueRef {
-  repo: string;
-  number: number;
-  url: string;
-}
-
-export interface KnownFailureMatch {
-  service?: string;
-  type?: string;
-  path: string;
-  failureKey?: string;
-  errorIncludes?: string;
-}
-
-export interface KnownFailureEntry {
-  id: string;
-  /** Exact issue-tracker title for the linked issue. */
-  title: string;
-  classification: KnownFailureClassification;
-  state: KnownFailureState;
-  issue: KnownFailureIssueRef;
-  /** Product-local bug slice or route-family summary. */
-  description: string;
-  /** Underlying technical cause of the failure. */
-  whyFailing: string;
-  lastReviewedAt: string;
-  matches: KnownFailureMatch[];
-}
-
-export interface KnownFailuresDocument {
-  schemaVersion: 1;
-  issueRepo?: string | null;
-  entries: KnownFailureEntry[];
-}
-
-export interface KnownFailuresValidationResult {
-  errors: string[];
-  warnings: string[];
-  stats: {
-    entries: number;
-    matches: number;
-    failedTests: number;
-    triagedFailedTests: number;
-    untriagedFailedTests: number;
-  };
-}
-
-export interface KnownFailureIssueValidationConfig {
-  provider?: "github";
-  mode?: "off" | "warn" | "error";
-  cacheTtlSeconds?: number;
-}
-
-export interface KnownFailureIssueValidationFinding {
-  code: string;
-  severity: "warning" | "error";
-  message: string;
-}
-
-export interface KnownFailureIssueValidationEntry {
-  id: string;
-  title: string;
-  issue: KnownFailureIssueRef;
-  observed: {
-    matchedTests: number;
-    executedTests: number;
-    passedTests: number;
-    failedTests: number;
-    skippedTests: number;
-    notRunTests: number;
-    reproduced: boolean;
-  };
-  github: {
-    exists: boolean | null;
-    title: string | null;
-    state: string | null;
-    url: string | null;
-    checkedAt: string | null;
-    cached: boolean;
-  };
-  findings: KnownFailureIssueValidationFinding[];
-  status: string;
-}
-
-export interface KnownFailureIssueValidationResult {
-  schemaVersion: 2;
-  provider: "github";
-  mode: "off" | "warn" | "error";
-  checkedAt: string;
-  repo: {
-    detected: string | null;
-    remoteUrl: string | null;
-    configured: string | null;
-  };
-  availability: {
-    hasFreshData: boolean;
-    usedCachedFallback: boolean;
-  };
-  findings: KnownFailureIssueValidationFinding[];
-  summary: {
-    entries: number;
-    observedEntries: number;
-    errors: number;
-    warnings: number;
-    byCode: Record<string, number>;
-    byStatus: Record<string, number>;
-  };
-  entries: KnownFailureIssueValidationEntry[];
-}
-
-export declare function loadKnownFailuresConfig(
-  productDir: string,
-  config: { knownFailuresFile?: string | null } | null
-): KnownFailuresDocument | null;
-export declare function loadKnownFailuresDocument(
-  filePath: string,
-  relativePath?: string
-): KnownFailuresDocument;
-export declare function normalizeKnownFailuresDocument(
-  document: unknown,
-  relativePath?: string
-): KnownFailuresDocument;
-export declare function validateKnownFailuresDocument(
-  document: KnownFailuresDocument,
-  options?: {
-    productDir?: string;
-    statusArtifactPath?: string;
-    statusArtifact?: unknown;
-  }
-): KnownFailuresValidationResult;
-export declare function renderKnownFailuresMarkdown(document: KnownFailuresDocument): string;
-export declare function findMatchingKnownFailureEntries(
-  document: KnownFailuresDocument,
-  fileSummary: {
-    service?: string;
-    type?: string;
-    path: string;
-    status?: string;
-    error?: string | null;
-    failureDetails?: Array<{ key?: string }>;
-  }
-): KnownFailureEntry[];
-export declare function matchesKnownFailureEntry(
-  entry: KnownFailureEntry,
-  fileSummary: {
-    service?: string;
-    type?: string;
-    path: string;
-    error?: string | null;
-    failureDetails?: Array<{ key?: string }>;
-  }
-): boolean;
-export declare function buildKnownFailureFileIdentity(
-  service: string,
-  type: string,
-  filePath: string
-): string;
-
-export declare function normalizeKnownFailureIssueValidationConfig(
-  value: unknown
-): {
-  provider: "github";
-  mode: "off" | "warn" | "error";
-  cacheTtlSeconds: number;
-} | null;
-export declare function validateKnownFailureIssues(options: {
-  productDir: string;
-  document: KnownFailuresDocument | null;
-  runArtifact?: unknown;
-  statusArtifact?: unknown;
-  config?: KnownFailureIssueValidationConfig | null;
-  gitMetadata?: {
-    repoSlug?: string | null;
-    remoteUrl?: string | null;
-  } | null;
-}): Promise<KnownFailureIssueValidationResult | null>;
-export declare function shouldFailKnownFailureIssueValidation(
-  result: KnownFailureIssueValidationResult | null
-): boolean;
-export declare function buildKnownFailureIssueValidationSummaryLines(
-  result: KnownFailureIssueValidationResult | null
-): string[];
-export declare function parseGitHubRepoSlug(remoteUrl: string | null | undefined): string | null;

package/lib/runner/triage.mjs

@@ -1,221 +0,0 @@
-import {
-  buildKnownFailureFileIdentity,
-  findMatchingKnownFailureEntries,
-  loadKnownFailuresConfig,
-} from "../known-failures/index.mjs";
-
-export { loadKnownFailuresConfig };
-
-export function applyKnownFailuresToArtifacts(runArtifact, statusArtifact, knownFailures) {
-  if (!knownFailures) return { runArtifact, statusArtifact };
-
-  const runEntries = extractRunFileEntries(runArtifact);
-  const statusEntries = extractStatusFileEntries(statusArtifact);
-  const fileSummaries = new Map();
-
-  for (const entry of [...runEntries, ...statusEntries]) {
-    const key = buildKnownFailureFileIdentity(entry.service, entry.type, entry.path);
-    if (!fileSummaries.has(key)) {
-      fileSummaries.set(key, {
-        service: entry.service,
-        type: entry.type,
-        path: entry.path,
-        status: entry.status,
-        error: entry.error || null,
-        failureDetails: Array.isArray(entry.failureDetails) ? entry.failureDetails : [],
-      });
-    }
-  }
-
-  const matchesByFileKey = new Map();
-  const matchedByFailedEntryIds = new Set();
-
-  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 = buildKnownFailureFileIdentity(entry.service, entry.type, entry.path);
-    const matches = matchesByFileKey.get(fileKey) || [];
-    if (matches.length === 0) {
-      if (entry.status === "failed") {
-        setEntryTriage(entry, {
-          status: "untriaged",
-          entries: [],
-        });
-      }
-      continue;
-    }
-
-    setEntryTriage(entry, {
-      status: entry.status === "failed" ? "known_failure" : "known_issue_not_reproduced",
-      classifications: [...new Set(matches.map((match) => match.classification))].sort(),
-      entries: matches,
-    });
-  }
-
-  const summaryTests = statusArtifact?.tests || runEntries;
-  const triageSummary = buildTriageSummary(
-    summaryTests,
-    knownFailures.entries,
-    matchedByFailedEntryIds
-  );
-  runArtifact.triageSummary = triageSummary;
-  if (statusArtifact) {
-    statusArtifact.triageSummary = triageSummary;
-  }
-  return { runArtifact, statusArtifact };
-}
-
-export function applyKnownFailureIssueValidationToArtifacts(
-  runArtifact,
-  statusArtifact,
-  issueValidation
-) {
-  if (!issueValidation) return { runArtifact, statusArtifact };
-
-  const validationById = new Map(
-    (issueValidation.entries || []).map((entry) => [entry.id, entry])
-  );
-
-  for (const entry of [...extractRunFileEntries(runArtifact), ...extractStatusFileEntries(statusArtifact)]) {
-    const triage = entry.target ? entry.target.triage : entry.triage;
-    if (!triage?.entries?.length) continue;
-
-    const matchedValidationEntries = triage.entries
-      .map((triageEntry) => validationById.get(triageEntry.id))
-      .filter(Boolean);
-
-    if (matchedValidationEntries.length === 0) continue;
-
-    const enrichedEntries = triage.entries.map((triageEntry) => {
-      const validationEntry = validationById.get(triageEntry.id);
-      if (!validationEntry) return triageEntry;
-      return {
-        ...triageEntry,
-        github: validationEntry.github,
-        validationStatus: validationEntry.status,
-        findings: validationEntry.findings,
-      };
-    });
-
-    const nextTriage = {
-      ...triage,
-      entries: enrichedEntries,
-      availability: summarizeIssueValidationAvailability(issueValidation, matchedValidationEntries),
-    };
-    setEntryTriage(entry, nextTriage);
-  }
-
-  return { runArtifact, statusArtifact };
-}
-
-function toArtifactTriageEntry(entry) {
-  return {
-    id: entry.id,
-    title: entry.title,
-    classification: entry.classification,
-    state: entry.state,
-    issue: entry.issue,
-    description: entry.description,
-    whyFailing: entry.whyFailing,
-    lastReviewedAt: entry.lastReviewedAt,
-  };
-}
-
-function buildTriageSummary(tests, entries, matchedEntryIds) {
-  const failedTests = tests.filter((test) => test.status === "failed");
-  const knownFailedTests = failedTests.filter((test) => test.triage?.status === "known_failure");
-  const byClassification = {};
-
-  for (const test of knownFailedTests) {
-    for (const classification of test.triage?.classifications || []) {
-      byClassification[classification] = (byClassification[classification] || 0) + 1;
-    }
-  }
-
-  return {
-    failed: {
-      total: failedTests.length,
-      known: knownFailedTests.length,
-      untriaged: failedTests.length - knownFailedTests.length,
-      byClassification,
-    },
-    entries: {
-      total: entries.length,
-      matchedByFailedTests: matchedEntryIds.size,
-      unmatched: entries.length - matchedEntryIds.size,
-    },
-  };
-}
-
-function extractRunFileEntries(runArtifact) {
-  const entries = [];
-
-  for (const service of runArtifact.services || []) {
-    for (const suite of service.suites || []) {
-      for (const file of suite.files || []) {
-        entries.push({
-          target: file,
-          service: service.name,
-          type: suite.type,
-          path: file.path,
-          status: file.status,
-          error: file.error || null,
-          failureDetails: Array.isArray(file.failureDetails) ? file.failureDetails : [],
-        });
-      }
-    }
-  }
-
-  return entries;
-}
-
-function extractStatusFileEntries(statusArtifact) {
-  return statusArtifact?.tests || [];
-}
-
-function setEntryTriage(entry, triage) {
-  if (entry?.target) {
-    entry.target.triage = triage;
-    return;
-  }
-  entry.triage = triage;
-}
-
-function summarizeIssueValidationAvailability(issueValidation, entries) {
-  if (entries.some((entry) => entry.github?.cached)) {
-    return {
-      mode: "cache",
-      reason: issueValidation.availability?.usedCachedFallback
-        ? "used stale cache"
-        : "used cached issue metadata",
-    };
-  }
-  if (entries.some((entry) => entry.status === "validation_unavailable")) {
-    const globalReason = (issueValidation.findings || []).find(
-      (finding) => finding.code === "validation_unavailable"
-    );
-    return {
-      mode: "offline",
-      reason: globalReason?.message || "validation unavailable",
-    };
-  }
-  return {
-    mode: "live",
-    reason: null,
-  };
-}