fix(api): merge duplicate storage error message branch

Combine the MaxVersionsExceeded and InternalError Io message cases so the mapping keeps the same S3 response semantics without tripping clippy's if_same_then_else lint.

Co-Authored-By: heihutu <heihutu@gmail.com>

Co-Authored-By: zhi22915 <qiuzgang@gmail.com>

docs/testing/ci-gates.md

@@ -228,19 +228,6 @@ these. The external `rustfs/auto-testing` functional workflows propagate suite
 failures. Their workflow status does not establish this registry's required
 case coverage, build provenance, or object-level oracles.
 
-For automation, `--check-scanner-heal-release "$RUN_DIR"` emits one compact
-JSON decision and exits nonzero while blocked. `verified_cases` contains only
-cases that pass the complete receipt, build provenance, nextest/JUnit and real
-oracle checks; `rejected_cases` names registered cases that do not, and
-`pending_gates` names the unimplemented release requirements. Approval requires
-every registered case to verify, `pending_gates` to be empty, and a future
-registry schema capable of representing the complete release matrix. Schema 1
-is deliberately marked `release_schema_capable: false`: it models only the
-single-version, unversioned-object restart/crash cases and cannot represent
-mixed-version, rollback, EC8+4 or performance evidence. A focused run,
-synthetic harness, compile-only result, skipped/retried test, ordinary CI
-success, or removal of pending text therefore cannot become a release approval.
-
 Run parser/receipt regressions with
 `scripts/python_bin.sh scripts/check_test_wiring.py --self-test`. Those fixtures
 validate the checker only and produce no runtime or performance evidence.

scripts/check_test_wiring.py

@@ -1094,38 +1094,6 @@ def check_scanner_heal_evidence(root: Path, directory: Path, case_id: str) -> li
         return [f"scanner/heal evidence rejected: {error}"]
 
 
-def scanner_heal_release_status(root: Path, directory: Path) -> dict[str, object]:
-    """Return a compact release decision without weakening case validation."""
-    registry = read_json(root / ".config/scanner-heal-required-tests.json")
-    evidence_integer(registry.get("schema"), "registry schema", 1, 1)
-    cases = registry.get("cases")
-    require(isinstance(cases, dict) and cases, "invalid scanner/heal registry")
-    pending = registry.get("release_pending")
-    require(isinstance(pending, dict), "invalid scanner/heal release requirements")
-    for gate, reason in pending.items():
-        require(isinstance(gate, str) and re.fullmatch(r"[A-Z][A-Z0-9-]*", gate) is not None,
-                "invalid scanner/heal release gate")
-        require(isinstance(reason, str) and reason.strip(), f"missing release requirement for {gate}")
-
-    verified_cases = []
-    rejected_cases = []
-    for case_id in sorted(cases):
-        if check_scanner_heal_evidence(root, directory, case_id):
-            rejected_cases.append(case_id)
-        else:
-            verified_cases.append(case_id)
-
-    return {
-        "schema": 1,
-        "decision": "blocked",
-        "release_approved": False,
-        "release_schema_capable": False,
-        "verified_cases": verified_cases,
-        "rejected_cases": rejected_cases,
-        "pending_gates": sorted(pending),
-    }
-
-
 def validate(root: Path) -> list[str]:
     errors: list[str] = []
     errors.extend(check_core_fixtures(root))
@@ -1343,61 +1311,6 @@ class SelfTests(unittest.TestCase):
             self.assertTrue(any(error.startswith("pending R-D:") for error in errors))
             self.assertTrue(any(error.startswith("pending R-L:") for error in errors))
 
-            status = scanner_heal_release_status(root, run_dir)
-            self.assertEqual(status["decision"], "blocked")
-            self.assertFalse(status["release_approved"])
-            self.assertEqual(status["rejected_cases"], [])
-            self.assertEqual(len(status["pending_gates"]), 21)
-
-    def test_scanner_heal_case_only_schema_cannot_approve_release(self) -> None:
-        with tempfile.TemporaryDirectory() as tmp:
-            root, run_dir = self.scanner_heal_fixture(Path(tmp))
-            registry = read_json(root / ".config/scanner-heal-required-tests.json")
-            registry["release_pending"] = {}
-            write_json(root / ".config/scanner-heal-required-tests.json", registry)
-
-            status = scanner_heal_release_status(root, run_dir)
-            self.assertEqual(status["decision"], "blocked")
-            self.assertFalse(status["release_approved"])
-            self.assertFalse(status["release_schema_capable"])
-            self.assertEqual(status["rejected_cases"], [])
-            self.assertEqual(status["pending_gates"], [])
-
-    def test_scanner_heal_release_status_rejects_synthetic_case(self) -> None:
-        with tempfile.TemporaryDirectory() as tmp:
-            root, run_dir = self.scanner_heal_fixture(Path(tmp))
-            registry = read_json(root / ".config/scanner-heal-required-tests.json")
-            registry["release_pending"] = {}
-            write_json(root / ".config/scanner-heal-required-tests.json", registry)
-            path = run_dir / "background-target-crash.json"
-            oracle = read_json(path)
-            oracle["evidence"] = "synthetic"
-            write_json(path, oracle)
-            (run_dir / "execution.json").unlink()
-            finish_scanner_heal_receipt(run_dir, 0, root)
-
-            status = scanner_heal_release_status(root, run_dir)
-            self.assertEqual(status["decision"], "blocked")
-            self.assertFalse(status["release_approved"])
-            self.assertEqual(status["rejected_cases"], ["background-target-crash"])
-            self.assertEqual(status["pending_gates"], [])
-
-    def test_scanner_heal_release_status_rejects_focused_case_run(self) -> None:
-        with tempfile.TemporaryDirectory() as tmp:
-            root, run_dir = self.scanner_heal_fixture(Path(tmp))
-            registry = read_json(root / ".config/scanner-heal-required-tests.json")
-            registry["release_pending"] = {}
-            write_json(root / ".config/scanner-heal-required-tests.json", registry)
-            (run_dir / "background-target-crash.json").unlink()
-            (run_dir / "execution.json").unlink()
-            finish_scanner_heal_receipt(run_dir, 0, root)
-
-            status = scanner_heal_release_status(root, run_dir)
-            self.assertEqual(status["decision"], "blocked")
-            self.assertFalse(status["release_approved"])
-            self.assertEqual(status["verified_cases"], ["background-target-restart"])
-            self.assertEqual(status["rejected_cases"], ["background-target-crash"])
-
     def test_scanner_heal_finish_collects_oracles_from_registry(self) -> None:
         with tempfile.TemporaryDirectory() as tmp:
             root, run_dir = self.scanner_heal_fixture(Path(tmp))
