from __future__ import annotations from dataclasses import replace from decimal import Decimal import json import os from pathlib import Path import subprocess import sys import pytest import dx_productivity.part_replace.controller as controller_module from dx_productivity.part_replace.certification import CertificationStore, interface_fingerprint from dx_productivity.part_replace.cli import main from dx_productivity.part_replace.controller import BatchController from dx_productivity.part_replace.models import ( ComponentSnapshot, DesignSnapshot, ExternalChecks, MappingRule, PinSnapshot, UnitSnapshot, ) from dx_productivity.part_replace.protocol import ( atomic_write_text, load_status, snapshot_fingerprint, write_snapshot, ) from dx_productivity.part_replace.verification import verify_replacement ROOT = Path(__file__).resolve().parents[2] PROFILE = ROOT / "tests" / "fixtures" / "part_replace" / "compatibility-profile-v1.json" def _project_inputs(tmp_path: Path) -> tuple[Path, Path, Path]: project_root = tmp_path / "project" project_root.mkdir() marker = project_root / "demo.prj" marker.write_text("demo\n", encoding="utf-8") mapping = tmp_path / "mapping.csv" mapping.write_text("old_part_number,new_part_number\nOLD-1,NEW-1\n", encoding="utf-8") projects = tmp_path / "projects.txt" projects.write_text(str(marker.resolve()) + "\n", encoding="utf-8") return marker, mapping, projects def _snapshot(project_id: str, marker: Path, part: str, fingerprint: str, *, net: str | None = "N1") -> DesignSnapshot: return DesignSnapshot( format_version=2, project_id=project_id, project_path=str(marker.resolve()), fingerprint=fingerprint, components=( ComponentSnapshot( logical_key="/MAIN|U1", refdes="U1", part_number=part, units=( UnitSnapshot( "A", "/MAIN", "LIB:NEW" if part == "NEW-1" else "LIB:OLD", Decimal("0.5"), Decimal("1.5"), Decimal("1"), Decimal("2"), 0, False, (PinSnapshot("1", "P", Decimal("1"), Decimal("2"), net),), ), ), ), ), ) def _certify(path: Path, before: DesignSnapshot) -> None: rule = MappingRule("OLD-1", "NEW-1") after = replace(before, fingerprint="after", components=(_snapshot(before.project_id, Path(before.project_path), "NEW-1", "after").components[0],)) result = verify_replacement(before, after, rule, ("/MAIN|U1",)) CertificationStore( path, before=before, after=after, verification=result, evidence_paths=("before", "after", "packager", "erc", "netlist"), ).record( rule, interface_fingerprint(after, ("/MAIN|U1",)), "lib-r42", ExternalChecks(True, True, True), ) def _bridge_snapshot(snapshot: DesignSnapshot) -> DesignSnapshot: return replace(snapshot, fingerprint=snapshot_fingerprint(snapshot)) def _write_correlated_status( path: Path, *, command: dict[str, object], state: str, snapshot: Path, ) -> None: atomic_write_text( path, json.dumps( { "command_id": command["command_id"], "details": [ ["action", command["action"]], ["expected_count", str(command["expected_count"])], ["job_id", command["job_id"]], ], "error_code": None, "error_message": None, "format_version": 1, "project_id": command["project_id"], "snapshot_path": str(snapshot.resolve()), "state": state, }, sort_keys=True, separators=(",", ":"), ) + "\n", ) def _publish_active_command_snapshot( run: Path, project_id: str, snapshot: DesignSnapshot, state: str, *, status_action: str | None = None, ) -> tuple[dict[str, object], DesignSnapshot, Path]: mailbox = run / "mailbox" / project_id command = json.loads((mailbox / "command.json").read_text(encoding="utf-8")) observed = _bridge_snapshot(snapshot) snapshot_path = mailbox / "snapshot.json" write_snapshot(snapshot_path, observed) status_command = dict(command) if status_action is not None: status_command["action"] = status_action _write_correlated_status( mailbox / "status.json", command=status_command, state=state, snapshot=snapshot_path, ) return command, observed, snapshot_path def _publish_inventory( run: Path, project_id: str, snapshot: DesignSnapshot, ) -> DesignSnapshot: BatchController.open(run).prepare_inventory(project_id) _, observed, _ = _publish_active_command_snapshot( run, project_id, snapshot, "inventory_exported", ) return observed def _ready_for_apply_cli( run: Path, project_id: str, before: DesignSnapshot, capsys, ) -> None: assert main(["--json", "prepare-close", str(run), project_id]) == 4 capsys.readouterr() _publish_active_command_snapshot(run, project_id, before, "project_closed") assert main(["--json", "confirm-close", str(run), project_id]) == 0 capsys.readouterr() assert main(["--json", "prepare-open", str(run), project_id]) == 4 capsys.readouterr() _publish_active_command_snapshot(run, project_id, before, "project_opened") assert main(["--json", "confirm-open", str(run), project_id]) == 0 capsys.readouterr() def _write_manual_action_status( path: Path, *, command: dict[str, object], ) -> None: atomic_write_text( path, json.dumps( { "command_id": command["command_id"], "details": [ ["action", "replace_part"], ["expected_count", str(command["expected_count"])], ["job_id", command["job_id"]], ["instruction", "Complete the native Replace Part dialog"], ["manual_route", "manual_native_dialog"], ["new_part_number", command["new_part_number"]], ["old_part_number", command["old_part_number"]], ], "error_code": None, "error_message": None, "format_version": 1, "project_id": command["project_id"], "snapshot_path": None, "state": "manual_action_required", }, sort_keys=True, separators=(",", ":"), ) + "\n", ) def _durable_intent(run: Path, event_name: str) -> dict[str, object]: events = [ json.loads(line) for line in (run / "events.jsonl").read_text(encoding="utf-8").splitlines() ] return next(event["payload"]["command"] for event in events if event["event"] == event_name) def test_discover_json_is_machine_readable_and_does_not_create_a_job(tmp_path: Path, capsys) -> None: # Catches JSON mode that emits prose or discovery that silently mutates batch state. marker, _, _ = _project_inputs(tmp_path) code = main(["--json", "discover", str(tmp_path), "--suffix", ".prj"]) payload = json.loads(capsys.readouterr().out) assert code == 0 assert payload == {"projects": [str(marker.resolve())]} assert not (tmp_path / "run").exists() def test_invalid_create_returns_exit_2_with_stable_json_error(tmp_path: Path, capsys) -> None: # Catches invalid input escaping as a traceback, exit 1, or non-machine-readable output. marker, mapping, projects = _project_inputs(tmp_path) mapping.write_text("old_part_number,new_part_number\nOLD-1,OLD-1\n", encoding="utf-8") code = main([ "--json", "create", str(tmp_path / "run"), "--mapping", str(mapping), "--projects", str(projects), "--certifications", str(tmp_path / "certifications.json"), "--suffix", marker.suffix, ]) payload = json.loads(capsys.readouterr().out) assert code == 2 assert payload["error"]["code"] == "equal_rule" def test_prepare_returns_manual_exit_4_and_exact_command_json(tmp_path: Path, capsys) -> None: # Catches treating a prepared native dialog as completed unattended work. marker, mapping, projects = _project_inputs(tmp_path) run = tmp_path / "run" certifications = tmp_path / "certifications.json" assert main([ "--json", "create", str(run), "--mapping", str(mapping), "--projects", str(projects), "--certifications", str(certifications), "--suffix", ".prj", "--library-identity", "lib-r42", ]) == 0 created = json.loads(capsys.readouterr().out) project_id = created["projects"][0]["project_id"] before = _snapshot(project_id, marker, "OLD-1", "inventory") before = _publish_inventory(run, project_id, before) _certify(certifications, before) assert main(["--json", "ingest", str(run), project_id]) == 0 capsys.readouterr() _ready_for_apply_cli(run, project_id, before, capsys) code = main(["--json", "prepare", str(run), project_id, "0"]) payload = json.loads(capsys.readouterr().out) assert code == 4 assert payload["action"] == "replace_part" assert payload["expected_logical_keys"] == ["/MAIN|U1"] def test_prepare_inventory_returns_the_complete_bridge_command_json( tmp_path: Path, capsys, ) -> None: # Catches CLI output omitting a protocol field that exists in the mailbox command. marker, mapping, projects = _project_inputs(tmp_path) run = tmp_path / "run" assert main( [ "--json", "create", str(run), "--mapping", str(mapping), "--projects", str(projects), "--certifications", str(tmp_path / "certifications.json"), "--suffix", marker.suffix, ] ) == 0 created = json.loads(capsys.readouterr().out) project_id = created["projects"][0]["project_id"] code = main(["--json", "prepare-inventory", str(run), project_id]) payload = json.loads(capsys.readouterr().out) assert code == 0 assert set(payload) == { "action", "command_id", "expected_count", "expected_fingerprint", "expected_logical_keys", "format_version", "job_id", "new_part_number", "old_part_number", "project_id", "scope", } assert payload["format_version"] == 1 assert payload["action"] == "inventory" assert payload["project_id"] == project_id assert payload["scope"] == "full_project" assert payload["expected_count"] == 0 assert payload["expected_logical_keys"] == [] assert payload["expected_fingerprint"] == "" assert payload["old_part_number"] == payload["new_part_number"] == "" def test_operator_step_returns_one_manifest_ready_current_command( tmp_path: Path, capsys, ) -> None: # Catches the public operator loop omitting a command/project binding or using exit 0 early. marker, mapping, projects = _project_inputs(tmp_path) run = tmp_path / "run" assert main([ "--json", "create", str(run), "--mapping", str(mapping), "--projects", str(projects), "--certifications", str(tmp_path / "certifications.json"), "--suffix", marker.suffix, ]) == 0 created = json.loads(capsys.readouterr().out) project = created["projects"][0] code = main(["--json", "operator-step", str(run)]) payload = json.loads(capsys.readouterr().out) assert code == 4 assert payload == { "bridge_state": None, "command": { "action": "inventory", "command_id": payload["command"]["command_id"], "expected_count": 0, "expected_fingerprint": "", "expected_logical_keys": [], "format_version": 1, "job_id": run.resolve().name, "new_part_number": "", "old_part_number": "", "project_id": project["project_id"], "scope": "full_project", }, "complete": False, "consumed_action": None, "instruction": None, "manual_route": None, "project": project, "state": "inventory_pending", } def test_operator_step_returns_exit_zero_after_consuming_final_noop_inventory( tmp_path: Path, capsys, ) -> None: # Catches a completed no-op job retaining a stale current command in the launcher manifest. marker, mapping, projects = _project_inputs(tmp_path) run = tmp_path / "run" assert main([ "--json", "create", str(run), "--mapping", str(mapping), "--projects", str(projects), "--certifications", str(tmp_path / "certifications.json"), "--suffix", marker.suffix, ]) == 0 project_id = json.loads(capsys.readouterr().out)["projects"][0]["project_id"] assert main(["--json", "operator-step", str(run)]) == 4 command = json.loads(capsys.readouterr().out)["command"] snapshot = _bridge_snapshot(_snapshot(project_id, marker, "KEEP-1", "noop")) mailbox = run / "mailbox" / project_id write_snapshot(mailbox / "snapshot.json", snapshot) _write_correlated_status( mailbox / "status.json", command=command, state="inventory_exported", snapshot=mailbox / "snapshot.json", ) code = main(["--json", "operator-step", str(run)]) assert code == 0 assert json.loads(capsys.readouterr().out) == { "bridge_state": None, "command": None, "complete": True, "consumed_action": "inventory", "instruction": None, "manual_route": None, "project": None, "state": None, } def test_cli_runs_correlated_close_open_save_and_external_checks( tmp_path: Path, capsys, ) -> None: # Catches an operator command bypassing its prepared mailbox evidence or accepting caller check flags. marker, mapping, projects = _project_inputs(tmp_path) run = tmp_path / "run" certifications = tmp_path / "certifications.json" assert main( [ "--json", "create", str(run), "--mapping", str(mapping), "--projects", str(projects), "--certifications", str(certifications), "--suffix", marker.suffix, "--library-identity", "lib-r42", ] ) == 0 created = json.loads(capsys.readouterr().out) project_id = created["projects"][0]["project_id"] before = _publish_inventory( run, project_id, _snapshot(project_id, marker, "OLD-1", "inventory"), ) _certify(certifications, before) assert main(["--json", "ingest", str(run), project_id]) == 0 capsys.readouterr() assert main(["--json", "prepare-close", str(run), project_id]) == 4 close_command = json.loads(capsys.readouterr().out) assert close_command["action"] == "close_project" _publish_active_command_snapshot(run, project_id, before, "project_closed") assert main(["--json", "confirm-close", str(run), project_id]) == 0 assert json.loads(capsys.readouterr().out) == { "project_id": project_id, "state": "apply_pending", } assert main(["--json", "prepare-open", str(run), project_id]) == 4 open_command = json.loads(capsys.readouterr().out) assert open_command["action"] == "open_project" _publish_active_command_snapshot(run, project_id, before, "project_opened") assert main(["--json", "confirm-open", str(run), project_id]) == 0 assert json.loads(capsys.readouterr().out) == { "project_id": project_id, "state": "apply_pending", } assert main(["--json", "prepare", str(run), project_id, "0"]) == 4 apply_command = json.loads(capsys.readouterr().out) after = _snapshot(project_id, marker, "NEW-1", "after") _publish_active_command_snapshot(run, project_id, after, "applied") assert main(["--json", "verify", str(run), project_id, "0"]) == 0 assert json.loads(capsys.readouterr().out)["passed"] is True assert main(["--json", "prepare-save", str(run), project_id]) == 4 save_command = json.loads(capsys.readouterr().out) assert save_command["action"] == "save" _publish_active_command_snapshot( run, project_id, after, "saved", status_action="replace_part", ) assert main(["--json", "confirm-saved", str(run), project_id]) == 4 assert json.loads(capsys.readouterr().out) == { "project_id": project_id, "state": "awaiting_external_checks", } for index, check in enumerate(("packager", "erc", "netlist")): assert main( ["--json", "prepare-check", str(run), project_id, check] ) == 4 check_command = json.loads(capsys.readouterr().out) assert check_command["action"] == check _publish_active_command_snapshot( run, project_id, after, "external_check_passed", ) expected_code = 0 if index == 2 else 4 assert main( ["--json", "confirm-check", str(run), project_id, check] ) == expected_code expected_state = ( "verified_saved" if index == 2 else "awaiting_external_checks" ) assert json.loads(capsys.readouterr().out) == { "project_id": project_id, "state": expected_state, } def test_cli_requires_correlated_undo_before_reconcile( tmp_path: Path, capsys, ) -> None: # Catches a failed native replacement being reconciled without exact Undo evidence. marker, mapping, projects = _project_inputs(tmp_path) run = tmp_path / "run" certifications = tmp_path / "certifications.json" assert main( [ "--json", "create", str(run), "--mapping", str(mapping), "--projects", str(projects), "--certifications", str(certifications), "--suffix", marker.suffix, "--library-identity", "lib-r42", ] ) == 0 project_id = json.loads(capsys.readouterr().out)["projects"][0]["project_id"] before = _publish_inventory( run, project_id, _snapshot(project_id, marker, "OLD-1", "inventory"), ) _certify(certifications, before) assert main(["--json", "ingest", str(run), project_id]) == 0 capsys.readouterr() _ready_for_apply_cli(run, project_id, before, capsys) assert main(["--json", "prepare", str(run), project_id, "0"]) == 4 apply_command = json.loads(capsys.readouterr().out) wrong_target = _snapshot(project_id, marker, "WRONG-1", "wrong") _publish_active_command_snapshot(run, project_id, wrong_target, "applied") assert main(["--json", "verify", str(run), project_id, "0"]) == 3 failed = json.loads(capsys.readouterr().out) assert {issue["code"] for issue in failed["issues"]} == { "uncertified_target", "wrong_target_part_number", } assert main(["--json", "prepare-undo", str(run), project_id]) == 4 undo_command = json.loads(capsys.readouterr().out) assert undo_command["action"] == "undo" assert undo_command["command_id"] == apply_command["command_id"] _publish_active_command_snapshot( run, project_id, before, "undo_verified", status_action="replace_part", ) assert main(["--json", "confirm-undo", str(run), project_id]) == 0 assert json.loads(capsys.readouterr().out) == { "project_id": project_id, "state": "blocked", } assert main(["--json", "reconcile", str(run), project_id]) == 0 assert json.loads(capsys.readouterr().out) == { "project_id": project_id, "state": "inventory_pending", } def test_cli_restores_verified_backup_after_closed_disk_mismatch( tmp_path: Path, capsys, ) -> None: # Catches a changed on-disk project being trusted after close-without-save or overwritten without preservation. marker, mapping, projects = _project_inputs(tmp_path) run = tmp_path / "run" certifications = tmp_path / "certifications.json" assert main( [ "--json", "create", str(run), "--mapping", str(mapping), "--projects", str(projects), "--certifications", str(certifications), "--suffix", marker.suffix, "--library-identity", "lib-r42", ] ) == 0 project_id = json.loads(capsys.readouterr().out)["projects"][0]["project_id"] before = _publish_inventory( run, project_id, _snapshot(project_id, marker, "OLD-1", "inventory"), ) _certify(certifications, before) assert main(["--json", "ingest", str(run), project_id]) == 0 capsys.readouterr() _ready_for_apply_cli(run, project_id, before, capsys) assert main(["--json", "prepare", str(run), project_id, "0"]) == 4 capsys.readouterr() wrong_target = _snapshot(project_id, marker, "WRONG-1", "wrong") _publish_active_command_snapshot(run, project_id, wrong_target, "applied") assert main(["--json", "verify", str(run), project_id, "0"]) == 3 capsys.readouterr() marker.write_text("failed on-disk change\n", encoding="utf-8") assert main(["--json", "prepare-close", str(run), project_id]) == 4 close_command = json.loads(capsys.readouterr().out) assert close_command["action"] == "close_without_save" _publish_active_command_snapshot( run, project_id, wrong_target, "project_closed", ) assert main(["--json", "confirm-close", str(run), project_id]) == 3 assert json.loads(capsys.readouterr().out)["error"]["code"] == ( "closed_disk_mismatch" ) assert main(["--json", "restore", str(run), project_id]) == 0 restored = json.loads(capsys.readouterr().out) recovery = Path(restored["recovery_path"]) assert restored["state"] == "blocked" assert marker.read_text(encoding="utf-8") == "demo\n" assert (recovery / marker.name).read_text(encoding="utf-8") == ( "failed on-disk change\n" ) assert main(["--json", "reconcile", str(run), project_id]) == 0 assert json.loads(capsys.readouterr().out)["state"] == "inventory_pending" assert main(["--json", "next", str(run)]) == 4 assert json.loads(capsys.readouterr().out)["action"] == "prepare-open" def test_prepare_inventory_recovers_malformed_command_from_correlated_outputs_via_cli( tmp_path: Path, capsys, monkeypatch: pytest.MonkeyPatch, ) -> None: # Catches command corruption stranding a valid inventory export outside every CLI route. marker, mapping, projects = _project_inputs(tmp_path) run = tmp_path / "run" assert main( [ "--json", "create", str(run), "--mapping", str(mapping), "--projects", str(projects), "--certifications", str(tmp_path / "certifications.json"), "--suffix", marker.suffix, ] ) == 0 created = json.loads(capsys.readouterr().out) project_id = created["projects"][0]["project_id"] real_write_command = controller_module.write_command def interrupt_after_publish(path: Path, command: object) -> None: real_write_command(path, command) raise RuntimeError("inventory publication interrupted") monkeypatch.setattr(controller_module, "write_command", interrupt_after_publish) with pytest.raises(RuntimeError, match="inventory publication interrupted"): main(["--json", "prepare-inventory", str(run), project_id]) monkeypatch.setattr(controller_module, "write_command", real_write_command) intended = _durable_intent(run, "inventory_command_publication_started") mailbox = run / "mailbox" / project_id command_path = mailbox / "command.json" command_path.write_bytes(b"{malformed-command") snapshot_path = mailbox / "snapshot.json" write_snapshot( snapshot_path, _bridge_snapshot(_snapshot(project_id, marker, "OLD-1", "ignored")), ) status_path = mailbox / "status.json" _write_correlated_status( status_path, command=intended, state="inventory_exported", snapshot=snapshot_path, ) status_bytes = status_path.read_bytes() snapshot_bytes = snapshot_path.read_bytes() retry_code = main(["--json", "prepare-inventory", str(run), project_id]) recovered = json.loads(capsys.readouterr().out) ingest_code = main(["--json", "ingest", str(run), project_id]) ingested = json.loads(capsys.readouterr().out) assert retry_code == 0 assert recovered == intended assert json.loads(command_path.read_text(encoding="utf-8")) == intended assert status_path.read_bytes() == status_bytes assert snapshot_path.read_bytes() == snapshot_bytes assert ingest_code == 0 assert ingested == {"project_id": project_id, "state": "apply_pending"} def test_prepare_apply_recovers_malformed_command_from_correlated_outputs_via_cli( tmp_path: Path, capsys, monkeypatch: pytest.MonkeyPatch, ) -> None: # Catches command corruption stranding a completed native Apply before hard verification. marker, mapping, projects = _project_inputs(tmp_path) run = tmp_path / "run" certifications = tmp_path / "certifications.json" assert main( [ "--json", "create", str(run), "--mapping", str(mapping), "--projects", str(projects), "--certifications", str(certifications), "--suffix", marker.suffix, "--library-identity", "lib-r42", ] ) == 0 created = json.loads(capsys.readouterr().out) project_id = created["projects"][0]["project_id"] before = _bridge_snapshot(_snapshot(project_id, marker, "OLD-1", "ignored")) before = _publish_inventory(run, project_id, before) _certify(certifications, before) assert main(["--json", "ingest", str(run), project_id]) == 0 capsys.readouterr() _ready_for_apply_cli(run, project_id, before, capsys) real_write_command = controller_module.write_command def interrupt_after_publish(path: Path, command: object) -> None: real_write_command(path, command) raise RuntimeError("apply publication interrupted") monkeypatch.setattr(controller_module, "write_command", interrupt_after_publish) with pytest.raises(RuntimeError, match="apply publication interrupted"): main(["--json", "prepare", str(run), project_id, "0"]) monkeypatch.setattr(controller_module, "write_command", real_write_command) intended = _durable_intent(run, "apply_command_publication_started") mailbox = run / "mailbox" / project_id command_path = mailbox / "command.json" command_path.write_bytes(b"{malformed-command") after_path = mailbox / "snapshot.json" after = _bridge_snapshot( _snapshot(project_id, marker, "NEW-1", "ignored", net="N1") ) write_snapshot(after_path, after) status_path = mailbox / "status.json" _write_correlated_status( status_path, command=intended, state="applied", snapshot=after_path, ) status_bytes = status_path.read_bytes() snapshot_bytes = after_path.read_bytes() retry_code = main(["--json", "prepare", str(run), project_id, "0"]) recovered = json.loads(capsys.readouterr().out) verify_code = main(["--json", "verify", str(run), project_id, "0"]) verified = json.loads(capsys.readouterr().out) assert retry_code == 4 assert recovered == intended assert json.loads(command_path.read_text(encoding="utf-8")) == intended assert status_path.read_bytes() == status_bytes assert after_path.read_bytes() == snapshot_bytes assert verify_code == 0 assert verified["passed"] is True @pytest.mark.parametrize("phase", ("inventory", "apply")) def test_uncorrelated_publication_outputs_reconcile_and_prepare_via_cli( tmp_path: Path, capsys, monkeypatch: pytest.MonkeyPatch, phase: str, ) -> None: # Catches a reconcile cycle leaving uncertain mailbox files active for the next prepare. marker, mapping, projects = _project_inputs(tmp_path) run = tmp_path / "run" certifications = tmp_path / "certifications.json" assert main( [ "--json", "create", str(run), "--mapping", str(mapping), "--projects", str(projects), "--certifications", str(certifications), "--suffix", marker.suffix, "--library-identity", "lib-r42", ] ) == 0 created = json.loads(capsys.readouterr().out) project_id = created["projects"][0]["project_id"] before = _bridge_snapshot(_snapshot(project_id, marker, "OLD-1", "ignored")) _certify(certifications, before) if phase == "apply": _publish_inventory(run, project_id, before) assert main(["--json", "ingest", str(run), project_id]) == 0 capsys.readouterr() _ready_for_apply_cli(run, project_id, before, capsys) command_args = ( ["--json", "prepare-inventory", str(run), project_id] if phase == "inventory" else ["--json", "prepare", str(run), project_id, "0"] ) real_write_command = controller_module.write_command def interrupt_after_publish(path: Path, command: object) -> None: real_write_command(path, command) raise RuntimeError(f"{phase} publication interrupted") monkeypatch.setattr(controller_module, "write_command", interrupt_after_publish) with pytest.raises(RuntimeError, match=f"{phase} publication interrupted"): main(command_args) monkeypatch.setattr(controller_module, "write_command", real_write_command) intended = _durable_intent( run, "inventory_command_publication_started" if phase == "inventory" else "apply_command_publication_started", ) mailbox = run / "mailbox" / project_id command_path = mailbox / "command.json" status_path = mailbox / "status.json" snapshot_path = mailbox / "snapshot.json" command_bytes = b"{malformed-command" status_bytes = b"{malformed-status" command_path.write_bytes(command_bytes) status_path.write_bytes(status_bytes) write_snapshot(snapshot_path, before) snapshot_bytes = snapshot_path.read_bytes() failed_code = main(command_args) failed = json.loads(capsys.readouterr().out) next_code = main(["--json", "next", str(run)]) next_action = json.loads(capsys.readouterr().out) if phase == "apply": assert main(["--json", "prepare-close", str(run), project_id]) == 4 capsys.readouterr() _publish_active_command_snapshot( run, project_id, before, "project_closed", ) assert main(["--json", "confirm-close", str(run), project_id]) == 0 capsys.readouterr() reconcile_code = main(["--json", "reconcile", str(run), project_id]) reconciled = json.loads(capsys.readouterr().out) mailbox_outputs_cleared = not any( path.exists() for path in (status_path, snapshot_path) ) active_command = ( json.loads(command_path.read_text(encoding="utf-8")) if command_path.exists() else None ) if phase == "apply": assert main(["--json", "prepare-open", str(run), project_id]) == 4 capsys.readouterr() _publish_active_command_snapshot( run, project_id, before, "project_opened", ) assert main(["--json", "confirm-open", str(run), project_id]) == 0 capsys.readouterr() fresh_inventory_code = main( ["--json", "prepare-inventory", str(run), project_id] ) fresh_inventory = json.loads(capsys.readouterr().out) _publish_active_command_snapshot( run, project_id, before, "inventory_exported", ) ingest_code = main(["--json", "ingest", str(run), project_id]) ingested = json.loads(capsys.readouterr().out) _ready_for_apply_cli(run, project_id, before, capsys) prepare_next_code = main(["--json", "next", str(run)]) prepare_next = json.loads(capsys.readouterr().out) fresh_prepare_code = main( ["--json", "prepare", str(run), project_id, "0"] ) fresh_command = json.loads(capsys.readouterr().out) quarantine = ( run / "history" / "mailbox" / project_id / str(intended["command_id"]) / "uncertain" ) events = [ json.loads(line) for line in (run / "events.jsonl").read_text(encoding="utf-8").splitlines() ] quarantine_events = [ event for event in events if event["event"] == "mailbox_evidence_quarantined" ] assert failed_code == 3 assert failed["error"]["code"] == "mailbox_reconcile_required" assert next_code == 4 assert next_action["action"] == ( "prepare-close" if phase == "apply" else "reconcile" ) assert reconcile_code == 0 assert reconciled == {"project_id": project_id, "state": "inventory_pending"} assert mailbox_outputs_cleared if phase == "apply": assert active_command["action"] == "close_without_save" else: assert active_command is None assert fresh_inventory_code == 0 assert fresh_inventory["action"] == "inventory" assert fresh_inventory["command_id"] != intended["command_id"] assert ingest_code == 0 assert ingested == {"project_id": project_id, "state": "apply_pending"} assert prepare_next_code == 4 assert prepare_next["action"] == "prepare" assert fresh_prepare_code == 4 assert fresh_command["action"] == "replace_part" assert fresh_command["command_id"] != intended["command_id"] assert (quarantine / "command.json").read_bytes() == command_bytes assert (quarantine / "status.json").read_bytes() == status_bytes assert (quarantine / "snapshot.json").read_bytes() == snapshot_bytes assert len(quarantine_events) == 1 quarantined = quarantine_events[0] assert quarantined["payload"]["command_id"] == intended["command_id"] assert set(quarantined["payload"]["paths"]) == { path.relative_to(run).as_posix() for path in quarantine.iterdir() } def test_valid_manual_action_status_enters_reachable_cli_reconcile_path( tmp_path: Path, capsys, monkeypatch: pytest.MonkeyPatch, ) -> None: # Catches incomplete but valid manual evidence becoming neither resumable nor reconcilable. marker, mapping, projects = _project_inputs(tmp_path) run = tmp_path / "run" certifications = tmp_path / "certifications.json" assert main( [ "--json", "create", str(run), "--mapping", str(mapping), "--projects", str(projects), "--certifications", str(certifications), "--suffix", marker.suffix, "--library-identity", "lib-r42", ] ) == 0 created = json.loads(capsys.readouterr().out) project_id = created["projects"][0]["project_id"] before = _bridge_snapshot(_snapshot(project_id, marker, "OLD-1", "ignored")) _publish_inventory(run, project_id, before) _certify(certifications, before) assert main(["--json", "ingest", str(run), project_id]) == 0 capsys.readouterr() _ready_for_apply_cli(run, project_id, before, capsys) real_write_command = controller_module.write_command def interrupt_after_publish(path: Path, command: object) -> None: real_write_command(path, command) raise RuntimeError("apply publication interrupted") monkeypatch.setattr(controller_module, "write_command", interrupt_after_publish) with pytest.raises(RuntimeError, match="apply publication interrupted"): main(["--json", "prepare", str(run), project_id, "0"]) monkeypatch.setattr(controller_module, "write_command", real_write_command) intended = _durable_intent(run, "apply_command_publication_started") mailbox = run / "mailbox" / project_id command_path = mailbox / "command.json" status_path = mailbox / "status.json" malformed_command = b"{malformed-command" command_path.write_bytes(malformed_command) _write_manual_action_status(status_path, command=intended) manual_status = load_status(status_path) status_bytes = status_path.read_bytes() failed_code = main(["--json", "prepare", str(run), project_id, "0"]) failed = json.loads(capsys.readouterr().out) reconcile_next_code = main(["--json", "next", str(run)]) reconcile_next = json.loads(capsys.readouterr().out) assert main(["--json", "prepare-close", str(run), project_id]) == 4 capsys.readouterr() _publish_active_command_snapshot( run, project_id, before, "project_closed", ) assert main(["--json", "confirm-close", str(run), project_id]) == 0 capsys.readouterr() reconcile_code = main(["--json", "reconcile", str(run), project_id]) reconciled = json.loads(capsys.readouterr().out) assert main(["--json", "prepare-open", str(run), project_id]) == 4 capsys.readouterr() _publish_active_command_snapshot( run, project_id, before, "project_opened", ) assert main(["--json", "confirm-open", str(run), project_id]) == 0 capsys.readouterr() assert main(["--json", "prepare-inventory", str(run), project_id]) == 0 capsys.readouterr() _publish_active_command_snapshot( run, project_id, before, "inventory_exported", ) assert main(["--json", "ingest", str(run), project_id]) == 0 capsys.readouterr() _ready_for_apply_cli(run, project_id, before, capsys) prepare_next_code = main(["--json", "next", str(run)]) prepare_next = json.loads(capsys.readouterr().out) fresh_prepare_code = main( ["--json", "prepare", str(run), project_id, "0"] ) fresh_command = json.loads(capsys.readouterr().out) quarantine = ( run / "history" / "mailbox" / project_id / str(intended["command_id"]) / "uncertain" ) assert manual_status.state == "manual_action_required" assert manual_status.error_code is None assert manual_status.snapshot_path is None assert failed_code == 3 assert failed["error"]["code"] == "mailbox_reconcile_required" assert reconcile_next_code == 4 assert reconcile_next["action"] == "prepare-close" assert reconcile_code == 0 assert reconciled == {"project_id": project_id, "state": "inventory_pending"} assert prepare_next_code == 4 assert prepare_next["action"] == "prepare" assert fresh_prepare_code == 4 assert fresh_command["command_id"] != intended["command_id"] assert (quarantine / "command.json").read_bytes() == malformed_command assert (quarantine / "status.json").read_bytes() == status_bytes assert not (quarantine / "snapshot.json").exists() assert not status_path.exists() def test_deploy_profile_cli_publishes_exact_bytes_and_reports_destination( tmp_path: Path, capsys, ) -> None: # Catches the installer-facing command rewriting or publishing elsewhere. source = tmp_path / "source profile.json" destination = tmp_path / "runs" / "compatibility-profile.json" source.write_bytes(PROFILE.read_bytes()) code = main(["--json", "deploy-profile", str(source), str(destination)]) assert code == 0 assert json.loads(capsys.readouterr().out) == { "compatibility_profile": str(destination.resolve()) } assert destination.read_bytes() == source.read_bytes() def test_deploy_profile_cli_rejects_duplicate_keys_without_replacing_destination( tmp_path: Path, capsys, ) -> None: source = tmp_path / "source.json" destination = tmp_path / "runs" / "compatibility-profile.json" destination.parent.mkdir() source.write_bytes(b'{"format_version":1,"format_version":1}\n') destination.write_bytes(b"previous-profile") code = main(["--json", "deploy-profile", str(source), str(destination)]) payload = json.loads(capsys.readouterr().out) assert code == 2 assert payload["error"]["code"] == "invalid_compatibility_profile" assert destination.read_bytes() == b"previous-profile" assert not list(destination.parent.glob(".*.tmp")) def test_promote_profile_cli_requires_a_bound_acceptance_manifest( tmp_path: Path, capsys, ) -> None: # Catches supported tooling exposing only unchecked deployment or a bare trust flag. source = tmp_path / "probe.json" source.write_bytes(PROFILE.read_bytes()) destination = tmp_path / "runs" / "compatibility-profile.json" code = main( [ "--json", "promote-profile", str(source), str(tmp_path / "missing-acceptance.json"), str(destination), ] ) payload = json.loads(capsys.readouterr().out) assert code == 2 assert payload["error"]["code"] == "invalid_compatibility_profile" assert not destination.exists() def test_failed_verify_returns_blocking_exit_3_and_issue_json(tmp_path: Path, capsys) -> None: # Catches hard verification failures being reported as successful CLI commands. marker, mapping, projects = _project_inputs(tmp_path) run = tmp_path / "run" certifications = tmp_path / "certifications.json" main([ "--json", "create", str(run), "--mapping", str(mapping), "--projects", str(projects), "--certifications", str(certifications), "--suffix", ".prj", "--library-identity", "lib-r42", ]) created = json.loads(capsys.readouterr().out) project_id = created["projects"][0]["project_id"] before = _snapshot(project_id, marker, "OLD-1", "inventory") before = _publish_inventory(run, project_id, before) _certify(certifications, before) main(["--json", "ingest", str(run), project_id]) capsys.readouterr() _ready_for_apply_cli(run, project_id, before, capsys) main(["--json", "prepare", str(run), project_id, "0"]) capsys.readouterr() unsafe = _snapshot(project_id, marker, "NEW-1", "after", net="CHANGED") _publish_active_command_snapshot(run, project_id, unsafe, "applied") code = main(["--json", "verify", str(run), project_id, "0"]) payload = json.loads(capsys.readouterr().out) assert code == 3 assert payload["passed"] is False assert "connectivity_changed" in {issue["code"] for issue in payload["issues"]} @pytest.mark.parametrize("json_output", (False, True)) def test_ingest_returns_blocking_exit_3_when_impact_blocks_project( tmp_path: Path, capsys, json_output: bool, ) -> None: # Catches successful CLI status after durable impact analysis has blocked the project. marker, mapping, projects = _project_inputs(tmp_path) run = tmp_path / "run" certifications = tmp_path / "certifications.json" create_args = [ "create", str(run), "--mapping", str(mapping), "--projects", str(projects), "--certifications", str(certifications), "--suffix", ".prj", ] assert main(["--json", *create_args]) == 0 created = json.loads(capsys.readouterr().out) project_id = created["projects"][0]["project_id"] incomplete = _snapshot(project_id, marker, "OLD-1", "inventory", net=None) _publish_inventory(run, project_id, incomplete) ingest_args = ["ingest", str(run), project_id] if json_output: ingest_args.insert(0, "--json") code = main(ingest_args) output = capsys.readouterr().out.strip() assert code == 3 if json_output: payload = json.loads(output) assert payload["state"] == "blocked" assert payload["error"]["code"] == "impact_blocked" else: assert output == "impact_blocked: inventory impact contains blocking issues" def test_package_module_exposes_same_cli_help(tmp_path: Path) -> None: # Catches python -m dx_productivity failing to route to the reproducible CLI. environment = os.environ.copy() source = str(Path(__file__).parents[2] / "src") environment["PYTHONPATH"] = source completed = subprocess.run( [sys.executable, "-m", "dx_productivity", "--help"], cwd=tmp_path, env=environment, text=True, capture_output=True, check=False, ) assert completed.returncode == 0 assert ( "{discover,create,deploy-profile,promote-profile,ingest,next,operator-step,prepare-inventory,prepare-close," "confirm-close,prepare-open,confirm-open,prepare-undo,confirm-undo,prepare-save,confirm-saved," "restore,reconcile,prepare-check,confirm-check,prepare,verify,report,status}" ) in completed.stdout