| 1 | """Independent CLI integration: real Git, mock agent, durable campaign records."""
|
| 2 | from pathlib import Path
|
| 3 | import json
|
| 4 | import shutil
|
| 5 | import subprocess
|
| 6 | import sys
|
| 7 | import tempfile
|
| 8 | import unittest
|
| 9 |
|
| 10 |
|
| 11 | ROOT = Path(__file__).resolve().parents[1]
|
| 12 | CLI = ROOT / "scripts" / "agent_campaign.py"
|
| 13 |
|
| 14 |
|
| 15 | @unittest.skipUnless(shutil.which("git"), "Git is required for the campaign integration")
|
| 16 | class CampaignCLIIntegrationTests(unittest.TestCase):
|
| 17 | def setUp(self):
|
| 18 | self.temp = tempfile.TemporaryDirectory(prefix="oakbench-campaign-cli-")
|
| 19 | self.addCleanup(self.temp.cleanup)
|
| 20 | self.root = Path(self.temp.name).resolve()
|
| 21 | self.campaign = self.root / "campaign"
|
| 22 | self.agents = self.root / "agents.toml"
|
| 23 | self.agents.write_text('[agents.mock]\nenabled = true\nadapter = "deterministic_mock"\nprovider = "local"\n')
|
| 24 | self.subjects = self.root / "subjects.toml"
|
| 25 | self.subjects.write_text('[subjects.git]\nenabled = true\nkind = "git"\nlabel = "Git"\nbin = '
|
| 26 | + json.dumps(shutil.which("git")) + '\n')
|
| 27 | self.manifest = self.root / "manifest.json"
|
| 28 | self.manifest.write_text(json.dumps({
|
| 29 | "schema_version": 1, "campaign_id": "cli-integration",
|
| 30 | "agents_config": str(self.agents), "subjects_config": str(self.subjects),
|
| 31 | "agents": [{"name": "mock", "model": None}], "subjects": ["git"],
|
| 32 | "workflows": ["wide_config_refactor"], "instruction_levels": ["cheat-sheet"],
|
| 33 | "repetitions": 2, "seed": 194, "max_trials": 2, "max_wall_seconds": 180,
|
| 34 | "trial_timeout_seconds": 30, "track": "agent-default", "agent_environment": "minimal",
|
| 35 | }))
|
| 36 |
|
| 37 | def invoke(self, command, *args):
|
| 38 | return subprocess.run([sys.executable, str(CLI), command,
|
| 39 | "--campaign-dir", str(self.campaign), *args],
|
| 40 | cwd=ROOT, text=True, capture_output=True, timeout=120)
|
| 41 |
|
| 42 | def plan(self):
|
| 43 | result = self.invoke("plan", "--manifest", str(self.manifest))
|
| 44 | self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
|
| 45 | return json.loads((self.campaign / "plan.json").read_text())
|
| 46 |
|
| 47 | def events(self):
|
| 48 | return [json.loads(line) for line in (self.campaign / "events.jsonl").read_text().splitlines()]
|
| 49 |
|
| 50 | def test_real_git_mock_completion_and_noop_resume_preserve_evidence(self):
|
| 51 | plan = self.plan()
|
| 52 | self.assertEqual(len(plan["schedule"]), 2)
|
| 53 | result = self.invoke("run")
|
| 54 | self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
|
| 55 | self.assertEqual(json.loads(result.stdout)["finished"], 2)
|
| 56 | self.assertIn("[trial]", result.stderr)
|
| 57 | events = self.events()
|
| 58 | self.assertEqual([event["event"] for event in events], ["started", "finished"] * 2)
|
| 59 | finished = [event for event in events if event["event"] == "finished"]
|
| 60 | for event in finished:
|
| 61 | self.assertTrue(event["row"]["success"], event)
|
| 62 | self.assertTrue(event["row"]["success_criteria"]["checks"]["required_checks_passed"])
|
| 63 | self.assertEqual(event["row"]["task_id"], event["trial_id"])
|
| 64 | journal = (self.campaign / "events.jsonl").read_bytes()
|
| 65 | # Simulate the crash window after the authoritative terminal fsync but
|
| 66 | # before refreshing the derived rows. Resume must repair this view.
|
| 67 | (self.campaign / "rows.jsonl").write_text("")
|
| 68 | result = self.invoke("resume")
|
| 69 | self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
|
| 70 | self.assertEqual((self.campaign / "events.jsonl").read_bytes(), journal)
|
| 71 | recovered = [json.loads(line) for line in (self.campaign / "rows.jsonl").read_text().splitlines()]
|
| 72 | self.assertEqual(recovered, [event["row"] for event in finished])
|
| 73 | result = self.invoke("report")
|
| 74 | self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
|
| 75 | self.assertIn('"claim_eligible": false', result.stdout.lower())
|
| 76 |
|
| 77 | def test_existing_plan_and_changed_config_fail_before_agent_execution(self):
|
| 78 | self.plan()
|
| 79 | frozen = (self.campaign / "plan.json").read_bytes()
|
| 80 | result = self.invoke("plan", "--manifest", str(self.manifest))
|
| 81 | self.assertNotEqual(result.returncode, 0)
|
| 82 | self.assertEqual((self.campaign / "plan.json").read_bytes(), frozen)
|
| 83 | self.agents.write_text(self.agents.read_text() + "\n# changed configuration\n")
|
| 84 | result = self.invoke("run")
|
| 85 | self.assertNotEqual(result.returncode, 0)
|
| 86 | self.assertFalse((self.campaign / "events.jsonl").exists())
|
| 87 |
|
| 88 | def test_torn_journal_cannot_be_discarded_to_retry_a_trial(self):
|
| 89 | plan = self.plan()
|
| 90 | started = {"event": "started", "trial_id": plan["schedule"][0]["trial_id"],
|
| 91 | "plan_sha256": plan["plan_sha256"], "timeout_seconds": 30,
|
| 92 | "ordinal": 0, "timestamp_utc": "2026-09-10T00:00:00Z"}
|
| 93 | journal = json.dumps(started).encode() + b"\n" + b'{"event":"finished"'
|
| 94 | (self.campaign / "events.jsonl").write_bytes(journal)
|
| 95 | result = self.invoke("resume")
|
| 96 | self.assertEqual(result.returncode, 2)
|
| 97 | self.assertIn("--acknowledge-torn-journal", result.stderr)
|
| 98 | self.assertEqual((self.campaign / "events.jsonl").read_bytes(), journal)
|
| 99 | self.assertFalse((self.campaign / "trials").exists())
|
| 100 |
|
| 101 | def test_insufficient_budget_stops_without_shortening_timeout(self):
|
| 102 | manifest = json.loads(self.manifest.read_text())
|
| 103 | manifest["max_wall_seconds"] = 0.15
|
| 104 | self.manifest.write_text(json.dumps(manifest))
|
| 105 | self.plan()
|
| 106 | result = self.invoke("run")
|
| 107 | self.assertEqual(result.returncode, 3, result.stdout + result.stderr)
|
| 108 | state = json.loads(result.stdout)
|
| 109 | self.assertEqual(state["stopped_reason"], "insufficient_budget_for_frozen_trial_timeout")
|
| 110 | self.assertEqual(len(state["pending_trial_ids"]), 2)
|
| 111 | self.assertFalse((self.campaign / "events.jsonl").exists())
|
| 112 |
|
| 113 | def test_torn_start_readonly_and_acknowledged_recovery_never_retries(self):
|
| 114 | plan = self.plan()
|
| 115 | interrupted = plan["schedule"][0]["trial_id"]
|
| 116 | raw = b'{"event":"started","trial_id":'
|
| 117 | journal = self.campaign / "events.jsonl"
|
| 118 | journal.write_bytes(raw)
|
| 119 | for command in ("status", "report"):
|
| 120 | result = self.invoke(command)
|
| 121 | self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
|
| 122 | evidence = json.loads(result.stdout)
|
| 123 | self.assertFalse(evidence["journal_recoveries"][0]["acknowledged"])
|
| 124 | self.assertEqual(journal.read_bytes(), raw)
|
| 125 | result = self.invoke("resume", "--acknowledge-torn-journal")
|
| 126 | self.assertEqual(result.returncode, 3, result.stdout + result.stderr)
|
| 127 | events = self.events()
|
| 128 | self.assertEqual(events[0]["trial_id"], interrupted)
|
| 129 | self.assertTrue(events[0]["uncertain_torn_start"])
|
| 130 | marker = events[1]
|
| 131 | self.assertTrue(marker["acknowledged"])
|
| 132 | self.assertEqual((self.campaign / marker["archive"]).read_bytes(), raw)
|
| 133 | self.assertFalse((self.campaign / "trials" / interrupted).exists())
|
| 134 | self.assertEqual(len([e for e in events if e["event"] == "finished"]), 1)
|
| 135 | result = self.invoke("resume")
|
| 136 | self.assertEqual(result.returncode, 3, result.stdout + result.stderr)
|
| 137 | self.assertEqual(self.events(), events)
|
| 138 |
|
| 139 | def test_valid_digest_malformed_plan_exits_contract_error(self):
|
| 140 | import hashlib
|
| 141 | self.campaign.mkdir()
|
| 142 | malformed = {"schema_version": 1}
|
| 143 | malformed["plan_sha256"] = hashlib.sha256(b'{"schema_version":1}').hexdigest()
|
| 144 | (self.campaign / "plan.json").write_text(json.dumps(malformed))
|
| 145 | result = self.invoke("status")
|
| 146 | self.assertEqual(result.returncode, 2)
|
| 147 | self.assertIn("invalid frozen plan", result.stderr)
|
| 148 | self.assertNotIn("Traceback", result.stderr)
|
| 149 |
|
| 150 | def test_bounded_invocation_resumes_only_remaining_trial(self):
|
| 151 | self.plan()
|
| 152 | result = self.invoke("run", "--limit", "1")
|
| 153 | self.assertEqual(result.returncode, 3, result.stdout + result.stderr)
|
| 154 | first = self.events()
|
| 155 | self.assertEqual(len(first), 2)
|
| 156 | self.assertTrue(first[1]["row"]["success"], first[1])
|
| 157 | result = self.invoke("resume", "--limit", "1")
|
| 158 | self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
|
| 159 | self.assertEqual(self.events()[:2], first)
|
| 160 | self.assertEqual(len(self.events()), 4)
|
| 161 |
|
| 162 | def test_interrupted_attempt_stays_visible_after_remaining_trial_runs(self):
|
| 163 | plan = self.plan()
|
| 164 | interrupted = plan["schedule"][0]["trial_id"]
|
| 165 | started = {"event": "started", "trial_id": interrupted,
|
| 166 | "plan_sha256": plan["plan_sha256"], "timeout_seconds": 30,
|
| 167 | "ordinal": 0, "timestamp_utc": "2026-09-10T00:00:00Z"}
|
| 168 | (self.campaign / "events.jsonl").write_text(json.dumps(started) + "\n")
|
| 169 | result = self.invoke("resume")
|
| 170 | self.assertEqual(result.returncode, 3, result.stdout + result.stderr)
|
| 171 | events = self.events()
|
| 172 | self.assertEqual(len(events), 3)
|
| 173 | self.assertEqual(events[0], started)
|
| 174 | self.assertNotEqual(events[-1]["trial_id"], interrupted)
|
| 175 | self.assertTrue(events[-1]["row"]["success"], events[-1])
|
| 176 | self.assertFalse((self.campaign / "trials" / interrupted).exists())
|
| 177 | result = self.invoke("report", "--format", "json")
|
| 178 | self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
|
| 179 | counts = json.loads(result.stdout)["counts"]
|
| 180 | self.assertEqual((counts["started"], counts["success"], counts["interrupted"]), (2, 1, 1))
|
| 181 |
|
| 182 |
|
| 183 | if __name__ == "__main__":
|
| 184 | unittest.main()
|