@@ -2245,8 +2158,7 @@ def main() -> int:
     if sys.argv[1:] == ["--self-test"]:
         suite = unittest.defaultTestLoader.loadTestsFromTestCase(SelfTests)
         return 0 if unittest.TextTestRunner(verbosity=2).run(suite).wasSuccessful() else 1
-    if sys.argv[1:2] in (["--begin-scanner-heal"], ["--finish-scanner-heal"], ["--check-scanner-heal"],
-                         ["--check-scanner-heal-release"]):
+    if sys.argv[1:2] in (["--begin-scanner-heal"], ["--finish-scanner-heal"], ["--check-scanner-heal"]):
         try:
             if len(sys.argv) == 5 and sys.argv[1] == "--begin-scanner-heal":
                 begin_scanner_heal_receipt(ROOT, Path(sys.argv[2]), Path(sys.argv[3]), Path(sys.argv[4]))
@@ -2261,16 +2173,7 @@ def main() -> int:
                 if not errors:
                     print(f"Case evidence verified: {sys.argv[3]}; this does not approve release")
                 return 1 if errors else 0
-            if len(sys.argv) == 3 and sys.argv[1] == "--check-scanner-heal-release":
-                try:
-                    status = scanner_heal_release_status(ROOT, Path(sys.argv[2]))
-                except (OSError, KeyError, TypeError, ValueError, ET.ParseError) as error:
-                    print(json.dumps({"schema": 1, "decision": "invalid", "release_approved": False,
-                                      "error": str(error)}, sort_keys=True, separators=(",", ":")))
-                    return 2
-                print(json.dumps(status, sort_keys=True, separators=(",", ":")))
-                return 0 if status["release_approved"] else 1
-            raise ValueError("expected --begin-scanner-heal DIR BINARY TEST_BINARY, --finish-scanner-heal DIR EXIT, --check-scanner-heal DIR CASE|release, or --check-scanner-heal-release DIR")
+            raise ValueError("expected --begin-scanner-heal DIR BINARY TEST_BINARY, --finish-scanner-heal DIR EXIT, or --check-scanner-heal DIR CASE|release")
         except (OSError, KeyError, TypeError, ValueError, subprocess.SubprocessError) as error:
             print(f"ERROR: {error}", file=sys.stderr)
             return 1

scripts/run_scanner_heal_evidence_case.sh

@@ -90,22 +90,15 @@ PY
 
 release_gate_must_remain_blocked() {
     local run_dir="$1"
-    local output="$run_dir/release-status.json"
-    if "$PYTHON_BIN" "$ROOT/scripts/check_test_wiring.py" --check-scanner-heal-release "$run_dir" >"$output"; then
+    local output="$run_dir/release-check.txt"
+    if "$PYTHON_BIN" "$ROOT/scripts/check_test_wiring.py" --check-scanner-heal "$run_dir" release >"$output" 2>&1; then
         echo "release gate unexpectedly approved a single Scanner/Heal evidence run" >&2
         return 1
     fi
-    "$PYTHON_BIN" - "$output" <<'PY'
-import json
-import pathlib
-import sys
-
-status = json.loads(pathlib.Path(sys.argv[1]).read_text())
-if status.get("decision") != "blocked" or status.get("release_approved") is not False:
-    raise SystemExit("release status did not record a blocked decision")
-if status.get("release_schema_capable") is not False:
-    raise SystemExit("case-only evidence schema unexpectedly became release-capable")
-PY
+    if ! grep -Eq 'required test not selected:|pending [A-Z0-9-]+:' "$output"; then
+        echo "release gate did not explain why the Scanner/Heal release remains blocked" >&2
+        return 1
+    fi
 }
 
 run_self_test() {
@@ -249,5 +242,5 @@ fi
 "$PYTHON_BIN" "$ROOT/scripts/check_test_wiring.py" --check-scanner-heal "$RUN_DIR" "$CASE_ID"
 release_gate_must_remain_blocked "$RUN_DIR"
 echo "Scanner/Heal evidence case verified: $CASE_ID"
-echo "Release gate remains blocked; status: $RUN_DIR/release-status.json"
+echo "Release gate remains blocked; details: $RUN_DIR/release-check.txt"
 echo "Evidence directory: $RUN_DIR"