didericis-claude
a81f0ffa49
die() raises Die(SystemExit), which implies a process exit. A timeout in wait_exec_ready is a bringup failure — raising SmolvmError lets the caller decide whether it's fatal, consistent with how machine_start failures propagate.
264 lines
9.5 KiB
Python
264 lines
9.5 KiB
Python
"""Unit: smolvm subprocess wrapper (PRD 0023 chunk 2b).
|
|
|
|
The wrapper is one thin function per smolvm CLI subcommand. Tests
|
|
mock `subprocess.run` and assert on the constructed argv +
|
|
SmolvmError raising on non-zero. The actual smolvm binary's
|
|
behavior is exercised in chunk 2d's integration smoke test."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import subprocess
|
|
import unittest
|
|
from pathlib import Path
|
|
from unittest.mock import patch
|
|
|
|
from bot_bottle.backend.smolmachines import smolvm as smolvm_mod
|
|
from bot_bottle.backend.smolmachines.smolvm import (
|
|
SmolvmError,
|
|
SmolvmRunResult,
|
|
is_available,
|
|
machine_cp,
|
|
machine_create,
|
|
machine_delete,
|
|
machine_exec,
|
|
machine_start,
|
|
machine_stop,
|
|
pack_create,
|
|
wait_exec_ready,
|
|
)
|
|
|
|
|
|
def _ok(stdout: str = "", stderr: str = "") -> subprocess.CompletedProcess:
|
|
return subprocess.CompletedProcess(
|
|
args=[], returncode=0, stdout=stdout, stderr=stderr,
|
|
)
|
|
|
|
|
|
def _fail(stderr: str = "boom") -> subprocess.CompletedProcess:
|
|
return subprocess.CompletedProcess(
|
|
args=[], returncode=1, stdout="", stderr=stderr,
|
|
)
|
|
|
|
|
|
class TestArgvShapes(unittest.TestCase):
|
|
"""The CLI mixes `--name NAME` and positional-NAME styles
|
|
across subcommands. The wrapper hides that inconsistency
|
|
behind a uniform `name=` kwarg; lock down which form lands
|
|
in each argv."""
|
|
|
|
def _patch_run(self):
|
|
return patch(
|
|
"bot_bottle.backend.smolmachines.smolvm.subprocess.run",
|
|
return_value=_ok(),
|
|
)
|
|
|
|
def test_pack_create_argv(self):
|
|
with self._patch_run() as m:
|
|
pack_create("bot-bottle-claude:latest", Path("/tmp/agent.smolmachine"))
|
|
argv = m.call_args.args[0]
|
|
self.assertEqual(
|
|
["smolvm", "pack", "create",
|
|
"--image", "bot-bottle-claude:latest",
|
|
"-o", "/tmp/agent.smolmachine"],
|
|
argv,
|
|
)
|
|
|
|
def test_machine_create_minimal(self):
|
|
with self._patch_run() as m:
|
|
machine_create("agent-xyz")
|
|
self.assertEqual(
|
|
["smolvm", "machine", "create", "agent-xyz"],
|
|
m.call_args.args[0],
|
|
)
|
|
|
|
def test_machine_create_with_from_and_allow_cidr_and_env(self):
|
|
with self._patch_run() as m:
|
|
machine_create(
|
|
"agent-xyz",
|
|
from_path=Path("/stage/agent.smolmachine"),
|
|
allow_cidrs=["192.168.50.2/32"],
|
|
env={"HTTPS_PROXY": "http://192.168.50.2:8888"},
|
|
)
|
|
argv = m.call_args.args[0]
|
|
# --from + --allow-cidr + -e are all flags, name is positional.
|
|
self.assertEqual("smolvm", argv[0])
|
|
self.assertIn("--from", argv)
|
|
self.assertIn("/stage/agent.smolmachine", argv)
|
|
# `--net` is explicit because smolvm 0.8.0's implied-net
|
|
# from --allow-cidr doesn't fire when --from is set.
|
|
self.assertIn("--net", argv)
|
|
self.assertIn("--allow-cidr", argv)
|
|
self.assertIn("192.168.50.2/32", argv)
|
|
self.assertIn("-e", argv)
|
|
self.assertIn("HTTPS_PROXY=http://192.168.50.2:8888", argv)
|
|
self.assertEqual("agent-xyz", argv[-1])
|
|
|
|
def test_machine_create_omits_net_when_no_allow_cidrs(self):
|
|
with self._patch_run() as m:
|
|
machine_create("agent-xyz", from_path=Path("/x.smolmachine"))
|
|
self.assertNotIn("--net", m.call_args.args[0])
|
|
|
|
def test_machine_start_uses_dash_name(self):
|
|
# `start` is the --name flag form, NOT positional.
|
|
with self._patch_run() as m:
|
|
machine_start("agent-xyz")
|
|
self.assertEqual(
|
|
["smolvm", "machine", "start", "--name", "agent-xyz"],
|
|
m.call_args.args[0],
|
|
)
|
|
|
|
def test_machine_stop_uses_dash_name(self):
|
|
with self._patch_run() as m:
|
|
machine_stop("agent-xyz")
|
|
self.assertEqual(
|
|
["smolvm", "machine", "stop", "--name", "agent-xyz"],
|
|
m.call_args.args[0],
|
|
)
|
|
|
|
def test_machine_delete_uses_positional_name_and_force(self):
|
|
# delete NAME is positional; -f required so no interactive
|
|
# confirmation blocks teardown.
|
|
with self._patch_run() as m:
|
|
machine_delete("agent-xyz")
|
|
self.assertEqual(
|
|
["smolvm", "machine", "delete", "-f", "agent-xyz"],
|
|
m.call_args.args[0],
|
|
)
|
|
|
|
def test_machine_exec_argv_with_separator(self):
|
|
# `--` separator before the command — smolvm's flag parser
|
|
# would otherwise grab argv items that look like flags.
|
|
with self._patch_run() as m:
|
|
machine_exec("agent-xyz", ["echo", "hello"])
|
|
self.assertEqual(
|
|
["smolvm", "machine", "exec", "--name", "agent-xyz",
|
|
"--", "echo", "hello"],
|
|
m.call_args.args[0],
|
|
)
|
|
|
|
def test_machine_exec_env_workdir_timeout(self):
|
|
with self._patch_run() as m:
|
|
machine_exec(
|
|
"agent-xyz",
|
|
["ls"],
|
|
env={"FOO": "bar", "BAZ": "qux"},
|
|
workdir="/app",
|
|
timeout="30s",
|
|
)
|
|
argv = m.call_args.args[0]
|
|
self.assertIn("-w", argv); self.assertIn("/app", argv)
|
|
self.assertIn("--timeout", argv); self.assertIn("30s", argv)
|
|
# Both env vars present as -e K=V pairs.
|
|
for pair in ("FOO=bar", "BAZ=qux"):
|
|
self.assertIn(pair, argv)
|
|
|
|
def test_machine_cp_positional_argv(self):
|
|
with self._patch_run() as m:
|
|
machine_cp("/host/file", "agent-xyz:/dest/file")
|
|
self.assertEqual(
|
|
["smolvm", "machine", "cp",
|
|
"/host/file", "agent-xyz:/dest/file"],
|
|
m.call_args.args[0],
|
|
)
|
|
|
|
def test_machine_cp_empty_is_noop(self):
|
|
# Guard against an upstream caller passing an unset path —
|
|
# cp with an empty string is meaningless and would just
|
|
# confuse smolvm's error message.
|
|
with self._patch_run() as m:
|
|
machine_cp("", "agent-xyz:/dest")
|
|
machine_cp("/host", "")
|
|
self.assertEqual(0, m.call_count)
|
|
|
|
|
|
class TestErrorPath(unittest.TestCase):
|
|
"""`check=True` paths raise SmolvmError on non-zero; `exec` is
|
|
the one path that returns a result regardless."""
|
|
|
|
def test_create_failure_raises(self):
|
|
with patch(
|
|
"bot_bottle.backend.smolmachines.smolvm.subprocess.run",
|
|
return_value=_fail("no such image"),
|
|
):
|
|
with self.assertRaises(SmolvmError) as cm:
|
|
machine_create("agent-xyz")
|
|
self.assertEqual(1, cm.exception.returncode)
|
|
self.assertIn("no such image", str(cm.exception))
|
|
|
|
def test_pack_create_failure_raises(self):
|
|
with patch(
|
|
"bot_bottle.backend.smolmachines.smolvm.subprocess.run",
|
|
return_value=_fail("pack failed"),
|
|
):
|
|
with self.assertRaises(SmolvmError):
|
|
pack_create("missing:tag", Path("/tmp/out"))
|
|
|
|
def test_exec_failure_returns_result(self):
|
|
# The in-VM command's exit code is what Bottle.exec sees;
|
|
# `false` exiting non-zero is not a smolvm failure.
|
|
with patch(
|
|
"bot_bottle.backend.smolmachines.smolvm.subprocess.run",
|
|
return_value=subprocess.CompletedProcess(
|
|
args=[], returncode=42, stdout="", stderr="nope",
|
|
),
|
|
):
|
|
r = machine_exec("agent-xyz", ["sh", "-c", "exit 42"])
|
|
self.assertEqual(SmolvmRunResult(42, "", "nope"), r)
|
|
|
|
|
|
class TestWaitExecReady(unittest.TestCase):
|
|
"""wait_exec_ready polls machine_exec(name, ["true"]) until it
|
|
returns 0, then exits. On timeout it calls die()."""
|
|
|
|
def test_returns_immediately_when_exec_succeeds_first_try(self):
|
|
with patch.object(smolvm_mod, "machine_exec",
|
|
return_value=SmolvmRunResult(0, "", "")) as m:
|
|
wait_exec_ready("vm-x")
|
|
m.assert_called_once_with("vm-x", ["true"])
|
|
|
|
def test_retries_on_nonzero_and_returns_on_success(self):
|
|
results = [
|
|
SmolvmRunResult(1, "", "not ready"),
|
|
SmolvmRunResult(1, "", "not ready"),
|
|
SmolvmRunResult(0, "", ""),
|
|
]
|
|
with patch.object(smolvm_mod, "machine_exec",
|
|
side_effect=results) as m, \
|
|
patch.object(smolvm_mod.time, "sleep"):
|
|
wait_exec_ready("vm-x")
|
|
self.assertEqual(3, m.call_count)
|
|
|
|
def test_raises_smolvm_error_on_timeout(self):
|
|
# machine_exec always returns non-zero; monotonic advances past
|
|
# the deadline after the first sleep so the loop exits.
|
|
ticks = [0.0, 0.0, 10.0] # third call puts us past deadline
|
|
with patch.object(smolvm_mod, "machine_exec",
|
|
return_value=SmolvmRunResult(1, "", "")), \
|
|
patch.object(smolvm_mod.time, "monotonic",
|
|
side_effect=ticks), \
|
|
patch.object(smolvm_mod.time, "sleep"):
|
|
with self.assertRaises(SmolvmError) as cm:
|
|
wait_exec_ready("vm-x", timeout=5.0)
|
|
self.assertIn("vm-x", str(cm.exception))
|
|
self.assertIn("not ready", str(cm.exception))
|
|
|
|
|
|
class TestIsAvailable(unittest.TestCase):
|
|
def test_true_when_on_path(self):
|
|
with patch(
|
|
"bot_bottle.backend.smolmachines.smolvm.shutil.which",
|
|
return_value="/usr/local/bin/smolvm",
|
|
):
|
|
self.assertTrue(is_available())
|
|
|
|
def test_false_when_missing(self):
|
|
with patch(
|
|
"bot_bottle.backend.smolmachines.smolvm.shutil.which",
|
|
return_value=None,
|
|
):
|
|
self.assertFalse(is_available())
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|