Close parity review edge cases

Author: flemming-n-larsen

compat-test/compat_test.py

@@ -308,7 +308,12 @@ def collected():
             kill_process_tree(proc)
             return -1, collected() + "\n<stopped: exception with no classic counterpart>", False
         time.sleep(poll_seconds)
-    return proc.returncode, collected(), False
+    output = collected()
+    # A short-lived worker can write its final exception and exit between polls. Its
+    # output is still a bridge-only failure and must not leave a score in the result.
+    if abort_when(output):
+        return -1, output + "\n<stopped: exception with no classic counterpart>", False
+    return proc.returncode, output, False
 
 
 def _drain(stream, sink):
@@ -991,6 +996,17 @@ def should_run(entry, opts, registry=None, key=None):
     return False
 
 
+def retest_option_error(opts, todo=None):
+    """Return an actionable invalid-retetest message, or None when selection is valid."""
+    if opts.repair and not opts.retest_cause:
+        return "--repair requires --retest-cause so it can be linked to a diagnosis."
+    if opts.retest_cause and not opts.repair:
+        return "--retest-cause requires --repair to preserve repair evidence."
+    if todo is not None and opts.retest_cause and not todo:
+        return f"No unresolved registry subject is diagnosed with cause: {opts.retest_cause}"
+    return None
+
+
 def check_prerequisites(opts):
     problems = []
     for label, path in [
@@ -1633,8 +1649,9 @@ def division_setup(collection, opts):
 def main():
     opts = parse_args()
 
-    if opts.repair and not opts.retest_cause:
-        print("--repair requires --retest-cause so it can be linked to a diagnosis.", file=sys.stderr)
+    option_error = retest_option_error(opts)
+    if option_error:
+        print(option_error, file=sys.stderr)
         return 2
 
     if opts.conformance:
@@ -1677,6 +1694,10 @@ def main():
     registry = load_registry(PARITY_REGISTRY_FILE)
     todo = [(c, j) for c, j in jars
             if should_run(state["robots"].get(f"{c}/{j.name}"), opts, registry, f"{c}/{j.name}")]
+    option_error = retest_option_error(opts, todo)
+    if option_error:
+        print(option_error, file=sys.stderr)
+        return 2
     print(f"Found {len(jars)} jars; {len(jars) - len(todo)} already tested, "
           f"{len(todo)} to test.")
 

compat-test/parity_registry.py

@@ -137,7 +137,8 @@ def _migrate_subject(subject: dict) -> None:
         add_diagnosis(subject, legacy["cause"], legacy.get("owner"), "migrated")
 
 
-def _same_observation(observation: dict, entry: dict, manifest: dict) -> bool:
+def _same_observation(observation: dict, entry: dict, manifest: dict,
+                      source_identity: dict) -> bool:
     """Recognize schema-1 observations whose ID predates per-observation identity."""
     return (
         observation.get("completed_at") == entry.get("completed_at")
@@ -149,6 +150,7 @@ def _same_observation(observation: dict, entry: dict, manifest: dict) -> bool:
         and observation.get("confirmation") == entry.get("confirmation")
         and observation.get("retest") == entry.get("retest")
         and observation.get("manifest") == manifest
+        and observation.get("source_identity") == source_identity
     )
 
 
@@ -168,7 +170,8 @@ def sync_state(registry: dict, state: dict, collection_dir: Path, manifest: dict
         for observation in subject["observations"]:
             observation.setdefault("source_identity", subject["identity"])
         oid = observation_id(key, entry, manifest, identity)
-        if any(observation["id"] == oid or _same_observation(observation, entry, manifest)
+        if any(observation["id"] == oid or _same_observation(
+                   observation, entry, manifest, identity)
                for observation in subject["observations"]):
             continue
         subject["observations"].append({

compat-test/test_parity_registry.py

@@ -3,6 +3,7 @@
 import tempfile
 import unittest
 from pathlib import Path
+from types import SimpleNamespace
 
 
 MODULE = Path(__file__).with_name("parity_registry.py")
@@ -97,8 +98,7 @@ def testHARN001_UnitPositive_ObservationKeepsJarIdentityWhenSameKeyChanges(self)
             data = {"schema_version": 1, "subjects": {}}
             registry.sync_state(data, state, root, {"bridge_commit": "one"})
             jar.write_bytes(b"replacement")
-            state["robots"]["roborumble/a.Bot_1.0.jar"]["completed_at"] = "2026-09-10T00:00:00Z"
-            registry.sync_state(data, state, root, {"bridge_commit": "two"})
+            registry.sync_state(data, state, root, {"bridge_commit": "one"})
         observations = data["subjects"]["roborumble/a.Bot_1.0.jar"]["observations"]
         self.assertEqual(2, len(observations))
         self.assertNotEqual(observations[0]["source_identity"]["jar_sha256"],
@@ -133,6 +133,22 @@ def testC004_UnitNegative_ClassicWorkerExceptionDoesNotTriggerWatcher(self):
             "java.lang.IllegalStateException: classic equivalent\n"
             "  at legacy.Bot.run(Bot.java:12)"))
 
+    def testC004_UnitPositive_ImmediateWorkerExitStillTriggersWatcher(self):
+        watcher = harness.BridgeOnlyErrorWatcher([], [])
+        returncode, output, timed_out = harness.run_java(
+            [sys.executable, "-c", "print('java.lang.IllegalStateException: failure\\n  at legacy.Bot.run(Bot.java:12)')"],
+            Path.cwd(), timeout=5, abort_when=watcher, poll_seconds=0.1)
+        self.assertEqual(-1, returncode)
+        self.assertFalse(timed_out)
+        self.assertTrue(watcher.triggered)
+        self.assertIn("IllegalStateException", output)
+
+    def testHARN001_UnitNegative_CauseRetestRequiresRepairAndKnownSelection(self):
+        missing_repair = SimpleNamespace(repair=None, retest_cause="lifecycle")
+        unknown_cause = SimpleNamespace(repair="abc123", retest_cause="lifecycle")
+        self.assertIn("requires --repair", harness.retest_option_error(missing_repair))
+        self.assertIn("No unresolved", harness.retest_option_error(unknown_cause, []))
+
 
 if __name__ == "__main__":
     unittest.main()