| 1 | """Independent CLI integration: real Git, mock agent, durable campaign records."""
|
| 2 | from pathlib import Path
|
| 3 | import json
|
| 4 | import os
|
| 5 | import shutil
|
| 6 | import subprocess
|
| 7 | import sys
|
| 8 | import tempfile
|
| 9 | import unittest
|
| 10 |
|
| 11 |
|
| 12 | ROOT = Path(__file__).resolve().parents[1]
|
| 13 | CLI = ROOT / "scripts" / "agent_campaign.py"
|
| 14 |
|
| 15 |
|
| 16 | @unittest.skipUnless(shutil.which("git"), "Git is required for the campaign integration")
|
| 17 | class CampaignCLIIntegrationTests(unittest.TestCase):
|
| 18 | def setUp(self):
|
| 19 | self.temp = tempfile.TemporaryDirectory(prefix="oakbench-campaign-cli-")
|
| 20 | self.addCleanup(self.temp.cleanup)
|
| 21 | self.root = Path(self.temp.name).resolve()
|
| 22 | self.campaign = self.root / "campaign"
|
| 23 | self.agents = self.root / "agents.toml"
|
| 24 | self.agents.write_text('[agents.mock]\nenabled = true\nadapter = "deterministic_mock"\nprovider = "local"\n')
|
| 25 | self.subjects = self.root / "subjects.toml"
|
| 26 | self.subjects.write_text('[subjects.git]\nenabled = true\nkind = "git"\nlabel = "Git"\nbin = '
|
| 27 | + json.dumps(shutil.which("git")) + '\n')
|
| 28 | self.manifest = self.root / "manifest.json"
|
| 29 | self.manifest.write_text(json.dumps({
|
| 30 | "schema_version": 1, "campaign_id": "cli-integration",
|
| 31 | "agents_config": str(self.agents), "subjects_config": str(self.subjects),
|
| 32 | "agents": [{"name": "mock", "model": None}], "subjects": ["git"],
|
| 33 | "workflows": ["wide_config_refactor"], "instruction_levels": ["cheat-sheet"],
|
| 34 | "repetitions": 2, "seed": 194, "max_trials": 2, "max_wall_seconds": 180,
|
| 35 | "trial_timeout_seconds": 30, "track": "agent-default", "agent_environment": "minimal",
|
| 36 | }))
|
| 37 |
|
| 38 | def invoke(self, command, *args):
|
| 39 | return subprocess.run([sys.executable, str(CLI), command,
|
| 40 | "--campaign-dir", str(self.campaign), *args],
|
| 41 | cwd=ROOT, text=True, capture_output=True, timeout=120)
|
| 42 |
|
| 43 | def plan(self):
|
| 44 | result = self.invoke("plan", "--manifest", str(self.manifest))
|
| 45 | self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
|
| 46 | return json.loads((self.campaign / "plan.json").read_text())
|
| 47 |
|
| 48 | def fixture_hash(self, plan):
|
| 49 | sys.path.insert(0, str(ROOT / "scripts"))
|
| 50 | from oakbench import agent_campaign
|
| 51 | import workflow_ab
|
| 52 | agent_campaign.cached_fixture(self.campaign, plan, workflow_ab.WORKFLOWS["wide_config_refactor"])
|
| 53 | record = json.loads((self.campaign / "fixture-integrity/wide_config_refactor.json").read_text())
|
| 54 | return agent_campaign.digest(record["manifest"])
|
| 55 |
|
| 56 | def events(self):
|
| 57 | return [json.loads(line) for line in (self.campaign / "events.jsonl").read_text().splitlines()]
|
| 58 |
|
| 59 | def test_real_git_mock_completion_and_noop_resume_preserve_evidence(self):
|
| 60 | plan = self.plan()
|
| 61 | self.assertEqual(len(plan["schedule"]), 2)
|
| 62 | result = self.invoke("run")
|
| 63 | self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
|
| 64 | self.assertEqual(json.loads(result.stdout)["finished"], 2)
|
| 65 | self.assertIn("[trial]", result.stderr)
|
| 66 | events = self.events()
|
| 67 | self.assertEqual([event["event"] for event in events], ["started", "finished"] * 2)
|
| 68 | finished = [event for event in events if event["event"] == "finished"]
|
| 69 | for event in finished:
|
| 70 | self.assertTrue(event["row"]["success"], event)
|
| 71 | self.assertTrue(event["row"]["success_criteria"]["checks"]["required_checks_passed"])
|
| 72 | self.assertEqual(event["row"]["task_id"], event["trial_id"])
|
| 73 | journal = (self.campaign / "events.jsonl").read_bytes()
|
| 74 | # Simulate the crash window after the authoritative terminal fsync but
|
| 75 | # before refreshing the derived rows. Resume must repair this view.
|
| 76 | (self.campaign / "rows.jsonl").write_text("")
|
| 77 | shutil.rmtree(self.campaign / "fixtures")
|
| 78 | shutil.rmtree(self.campaign / "fixture-integrity")
|
| 79 | result = self.invoke("resume")
|
| 80 | self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
|
| 81 | self.assertEqual((self.campaign / "events.jsonl").read_bytes(), journal)
|
| 82 | self.assertFalse((self.campaign / "fixtures").exists())
|
| 83 | recovered = [json.loads(line) for line in (self.campaign / "rows.jsonl").read_text().splitlines()]
|
| 84 | self.assertEqual(recovered, [event["row"] for event in finished])
|
| 85 | result = self.invoke("report")
|
| 86 | self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
|
| 87 | self.assertIn('"claim_eligible": false', result.stdout.lower())
|
| 88 |
|
| 89 | @unittest.skipUnless(shutil.which("oak"), "Oak is required for the default Git-vs-Oak report")
|
| 90 | def test_default_git_vs_oak_campaign_report_renders_with_refused_pairs(self):
|
| 91 | # Default configuration: no byte-distinct Git instrument and no
|
| 92 | # independent Oak reader, so Git rows carry subject_binary_* evidence
|
| 93 | # and Oak rows subject_produced_*. The report must refuse those pairs,
|
| 94 | # never crash (regression: ValueError -> exit 2, no report).
|
| 95 | self.subjects.write_text(self.subjects.read_text() + '[subjects.oak_installed]\nenabled = true\nkind = "oak"\n'
|
| 96 | 'label = "Oak"\nbin = ' + json.dumps(shutil.which("oak")) + '\n')
|
| 97 | manifest = json.loads(self.manifest.read_text())
|
| 98 | manifest.update(subjects=["git", "oak_installed"], repetitions=1, max_trials=2)
|
| 99 | self.manifest.write_text(json.dumps(manifest))
|
| 100 | self.plan()
|
| 101 | result = self.invoke("run")
|
| 102 | self.assertIn(result.returncode, (0, 1), result.stdout + result.stderr)
|
| 103 | finished = [event for event in self.events() if event["event"] == "finished"]
|
| 104 | # Non-vacuous: both default-configuration trials must have succeeded,
|
| 105 | # which is exactly the case that used to crash the report.
|
| 106 | self.assertEqual(len(finished), 2, finished)
|
| 107 | self.assertTrue(all(isinstance(event.get("row"), dict) and event["row"]["success"] for event in finished), finished)
|
| 108 | classes = {event["row"]["subject"]: event["row"].get("workflow_integrity_evidence_class") for event in finished}
|
| 109 | for fmt in ("json", "markdown"):
|
| 110 | report = self.invoke("report", "--format", fmt)
|
| 111 | self.assertEqual(report.returncode, 0, report.stdout + report.stderr)
|
| 112 | summary = json.loads(self.invoke("report").stdout)
|
| 113 | pair = summary["groups"][0]["paired_comparisons"][0]
|
| 114 | if os.environ.get("OAK_BENCH_OAK_READER_PYTHON") or os.environ.get("OAK_BENCH_GIT_INSTRUMENT"):
|
| 115 | self.skipTest("default-configuration assertion; an independent reader/instrument is configured")
|
| 116 | self.assertEqual(len(set(classes.values())), 2, classes)
|
| 117 | self.assertTrue(pair["comparison_refused"], (classes, pair))
|
| 118 | self.assertIn("workflow_integrity_evidence_class", pair["incompatible_evidence_fields"])
|
| 119 | self.assertIn("paired_evidence_incompatible", summary["claim_ineligibility_reasons"])
|
| 120 | self.assertIsNone(pair["success_delta_percentage_points"])
|
| 121 |
|
| 122 | def test_corrupted_cache_resume_is_preflight_error_preserving_pending(self):
|
| 123 | self.plan()
|
| 124 | first = self.invoke("run", "--limit", "1")
|
| 125 | self.assertEqual(first.returncode, 3, first.stderr)
|
| 126 | journal = (self.campaign / "events.jsonl").read_bytes()
|
| 127 | payload = next((self.campaign / "fixtures/wide_config_refactor").glob("services/*/config.toml"))
|
| 128 | payload.chmod(0o600)
|
| 129 | payload.write_text("changed cached initial state")
|
| 130 | result = self.invoke("resume")
|
| 131 | self.assertEqual(result.returncode, 2, result.stdout + result.stderr)
|
| 132 | self.assertIn("fixture content drift", result.stderr)
|
| 133 | self.assertEqual((self.campaign / "events.jsonl").read_bytes(), journal)
|
| 134 | status = self.invoke("status")
|
| 135 | self.assertEqual(len(json.loads(status.stdout)["pending_trial_ids"]), 1)
|
| 136 |
|
| 137 | def test_cache_and_record_rewrite_cannot_rebind_prior_trial_input(self):
|
| 138 | import hashlib
|
| 139 | self.plan()
|
| 140 | first = self.invoke("run", "--limit", "1")
|
| 141 | self.assertEqual(first.returncode, 3, first.stderr)
|
| 142 | journal = (self.campaign / "events.jsonl").read_bytes()
|
| 143 | fixture = self.campaign / "fixtures/wide_config_refactor"
|
| 144 | payload = next(fixture.glob("services/*/config.toml"))
|
| 145 | payload.chmod(0o600)
|
| 146 | payload.write_bytes(b"changed baseline plus forged cache record")
|
| 147 | record_path = self.campaign / "fixture-integrity/wide_config_refactor.json"
|
| 148 | record = json.loads(record_path.read_text())
|
| 149 | entry = record["manifest"][payload.relative_to(fixture).as_posix()]
|
| 150 | entry.update(size=len(payload.read_bytes()), sha256=hashlib.sha256(payload.read_bytes()).hexdigest())
|
| 151 | record_path.write_text(json.dumps(record))
|
| 152 | result = self.invoke("resume")
|
| 153 | self.assertEqual(result.returncode, 2, result.stdout + result.stderr)
|
| 154 | self.assertIn("journal fixture binding", result.stderr)
|
| 155 | self.assertEqual((self.campaign / "events.jsonl").read_bytes(), journal)
|
| 156 | status = self.invoke("status")
|
| 157 | self.assertEqual(len(json.loads(status.stdout)["pending_trial_ids"]), 1)
|
| 158 |
|
| 159 | def test_incomplete_generation_fails_before_any_admission(self):
|
| 160 | self.plan()
|
| 161 | fixture = self.campaign / "fixtures/wide_config_refactor"
|
| 162 | fixture.mkdir(parents=True)
|
| 163 | (fixture / "partial").write_text("crashed generation")
|
| 164 | result = self.invoke("run")
|
| 165 | self.assertEqual(result.returncode, 2, result.stdout + result.stderr)
|
| 166 | self.assertIn("fixture cache is incomplete", result.stderr)
|
| 167 | self.assertFalse((self.campaign / "events.jsonl").exists())
|
| 168 | status = self.invoke("status")
|
| 169 | self.assertEqual(len(json.loads(status.stdout)["pending_trial_ids"]), 2)
|
| 170 |
|
| 171 | def test_existing_plan_and_changed_config_fail_before_agent_execution(self):
|
| 172 | self.plan()
|
| 173 | frozen = (self.campaign / "plan.json").read_bytes()
|
| 174 | result = self.invoke("plan", "--manifest", str(self.manifest))
|
| 175 | self.assertNotEqual(result.returncode, 0)
|
| 176 | self.assertEqual((self.campaign / "plan.json").read_bytes(), frozen)
|
| 177 | self.agents.write_text(self.agents.read_text() + "\n# changed configuration\n")
|
| 178 | result = self.invoke("run")
|
| 179 | self.assertNotEqual(result.returncode, 0)
|
| 180 | self.assertFalse((self.campaign / "events.jsonl").exists())
|
| 181 |
|
| 182 | def test_torn_journal_cannot_be_discarded_to_retry_a_trial(self):
|
| 183 | plan = self.plan()
|
| 184 | started = {"event": "started", "trial_id": plan["schedule"][0]["trial_id"],
|
| 185 | "plan_sha256": plan["plan_sha256"], "timeout_seconds": 30,
|
| 186 | "ordinal": 0, "timestamp_utc": "2026-09-10T00:00:00Z",
|
| 187 | "fixture_manifest_sha256": self.fixture_hash(plan)}
|
| 188 | journal = json.dumps(started).encode() + b"\n" + b'{"event":"finished"'
|
| 189 | (self.campaign / "events.jsonl").write_bytes(journal)
|
| 190 | result = self.invoke("resume")
|
| 191 | self.assertEqual(result.returncode, 2)
|
| 192 | self.assertIn("--acknowledge-torn-journal", result.stderr)
|
| 193 | self.assertEqual((self.campaign / "events.jsonl").read_bytes(), journal)
|
| 194 | self.assertFalse((self.campaign / "trials").exists())
|
| 195 |
|
| 196 | def test_impossible_budget_is_rejected_before_frozen_plan(self):
|
| 197 | manifest = json.loads(self.manifest.read_text())
|
| 198 | manifest["max_wall_seconds"] = 0.15
|
| 199 | self.manifest.write_text(json.dumps(manifest))
|
| 200 | result = self.invoke("plan", "--manifest", str(self.manifest))
|
| 201 | self.assertEqual(result.returncode, 2, result.stdout + result.stderr)
|
| 202 | self.assertIn("must admit at least one", result.stderr)
|
| 203 | self.assertFalse(self.campaign.exists())
|
| 204 |
|
| 205 | def test_remaining_budget_stops_without_shortening_timeout(self):
|
| 206 | plan = self.plan()
|
| 207 | started = {"event": "started", "trial_id": plan["schedule"][0]["trial_id"],
|
| 208 | "plan_sha256": plan["plan_sha256"], "timeout_seconds": 30,
|
| 209 | "fixture_manifest_sha256": self.fixture_hash(plan)}
|
| 210 | finished = {**started, "event": "finished", "outcome": "error", "wall_seconds": 179.85}
|
| 211 | (self.campaign / "events.jsonl").write_text(json.dumps(started) + "\n" + json.dumps(finished) + "\n")
|
| 212 | result = self.invoke("resume")
|
| 213 | self.assertEqual(result.returncode, 3, result.stdout + result.stderr)
|
| 214 | state = json.loads(result.stdout)
|
| 215 | self.assertEqual(state["stopped_reason"], "insufficient_budget_for_frozen_trial_timeout")
|
| 216 | self.assertEqual(len(state["pending_trial_ids"]), 1)
|
| 217 | self.assertEqual(len(self.events()), 2)
|
| 218 |
|
| 219 | def test_torn_start_readonly_and_acknowledged_recovery_never_retries(self):
|
| 220 | plan = self.plan()
|
| 221 | interrupted = plan["schedule"][0]["trial_id"]
|
| 222 | raw = b'{"event":"started","trial_id":'
|
| 223 | journal = self.campaign / "events.jsonl"
|
| 224 | journal.write_bytes(raw)
|
| 225 | for command in ("status", "report"):
|
| 226 | result = self.invoke(command)
|
| 227 | self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
|
| 228 | evidence = json.loads(result.stdout)
|
| 229 | self.assertFalse(evidence["journal_recoveries"][0]["acknowledged"])
|
| 230 | self.assertEqual(journal.read_bytes(), raw)
|
| 231 | result = self.invoke("resume", "--acknowledge-torn-journal")
|
| 232 | self.assertEqual(result.returncode, 3, result.stdout + result.stderr)
|
| 233 | events = self.events()
|
| 234 | self.assertEqual(events[0]["trial_id"], interrupted)
|
| 235 | self.assertTrue(events[0]["uncertain_torn_start"])
|
| 236 | marker = events[1]
|
| 237 | self.assertTrue(marker["acknowledged"])
|
| 238 | self.assertEqual((self.campaign / marker["archive"]).read_bytes(), raw)
|
| 239 | self.assertFalse((self.campaign / "trials" / interrupted).exists())
|
| 240 | self.assertEqual(len([e for e in events if e["event"] == "finished"]), 1)
|
| 241 | result = self.invoke("resume")
|
| 242 | self.assertEqual(result.returncode, 3, result.stdout + result.stderr)
|
| 243 | self.assertEqual(self.events(), events)
|
| 244 |
|
| 245 | def test_valid_digest_malformed_plan_exits_contract_error(self):
|
| 246 | import hashlib
|
| 247 | self.campaign.mkdir()
|
| 248 | malformed = {"schema_version": 1}
|
| 249 | malformed["plan_sha256"] = hashlib.sha256(b'{"schema_version":1}').hexdigest()
|
| 250 | (self.campaign / "plan.json").write_text(json.dumps(malformed))
|
| 251 | result = self.invoke("status")
|
| 252 | self.assertEqual(result.returncode, 2)
|
| 253 | self.assertIn("invalid frozen plan", result.stderr)
|
| 254 | self.assertNotIn("Traceback", result.stderr)
|
| 255 |
|
| 256 | def test_bounded_invocation_resumes_only_remaining_trial(self):
|
| 257 | self.plan()
|
| 258 | result = self.invoke("run", "--limit", "1")
|
| 259 | self.assertEqual(result.returncode, 3, result.stdout + result.stderr)
|
| 260 | first = self.events()
|
| 261 | self.assertEqual(len(first), 2)
|
| 262 | self.assertTrue(first[1]["row"]["success"], first[1])
|
| 263 | result = self.invoke("resume", "--limit", "1")
|
| 264 | self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
|
| 265 | self.assertEqual(self.events()[:2], first)
|
| 266 | self.assertEqual(len(self.events()), 4)
|
| 267 |
|
| 268 | def test_interrupted_attempt_stays_visible_after_remaining_trial_runs(self):
|
| 269 | plan = self.plan()
|
| 270 | interrupted = plan["schedule"][0]["trial_id"]
|
| 271 | started = {"event": "started", "trial_id": interrupted,
|
| 272 | "plan_sha256": plan["plan_sha256"], "timeout_seconds": 30,
|
| 273 | "ordinal": 0, "timestamp_utc": "2026-09-10T00:00:00Z",
|
| 274 | "fixture_manifest_sha256": self.fixture_hash(plan)}
|
| 275 | (self.campaign / "events.jsonl").write_text(json.dumps(started) + "\n")
|
| 276 | result = self.invoke("resume")
|
| 277 | self.assertEqual(result.returncode, 3, result.stdout + result.stderr)
|
| 278 | events = self.events()
|
| 279 | self.assertEqual(len(events), 3)
|
| 280 | self.assertEqual(events[0], started)
|
| 281 | self.assertNotEqual(events[-1]["trial_id"], interrupted)
|
| 282 | self.assertTrue(events[-1]["row"]["success"], events[-1])
|
| 283 | self.assertFalse((self.campaign / "trials" / interrupted).exists())
|
| 284 | result = self.invoke("report", "--format", "json")
|
| 285 | self.assertEqual(result.returncode, 0, result.stdout + result.stderr)
|
| 286 | counts = json.loads(result.stdout)["counts"]
|
| 287 | self.assertEqual((counts["started"], counts["success"], counts["interrupted"]), (2, 1, 1))
|
| 288 |
|
| 289 |
|
| 290 | if __name__ == "__main__":
|
| 291 | unittest.main()
|