"""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())