Datasets:
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())
|