File size: 9,216 Bytes
28adce7
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2504377
 
 
 
 
28adce7
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
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<digits>.
        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")