From a5910696a54c0f5e53ef8dafbff64b8733a8fbb0 Mon Sep 17 00:00:00 2001 From: didericis Date: Fri, 17 Jul 2026 01:11:05 -0400 Subject: [PATCH] fix(test): stop the macOS unit tests shelling out to the `container` CLI MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit CI's unit + coverage jobs failed with `FileNotFoundError: 'container'`: three tests reached the real Apple CLI, which exists on a macOS dev host but not on the Linux runner. They passed locally for that reason alone — and two of them were quietly creating real Apple networks on the dev host as a side effect. - `test_enumerate_active_is_empty_while_disabled` asserted the disabled-era stub and called `enumerate_active()` unmocked. The backend launches bottles again, so it now covers the real enumeration: slug parsing, exclusion of the shared gateway/orchestrator singletons, and the CLI-failure path. - The two orchestrator tests patched `orchestrator_service.container_mod`, but `_run_orchestrator_container` reaches the CLI through `ensure_networks`, which is imported from the gateway module and resolves `container_mod` in *its* namespace. Patch the imported name instead. Adds a test that the networks exist before the orchestrator runs — the ordering the escaped call was hiding. Verified by reproducing the CI environment locally (`PATH` without the `container` binary): 3 failures before, 1818 passing after. Co-Authored-By: Claude Opus 4.8 --- tests/unit/test_macos_container_cleanup.py | 32 +++++++++++++++++++--- tests/unit/test_macos_gateway.py | 29 ++++++++++++++++++-- 2 files changed, 55 insertions(+), 6 deletions(-) diff --git a/tests/unit/test_macos_container_cleanup.py b/tests/unit/test_macos_container_cleanup.py index df70988..4d5dd5e 100644 --- a/tests/unit/test_macos_container_cleanup.py +++ b/tests/unit/test_macos_container_cleanup.py @@ -43,10 +43,34 @@ class TestMacosContainerCleanup(unittest.TestCase): class TestMacosContainerEnumerate(unittest.TestCase): - def test_enumerate_active_is_empty_while_disabled(self): - # The macOS backend is disabled during the companion-container removal cleanup - # (#385); it launches nothing, so there is nothing to enumerate. - self.assertEqual([], enum_mod.enumerate_active()) + """The backend launches bottles again (PRD 0070), so enumeration is real + rather than the disabled-era stub. These must not shell out: `container` + does not exist on the Linux CI host.""" + + def _enumerate(self, stdout: str, returncode: int = 0): + completed = enum_mod.subprocess.CompletedProcess( + args=[], returncode=returncode, stdout=stdout, stderr="", + ) + with patch.object(enum_mod.subprocess, "run", return_value=completed), \ + patch.object(enum_mod, "read_metadata", return_value=None): + return enum_mod.enumerate_active() + + def test_lists_agent_containers_by_slug(self): + agents = self._enumerate("bot-bottle-dev-abc\nunrelated\n") + self.assertEqual(["dev-abc"], [a.slug for a in agents]) + self.assertEqual(["macos-container"], [a.backend_name for a in agents]) + + def test_excludes_the_shared_singletons(self): + """The gateway and control plane share the bot-bottle- prefix but are + infrastructure — listing them would invent an agent per host.""" + agents = self._enumerate( + "bot-bottle-mac-gateway\nbot-bottle-mac-orchestrator\n" + "bot-bottle-dev-abc\n" + ) + self.assertEqual(["dev-abc"], [a.slug for a in agents]) + + def test_empty_when_the_cli_fails(self): + self.assertEqual([], self._enumerate("", returncode=1)) if __name__ == "__main__": diff --git a/tests/unit/test_macos_gateway.py b/tests/unit/test_macos_gateway.py index cf9d9c0..588bad6 100644 --- a/tests/unit/test_macos_gateway.py +++ b/tests/unit/test_macos_gateway.py @@ -230,7 +230,12 @@ class TestMacosOrchestratorService(unittest.TestCase): reaches it there directly, so there is no --publish and no NAT leg.""" svc = MacosOrchestratorService(repo_root=Path("/r"), host_root=Path("/h")) run = Mock(return_value=_ok()) - with patch(f"{_ORCH}.container_mod") as mod: + # `ensure_networks` lives in the gateway module and shells out to the + # `container` CLI, which does not exist on the Linux CI host — patch it + # here, not gateway.container_mod, since it is called through this + # module's imported name. + with patch(f"{_ORCH}.container_mod") as mod, \ + patch(f"{_ORCH}.ensure_networks"): mod.run_container_argv = run svc._run_orchestrator_container("h1") argv = run.call_args.args[0] @@ -238,9 +243,29 @@ class TestMacosOrchestratorService(unittest.TestCase): self.assertEqual(["bot-bottle-mac-gateway"], networks) self.assertNotIn("--publish", argv) + def test_networks_exist_before_the_orchestrator_runs(self) -> None: + """The orchestrator is the first container on the shared network, so it + has to create it — the gateway that used to do so now starts second.""" + svc = MacosOrchestratorService(repo_root=Path("/r"), host_root=Path("/h")) + order: list[str] = [] + + def _networks(*_args: str) -> None: + order.append("networks") + + def _run(*_args: list[str]) -> Mock: + order.append("run") + return _ok() + + with patch(f"{_ORCH}.container_mod") as mod, \ + patch(f"{_ORCH}.ensure_networks", side_effect=_networks): + mod.run_container_argv = Mock(side_effect=_run) + svc._run_orchestrator_container("h1") + self.assertEqual(["networks", "run"], order) + def test_orchestrator_start_failure_raises(self) -> None: svc = MacosOrchestratorService(repo_root=Path("/r"), host_root=Path("/h")) - with patch(f"{_ORCH}.container_mod") as mod: + with patch(f"{_ORCH}.container_mod") as mod, \ + patch(f"{_ORCH}.ensure_networks"): mod.run_container_argv = Mock(return_value=_fail()) with self.assertRaises(OrchestratorStartError): svc._run_orchestrator_container("h1")