didericis-claude
28ee9a0974
Add tests for all exception paths (Die/ManifestError from resolve, Die from _launch_bottle, Die from freezer) plus the macos-container fall-through branch in destroy. Add TestDestroyDocker and TestDestroySmolmachines to exercise the backend helpers directly. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
392 lines
15 KiB
Python
392 lines
15 KiB
Python
"""Unit: bot_bottle public Python API (bot_bottle/__init__.py surface).
|
|
|
|
Covers start_headless, resume_headless, freeze, and destroy — the four
|
|
operations the bot-bottle-orchestrator's ProgrammaticBottleRunner uses.
|
|
All I/O is stubbed so no container is created.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import unittest
|
|
from pathlib import Path
|
|
from unittest.mock import MagicMock, patch
|
|
|
|
from bot_bottle import BottleError, destroy, freeze, resume_headless, start_headless
|
|
from bot_bottle.log import Die
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# helpers
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def _make_manifest(agent_name: str = "implementer", bottle_name: str = "claude"):
|
|
manifest = MagicMock()
|
|
manifest.agents = {agent_name: MagicMock(bottle=bottle_name)}
|
|
manifest.all_agent_names = [agent_name]
|
|
manifest.all_bottle_names = [bottle_name]
|
|
manifest.home_md = None # eager mode — _peek_agent_bottle uses agents dict
|
|
manifest.require_agent = MagicMock(return_value=None)
|
|
return manifest
|
|
|
|
|
|
def _metadata(
|
|
slug: str = "implementer-abc12",
|
|
agent_name: str = "implementer",
|
|
backend: str = "docker",
|
|
):
|
|
md = MagicMock()
|
|
md.identity = slug
|
|
md.agent_name = agent_name
|
|
md.cwd = "/repo"
|
|
md.copy_cwd = False
|
|
md.bottle_names = ["claude"]
|
|
md.backend = backend
|
|
return md
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# start_headless
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
class TestStartHeadless(unittest.TestCase):
|
|
def setUp(self) -> None:
|
|
self._manifest = _make_manifest()
|
|
patch("bot_bottle.api.ManifestIndex.resolve", return_value=self._manifest).start()
|
|
self._launch = patch(
|
|
"bot_bottle.api._launch_bottle", return_value=("implementer-abc12", 0)
|
|
).start()
|
|
patch(
|
|
"bot_bottle.api._uniquify_label_headless", side_effect=str
|
|
).start()
|
|
self.addCleanup(patch.stopall)
|
|
|
|
def _spec(self):
|
|
self._launch.assert_called_once()
|
|
return self._launch.call_args[0][0]
|
|
|
|
def test_returns_slug_on_success(self):
|
|
slug = start_headless("implementer", prompt="Do it")
|
|
self.assertEqual("implementer-abc12", slug)
|
|
|
|
def test_passes_assume_yes_and_prompt(self):
|
|
start_headless("implementer", prompt="Do it")
|
|
kwargs = self._launch.call_args[1]
|
|
self.assertTrue(kwargs["assume_yes"])
|
|
self.assertEqual("Do it", kwargs["headless_prompt_text"])
|
|
|
|
def test_explicit_bottles_forwarded(self):
|
|
start_headless("implementer", prompt="Do it", bottles=["dev", "claude"])
|
|
self.assertEqual(("dev", "claude"), self._spec().bottle_names)
|
|
|
|
def test_default_bottle_resolved_from_manifest(self):
|
|
start_headless("implementer", prompt="Do it")
|
|
self.assertEqual(("claude",), self._spec().bottle_names)
|
|
|
|
def test_forge_env_on_spec(self):
|
|
env = {"FORGE_GITEA_API": "https://gitea.example.com/api/v1", "FORGE_OWNER": "acme"}
|
|
start_headless("implementer", prompt="Do it", forge_env=env)
|
|
self.assertEqual(env, self._spec().forge_env)
|
|
|
|
def test_no_forge_env_defaults_to_empty_dict(self):
|
|
start_headless("implementer", prompt="Do it")
|
|
self.assertEqual({}, self._spec().forge_env)
|
|
|
|
def test_nonzero_exit_raises_bottle_error(self):
|
|
self._launch.return_value = ("implementer-abc12", 1)
|
|
with self.assertRaises(BottleError) as ctx:
|
|
start_headless("implementer", prompt="Do it")
|
|
self.assertEqual(1, ctx.exception.exit_code)
|
|
|
|
def test_no_default_bottle_raises_bottle_error(self):
|
|
manifest = _make_manifest(bottle_name="")
|
|
with patch("bot_bottle.api.ManifestIndex.resolve", return_value=manifest):
|
|
with self.assertRaises(BottleError):
|
|
start_headless("implementer", prompt="Do it")
|
|
self._launch.assert_not_called()
|
|
|
|
def test_manifest_error_in_resolve_raises_bottle_error(self):
|
|
from bot_bottle.manifest import ManifestError
|
|
patch(
|
|
"bot_bottle.api.ManifestIndex.resolve", side_effect=ManifestError("bad")
|
|
).start()
|
|
with self.assertRaises(BottleError):
|
|
start_headless("implementer", prompt="Do it")
|
|
self._launch.assert_not_called()
|
|
|
|
def test_die_from_launch_bottle_raises_bottle_error(self):
|
|
self._launch.side_effect = Die(3, "backend exploded")
|
|
with self.assertRaises(BottleError) as ctx:
|
|
start_headless("implementer", prompt="Do it")
|
|
self.assertEqual(3, ctx.exception.exit_code)
|
|
|
|
def test_backend_name_forwarded(self):
|
|
start_headless("implementer", prompt="Do it", backend_name="docker")
|
|
self.assertEqual("docker", self._launch.call_args[1]["backend_name"])
|
|
|
|
def test_label_forwarded_to_spec(self):
|
|
start_headless("implementer", prompt="Do it", label="nightly")
|
|
self.assertEqual("nightly", self._spec().label)
|
|
|
|
def test_color_forwarded_to_spec(self):
|
|
start_headless("implementer", prompt="Do it", color="green")
|
|
self.assertEqual("green", self._spec().color)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# resume_headless
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
class TestResumeHeadless(unittest.TestCase):
|
|
def setUp(self) -> None:
|
|
self._md = _metadata()
|
|
patch("bot_bottle.api.read_metadata", return_value=self._md).start()
|
|
manifest = _make_manifest()
|
|
patch("bot_bottle.api.ManifestIndex.resolve", return_value=manifest).start()
|
|
self._launch = patch(
|
|
"bot_bottle.api._launch_bottle", return_value=("implementer-abc12", 0)
|
|
).start()
|
|
self.addCleanup(patch.stopall)
|
|
|
|
def _spec(self):
|
|
self._launch.assert_called_once()
|
|
return self._launch.call_args[0][0]
|
|
|
|
def test_passes_assume_yes_and_prompt(self):
|
|
resume_headless("implementer-abc12", prompt="Address review")
|
|
kwargs = self._launch.call_args[1]
|
|
self.assertTrue(kwargs["assume_yes"])
|
|
self.assertEqual("Address review", kwargs["headless_prompt_text"])
|
|
|
|
def test_identity_set_on_spec(self):
|
|
resume_headless("implementer-abc12", prompt="Prompt")
|
|
self.assertEqual("implementer-abc12", self._spec().identity)
|
|
|
|
def test_forge_env_on_spec(self):
|
|
env = {"FORGE_ISSUE_NUMBER": "42"}
|
|
resume_headless("implementer-abc12", prompt="Prompt", forge_env=env)
|
|
self.assertEqual(env, self._spec().forge_env)
|
|
|
|
def test_missing_state_raises_bottle_error(self):
|
|
with patch("bot_bottle.api.read_metadata", return_value=None):
|
|
with self.assertRaises(BottleError):
|
|
resume_headless("no-such-abc12", prompt="Prompt")
|
|
self._launch.assert_not_called()
|
|
|
|
def test_nonzero_exit_raises_bottle_error(self):
|
|
self._launch.return_value = ("implementer-abc12", 2)
|
|
with self.assertRaises(BottleError) as ctx:
|
|
resume_headless("implementer-abc12", prompt="Prompt")
|
|
self.assertEqual(2, ctx.exception.exit_code)
|
|
|
|
def test_manifest_error_in_resolve_raises_bottle_error(self):
|
|
from bot_bottle.manifest import ManifestError
|
|
patch(
|
|
"bot_bottle.api.ManifestIndex.resolve", side_effect=ManifestError("bad")
|
|
).start()
|
|
with self.assertRaises(BottleError):
|
|
resume_headless("implementer-abc12", prompt="Prompt")
|
|
self._launch.assert_not_called()
|
|
|
|
def test_die_from_launch_bottle_raises_bottle_error(self):
|
|
self._launch.side_effect = Die(5, "resume failed")
|
|
with self.assertRaises(BottleError) as ctx:
|
|
resume_headless("implementer-abc12", prompt="Prompt")
|
|
self.assertEqual(5, ctx.exception.exit_code)
|
|
|
|
def test_backend_from_metadata_when_not_supplied(self):
|
|
resume_headless("implementer-abc12", prompt="Prompt")
|
|
self.assertEqual("docker", self._launch.call_args[1]["backend_name"])
|
|
|
|
def test_explicit_backend_overrides_metadata(self):
|
|
resume_headless(
|
|
"implementer-abc12", prompt="Prompt", backend_name="smolmachines"
|
|
)
|
|
self.assertEqual("smolmachines", self._launch.call_args[1]["backend_name"])
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# freeze
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
class TestFreeze(unittest.TestCase):
|
|
def setUp(self) -> None:
|
|
patch("bot_bottle.api.read_metadata", return_value=_metadata()).start()
|
|
self._freezer = MagicMock()
|
|
self._get_freezer = patch(
|
|
"bot_bottle.api.get_freezer", return_value=self._freezer
|
|
).start()
|
|
self.addCleanup(patch.stopall)
|
|
|
|
def test_calls_commit_slug(self):
|
|
freeze("implementer-abc12")
|
|
self._freezer.commit_slug.assert_called_once_with("implementer-abc12")
|
|
|
|
def test_backend_from_metadata_when_not_supplied(self):
|
|
freeze("implementer-abc12")
|
|
self._get_freezer.assert_called_once_with("docker")
|
|
|
|
def test_explicit_backend_used(self):
|
|
freeze("implementer-abc12", backend_name="smolmachines")
|
|
self._get_freezer.assert_called_once_with("smolmachines")
|
|
|
|
def test_commit_cancelled_raises_bottle_error(self):
|
|
from bot_bottle.backend.freeze import CommitCancelled
|
|
self._freezer.commit_slug.side_effect = CommitCancelled("declined")
|
|
with self.assertRaises(BottleError):
|
|
freeze("implementer-abc12")
|
|
|
|
def test_die_from_freezer_raises_bottle_error(self):
|
|
self._freezer.commit_slug.side_effect = Die(2, "commit exploded")
|
|
with self.assertRaises(BottleError) as ctx:
|
|
freeze("implementer-abc12")
|
|
self.assertEqual(2, ctx.exception.exit_code)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# destroy
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
class TestDestroy(unittest.TestCase):
|
|
def setUp(self) -> None:
|
|
patch("bot_bottle.api.read_metadata", return_value=_metadata()).start()
|
|
self._dd = patch("bot_bottle.api._destroy_docker").start()
|
|
patch("bot_bottle.api.clear_preserve_marker").start()
|
|
self._cleanup = patch("bot_bottle.api.cleanup_state").start()
|
|
self.addCleanup(patch.stopall)
|
|
|
|
def test_docker_backend_calls_destroy_docker(self):
|
|
destroy("implementer-abc12")
|
|
self._dd.assert_called_once_with("implementer-abc12")
|
|
|
|
def test_state_dir_always_cleaned(self):
|
|
destroy("implementer-abc12")
|
|
self._cleanup.assert_called_once_with("implementer-abc12")
|
|
|
|
def test_smolmachines_backend_calls_destroy_smolmachines(self):
|
|
patch(
|
|
"bot_bottle.api.read_metadata",
|
|
return_value=_metadata(backend="smolmachines"),
|
|
).start()
|
|
ds = patch("bot_bottle.api._destroy_smolmachines").start()
|
|
destroy("implementer-abc12")
|
|
ds.assert_called_once_with("implementer-abc12")
|
|
self._dd.assert_not_called()
|
|
|
|
def test_other_backend_skips_docker_and_smolmachines(self):
|
|
patch(
|
|
"bot_bottle.api.read_metadata",
|
|
return_value=_metadata(backend="macos-container"),
|
|
).start()
|
|
ds = patch("bot_bottle.api._destroy_smolmachines").start()
|
|
destroy("implementer-abc12")
|
|
self._dd.assert_not_called()
|
|
ds.assert_not_called()
|
|
self._cleanup.assert_called_once_with("implementer-abc12")
|
|
|
|
def test_missing_metadata_defaults_to_docker(self):
|
|
patch("bot_bottle.api.read_metadata", return_value=None).start()
|
|
destroy("no-state-abc12")
|
|
self._dd.assert_called_once_with("no-state-abc12")
|
|
|
|
def test_explicit_backend_overrides_metadata(self):
|
|
ds = patch("bot_bottle.api._destroy_smolmachines").start()
|
|
destroy("implementer-abc12", backend_name="smolmachines")
|
|
ds.assert_called_once_with("implementer-abc12")
|
|
self._dd.assert_not_called()
|
|
|
|
def test_die_from_backend_raises_bottle_error(self):
|
|
self._dd.side_effect = Die(1, "compose failed")
|
|
with self.assertRaises(BottleError):
|
|
destroy("implementer-abc12")
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# _destroy_docker (helper)
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
class TestDestroyDocker(unittest.TestCase):
|
|
def setUp(self) -> None:
|
|
self._compose_down = patch(
|
|
"bot_bottle.backend.docker.compose.compose_down"
|
|
).start()
|
|
self._compose_project_name = patch(
|
|
"bot_bottle.backend.docker.compose.compose_project_name",
|
|
return_value="bb-proj",
|
|
).start()
|
|
self._state_dir = patch(
|
|
"bot_bottle.bottle_state.bottle_state_dir",
|
|
return_value=Path("/fake/state"),
|
|
).start()
|
|
self.addCleanup(patch.stopall)
|
|
|
|
def _run(self, exists: bool) -> None:
|
|
fake_file = MagicMock()
|
|
fake_file.exists.return_value = exists
|
|
with patch(
|
|
"bot_bottle.backend.docker.compose.compose_file_path",
|
|
return_value=fake_file,
|
|
):
|
|
from bot_bottle.api import _destroy_docker
|
|
_destroy_docker("slug-1")
|
|
|
|
def test_calls_compose_down_when_file_exists(self) -> None:
|
|
self._run(exists=True)
|
|
self._compose_down.assert_called_once()
|
|
|
|
def test_noop_when_compose_file_absent(self) -> None:
|
|
self._run(exists=False)
|
|
self._compose_down.assert_not_called()
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# _destroy_smolmachines (helper)
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
class TestDestroySmolmachines(unittest.TestCase):
|
|
def setUp(self) -> None:
|
|
self._run = patch("subprocess.run").start()
|
|
self._run.return_value = MagicMock(returncode=0, stderr="", stdout="")
|
|
self.addCleanup(patch.stopall)
|
|
|
|
def _call(self) -> None:
|
|
from bot_bottle.api import _destroy_smolmachines
|
|
_destroy_smolmachines("slug-7")
|
|
|
|
def test_issues_stop_then_delete(self) -> None:
|
|
self._call()
|
|
self.assertEqual(2, self._run.call_count)
|
|
first_argv = self._run.call_args_list[0][0][0]
|
|
self.assertIn("stop", first_argv)
|
|
second_argv = self._run.call_args_list[1][0][0]
|
|
self.assertIn("delete", second_argv)
|
|
|
|
def test_nonzero_delete_does_not_raise(self) -> None:
|
|
self._run.side_effect = [
|
|
MagicMock(returncode=0),
|
|
MagicMock(returncode=1, stderr="not found", stdout=""),
|
|
]
|
|
self._call() # must not raise
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# public surface exported from bot_bottle.__init__
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
class TestPublicSurface(unittest.TestCase):
|
|
def test_importable_from_package(self):
|
|
import bot_bottle
|
|
for name in ("BottleError", "start_headless", "resume_headless", "freeze", "destroy"):
|
|
self.assertTrue(hasattr(bot_bottle, name), f"missing: {name}")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|