@quenty/nevermore-cli 4.41.1 → 4.42.0

package/src/utils/testing/test-log-parser.ts

@@ -10,27 +10,97 @@ export interface ParsedTestLogs {
   success: boolean;
   logs: string;
   testCounts?: ParsedTestCounts;
+  /** Why the run is not a pass. Empty when it is. */
+  failureReasons: string[];
+}
+
+export interface TestOutcomeOptions {
+  /**
+   * Require proof the runner ran. Off for probe scripts (--script-text), which
+   * legitimately produce no jest report.
+   */
+  requireTestReport?: boolean;
 }
 
 /**
- * Analyze test output for Jest failures and Luau runtime errors.
- * Shared by both Open Cloud log fetching and local run-in-roblox output.
+ * Decide whether test output represents a pass, and say why when it does not.
+ *
+ * The single definition of the rule. Both the single-package path and the batch
+ * path route through here — they previously carried divergent copies that
+ * disagreed about tracebacks, so the same commit could pass one and fail the
+ * other.
  */
-export function parseTestLogs(rawOutput: string): ParsedTestLogs {
+export function evaluateTestOutcome(
+  rawOutput: string,
+  options: TestOutcomeOptions = {}
+): { success: boolean; failureReasons: string[] } {
   const cleanLogs = OutputHelper.stripAnsi(rawOutput);
+  const failureReasons: string[] = [];
 
-  // Check for Jest-style test failures
   const failedSuites = cleanLogs.match(/Test Suites:\s*(\d+)\s+failed/);
   const failedTests = cleanLogs.match(/Tests:\s*(\d+)\s+failed/);
-  const hasJestFailures =
-    (failedSuites && parseInt(failedSuites[1], 10) > 0) ||
-    (failedTests && parseInt(failedTests[1], 10) > 0);
+  if (failedSuites && parseInt(failedSuites[1], 10) > 0) {
+    failureReasons.push(`${failedSuites[1]} test suite(s) failed`);
+  }
+  if (failedTests && parseInt(failedTests[1], 10) > 0) {
+    failureReasons.push(`${failedTests[1]} test(s) failed`);
+  }
+
+  // Tracebacks always fail. They catch use-after-free bugs that jest cannot
+  // see, since a deferred-callback crash fires outside any test.
+  const tracebacks = countTracebacks(cleanLogs);
+  if (tracebacks > 0) {
+    failureReasons.push(
+      `${tracebacks} Luau traceback(s) — see attributed errors below`
+    );
+  }
 
-  // Check for Luau runtime errors (stack traces)
-  const hasRuntimeError = /Stack Begin\s/.test(cleanLogs);
+  if (options.requireTestReport && !hasTestReport(cleanLogs)) {
+    failureReasons.push(
+      'no jest report in output — nothing proves any test ran'
+    );
+  }
+
+  return { success: failureReasons.length === 0, failureReasons };
+}
+
+/**
+ * True when jest reported at all, including reporting that it found nothing.
+ *
+ * "Ran and found no tests" is a legitimate answer for packages that ship
+ * without specs; "we never heard from jest" is not. Keying on the report
+ * rather than on a test count keeps `passWithNoTests` working.
+ */
+export function hasTestReport(rawOutput: string): boolean {
+  const clean = OutputHelper.stripAnsi(rawOutput);
+  return (
+    /Tests:\s+/.test(clean) ||
+    /Test Suites:\s+/.test(clean) ||
+    /No tests found/i.test(clean)
+  );
+}
+
+/** Count Luau tracebacks in output. */
+export function countTracebacks(rawOutput: string): number {
+  if (!rawOutput) {
+    return 0;
+  }
+  return OutputHelper.stripAnsi(rawOutput).match(/Stack Begin\s/g)?.length ?? 0;
+}
+
+/**
+ * Analyze test output for Jest failures and Luau runtime errors.
+ * Shared by both Open Cloud log fetching and local run-in-roblox output.
+ */
+export function parseTestLogs(
+  rawOutput: string,
+  options: TestOutcomeOptions = {}
+): ParsedTestLogs {
+  const outcome = evaluateTestOutcome(rawOutput, options);
 
   return {
-    success: !hasJestFailures && !hasRuntimeError,
+    success: outcome.success,
+    failureReasons: outcome.failureReasons,
     logs: rawOutput,
     testCounts: parseTestCounts(rawOutput),
   };