gdharness 1.2.1 → 1.2.2

package/build/cli.js

@@ -17977,7 +17977,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "project_test",
-      description: "Runs the project's gdUnit4 tests headless and answers with every case that did not pass: where it is, and what the assertion said. Suites where everything passed are counted rather than listed, and an engine message keeps the frames above gdUnit4 rather than the twenty inside it, so a clean tier answers in a few lines; identical engine messages come back once under engineEntries, with times saying how often they were printed, and engineErrors counts every one. The class list is rebuilt first, so a suite written a moment ago is found, and the rebuild's answer is under classes, with the classes each addon declares counted under addedInAddons and changedInAddons rather than named: a class it puts back that the cache had after the last rebuild is named under classes.lostSinceLastRebuild, which is the editor writing its shorter list over the file on every save until restarted. On Windows and Linux the run gets a user:// of its own, so a suite that saves a game writes nowhere near the saves of the copy somebody plays. On macOS the engine reads user:// off HOME and the run writes where the player keeps theirs, which the answer says under savesNote rather than leaving to be found in a save list. A run that found nothing to run is never called a pass: gdUnit4 exits cleanly for one, so the answer says so and names the path it looked in. A script that does not load stops gdUnit4 before any suite runs: its errors come back in full under scriptErrors, and the scripts that failed only because one they depend on did are listed by path under failedThroughDependency. When they failed on a class whose own script has a parser error, which gdUnit4 never names, that script is checked by the engine and its error comes first under scriptErrors, with the class it declares under declares, and the errors a script has only because that class did not resolve, which the engine reads as Variant, are kept apart under followFromUnresolved. A client that sends a progress token is told as each suite finishes, and at least every twenty seconds through a long one, so an idle limit does not end a long tier. A run that ends without a report, at its timeout or otherwise, names the suites it finished under suitesFinished, the failing ones with their failed cases under suitesFailing, and the one it was in under suiteRunning. When a client cuts a run off, that is kept in the project and the next project_test there carries it under previousRunCut. A run where nothing failed but nodes were left in the tree comes back under warnings, with the count per suite: gdUnit4 decides its verdict on those and keeps them out of its report, so they are read off what it printed. A run whose every case passed is still not called passed when it printed a script error that no case failed on: gdUnit4 fails a case on the script errors its logger sees, and it cannot see a stack overflow, so the cases pass on whatever the faulted calls returned. Those errors come back under uncaughtScriptErrors, and under engineEntries by index with detailUnder rather than with their backtrace a second time; a backtrace that repeats, as a recursion's does, has each repeated frame or cycle of frames written once with the frames it covers and how many times. One raised inside assert_error(...).is_runtime_error is the test's own and does not count, and none count when the project turns off gdUnit4's report/godot/script_error setting. Needs gdUnit4 under addons/gdUnit4.",
+      description: "Runs the project's gdUnit4 tests headless and answers with every case that did not pass: where it is, and what the assertion said. Each entry under failed carries its first report as message and detail, and, when it has more than one, every report under reports in the order the case met them: gdUnit4 goes on past a failed assertion, and a case can fail several and then stop on a runtime error, which makes its status error. failures counts the cases that failed an assertion and errors the cases that hit an error, so such a case counts in both. Suites where everything passed are counted rather than listed, and an engine message keeps the frames above gdUnit4 rather than the twenty inside it, so a clean tier answers in a few lines; identical engine messages come back once under engineEntries, with times saying how often they were printed, and engineErrors counts every one. The class list is rebuilt first, so a suite written a moment ago is found, and the rebuild's answer is under classes, with the classes each addon declares counted under addedInAddons and changedInAddons rather than named: a class it puts back that the cache had after the last rebuild is named under classes.lostSinceLastRebuild, which is the editor writing its shorter list over the file on every save until restarted. On Windows and Linux the run gets a user:// of its own, so a suite that saves a game writes nowhere near the saves of the copy somebody plays. On macOS the engine reads user:// off HOME and the run writes where the player keeps theirs, which the answer says under savesNote rather than leaving to be found in a save list. A run that found nothing to run is never called a pass: gdUnit4 exits cleanly for one, so the answer says so and names the path it looked in. A script that does not load stops gdUnit4 before any suite runs: its errors come back in full under scriptErrors, and the scripts that failed only because one they depend on did are listed by path under failedThroughDependency. When they failed on a class whose own script has a parser error, which gdUnit4 never names, that script is checked by the engine and its error comes first under scriptErrors, with the class it declares under declares, and the errors a script has only because that class did not resolve, which the engine reads as Variant, are kept apart under followFromUnresolved. A client that sends a progress token is told as each suite finishes, and at least every twenty seconds through a long one, so an idle limit does not end a long tier. A run that ends without a report, at its timeout or otherwise, names the suites it finished under suitesFinished, the failing ones with their failed cases under suitesFailing, and the one it was in under suiteRunning. When a client cuts a run off, that is kept in the project and the next project_test there carries it under previousRunCut. A run where nothing failed but nodes were left in the tree comes back under warnings, with the count per suite: gdUnit4 decides its verdict on those and keeps them out of its report, so they are read off what it printed. A run whose every case passed is still not called passed when it printed a script error that no case failed on: gdUnit4 fails a case on the script errors its logger sees, and it cannot see a stack overflow, so the cases pass on whatever the faulted calls returned. Those errors come back under uncaughtScriptErrors, and under engineEntries by index with detailUnder rather than with their backtrace a second time; a backtrace that repeats, as a recursion's does, has each repeated frame or cycle of frames written once with the frames it covers and how many times. One raised inside assert_error(...).is_runtime_error is the test's own and does not count, and none count when the project turns off gdUnit4's report/godot/script_error setting. Needs gdUnit4 under addons/gdUnit4.",
       parameters: {
         projectPath: PROJECT_PATH,
         path: {
@@ -39250,18 +39250,25 @@ function count(attributes, name) {
   return Number.isFinite(value) ? value : 0;
 }
 function caseOf(suite, element) {
-  const outcome = element.children.find((child) => ["failure", "error", "skipped"].includes(child.name));
-  const status = outcome === undefined ? "passed" : outcome.name === "failure" ? "failed" : outcome.name === "error" ? "error" : "skipped";
-  const detail = outcome?.text.trim() ?? "";
+  const of = (kind) => element.children.filter((child) => child.name === kind).map((child) => {
+    const detail = child.text.trim();
+    return { kind, message: child.attributes["message"] ?? null, detail: detail === "" ? null : detail };
+  });
+  const reports = [...of("failure"), ...of("error"), ...of("skipped")];
+  const status = reports.some((report) => report.kind === "error") ? "error" : reports.some((report) => report.kind === "failure") ? "failed" : reports.length > 0 ? "skipped" : "passed";
   return {
     suite: suite.attributes["name"] ?? "",
     name: element.attributes["name"] ?? "",
     status,
     time: count(element.attributes, "time"),
-    message: outcome?.attributes["message"] ?? null,
-    detail: detail === "" ? null : detail
+    message: reports[0]?.message ?? null,
+    detail: reports[0]?.detail ?? null,
+    reports
   };
 }
+function failedAnAssertion(entry) {
+  return entry.reports.some((report) => report.kind === "failure");
+}
 function pathOf(suite) {
   const directory = suite.attributes["package"];
   const name = suite.attributes["name"];
@@ -39276,7 +39283,7 @@ function parseJUnit(xml) {
   const suiteElements = top.name === "testsuite" ? [top] : top.children.filter((child) => child.name === "testsuite");
   const suites = suiteElements.map((suite) => {
     const cases = suite.children.filter((child) => child.name === "testcase").map((element) => caseOf(suite, element));
-    const failures = cases.filter((entry) => entry.status === "failed").length;
+    const failures = cases.filter(failedAnAssertion).length;
     const errors = cases.filter((entry) => entry.status === "error").length;
     const written = (kind) => suite.children.filter((child) => child.name === "testcase").reduce((sum, element) => sum + element.children.filter((child) => child.name === kind).length, 0);
     return {
@@ -39296,7 +39303,7 @@ function parseJUnit(xml) {
   const all = suites.flatMap((suite) => suite.cases);
   return {
     tests: all.length,
-    failures: all.filter((entry) => entry.status === "failed").length,
+    failures: all.filter(failedAnAssertion).length,
     errors: all.filter((entry) => entry.status === "error").length,
     hookFailures: suites.reduce((sum, suite) => sum + suite.hookFailures, 0),
     hookErrors: suites.reduce((sum, suite) => sum + suite.hookErrors, 0),
@@ -39418,6 +39425,25 @@ ${note}`;
     return detail === entry.detail ? entry : { ...entry, detail };
   });
 }
+function failedCases(report, printed) {
+  const cases = report.suites.flatMap((suite) => suite.cases.filter((entry) => entry.status === "failed" || entry.status === "error").map((entry) => ({ entry, path: suite.path })));
+  const read = withActualsPrinted(cases.flatMap(({ entry }) => entry.reports), printed);
+  let next = 0;
+  return cases.map(({ entry, path }) => {
+    const reports = read.slice(next, next + entry.reports.length);
+    next += entry.reports.length;
+    return {
+      suite: entry.suite,
+      name: entry.name,
+      status: entry.status,
+      time: entry.time,
+      path,
+      message: reports[0]?.message ?? null,
+      detail: reports[0]?.detail ?? null,
+      ...reports.length > 1 ? { reports } : {}
+    };
+  });
+}
 function masked(expected, actual) {
   const allSpelled = (value) => !PRINTED_DICTIONARY.test(value) && value.split("[").length === value.split(MASKED_BRACKET).length;
   return `${expected}${actual}`.includes(MASKED_BRACKET) && allSpelled(expected) && allSpelled(actual);
@@ -45432,7 +45458,7 @@ class GodotServer {
         isError: true
       };
     }
-    const failed = withActualsPrinted(report.suites.flatMap((suite) => suite.cases.filter((entry) => entry.status === "failed" || entry.status === "error").map((entry) => ({ ...entry, path: suite.path }))), Buffer.concat(console2).toString("utf8"));
+    const failed = failedCases(report, Buffer.concat(console2).toString("utf8"));
     const orphans = orphansPrinted(said);
     const leftBehind = new Map(orphans.suites.map((suite) => [suite.path, suite.orphans]));
     const orphansIn = (path) => path === null ? 0 : leftBehind.get(path) ?? 0;

package/build/index.js

@@ -29817,18 +29817,25 @@ function count(attributes, name) {
   return Number.isFinite(value) ? value : 0;
 }
 function caseOf(suite, element) {
-  const outcome = element.children.find((child) => ["failure", "error", "skipped"].includes(child.name));
-  const status = outcome === undefined ? "passed" : outcome.name === "failure" ? "failed" : outcome.name === "error" ? "error" : "skipped";
-  const detail = outcome?.text.trim() ?? "";
+  const of = (kind) => element.children.filter((child) => child.name === kind).map((child) => {
+    const detail = child.text.trim();
+    return { kind, message: child.attributes["message"] ?? null, detail: detail === "" ? null : detail };
+  });
+  const reports = [...of("failure"), ...of("error"), ...of("skipped")];
+  const status = reports.some((report) => report.kind === "error") ? "error" : reports.some((report) => report.kind === "failure") ? "failed" : reports.length > 0 ? "skipped" : "passed";
   return {
     suite: suite.attributes["name"] ?? "",
     name: element.attributes["name"] ?? "",
     status,
     time: count(element.attributes, "time"),
-    message: outcome?.attributes["message"] ?? null,
-    detail: detail === "" ? null : detail
+    message: reports[0]?.message ?? null,
+    detail: reports[0]?.detail ?? null,
+    reports
   };
 }
+function failedAnAssertion(entry) {
+  return entry.reports.some((report) => report.kind === "failure");
+}
 function pathOf(suite) {
   const directory = suite.attributes["package"];
   const name = suite.attributes["name"];
@@ -29843,7 +29850,7 @@ function parseJUnit(xml) {
   const suiteElements = top.name === "testsuite" ? [top] : top.children.filter((child) => child.name === "testsuite");
   const suites = suiteElements.map((suite) => {
     const cases = suite.children.filter((child) => child.name === "testcase").map((element) => caseOf(suite, element));
-    const failures = cases.filter((entry) => entry.status === "failed").length;
+    const failures = cases.filter(failedAnAssertion).length;
     const errors = cases.filter((entry) => entry.status === "error").length;
     const written = (kind) => suite.children.filter((child) => child.name === "testcase").reduce((sum, element) => sum + element.children.filter((child) => child.name === kind).length, 0);
     return {
@@ -29863,7 +29870,7 @@ function parseJUnit(xml) {
   const all = suites.flatMap((suite) => suite.cases);
   return {
     tests: all.length,
-    failures: all.filter((entry) => entry.status === "failed").length,
+    failures: all.filter(failedAnAssertion).length,
     errors: all.filter((entry) => entry.status === "error").length,
     hookFailures: suites.reduce((sum, suite) => sum + suite.hookFailures, 0),
     hookErrors: suites.reduce((sum, suite) => sum + suite.hookErrors, 0),
@@ -30010,6 +30017,25 @@ ${note}`;
     return detail === entry.detail ? entry : { ...entry, detail };
   });
 }
+function failedCases(report, printed) {
+  const cases = report.suites.flatMap((suite) => suite.cases.filter((entry) => entry.status === "failed" || entry.status === "error").map((entry) => ({ entry, path: suite.path })));
+  const read = withActualsPrinted(cases.flatMap(({ entry }) => entry.reports), printed);
+  let next = 0;
+  return cases.map(({ entry, path }) => {
+    const reports = read.slice(next, next + entry.reports.length);
+    next += entry.reports.length;
+    return {
+      suite: entry.suite,
+      name: entry.name,
+      status: entry.status,
+      time: entry.time,
+      path,
+      message: reports[0]?.message ?? null,
+      detail: reports[0]?.detail ?? null,
+      ...reports.length > 1 ? { reports } : {}
+    };
+  });
+}
 var MASKED_BRACKET = "[lb]";
 function masked(expected, actual) {
   const allSpelled = (value) => !PRINTED_DICTIONARY.test(value) && value.split("[").length === value.split(MASKED_BRACKET).length;
@@ -34054,7 +34080,7 @@ var TOOL_SPECS = [
   },
   {
     name: "project_test",
-    description: "Runs the project's gdUnit4 tests headless and answers with every case that did not pass: where it is, and what the assertion said. Suites where everything passed are counted rather than listed, and an engine message keeps the frames above gdUnit4 rather than the twenty inside it, so a clean tier answers in a few lines; identical engine messages come back once under engineEntries, with times saying how often they were printed, and engineErrors counts every one. The class list is rebuilt first, so a suite written a moment ago is found, and the rebuild's answer is under classes, with the classes each addon declares counted under addedInAddons and changedInAddons rather than named: a class it puts back that the cache had after the last rebuild is named under classes.lostSinceLastRebuild, which is the editor writing its shorter list over the file on every save until restarted. On Windows and Linux the run gets a user:// of its own, so a suite that saves a game writes nowhere near the saves of the copy somebody plays. On macOS the engine reads user:// off HOME and the run writes where the player keeps theirs, which the answer says under savesNote rather than leaving to be found in a save list. A run that found nothing to run is never called a pass: gdUnit4 exits cleanly for one, so the answer says so and names the path it looked in. A script that does not load stops gdUnit4 before any suite runs: its errors come back in full under scriptErrors, and the scripts that failed only because one they depend on did are listed by path under failedThroughDependency. When they failed on a class whose own script has a parser error, which gdUnit4 never names, that script is checked by the engine and its error comes first under scriptErrors, with the class it declares under declares, and the errors a script has only because that class did not resolve, which the engine reads as Variant, are kept apart under followFromUnresolved. A client that sends a progress token is told as each suite finishes, and at least every twenty seconds through a long one, so an idle limit does not end a long tier. A run that ends without a report, at its timeout or otherwise, names the suites it finished under suitesFinished, the failing ones with their failed cases under suitesFailing, and the one it was in under suiteRunning. When a client cuts a run off, that is kept in the project and the next project_test there carries it under previousRunCut. A run where nothing failed but nodes were left in the tree comes back under warnings, with the count per suite: gdUnit4 decides its verdict on those and keeps them out of its report, so they are read off what it printed. A run whose every case passed is still not called passed when it printed a script error that no case failed on: gdUnit4 fails a case on the script errors its logger sees, and it cannot see a stack overflow, so the cases pass on whatever the faulted calls returned. Those errors come back under uncaughtScriptErrors, and under engineEntries by index with detailUnder rather than with their backtrace a second time; a backtrace that repeats, as a recursion's does, has each repeated frame or cycle of frames written once with the frames it covers and how many times. One raised inside assert_error(...).is_runtime_error is the test's own and does not count, and none count when the project turns off gdUnit4's report/godot/script_error setting. Needs gdUnit4 under addons/gdUnit4.",
+    description: "Runs the project's gdUnit4 tests headless and answers with every case that did not pass: where it is, and what the assertion said. Each entry under failed carries its first report as message and detail, and, when it has more than one, every report under reports in the order the case met them: gdUnit4 goes on past a failed assertion, and a case can fail several and then stop on a runtime error, which makes its status error. failures counts the cases that failed an assertion and errors the cases that hit an error, so such a case counts in both. Suites where everything passed are counted rather than listed, and an engine message keeps the frames above gdUnit4 rather than the twenty inside it, so a clean tier answers in a few lines; identical engine messages come back once under engineEntries, with times saying how often they were printed, and engineErrors counts every one. The class list is rebuilt first, so a suite written a moment ago is found, and the rebuild's answer is under classes, with the classes each addon declares counted under addedInAddons and changedInAddons rather than named: a class it puts back that the cache had after the last rebuild is named under classes.lostSinceLastRebuild, which is the editor writing its shorter list over the file on every save until restarted. On Windows and Linux the run gets a user:// of its own, so a suite that saves a game writes nowhere near the saves of the copy somebody plays. On macOS the engine reads user:// off HOME and the run writes where the player keeps theirs, which the answer says under savesNote rather than leaving to be found in a save list. A run that found nothing to run is never called a pass: gdUnit4 exits cleanly for one, so the answer says so and names the path it looked in. A script that does not load stops gdUnit4 before any suite runs: its errors come back in full under scriptErrors, and the scripts that failed only because one they depend on did are listed by path under failedThroughDependency. When they failed on a class whose own script has a parser error, which gdUnit4 never names, that script is checked by the engine and its error comes first under scriptErrors, with the class it declares under declares, and the errors a script has only because that class did not resolve, which the engine reads as Variant, are kept apart under followFromUnresolved. A client that sends a progress token is told as each suite finishes, and at least every twenty seconds through a long one, so an idle limit does not end a long tier. A run that ends without a report, at its timeout or otherwise, names the suites it finished under suitesFinished, the failing ones with their failed cases under suitesFailing, and the one it was in under suiteRunning. When a client cuts a run off, that is kept in the project and the next project_test there carries it under previousRunCut. A run where nothing failed but nodes were left in the tree comes back under warnings, with the count per suite: gdUnit4 decides its verdict on those and keeps them out of its report, so they are read off what it printed. A run whose every case passed is still not called passed when it printed a script error that no case failed on: gdUnit4 fails a case on the script errors its logger sees, and it cannot see a stack overflow, so the cases pass on whatever the faulted calls returned. Those errors come back under uncaughtScriptErrors, and under engineEntries by index with detailUnder rather than with their backtrace a second time; a backtrace that repeats, as a recursion's does, has each repeated frame or cycle of frames written once with the frames it covers and how many times. One raised inside assert_error(...).is_runtime_error is the test's own and does not count, and none count when the project turns off gdUnit4's report/godot/script_error setting. Needs gdUnit4 under addons/gdUnit4.",
     parameters: {
       projectPath: PROJECT_PATH,
       path: {
@@ -37929,7 +37955,7 @@ class GodotServer {
         isError: true
       };
     }
-    const failed = withActualsPrinted(report.suites.flatMap((suite) => suite.cases.filter((entry) => entry.status === "failed" || entry.status === "error").map((entry) => ({ ...entry, path: suite.path }))), Buffer.concat(console2).toString("utf8"));
+    const failed = failedCases(report, Buffer.concat(console2).toString("utf8"));
     const orphans = orphansPrinted(said);
     const leftBehind = new Map(orphans.suites.map((suite) => [suite.path, suite.orphans]));
     const orphansIn = (path) => path === null ? 0 : leftBehind.get(path) ?? 0;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdharness",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "mcpName": "io.github.Aureliolo/gdharness",
   "description": "A harness for driving a Godot 4 project from an agent: editor addons, a runtime bridge into the running game, an MCP server in front of them, and a CLI that installs and diagnoses the Godot side.",
   "type": "module",