Datasets:
Download experiments/common/tests/test_container.py from PV-SJTU/PV-Bench: direct link, hf CLI and curl.
- Browser
- Download file 12.5 kB
-
https://huggingface.co/datasets/PV-SJTU/PV-Bench/resolve/main/experiments/common/tests/test_container.py
- Command line
-
hf download hf://datasets/PV-SJTU/PV-Bench/experiments/common/tests/test_container.py
-
curl -L -o test_container.py https://huggingface.co/datasets/PV-SJTU/PV-Bench/resolve/main/experiments/common/tests/test_container.py
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() | |
| 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() | |