Files
claude-config/bin/run_heavy/test_run_heavy.py
T

146 lines
6.3 KiB
Python

import contextlib
import fcntl
import os
import pathlib
import subprocess
import sys
import tempfile
import unittest
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
from run_heavy import main
from machine_load.memory import read_memory
from machine_load.slots import slot_count, usable_cpus
TOOL = pathlib.Path(__file__).resolve().parents[1] / "run-heavy"
class RunHeavy(unittest.TestCase):
def setUp(self):
state = tempfile.TemporaryDirectory()
self.addCleanup(state.cleanup)
self.env = {**os.environ, "XDG_STATE_HOME": state.name}
self.env.pop(main.HELD, None)
self.slots = pathlib.Path(state.name) / "run-heavy"
def run_tool(self, *args: str, env=None) -> subprocess.CompletedProcess[str]:
return subprocess.run([sys.executable, str(TOOL), *args], capture_output=True, text=True, env=env or self.env, timeout=30)
def start_tool(self, *args: str, env=None) -> subprocess.Popen[str]:
tool = subprocess.Popen([sys.executable, str(TOOL), *args], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True, env=env or self.env)
self.addCleanup(tool.kill)
return tool
@contextlib.contextmanager
def every_slot_held(self):
self.slots.mkdir(parents=True, exist_ok=True)
with contextlib.ExitStack() as held:
for slot in range(slot_count(usable_cpus())):
file = held.enter_context(open(self.slots / f"slot-{slot}", "a"))
fcntl.flock(file, fcntl.LOCK_EX | fcntl.LOCK_NB)
yield
def free_slots(self) -> int:
free = 0
for slot in range(slot_count(usable_cpus())):
with open(self.slots / f"slot-{slot}", "a") as file:
try:
fcntl.flock(file, fcntl.LOCK_EX | fcntl.LOCK_NB)
free += 1
except BlockingIOError:
pass
return free
def test_runs_the_command_and_exits_with_its_code(self):
result = self.run_tool("sh", "-c", "echo out; echo err >&2; exit 3")
self.assertEqual((result.returncode, result.stdout, result.stderr), (3, "out\n", "err\n"))
def test_holds_a_slot_while_the_command_runs_and_frees_it_after(self):
tool = self.start_tool("sh", "-c", "echo started; read line")
self.assertEqual(tool.stdout.readline(), "started\n")
self.assertEqual(self.free_slots(), slot_count(usable_cpus()) - 1)
tool.communicate("\n", timeout=30)
self.assertEqual(self.free_slots(), slot_count(usable_cpus()))
def test_a_command_inside_a_held_slot_runs_at_once(self):
with self.every_slot_held():
result = self.run_tool("echo", "nested", env={**self.env, main.HELD: "0"})
self.assertEqual((result.returncode, result.stdout), (0, "nested\n"))
def test_exits_125_saying_why_where_the_slot_folder_cannot_be_made(self):
with tempfile.NamedTemporaryFile() as state:
result = self.run_tool("echo", "ran", env={**self.env, "XDG_STATE_HOME": state.name})
self.assertEqual((result.returncode, result.stdout), (125, ""))
self.assertIn(state.name, result.stderr)
def test_a_command_not_found_exits_127_and_one_that_cannot_run_126_saying_why(self):
missing = self.run_tool("no-such-command-anywhere")
self.assertEqual((missing.returncode, missing.stdout), (127, ""))
self.assertIn("no-such-command-anywhere", missing.stderr)
with tempfile.NamedTemporaryFile(suffix=".sh") as unrunnable:
denied = self.run_tool(unrunnable.name)
self.assertEqual((denied.returncode, denied.stdout), (126, ""))
self.assertIn(unrunnable.name, denied.stderr)
def fake_docker(self) -> dict[str, str]:
"""An environment whose PATH finds, ahead of any real one, a docker that prints the arguments it was given."""
folder = tempfile.TemporaryDirectory()
self.addCleanup(folder.cleanup)
docker = pathlib.Path(folder.name) / "docker"
docker.write_text("#!/bin/sh\necho \"$@\"\n")
docker.chmod(0o755)
return {**self.env, "PATH": f"{folder.name}:{self.env['PATH']}"}
def test_a_docker_run_without_limits_gets_three_quarters_of_the_memory_split_across_the_slots(self):
memory = read_memory()
assert memory is not None, "this test needs MemTotal and MemAvailable from /proc/meminfo: run it on Linux"
share = f"{memory.total * 3 // 4 // slot_count(usable_cpus()) // 1024}m"
result = self.run_tool("docker", "run", "--rm", "img", "true", env=self.fake_docker())
self.assertEqual((result.returncode, result.stdout), (0, f"run --memory {share} --memory-swap {share} --rm img true\n"))
def test_a_docker_call_with_its_own_limits_or_that_starts_no_container_is_passed_on_unchanged(self):
env = self.fake_docker()
for args in [["run", "-m", "40g", "--memory-swap", "40g", "img"], ["ps", "-a"], ["build", "."]]:
with self.subTest(args):
result = self.run_tool("docker", *args, env=env)
self.assertEqual((result.returncode, result.stdout), (0, " ".join(args) + "\n"))
def test_a_command_on_a_machine_without_docker_finds_none(self):
folder = tempfile.TemporaryDirectory()
self.addCleanup(folder.cleanup)
(pathlib.Path(folder.name) / "python3").symlink_to(sys.executable)
(pathlib.Path(folder.name) / "sh").symlink_to("/bin/sh")
result = self.run_tool("sh", "-c", "command -v docker || echo none", env={**self.env, "PATH": folder.name})
self.assertEqual((result.returncode, result.stdout), (0, "none\n"))
def test_the_capped_docker_passes_a_call_on_unchanged_without_a_share(self):
env = self.fake_docker()
env.pop("RUN_HEAVY_MEMORY", None)
shim = pathlib.Path(TOOL).parent / "run_heavy" / "path_entry" / "docker"
result = subprocess.run([str(shim), "run", "img"], capture_output=True, text=True, env=env, timeout=30)
self.assertEqual((result.returncode, result.stdout), (0, "run img\n"))
def test_no_cap_where_the_memory_is_unknown(self):
self.assertEqual(main.capping(None, 4, self.fake_docker()), {})
def test_a_capped_docker_that_finds_no_docker_exits_127_saying_so(self):
folder = tempfile.TemporaryDirectory()
self.addCleanup(folder.cleanup)
(pathlib.Path(folder.name) / "python3").symlink_to(sys.executable)
result = self.run_tool("docker", "ps", env={**self.env, "PATH": folder.name})
self.assertEqual((result.returncode, result.stdout), (127, ""))
self.assertIn("docker", result.stderr)
def test_no_command_exits_125_with_the_usage_and_help_exits_0(self):
bare = self.run_tool()
self.assertEqual((bare.returncode, bare.stdout), (125, ""))
self.assertIn("usage: run-heavy <command>", bare.stderr)
helped = self.run_tool("--help")
self.assertEqual(helped.returncode, 0)
self.assertIn("usage: run-heavy <command>", helped.stdout)
if __name__ == "__main__":
unittest.main()