@polymorphism-tech/morph-spec 8.36.0 → 8.37.1

package/src/lib/validators/verify-runner.js

@@ -24,14 +24,14 @@
  */
 
 import { execFileSync } from 'child_process';
-import { existsSync, readFileSync } from 'fs';
+import { existsSync, readFileSync, rmSync } from 'fs';
 import { join, resolve } from 'path';
 
 import { runBuildCheck, getBuildSteps } from '../../../framework/hooks/shared/build-check.js';
 import { runE2eCheck } from '../../../framework/hooks/shared/e2e-check.js';
 import { buildComposeEnv } from '../e2e/compose-env.js';
 import {
-  runTestSuite, parseTestCount, compareTestCount, resolveTestTimeout, isZeroTestRun,
+  runTestSuite, parseTestCount, compareTestCount, resolveTestTimeout, isZeroTestRun, mtpSummaryTotals,
 } from '../tasks/test-runner.js';
 import {
   resolveTestNodes, parseTestFilter, nodeMatchesFilter, recordTestBaselines, morphConfigPath,
@@ -56,6 +56,7 @@ const OUTPUT_TAIL_LINES = 20;
 
 /** A narrowed run that proved ZERO tests ran (#87) — wording pinned by the plan. */
 const NARROWED_ZERO_TESTS = 'narrowed-zero-tests: o recorte executou 0 testes';
+const NARROWED_ZERO_TESTS_LINK = 'narrowed-zero-tests: um link do recorte executou 0 testes (bloco MTP com total: 0)';
 
 /** A narrowed run that exited green with no count anyone could read (#87): null is UNKNOWN, and unknown is never green. */
 const NARROWED_COUNT_UNKNOWN = 'narrowed-count-unknown: o recorte saiu verde sem contagem legível — '
@@ -469,14 +470,27 @@ async function runOneTestNode({
   const evalChannel = node.runner === EVAL_RUNNER
     ? evalNodeEnv(node, projectPath, { refresh: refreshCache })
     : null;
+  // The summary path is fixed per node id and pid, and nothing else removes the
+  // file: one left there by an earlier run (an earlier verify in the same
+  // process, a recycled pid) was read as THIS run's, handing a harness that
+  // wrote nothing the old scenario count — and hiding an empty run behind it.
+  if (evalChannel) discardFile(evalChannel.summaryPath);
 
   const start = Date.now();
   const result = await _runTestSuite(projectPath, {
     timeout, node, ...(evalChannel ? { env: evalChannel.env } : {}),
   });
   const entry = judgeRun({ node, result, durationMs: Date.now() - start });
+  if (!evalChannel) return entry;
 
-  return evalChannel ? judgeEvalRun(entry, node, evalChannel.summaryPath) : entry;
+  const judged = judgeEvalRun(entry, node, evalChannel.summaryPath);
+  discardFile(evalChannel.summaryPath);
+  return judged;
+}
+
+/** Remove a scratch file the CLI owns; a file that is not there (or will not go) changes nothing. */
+function discardFile(path) {
+  try { rmSync(path, { force: true }); } catch { /* best effort — the next run removes it first */ }
 }
 
 /**
@@ -484,10 +498,12 @@ async function runOneTestNode({
  * code said.
  *
  * Two things the exit code cannot see:
- *   - the scenario COUNT, which is what `expectedCount` is compared against.
- *     The summary wins when readable; otherwise the `dotnet` extractor's number
- *     stands, because an eval IS `dotnet test`. **null stays UNKNOWN, never 0** —
- *     an unreadable summary must not manufacture a count drop;
+ *   - the scenario COUNT, which is what `expectedCount` is compared against and
+ *     what `--record-baseline` writes. Read ONLY from the summary: the `dotnet`
+ *     extractor counts xunit cases, another unit — compared with (or recorded as)
+ *     a scenario baseline it failed green runs as drops (#110, #117 review). No
+ *     readable summary → **null, UNKNOWN, never 0** — an unreadable summary must
+ *     not manufacture a count drop;
  *   - a suite that evaluated ZERO scenarios and exited 0. Nothing failed, because
  *     nothing ran: the guardrail-inert shape this repository has already paid to
  *     learn to detect.
@@ -499,8 +515,7 @@ function judgeEvalRun(entry, node, summaryPath) {
   const cold = evalColdCacheWarning(summary);
   if (cold) warnings.push(cold);
 
-  const fromSummary = evalScenarioCount(summary);
-  const count = fromSummary ?? entry.count;
+  const count = evalScenarioCount(summary);
   const verdict = compareTestCount(count, node.expectedCount);
   if (verdict.warning) warnings.push(verdict.warning);
 
@@ -645,7 +660,12 @@ function judgeRun({ node, result, durationMs }) {
     return judgeNarrowedRun({ entry, node, result, durationMs, count });
   }
 
-  const verdict = compareTestCount(count, node.expectedCount);
+  // An eval node's unit is the SCENARIO (#110 part 2): its baseline is the
+  // summary's scenario count, and `judgeEvalRun` is the one that compares it.
+  // Comparing here too, with the extractor's count of xunit cases, failed a
+  // 24/24 run as "esperado 24, executado 2" — and `judgeEvalRun` only turns a
+  // pass into a fail, never the reverse.
+  const verdict = compareTestCount(count, node.runner === EVAL_RUNNER ? null : node.expectedCount);
   const warnings = verdict.warning ? [verdict.warning] : [];
 
   // A drop is the one count verdict that fails a node by itself: tests that
@@ -689,16 +709,24 @@ function judgeRun({ node, result, durationMs }) {
  *     must never buy. What counts as proof is the selection's `zeroGuard`
  *     (test-scope.js):
  *       `count`      only a parsed count > 0. **null is UNKNOWN, never green**;
- *       `mtp-exit-8` MTP exits 8 on zero tests, so exit 0 IS the proof.
- *     A parsed 0 is refused under either guard: it is positive evidence.
+ *       `mtp-exit-8` a parsed count > 0 proves it (the MTP summary is read in
+ *                    pt-BR and en-US, #115); with no readable summary (another
+ *                    locale), exit 0 does — MTP exits 8 on zero tests.
+ *     A parsed 0 is refused under either guard: it is positive evidence. It is
+ *     also what closes limit (f): with exit 8 IGNORED, MTP exits 0 over a
+ *     summary that says `total: 0` (measured, mtp-ignore-exit-code-8-zero-tests.txt).
+ *     In a narrowed `&&` chain the SUM would hide that link behind another's
+ *     count, so under `mtp-exit-8` every MTP block is checked on its own — MTP
+ *     prints one block per invocation (measured), and a `total: 0` block is red.
  *
  * A FAILED run is renamed `narrowed-zero-tests (…)` only when it carries the
  * runner's zero-test signature AND no count proves tests ran. A multi-project
  * VSTest output may print "No test matches…" for one project while another
  * ran and failed; that failure is the lead, never a zero. Anything else,
- * exit 9 included, keeps the executor's own raw reason: projects that impose
- * `--minimum-expected-tests` are never narrowed, so a 9 here is not ours to
- * reinterpret.
+ * exit 9 included, keeps the executor's own raw reason: a project that imposes
+ * `--minimum-expected-tests` is narrowed only with its floor lowered to 1 by
+ * `-p:` (#114, test-scope.js), where a run with tests cannot exit 9 — so a 9
+ * here is not ours to reinterpret.
  *
  * Every red leads its output with the verdict, like a timeout does: the
  * feedback line reads `output` before `reason`, and a tail alone would bury it.
@@ -712,6 +740,9 @@ function judgeNarrowedRun({ entry, node, result, durationMs, count }) {
 
   if (result.passed) {
     if (count === 0) return red(NARROWED_ZERO_TESTS);
+    if (entry.selection.zeroGuard === 'mtp-exit-8' && mtpSummaryTotals(result.output).includes(0)) {
+      return red(NARROWED_ZERO_TESTS_LINK);
+    }
     if (ranTests) return green();
     if (entry.selection.zeroGuard === 'mtp-exit-8' && result.exitCode === 0) return green();
     return red(NARROWED_COUNT_UNKNOWN);