PV-Bench / experiments /common /tests /test_container.py
cielseven's picture
add the experiment harnesses for t1 to t4 and t3-flat
28adce7
Raw History Blame Contribute Delete
12.5 kB
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()