import dataclasses import json import os import shutil import subprocess import sys import tempfile import time import unittest from pathlib import Path from unittest import mock sys.path.insert(0, str(Path(__file__).resolve().parents[1])) from pvbench_common.container import ( # noqa: E402 ContainerError, Role, available, build, max_parallel, memory_bytes, run, container_user, image_platform, DEFAULT_PLATFORM) from pvbench_common.task import Limits, Mount, Task # noqa: E402 GIB = 1024 ** 3 MOUNT_NAMES = ("problem", "examples", "knowledge", "lib", "src") IMAGE = os.environ.get("PVBENCH_IMAGE") def make_task(memory="4g", cpus=2): mounts = tuple(Mount(n, f"/work/{n}", "ro") for n in MOUNT_NAMES) mounts += (Mount("answer", "/work/answer", "rw"),) return Task(name="t3", limits=Limits(memory, cpus, 512, 3600, 1200), mounts=mounts, agent_cwd="/work/answer", prompt_file="prompt.md", tools_in_container=(), eval_recipe="t3", eval_set_version="v1", judge=None, runners=("codex",), egress_allow=("api.openai.com",)) class WorkspaceCase(unittest.TestCase): def setUp(self): self._tmp = tempfile.TemporaryDirectory() self.root = Path(self._tmp.name) self.ws = self.root / "ws" for n in MOUNT_NAMES + ("answer",): (self.ws / n).mkdir(parents=True) self.task = make_task() def tearDown(self): self._tmp.cleanup() def _pairs(args, flag): return [args[i + 1] for i, a in enumerate(args) if a == flag] class ImagePlatformTests(unittest.TestCase): def test_recorded_platform_else_build_default(self): with tempfile.TemporaryDirectory() as tmp: docker_dir = Path(tmp) (docker_dir / "images.json").write_text(json.dumps([ {"tag": "pvbench-env:arm", "id": "sha256:x", "commit": "c", "built": "2026-01-01T00:00:00+00:00", "dockerfile_sha256": "d", "platform": "linux/arm64"}])) self.assertEqual(image_platform("pvbench-env:arm", docker_dir), "linux/arm64") self.assertEqual(image_platform("pvbench-env:other", docker_dir), DEFAULT_PLATFORM) self.assertEqual(image_platform("pvbench-env:arm", docker_dir / "missing"), DEFAULT_PLATFORM) self.assertEqual(image_platform("no-such-image:zz"), DEFAULT_PLATFORM) class ContainerUserTests(unittest.TestCase): def test_default_is_the_host_user(self): self.assertEqual(container_user({}), f"{os.getuid()}:{os.getgid()}") def test_override_and_normalization(self): self.assertEqual(container_user({"PVBENCH_CONTAINER_USER": " 1002:1002 "}), "1002:1002") self.assertEqual(container_user({"PVBENCH_CONTAINER_USER": "0010:020"}), "10:20") self.assertEqual(container_user({"PVBENCH_CONTAINER_USER": ""}), f"{os.getuid()}:{os.getgid()}") def test_rejects_root_and_malformed(self): for bad in ("0:0", "0:1000", "1000", "coq:coq", "1000:", ":1000", "1000:1000:1"): with self.assertRaises(ContainerError, msg=bad): container_user({"PVBENCH_CONTAINER_USER": bad}) class BuildTests(WorkspaceCase): def test_build_order_and_hardening(self): inv = build(self.task, Role.ATTEMPT, self.ws, "img", ["true"], case_id="c1", network="pvnet") expected = ["--read-only", "--tmpfs", "/tmp:size=1g", "--cap-drop", "ALL", "--ulimit", "core=0", "--security-opt", "no-new-privileges", "--user", f"{os.getuid()}:{os.getgid()}", "-e", "HOME=/home/coq", "-w", "/work/answer", "--platform", "linux/amd64", "--memory", "4g", "--cpus", "2", "--pids-limit", "512", "--network", "pvnet"] self.assertEqual(list(inv.args[:len(expected)]), expected) self.assertEqual(inv.image, "img") self.assertEqual(inv.command, ("true",)) vols = _pairs(inv.args, "-v") self.assertEqual(vols[0], f"{self.ws / 'problem'}:/work/problem:ro") self.assertEqual(vols[-1], f"{self.ws / 'answer'}:/work/answer:rw") self.assertEqual(len(inv.mounts), 6) def test_build_uses_the_user_override(self): with mock.patch.dict(os.environ, {"PVBENCH_CONTAINER_USER": "1002:1002"}): inv = build(self.task, Role.EVAL, self.ws, "img", ["true"], case_id="u") self.assertEqual(_pairs(inv.args, "--user"), ["1002:1002"]) with mock.patch.dict(os.environ, {"PVBENCH_CONTAINER_USER": "0:0"}): with self.assertRaises(ContainerError): build(self.task, Role.EVAL, self.ws, "img", ["true"], case_id="u") def test_eval_role_has_no_network(self): inv = build(self.task, Role.EVAL, self.ws, "img", [], case_id="c", network="pvnet") self.assertEqual(_pairs(inv.args, "--network"), ["none"]) inv = build(self.task, Role.ATTEMPT, self.ws, "img", [], case_id="c", network="pvnet") self.assertEqual(_pairs(inv.args, "--network"), ["pvnet"]) with self.assertRaises(ContainerError): build(self.task, Role.ATTEMPT, self.ws, "img", [], case_id="c") def test_judge_role_uses_judge_mounts(self): from pvbench_common.task import JudgeSpec, Mount judge = JudgeSpec((Mount("src", "/work/src", "rw"), Mount("gold", "/work/gold", "ro"))) task = dataclasses.replace(self.task, judge=judge) (self.ws / "gold").mkdir() inv = build(task, Role.JUDGE, self.ws, "img", [], case_id="c", network="pvnet") self.assertEqual(_pairs(inv.args, "--network"), ["pvnet"]) self.assertEqual(_pairs(inv.args, "-v"), [f"{self.ws / 'src'}:/work/src:rw", f"{self.ws / 'gold'}:/work/gold:ro"]) with self.assertRaises(ContainerError): # a task without [judge] cannot build a judge container build(self.task, Role.JUDGE, self.ws, "img", [], case_id="c", network="pvnet") def test_rw_mount_redirected_for_eval(self): answer = self.root / "frozen-answer" answer.mkdir() base = build(self.task, Role.EVAL, self.ws, "img", [], case_id="c") inv = build(self.task, Role.EVAL, self.ws, "img", [], case_id="c", answer_dir=answer) for before, after in zip(base.mounts, inv.mounts): if after[2] == "rw": self.assertEqual(after, (str(answer), "/work/answer", "rw")) else: self.assertEqual(before, after) self.assertIn(f"{answer}:/work/answer:rw", _pairs(inv.args, "-v")) def test_missing_mount_source_raises(self): (self.ws / "lib").rmdir() with self.assertRaises(ContainerError) as cm: build(self.task, Role.EVAL, self.ws, "img", [], case_id="c") self.assertIn(str(self.ws / "lib"), str(cm.exception)) self.assertFalse((self.ws / "lib").exists()) def test_mount_collision_raises(self): extra = self.root / "extra" extra.mkdir() with self.assertRaises(ContainerError): build(self.task, Role.JUDGE, self.ws, "img", [], case_id="c", network="n", extra_mounts=[(extra, "/work/problem", "ro")]) def test_env_pairs_and_no_inherit(self): with mock.patch.dict(os.environ, {"HTTPS_PROXY": "http://proxy:3128"}): inv = build(self.task, Role.ATTEMPT, self.ws, "img", [], case_id="c", network="n", env=[("B", "2"), ("A", "1=x")]) self.assertEqual(_pairs(inv.args, "-e"), ["HOME=/home/coq", "B=2", "A=1=x"]) self.assertFalse(any("HTTPS_PROXY" in a for a in inv.args)) def test_name_unique_per_call(self): a = build(self.task, Role.ATTEMPT, self.ws, "img", [], case_id="P01", network="n") b = build(self.task, Role.ATTEMPT, self.ws, "img", [], case_id="P01", network="n") self.assertNotEqual(a.name, b.name) for inv in (a, b): self.assertTrue(inv.name.startswith("pvbench-attempt-P01-")) class MaxParallelTests(unittest.TestCase): def test_max_parallel(self): task = make_task("4g", 2) self.assertEqual(max_parallel(task, (6, 12 * GIB)), 3) self.assertEqual(max_parallel(task, (1, 2 * GIB)), 1) self.assertEqual(memory_bytes("512m"), 512 * 1024 ** 2) self.assertEqual(max_parallel(make_task("512m", 1), (4, 1 * GIB)), 2) FAKE_DOCKER = """#!/bin/sh dir=$(dirname "$0") echo "$*" >> "$dir/calls.log" case "$1" in run) for a in "$@"; do [ "$a" = sleep-long ] && exec sleep 3; done echo ok; exit 0 ;; inspect) cat "$dir/inspect.txt" ;; *) exit 0 ;; esac """ class FakeDockerTests(WorkspaceCase): def setUp(self): super().setUp() self.bin = self.root / "bin" self.bin.mkdir() self.docker = self.bin / "docker" self.docker.write_text(FAKE_DOCKER) self.docker.chmod(0o755) (self.bin / "inspect.txt").write_text("0 false\n") def _run(self, command, timeout_s=10): inv = build(self.task, Role.EVAL, self.ws, "img", command, case_id="c") out = run(inv, timeout_s=timeout_s, stdout=self.root / "out", stderr=self.root / "err", docker=str(self.docker)) calls = (self.bin / "calls.log").read_text().splitlines() return inv, out, calls def test_run_sequence_with_fake_docker(self): inv, out, calls = self._run(["echo"]) self.assertEqual((out.exit_code, out.timed_out, out.oom_killed), (0, False, False)) self.assertEqual([c.split()[0] for c in calls], ["run", "inspect", "rm"]) self.assertTrue(calls[0].startswith(f"run --name {inv.name} --read-only")) self.assertTrue(calls[0].endswith("img echo")) self.assertNotIn("--rm", calls[0].split()) self.assertEqual(calls[2], f"rm -f {inv.name}") self.assertEqual((self.root / "out").read_text(), "ok\n") def test_run_timeout_with_fake_docker(self): inv, out, calls = self._run(["sleep-long"], timeout_s=1) self.assertTrue(out.timed_out) self.assertEqual([c.split()[0] for c in calls], ["run", "kill", "inspect", "rm"]) self.assertEqual(calls[1], f"kill {inv.name}") def test_run_oom_with_fake_docker(self): (self.bin / "inspect.txt").write_text("137 true\n") _, out, _ = self._run(["echo"]) self.assertEqual((out.exit_code, out.oom_killed, out.timed_out), (137, True, False)) def test_inspect_failure_falls_back_to_return_code(self): (self.bin / "inspect.txt").write_text("") _, out, _ = self._run(["echo"]) self.assertEqual((out.exit_code, out.oom_killed), (0, False)) def test_missing_docker_binary_raises(self): inv = build(self.task, Role.EVAL, self.ws, "img", ["x"], case_id="c") with self.assertRaises(ContainerError): run(inv, timeout_s=5, stdout=self.root / "o", stderr=self.root / "e", docker=str(self.root / "no-such-docker")) REAL = bool(IMAGE) and available() @unittest.skipUnless(REAL, "set PVBENCH_IMAGE and have a reachable Docker daemon") class RealDockerTests(WorkspaceCase): def _run(self, command, timeout_s=60, task=None): inv = build(task or self.task, Role.EVAL, self.ws, IMAGE, command, case_id="test") t0 = time.monotonic() out = run(inv, timeout_s=timeout_s, stdout=self.root / "out", stderr=self.root / "err") return inv, out, time.monotonic() - t0 def test_real_run_echo(self): _, out, _ = self._run(["echo", "ok"]) self.assertEqual(out.exit_code, 0, (self.root / "err").read_text()) self.assertIn("ok", (self.root / "out").read_text()) def test_real_readonly_root(self): _, out, _ = self._run(["touch", "/opt/x"]) self.assertNotEqual(out.exit_code, 0) def test_real_oom_flag(self): task = make_task(memory="64m", cpus=1) _, out, _ = self._run(["python3", "-c", "x=bytearray(200*1024*1024)"], task=task) self.assertTrue(out.oom_killed, (self.root / "err").read_text()) self.assertFalse(out.timed_out) def test_real_timeout(self): inv, out, elapsed = self._run(["sleep", "30"], timeout_s=2) self.assertTrue(out.timed_out) self.assertLess(elapsed, 15) ps = subprocess.run(["docker", "ps", "-a", "--filter", f"name={inv.name}", "--format", "{{.Names}}"], capture_output=True, text=True) self.assertNotIn(inv.name, ps.stdout) if __name__ == "__main__": unittest.main()