File size: 10,618 Bytes
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
"""Only synthetic case lists; never launch a real model or benchmark batch."""
import contextlib
import io
import json
from pathlib import Path
import platform
import shutil
import threading
import sys
import time
from unittest.mock import patch

from helpers import EGRESS, Fixture, fake_credentials
from pvbench_common.container import Outcome
from t2 import runners
from t2.batch import read_cases
from t2.cli import main
from t2.config import Case


class BatchTests(Fixture):
    def setUp(self):
        super().setUp()
        shutil.copytree(self.bench / "Toy", self.bench / "Category/Second")
        self.list_file = self.root / "synthetic cases.txt"
        self.list_file.write_bytes(b"\xef\xbb\xbf# Test fixtures only\r\nToy\r\n\r\nCategory/Second # second case\r\nToy\r\n")

    def args(self, runner="codex", mask="batch-test", dry=False):
        return ["run-all", str(self.list_file), "--runner", runner,
                "--model", "fake-model", "--mask", mask, *(["--dry-run"] if dry else [])]

    def reports(self):
        return [json.loads(p.read_text()) for p in sorted((self.cfg.ws_root / ".batches").glob("*/summary.json"))]

    def test_comments_bom_crlf_order_and_duplicates(self):
        data, cases, duplicates = read_cases(self.list_file)
        self.assertEqual(data, self.list_file.read_bytes())
        self.assertEqual(cases, ["Toy", "Category/Second"])
        self.assertEqual(duplicates, ["Toy"])

    def test_dry_batch_prepares_both_runners_without_subprocesses(self):
        platform.system()  # Windows discovers its version via subprocess on first call.
        for name in ("codex", "claude"):
            mask = "preview-" + name
            with self.subTest(runner=name), patch("t2.cli.Config.load", return_value=self.cfg), \
                    patch("t2.cli.runners.run") as runner, patch("t2.cli.runners.preflight") as preflight, \
                    patch("subprocess.Popen", side_effect=AssertionError("dry batch must not launch subprocesses")), \
                    contextlib.redirect_stdout(io.StringIO()):
                code = main(self.args(name, mask, dry=True))
            self.assertEqual(code, 0)
            runner.assert_not_called()
            preflight.assert_not_called()
            report = next(r for r in self.reports() if r["mask"] == mask)
            self.assertEqual(report["counts"], {"prepared": 2})
            self.assertEqual(report["duplicates_ignored"], ["Toy"])
            self.assertEqual(report["proof_status"], "not_checked")
            for problem in ("Toy", "Category/Second"):
                case = Case.create(self.cfg, problem, "fake-model", name, mask)
                self.assertTrue((case.workspace / "answer/solution_annotated.c").is_file())
                self.assertFalse((case.evidence / "events.jsonl").exists())
                command = json.loads((case.evidence / "command.json").read_text())
                self.assertEqual(command[0], name)
                self.assertNotIn("--effort", command)
                self.assertFalse(any("model_reasoning_effort" in arg for arg in command))

    def test_existing_attempts_are_skipped_and_untouched(self):
        with patch("t2.cli.Config.load", return_value=self.cfg), contextlib.redirect_stdout(io.StringIO()):
            self.assertEqual(main(self.args(dry=True)), 0)
        first = Case.create(self.cfg, "Toy", "fake-model", "codex", "batch-test")
        answer = first.workspace / "answer/solution_annotated.c"
        answer.write_text("preserved saved answer")
        with patch("t2.cli.Config.load", return_value=self.cfg), patch("t2.cli.run_case") as run_case, \
                contextlib.redirect_stdout(io.StringIO()):
            self.assertEqual(main(self.args()), 0)
        run_case.assert_not_called()
        self.assertEqual(answer.read_text(), "preserved saved answer")
        self.assertTrue(any(r["counts"] == {"skipped": 2} for r in self.reports()))

    def test_invalid_or_empty_list_fails_before_any_workspace_or_session(self):
        for contents in ("Toy\nMissing\n", "# only a comment\n", "Toy\n../escape\n"):
            self.list_file.write_text(contents)
            with self.subTest(contents=contents), patch("t2.cli.Config.load", return_value=self.cfg), \
                    patch("t2.cli.run_case") as run_case, contextlib.redirect_stderr(io.StringIO()):
                self.assertEqual(main(self.args()), 2)
            run_case.assert_not_called()
            self.assertFalse(self.cfg.ws_root.exists())

    def test_failed_case_does_not_stop_later_cases(self):
        order = []
        def fake_run(cfg, case, effort, dry):
            order.append(case.problem)
            self.assertEqual(case.mask, "batch-test")
            self.assertEqual(cfg.timeout, cfg.task.limits.agent_timeout_s)
            self.assertIsNone(effort)
            return 1 if case.problem == "Toy" else 0
        with patch("t2.cli.Config.load", return_value=self.cfg), patch("t2.cli.run_case", side_effect=fake_run), \
                contextlib.redirect_stdout(io.StringIO()):
            self.assertEqual(main(self.args()), 1)
        self.assertEqual(order, ["Toy", "Category/Second"])
        self.assertEqual(self.reports()[0]["counts"], {"failed": 1, "completed": 1})

    def test_jobs_two_runs_cases_concurrently_and_records_results(self):
        lock = threading.Lock()
        active = 0
        peak = 0

        def fake_run(cfg, case, effort, dry, **kwargs):
            nonlocal active, peak
            with lock:
                active += 1
                peak = max(peak, active)
            time.sleep(0.15)
            with lock:
                active -= 1
            return 1 if case.problem == "Toy" else 0

        with patch("t2.cli.Config.load", return_value=self.cfg), \
                patch("t2.cli.run_case", side_effect=fake_run), \
                patch("pvbench_common.container.daemon_resources", return_value=(6, 24 * 1024 ** 3)), \
                contextlib.redirect_stdout(io.StringIO()):
            self.assertEqual(main(self.args() + ["--jobs", "2"]), 1)
        self.assertEqual(peak, 2)
        report = self.reports()[0]
        self.assertEqual(report["jobs"], 2)
        self.assertEqual(report["counts"], {"failed": 1, "completed": 1})

    def test_invalid_jobs_rejected_before_writing(self):
        with patch("t2.cli.Config.load", return_value=self.cfg), \
                contextlib.redirect_stderr(io.StringIO()):
            self.assertEqual(main(self.args() + ["--jobs", "0"]), 2)
        self.assertFalse(self.cfg.ws_root.exists())

    def test_parallel_interrupt_stops_unstarted_case(self):
        shutil.copytree(self.bench / "Toy", self.bench / "Category/Third")
        self.list_file.write_text("Toy\nCategory/Second\nCategory/Third\n")
        started = []

        def fake_run(cfg, case, effort, dry, *, cancel_event, **kwargs):
            started.append(case.problem)
            if case.problem == "Toy":
                time.sleep(0.05)
                return 130
            self.assertTrue(cancel_event.wait(2))
            return 130

        with patch("t2.cli.Config.load", return_value=self.cfg), \
                patch("t2.cli.run_case", side_effect=fake_run), \
                patch("pvbench_common.container.daemon_resources", return_value=(6, 24 * 1024 ** 3)), \
                contextlib.redirect_stdout(io.StringIO()):
            self.assertEqual(main(self.args() + ["--jobs", "2"]), 130)
        self.assertCountEqual(started, ["Toy", "Category/Second"])
        self.assertEqual(self.reports()[0]["counts"], {"interrupted": 2, "not_started": 1})

    def test_jobs_capped_by_daemon_resources(self):
        seen = []
        def fake_run(cfg, case, effort, dry, **kwargs):
            seen.append(kwargs.get("concurrent"))
            return 0
        out = io.StringIO()
        with patch("t2.cli.Config.load", return_value=self.cfg), patch("t2.cli.run_case", side_effect=fake_run), \
                patch("pvbench_common.container.daemon_resources", return_value=(4, 16 * 1024 ** 3)), \
                contextlib.redirect_stdout(out):
            self.assertEqual(main(self.args() + ["--jobs", "8"]), 0)
        self.assertIn("--jobs 8 capped at 2", out.getvalue())
        self.assertEqual(self.reports()[0]["jobs"], 2)
        self.assertEqual(seen, [2, 2])

    def test_interrupt_stops_batch_before_next_case(self):
        with patch("t2.cli.Config.load", return_value=self.cfg), \
                patch("t2.cli.run_case", side_effect=KeyboardInterrupt) as run_case, \
                contextlib.redirect_stdout(io.StringIO()):
            self.assertEqual(main(self.args()), 130)
        self.assertEqual(run_case.call_count, 1)
        report = self.reports()[0]
        self.assertEqual(report["status"], "interrupted")
        self.assertEqual(report["counts"], {"interrupted": 1, "not_started": 1})

    def test_fake_sessions_use_single_case_lifecycle_for_each_case(self):
        def fake_container(inv, *, timeout_s, stdout, stderr):
            host = next(h for h, at, _ in inv.mounts if at == "/work/answer")
            (Path(host) / "solution_annotated.c").write_text("synthetic batch answer")
            Path(stdout).write_text('{"type":"turn.completed","usage":{}}\n'); Path(stderr).write_text("")
            now = time.time()
            return Outcome(0, False, False, now - 1, now, Path(stdout), Path(stderr))
        with patch("t2.cli.Config.load", return_value=self.cfg), patch("t2.runners.preflight"), \
                patch.object(runners.egress, "ensure", return_value=EGRESS), \
                patch.object(runners.egress, "log_since", return_value=[]), \
                patch.object(runners.credentials, "prepare", side_effect=fake_credentials), \
                patch.object(runners.container, "daemon_resources", return_value=(6, 12 * 1024 ** 3)), \
                patch.object(runners.container, "run", side_effect=fake_container), \
                contextlib.redirect_stdout(io.StringIO()):
            self.assertEqual(main(self.args()), 0)
        report = self.reports()[0]
        self.assertEqual(report["counts"], {"completed": 2})
        for problem in ("Toy", "Category/Second"):
            case = Case.create(self.cfg, problem, "fake-model", "codex", "batch-test")
            self.assertEqual((case.root / "out/solution_annotated.c").read_text(), "synthetic batch answer")
            self.assertEqual(json.loads((case.root / "summary.json").read_text())["proof_status"], "not_checked")
            self.assertFalse((case.workspace / "answer/feedback/latest.json").exists())