import dataclasses import sys import tempfile import unittest from pathlib import Path COMMON = Path(__file__).resolve().parents[1] sys.path.insert(0, str(COMMON)) from pvbench_common.task import Limits, TaskError, docker_limit_args, fingerprint, load # noqa: E402 EXPERIMENTS = COMMON.parent GOOD = """\ [task] name = "t3" agent_cwd = "/work" prompt_file = "PROMPT.md" tools_in_container = [] eval_recipe = "t3" eval_set_version = "v1" runners = ["codex", "claude"] egress_allow = ["api.openai.com", "chatgpt.com", "auth.openai.com", "api.anthropic.com"] [limits] memory = "8g" cpus = 2 pids = 512 agent_timeout_s = 3600 eval_timeout_s = 1200 [mounts] problem = { at = "/work/problem", mode = "ro" } examples = { at = "/work/examples", mode = "ro" } knowledge = { at = "/work/knowledge", mode = "ro" } lib = { at = "/work/lib", mode = "ro" } src = { at = "/work/src", mode = "ro" } answer = { at = "/work/answer", mode = "rw" } """ def replace_line(text: str, prefix: str, new: str) -> str: """Replace the single line starting with ``prefix`` (``new`` = "" deletes it).""" lines = text.splitlines(keepends=True) hits = [i for i, line in enumerate(lines) if line.startswith(prefix)] assert len(hits) == 1, (prefix, hits) lines[hits[0]] = new + "\n" if new else "" return "".join(lines) class TaskTests(unittest.TestCase): def setUp(self): self._tmp = tempfile.TemporaryDirectory() self.addCleanup(self._tmp.cleanup) self._n = 0 def write(self, text: str) -> Path: self._n += 1 path = Path(self._tmp.name) / f"task{self._n}.toml" path.write_text(text, encoding="utf-8") return path def load_text(self, text: str): return load(self.write(text)) def assert_rejected(self, text: str, key_path: str | None = None): with self.assertRaises(TaskError) as cm: self.load_text(text) if key_path is not None: self.assertIn(key_path, str(cm.exception)) return cm.exception def test_load_good_returns_frozen_task(self): task = self.load_text(GOOD) self.assertEqual(task.limits, Limits("8g", 2, 512, 3600, 1200)) self.assertEqual(sum(m.mode == "ro" for m in task.mounts), 5) self.assertEqual([m.name for m in task.mounts if m.mode == "rw"], ["answer"]) self.assertEqual(task.runners, ("codex", "claude")) self.assertIsNone(task.judge) with self.assertRaises(dataclasses.FrozenInstanceError): task.name = "t1" with self.assertRaises(dataclasses.FrozenInstanceError): task.limits.cpus = 4 def test_missing_limit_is_an_error(self): # Breaks: deletes one mandatory limit key at a time. for key in ("memory", "cpus", "pids", "agent_timeout_s", "eval_timeout_s"): with self.subTest(key=key): self.assert_rejected(replace_line(GOOD, f"{key} =", ""), f"limits.{key}") def test_check_timeout_is_optional_and_positive(self): self.assertIsNone(load(self.write(GOOD)).limits.check_timeout_s) self.assertEqual(load(self.write(GOOD.replace("[limits]\n", "[limits]\ncheck_timeout_s = 300\n"))).limits.check_timeout_s, 300) self.assert_rejected(GOOD.replace("[limits]\n", "[limits]\ncheck_timeout_s = 0\n"), "limits.check_timeout_s") def test_non_positive_limit_is_an_error(self): # Breaks: a limit value that is zero or negative. self.assert_rejected(replace_line(GOOD, "cpus =", "cpus = 0"), "limits.cpus") self.assert_rejected(replace_line(GOOD, "pids =", "pids = -1"), "limits.pids") self.assert_rejected(replace_line(GOOD, "memory =", 'memory = "0g"'), "limits.memory") def test_memory_format(self): # Breaks (for rejected cases): memory unit/casing/suffix. for ok in ("4g", "512m"): with self.subTest(ok=ok): task = self.load_text(replace_line(GOOD, "memory =", f'memory = "{ok}"')) self.assertEqual(task.limits.memory, ok) for bad in ("4G", "4gb", "4"): with self.subTest(bad=bad): self.assert_rejected(replace_line(GOOD, "memory =", f'memory = "{bad}"'), "limits.memory") def test_exactly_one_rw_mount_named_answer(self): # Breaks: zero rw mounts. zero = replace_line(GOOD, "answer ", 'answer = { at = "/work/answer", mode = "ro" }') self.assert_rejected(zero, "mounts") # Breaks: two rw mounts. two = replace_line(GOOD, "src ", 'src = { at = "/work/src", mode = "rw" }') self.assert_rejected(two, "mounts") # Breaks: the single rw mount is named "problem", not "answer". wrong = replace_line(zero, "problem ", 'problem = { at = "/work/problem", mode = "rw" }') self.assert_rejected(wrong, "mounts") def test_mount_paths(self): cases = { "relative path": 'lib = { at = "work/lib", mode = "ro" }', "duplicate at": 'lib = { at = "/work/src", mode = "ro" }', "outside /work": 'lib = { at = "/opt/lib", mode = "ro" }', "/work itself": 'lib = { at = "/work", mode = "ro" }', } for why, line in cases.items(): with self.subTest(why=why): self.assert_rejected(replace_line(GOOD, "lib ", line), "mounts.") def test_tools_in_container_are_bare_names(self): ok = self.load_text(replace_line(GOOD, "tools_in_container", 'tools_in_container = ["symexec.sh"]')) self.assertEqual(ok.tools_in_container, ("symexec.sh",)) # Breaks: tool entry with a directory component, absolute, or empty. for bad in ("bin/symexec.sh", "/usr/bin/x", ""): with self.subTest(bad=bad): text = replace_line(GOOD, "tools_in_container", f'tools_in_container = ["{bad}"]') self.assert_rejected(text, "task.tools_in_container") def test_eval_set_version_format(self): self.assertEqual(self.load_text(GOOD).eval_set_version, "v1") # Breaks: eval_set_version not of the form v. for bad in ("1", "v1.2", "latest"): with self.subTest(bad=bad): text = replace_line(GOOD, "eval_set_version", f'eval_set_version = "{bad}"') self.assert_rejected(text, "task.eval_set_version") def test_unknown_key_is_an_error(self): # Breaks: a typo'd limit key next to the real one. self.assert_rejected(GOOD.replace('memory = "8g"\n', 'memory = "8g"\nmemroy = "4g"\n'), "limits.memroy") # Breaks: an unknown top-level table. self.assert_rejected(GOOD + "\n[extras]\nfoo = 1\n", "extras") def test_fingerprint_is_stable_under_formatting(self): task_part, rest = GOOD.split("[limits]") limits_part, mounts_part = rest.split("[mounts]") # Same definition: tables and keys reordered, whitespace and quoting changed. reordered = ( "[mounts]" + mounts_part.replace(" ", " ") + "\n[limits]\neval_timeout_s=1200\nagent_timeout_s=3600\npids=512\ncpus=2\nmemory='8g'\n\n" + "\n".join(reversed(task_part.strip().splitlines()[1:])).join(["[task]\n", "\n"]) ) base = fingerprint(self.write(GOOD)) self.assertEqual(load(self.write(reordered)), load(self.write(GOOD))) self.assertEqual(fingerprint(self.write(reordered)), base) # Breaks: a changed value. changed = replace_line(GOOD, "cpus =", "cpus = 3") self.assertNotEqual(fingerprint(self.write(changed)), base) def test_docker_limit_args(self): self.assertEqual(docker_limit_args(Limits("4g", 2, 512, 3600, 1200)), ["--memory", "4g", "--cpus", "2", "--pids-limit", "512"]) self.assertEqual(docker_limit_args(Limits("4g", 1.5, 512, 3600, 1200))[3], "1.5") def test_real_task_files_load(self): tasks = {n: load(EXPERIMENTS / n / "task.toml") for n in ("t1", "t2", "t3")} for name, task in tasks.items(): self.assertEqual((task.name, task.eval_recipe), (name, name)) self.assertEqual(tasks["t2"].tools_in_container, ("symexec.sh",)) self.assertIsNone(tasks["t3"].judge) self.assertIn("gold", [m.name for m in tasks["t1"].judge.mounts]) if __name__ == "__main__": unittest.main() class JudgeMountsReadOnly(TaskTests): def test_judge_mounts_are_a_complete_set(self): good = GOOD + '\n[judge]\nmounts = { src = { at = "/work/src", mode = "rw" }, gold = { at = "/work/gold", mode = "ro" } }\n' task = self.load_text(good) self.assertEqual([m.name for m in task.judge.mounts], ["src", "gold"]) # gold must be present and read-only; exactly one rw mount self.assert_rejected(GOOD + '\n[judge]\nmounts = { gold = { at = "/work/gold", mode = "rw" } }\n', "judge.mounts") self.assert_rejected(GOOD + '\n[judge]\nmounts = { src = { at = "/work/src", mode = "rw" } }\n', "judge.mounts.gold") self.assert_rejected(GOOD + '\n[judge]\nmounts = { a = { at = "/work/a", mode = "rw" }, b = { at = "/work/b", mode = "rw" }, gold = { at = "/work/gold", mode = "ro" } }\n', "judge.mounts")