Kill the mutants that survived on the lines the release review changed
This commit is contained in:
@@ -80,6 +80,13 @@ class Cycles(unittest.TestCase):
|
||||
self.assertEqual(run.run_cycle(self.cycle(fake)).verdict, Finished("working"))
|
||||
self.assertEqual(self.archived_outcomes(), [f"Task: Do it.\n\n2026-09-21T14:13:20Z Verdict: finished\n\nEvidence:\n> working\n\nConfig: {CONFIG}\nJudge: judge-model\nWorker: {OFF_LADDER}\n"])
|
||||
|
||||
def test_says_where_it_archived_the_transcript(self):
|
||||
fake = FakeEffects(streams=[Worker(self.paths.claude_code_transcripts.parent)], claude=[judged("finished")])
|
||||
with contextlib.redirect_stderr(io.StringIO()) as said:
|
||||
run.run_cycle(self.cycle(fake))
|
||||
copy, = self.archive.glob("*/*.jsonl")
|
||||
self.assertIn(f"transcript: {copy}\n", said.getvalue())
|
||||
|
||||
def test_archives_the_cost_the_judges_reply_records_beside_its_verdict(self):
|
||||
fake = FakeEffects(streams=[Worker(self.paths.claude_code_transcripts.parent)], claude=[judged("finished", cost=0.25)])
|
||||
self.assertEqual(run.run_cycle(self.cycle(fake)).verdict, Finished("working", judged=Judged(cost=0.25)))
|
||||
|
||||
@@ -24,6 +24,13 @@ class TheHeadOfAnEntry(unittest.TestCase):
|
||||
self.assertEqual(found, Entry("ABC-1", {"issuelinks": [BLOCKED, outward, relates]}, (Link("ABC-2", "9"),), {"L": 2}))
|
||||
self.assertEqual(entry_of(raw(), "plan"), Entry("ABC-1", {"issuelinks": []}, (), {}))
|
||||
|
||||
def test_finds_a_blocked_by_link_listed_after_a_link_of_another_kind(self):
|
||||
outward = {"id": "3", "type": {"inward": "is blocked by"}, "outwardIssue": {"key": "ABC-3"}}
|
||||
relates = {"id": "4", "type": {"inward": "relates to"}, "inwardIssue": {"key": "ABC-4"}}
|
||||
for other in (outward, relates):
|
||||
with self.subTest(other=other):
|
||||
self.assertEqual(jira.blocked_by_links({"issuelinks": [other, BLOCKED]}), (Link("ABC-2", "9"),))
|
||||
|
||||
def test_an_entry_without_an_issue_key_is_a_failure(self):
|
||||
for wrong in ([], {}, {"key": 7}, {"key": "abc"}):
|
||||
with self.subTest(wrong=wrong):
|
||||
|
||||
@@ -1,5 +1,7 @@
|
||||
import contextlib
|
||||
import dataclasses
|
||||
import fcntl
|
||||
import io
|
||||
import json
|
||||
import pathlib
|
||||
import sys
|
||||
@@ -24,6 +26,52 @@ class Overridden(unittest.TestCase):
|
||||
self.assertEqual(model_choice.overridden({"LOOP_CLAUDE_JUDGE_MODEL": "j", "LOOP_CLAUDE_WORKER_MODEL": "w"}, "saved"), model_choice.Models("j", "w"))
|
||||
|
||||
|
||||
class ModelsOfARun(unittest.TestCase):
|
||||
def setUp(self):
|
||||
temp = tempfile.TemporaryDirectory()
|
||||
self.addCleanup(temp.cleanup)
|
||||
self.paths = paths_from(pathlib.Path(temp.name))
|
||||
self.paths.models_file.parent.mkdir()
|
||||
|
||||
def test_a_run_that_names_both_models_reads_no_models_file_and_asks_nothing(self):
|
||||
self.paths.models_file.write_text("not json")
|
||||
fake = FakeEffects()
|
||||
env = {"LOOP_CLAUDE_JUDGE_MODEL": "j", "LOOP_CLAUDE_WORKER_MODEL": "w"}
|
||||
self.assertEqual(model_choice.get_or_ask_models("proj", self.paths, env, LOOP_CLAUDE, fake.effects()), model_choice.Models("j", "w"))
|
||||
self.assertEqual(fake.calls, [])
|
||||
|
||||
def test_a_run_that_names_one_model_takes_the_other_from_the_models_file(self):
|
||||
self.paths.models_file.write_text(json.dumps({"proj": "saved"}))
|
||||
fake = FakeEffects()
|
||||
self.assertEqual(model_choice.get_or_ask_models("proj", self.paths, {"LOOP_CLAUDE_JUDGE_MODEL": "j"}, LOOP_CLAUDE, fake.effects()), model_choice.Models("j", "saved"))
|
||||
self.assertEqual(model_choice.get_or_ask_models("proj", self.paths, {"LOOP_CLAUDE_WORKER_MODEL": "w"}, LOOP_CLAUDE, fake.effects()), model_choice.Models("saved", "w"))
|
||||
self.assertEqual(fake.calls, [])
|
||||
|
||||
def test_a_run_that_names_one_model_asks_for_the_projects_where_none_is_saved_and_saves_the_pick(self):
|
||||
fake, said = FakeEffects(inputs=["my-model"]), io.StringIO()
|
||||
with contextlib.redirect_stderr(said):
|
||||
models = model_choice.get_or_ask_models("proj", self.paths, {"LOOP_CLAUDE_JUDGE_MODEL": "j"}, LOOP_CLAUDE, fake.effects())
|
||||
self.assertEqual(models, model_choice.Models("j", "my-model"))
|
||||
self.assertEqual(json.loads(self.paths.models_file.read_text()), {"proj": "my-model"})
|
||||
self.assertIn(" proj runs on my-model\n", said.getvalue())
|
||||
|
||||
def test_off_a_terminal_it_stops_naming_the_driver_to_rerun_and_the_file_to_merge_the_model_into(self):
|
||||
fake = FakeEffects(on_terminal=False)
|
||||
stop = model_choice.get_or_ask_models("proj", self.paths, {}, LOOP_CLAUDE, fake.effects())
|
||||
assert isinstance(stop, Stop)
|
||||
self.assertEqual(stop.code, 2)
|
||||
self.assertIn(f"pick proj's model, or merge {{\"proj\": \"<model>\"}} into {self.paths.models_file}", stop.reason)
|
||||
self.assertIn(LOOP_CLAUDE, stop.reason)
|
||||
self.assertFalse(self.paths.models_file.exists())
|
||||
|
||||
def test_stops_with_exit_1_where_the_models_file_maps_no_projects_to_model_names(self):
|
||||
for held in ("[]", '{"proj": 5}', '{"proj": ""}'):
|
||||
with self.subTest(held=held):
|
||||
self.paths.models_file.write_text(held)
|
||||
stop = model_choice.get_or_ask_models("proj", self.paths, {}, LOOP_CLAUDE, FakeEffects().effects())
|
||||
self.assertEqual(stop, Stop(1, f"could not read {self.paths.models_file}: not an object mapping projects to model names"))
|
||||
|
||||
|
||||
class SavingAModel(unittest.TestCase):
|
||||
def setUp(self):
|
||||
temp = tempfile.TemporaryDirectory()
|
||||
@@ -37,6 +85,12 @@ class SavingAModel(unittest.TestCase):
|
||||
self.assertIsNone(model_choice.save_model("proj", "model-b", self.paths, replace_file))
|
||||
self.assertEqual(json.loads(self.paths.models_file.read_text()), {"other": "model-x", "proj": "model-b"})
|
||||
|
||||
def test_writes_the_file_for_a_human_to_merge_into_a_project_per_tab_indented_line_in_the_order_of_their_keys(self):
|
||||
self.paths.models_file.parent.mkdir()
|
||||
self.paths.models_file.write_text(json.dumps({"zebra": "model-z", "other": "model-x"}))
|
||||
self.assertIsNone(model_choice.save_model("proj", "model-b", self.paths, replace_file))
|
||||
self.assertEqual(self.paths.models_file.read_text(), '{\n\t"other": "model-x",\n\t"proj": "model-b",\n\t"zebra": "model-z"\n}')
|
||||
|
||||
def lock_is_held(self) -> bool:
|
||||
with open(self.lock, "a") as other:
|
||||
try:
|
||||
@@ -91,6 +145,8 @@ class ModelPrompt(unittest.TestCase):
|
||||
|
||||
def test_reads_a_number_as_the_offered_model_and_anything_else_as_a_name(self):
|
||||
self.assertEqual(model_choice.model_picked(" 2 ", self.OFFERED), "claude-haiku-4-5")
|
||||
self.assertEqual(model_choice.model_picked("1", self.OFFERED), "claude-opus-5-5")
|
||||
self.assertEqual(model_choice.model_picked("0", self.OFFERED), Failure("pick 1 to 2"))
|
||||
self.assertEqual(model_choice.model_picked("opus", self.OFFERED), "opus")
|
||||
self.assertEqual(model_choice.model_picked("3", []), "3")
|
||||
self.assertEqual(model_choice.model_picked("3", self.OFFERED), Failure("pick 1 to 2"))
|
||||
|
||||
@@ -20,6 +20,7 @@ from text_files.file_writes import replace_file
|
||||
from model_routing.route import Route
|
||||
from agent_cycle import run
|
||||
from claude_code import session
|
||||
from agent_cycle.stop import Stop
|
||||
|
||||
OPUS_PROJECT = ProjectRung(read_ladder(SHIPPED), Rung("claude-opus-5-5", "medium"))
|
||||
|
||||
@@ -71,6 +72,33 @@ class Steps(unittest.TestCase):
|
||||
stop = chunk_run.closed_cycle(chunk_run.ChunkRun(cycle_number=1, task="Do it.", unfinished_evidence=""), OPUS_PROJECT, run.Concluded(Unfinished("working", taken_in=TakenIn(highest_likelihood=4)), before), blocked, "a-driver", a_loop(FakeEffects().effects(), session=opened))
|
||||
self.assertEqual((stop.code, stop.reason.split(":")[0]), (1, "could not archive the transcript"))
|
||||
|
||||
def outcomes_after(self, unfinished_run: int, taken_in: TakenIn) -> tuple[object, str]:
|
||||
"""What closed_cycle answers for a-driver's chunk `Do it.`, after an unfinished verdict that follows unfinished_run others, and the outcomes it archived for a transcript not archived before."""
|
||||
with tempfile.TemporaryDirectory() as home:
|
||||
opened = session.session_named("A proj a-driver", pathlib.Path(home, "projects"))
|
||||
archive = pathlib.Path(home, "archive")
|
||||
transcript = pathlib.Path(home, "projects", "-fake", f"{opened.id}.jsonl")
|
||||
transcript.parent.mkdir(parents=True)
|
||||
transcript.write_text(json.dumps({"type": "queue-operation", "timestamp": "1"}) + "\n")
|
||||
before = Route(self.FABLE_LOW, 3, 3, 4)
|
||||
with contextlib.redirect_stderr(io.StringIO()):
|
||||
closed = chunk_run.closed_cycle(chunk_run.ChunkRun(cycle_number=1, task="Do it.", unfinished_evidence="", unfinished_run=unfinished_run), OPUS_PROJECT, run.Concluded(Unfinished("working", taken_in=taken_in), before), archive, "a-driver", a_loop(FakeEffects().effects(), session=opened))
|
||||
return closed, "".join(file.read_text() for file in archive.rglob("*") if file.is_file() and file.suffix != ".jsonl")
|
||||
|
||||
def test_a_step_up_archived_first_for_its_transcript_names_the_chunks_task(self):
|
||||
closed, outcomes_kept = self.outcomes_after(0, TakenIn(highest_likelihood=4))
|
||||
self.assertEqual(closed.route.rung, self.FABLE_MEDIUM)
|
||||
self.assertIn("Do it.\n", outcomes_kept)
|
||||
|
||||
def test_the_sixth_unfinished_verdict_running_stops_for_the_human_naming_the_driver_to_rerun_and_archives_why_with_the_task(self):
|
||||
reason = "the human is needed to go on with the chunk, but the judge ruled it unfinished 6 cycles running; finish the chunk yourself, or rerun a-driver to give it 6 more cycles"
|
||||
closed, outcomes_kept = self.outcomes_after(5, TakenIn())
|
||||
self.assertEqual(closed, Stop(2, reason))
|
||||
self.assertIn("Do it.\n", outcomes_kept)
|
||||
self.assertIn(f"Stopped: {reason}\n", outcomes_kept)
|
||||
closed, outcomes_kept = self.outcomes_after(4, TakenIn())
|
||||
self.assertEqual((closed.unfinished_run, outcomes_kept), (5, ""))
|
||||
|
||||
def test_archives_a_higher_e_plus_i_taken_in_so_a_rerun_keeps_it(self):
|
||||
with tempfile.TemporaryDirectory() as home:
|
||||
opened = session.session_named("A proj a-driver", pathlib.Path(home, "projects"))
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
import contextlib
|
||||
import dataclasses
|
||||
import functools
|
||||
import io
|
||||
import json
|
||||
@@ -12,16 +13,23 @@ import unittest
|
||||
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
|
||||
|
||||
from chunk_driver.doubles import a_loop
|
||||
from project_config.doubles import configured
|
||||
from agent_cycle.run import Cycle
|
||||
from chunk_driver import cycle_start
|
||||
from failure import Failure
|
||||
from loop_effects.doubles import FakeEffects, NOW, STAMP
|
||||
from git_cli import git_repo
|
||||
from chunk_driver.project.model_choice import Models
|
||||
from transcript_archive import outcomes, write
|
||||
from loop_state.paths import paths_from
|
||||
from model_routing.ladder import ProjectRung, Rung
|
||||
from model_routing.ladder_file import read_ladder, SHIPPED
|
||||
from text_files.file_writes import replace_file
|
||||
from model_routing.route import Route, WorkerLine
|
||||
from claude_code import session
|
||||
from agent_cycle.stop import Stop
|
||||
from agent_cycle.verdicts import TakenIn
|
||||
from agent_cycle.worker_prompts import WorkerPrompts
|
||||
|
||||
OPUS_PROJECT = ProjectRung(read_ladder(SHIPPED), Rung("claude-opus-5-5", "medium"))
|
||||
|
||||
@@ -49,6 +57,100 @@ class SetupVersion(unittest.TestCase):
|
||||
self.assertEqual(cycle_start.setup_version(pathlib.Path("/r"), fake_git), "unknown: fatal: bad HEAD hint: repair it")
|
||||
|
||||
|
||||
class ProjectRouting(unittest.TestCase):
|
||||
def setUp(self):
|
||||
temp = tempfile.TemporaryDirectory()
|
||||
self.addCleanup(temp.cleanup)
|
||||
self.home = pathlib.Path(temp.name)
|
||||
self.paths = paths_from(self.home)
|
||||
self.checkout = self.home / "code" / "acme"
|
||||
self.checkout.mkdir(parents=True)
|
||||
self.config = configured(self, self.checkout, home=self.home)
|
||||
self.paths.models_file.parent.mkdir(exist_ok=True)
|
||||
|
||||
def routing(self, fake=None, env=None):
|
||||
return cycle_start.project_routing(a_loop((fake or FakeEffects()).effects(), root=str(self.checkout), paths=self.paths, env=env or {}), "a-driver")
|
||||
|
||||
def test_routes_on_the_projects_saved_model_and_names_the_shipped_ladder_or_the_projects_own_as_its_file(self):
|
||||
self.paths.models_file.write_text(json.dumps({"acme": "claude-opus-5-5"}))
|
||||
shipped = read_ladder(SHIPPED)
|
||||
self.assertEqual(self.routing(), cycle_start.Routing(Models("claude-opus-5-5", "claude-opus-5-5"), shipped, SHIPPED))
|
||||
self.assertEqual(self.routing(env={"LOOP_CLAUDE_JUDGE_MODEL": "j"}), cycle_start.Routing(Models("j", "claude-opus-5-5"), shipped, SHIPPED))
|
||||
own = self.config / "routing-ladder.json"
|
||||
own.write_text('[{"model": "claude-fable-5-2", "effort": "low"}]', encoding="utf-8")
|
||||
routing = self.routing()
|
||||
assert isinstance(routing, cycle_start.Routing)
|
||||
self.assertEqual((routing.ladder_file, [str(rung) for rung in routing.ladder.rungs]), (own, ["claude-fable-5-2 at low effort"]))
|
||||
|
||||
def test_stops_with_exit_1_naming_the_ladder_file_that_cannot_be_read(self):
|
||||
self.paths.models_file.write_text(json.dumps({"acme": "claude-opus-5-5"}))
|
||||
own = self.config / "routing-ladder.json"
|
||||
own.write_text("not json", encoding="utf-8")
|
||||
stop = self.routing()
|
||||
assert isinstance(stop, Stop)
|
||||
self.assertEqual(stop.code, 1)
|
||||
self.assertIn(str(own), stop.reason)
|
||||
|
||||
def test_stops_with_exit_1_naming_the_config_that_cannot_be_read(self):
|
||||
self.paths.models_file.write_text(json.dumps({"acme": "claude-opus-5-5"}))
|
||||
(self.config / "config.toml").write_text("not toml", encoding="utf-8")
|
||||
stop = self.routing()
|
||||
assert isinstance(stop, Stop)
|
||||
self.assertEqual(stop.code, 1)
|
||||
self.assertIn(str(self.config / "config.toml"), stop.reason)
|
||||
|
||||
def test_asks_for_the_model_where_none_is_saved_and_off_a_terminal_stops_naming_the_driver_to_rerun(self):
|
||||
stop = self.routing(FakeEffects(on_terminal=False))
|
||||
assert isinstance(stop, Stop)
|
||||
self.assertEqual(stop.code, 2)
|
||||
self.assertIn("pick acme's model", stop.reason)
|
||||
self.assertIn("rerun a-driver on a terminal", stop.reason)
|
||||
with contextlib.redirect_stderr(io.StringIO()):
|
||||
self.assertEqual(self.routing(FakeEffects(inputs=["claude-opus-5-5"])), cycle_start.Routing(Models("claude-opus-5-5", "claude-opus-5-5"), read_ladder(SHIPPED), SHIPPED))
|
||||
|
||||
|
||||
class CycleStart(unittest.TestCase):
|
||||
ROUTING = cycle_start.Routing(Models("judge-model", "claude-opus-5-5"), OPUS_PROJECT.ladder, SHIPPED)
|
||||
|
||||
def test_announces_the_route_the_chunks_run_holds_and_else_the_one_its_archive_last_names(self):
|
||||
def never():
|
||||
raise AssertionError("not asked")
|
||||
|
||||
kept = Route(Rung("claude-opus-5-5", "xhigh"), 3, 4, 5)
|
||||
with tempfile.TemporaryDirectory() as home:
|
||||
opened = session.session_named("A proj a-driver", pathlib.Path(home, "projects"))
|
||||
loop = a_loop(FakeEffects().effects(), session=opened)
|
||||
archive = pathlib.Path(home, "archive")
|
||||
with contextlib.redirect_stdout(io.StringIO()) as said:
|
||||
self.assertEqual(cycle_start.announced_route(4, kept, self.ROUTING, archive, never, loop), kept)
|
||||
self.assertEqual(said.getvalue(), f"\n{STAMP} === cycle 4, worker on claude-opus-5-5 at xhigh effort ===\n")
|
||||
transcript = pathlib.Path(home, "projects", "-fake", f"{opened.id}.jsonl")
|
||||
transcript.parent.mkdir(parents=True)
|
||||
transcript.write_text(json.dumps({"type": "queue-operation", "timestamp": "1"}) + "\n")
|
||||
with contextlib.redirect_stderr(io.StringIO()):
|
||||
self.assertIsNone(write.archive(archive, str(transcript), "Do it.", outcomes.unfinished(kept.worker_line(), "working", "j", ""), NOW, replace=replace_file))
|
||||
with contextlib.redirect_stdout(io.StringIO()):
|
||||
self.assertEqual(cycle_start.announced_route(1, None, self.ROUTING, archive, never, loop), kept)
|
||||
|
||||
def test_builds_the_cycle_from_the_loop_the_routing_and_what_the_entry_point_knows(self):
|
||||
asked = []
|
||||
|
||||
def git(*args, cwd=None):
|
||||
asked.append(cwd)
|
||||
return "v0.1.0\n" if args[0] == "describe" else "abc\n"
|
||||
|
||||
effects = dataclasses.replace(FakeEffects().effects(), git=git)
|
||||
loop, route, archive = a_loop(effects), Route(Rung("claude-opus-5-5", "xhigh"), 3, 4, 5), pathlib.Path("/t/r")
|
||||
prompts = WorkerPrompts("a-driver", lambda *args: "fresh", lambda *args: "resumed", lambda *args: "", "the sources", "the destinations", "the records named")
|
||||
def taken_in(entries):
|
||||
return TakenIn()
|
||||
|
||||
cycle = cycle_start.cycle_of(loop, self.ROUTING, route, archive, task="the task", facts="the facts", premises="the premises", records="the records", unfinished_evidence="the evidence", prompts=prompts, taken_in=taken_in)
|
||||
self.assertEqual(cycle, Cycle(config="v0.1.0 (abc)", effects=effects, facts="the facts", judge=Rung("judge-model"), premises="the premises", project=OPUS_PROJECT, project_archive=archive, records="the records", root="/r",
|
||||
route=route, session=loop.session, task="the task", prompts=prompts, taken_in=taken_in, unfinished_evidence="the evidence", window=loop.window))
|
||||
self.assertEqual(asked, ["/h/.claude", "/h/.claude"])
|
||||
|
||||
|
||||
class Routes(unittest.TestCase):
|
||||
OPUS = Rung("claude-opus-5-5", "medium")
|
||||
SONNET = Rung("claude-sonnet-5-5", "high")
|
||||
|
||||
@@ -268,7 +268,6 @@ def chunk_run(key: str, epic: EpicRun) -> Stop:
|
||||
if isinstance(cycle, EpicReopened):
|
||||
say(f"the epic {epic.key} holds an open issue again, so its finishing chunk ends until none is open", epic.effects, stdout=True)
|
||||
return handed_on(key, epic)
|
||||
run = dataclasses.replace(run, task=cycle.task)
|
||||
concluded = run_cycle(cycle)
|
||||
if isinstance(concluded, Stop):
|
||||
return concluded
|
||||
|
||||
@@ -193,7 +193,7 @@ class ACycleOfAChunkWithoutARepo(DoEpicTest):
|
||||
self.assertEqual(code, 1)
|
||||
self.assertRegex(err, f"could not make the chunk's folder {self.home}/.local/state/do-epic/ABC-12: \\w")
|
||||
|
||||
def cycle(self, env: dict[str, str] | None = None) -> main.Cycle:
|
||||
def cycle(self, env: dict[str, str] | None = None, run: ChunkRun = ChunkRun(1)) -> main.Cycle:
|
||||
fake = FakeEffects(git=[Failure("no git"), Failure("no git")])
|
||||
paths = paths_from(self.home)
|
||||
epic = self.epic_run(fake, env)
|
||||
@@ -203,7 +203,7 @@ class ACycleOfAChunkWithoutARepo(DoEpicTest):
|
||||
self.assertIsNone(main.folder_made(root))
|
||||
loop = Loop(root=root, session=main.session_named("A ABC-12 do-epic ABC-21", paths.claude_code_transcripts), window=tmux.Window("epic-ABC-12", "ABC-21", "%1"), paths=paths, env=env or {}, launcher=pathlib.Path("/b/do-epic"), effects=fake.effects())
|
||||
with contextlib.redirect_stdout(io.StringIO()):
|
||||
found = main.next_cycle(ChunkRun(1), loop, repo is not None, epic)
|
||||
found = main.next_cycle(run, loop, repo is not None, epic)
|
||||
assert isinstance(found, main.Cycle), found
|
||||
return found
|
||||
|
||||
@@ -216,6 +216,16 @@ class ACycleOfAChunkWithoutARepo(DoEpicTest):
|
||||
self.assertEqual(self.cycle({"LOOP_CLAUDE_WORKER_MODEL": "off-the-ladder"}).route, Route(Rung("off-the-ladder")))
|
||||
self.assertEqual(self.cycle({"LOOP_CLAUDE_JUDGE_MODEL": "claude-fable-5-2"}).judge.model, "claude-fable-5-2")
|
||||
|
||||
def test_keeps_the_route_and_the_evidence_its_run_holds(self) -> None:
|
||||
kept = Route(Rung("claude-opus-5-5", "xhigh"), 21, 3, 5)
|
||||
cycle = self.cycle(run=ChunkRun(2, unfinished_evidence="the evidence", route=kept))
|
||||
self.assertEqual((cycle.route, cycle.unfinished_evidence), (kept, "the evidence"))
|
||||
|
||||
def test_a_chunk_that_was_not_parked_starts_on_the_drivers_own_prompts_with_no_facts(self) -> None:
|
||||
cycle = self.cycle()
|
||||
self.assertIs(cycle.prompts, chunk_prompt.WORKER)
|
||||
self.assertEqual(cycle.facts, "")
|
||||
|
||||
def test_works_in_the_epics_folder_and_archives_apart_from_loop_claude(self) -> None:
|
||||
cycle = self.cycle()
|
||||
self.assertEqual((cycle.root, cycle.project_archive, cycle.records), (str(self.home / ".local/state/do-epic/ABC-12"), self.home / ".claude/do-epic-transcripts/ABC-12", ""))
|
||||
@@ -392,6 +402,14 @@ class AChunksRun(DoEpicTest):
|
||||
self.assertEqual(code, 2, out)
|
||||
self.assertIn("the judge ruled it unfinished 6 cycles running; finish the chunk yourself, or rerun do-epic to give it 6 more cycles", err + out)
|
||||
|
||||
def test_every_archived_transcript_opens_with_the_chunks_task_through_step_ups_and_the_stop_for_the_human(self) -> None:
|
||||
fake = FakeEffects(streams=[self.worker()] * 6, claude=[judged("unfinished", escalation="working")] + [judged("unfinished")] * 5, git=UNREAD)
|
||||
code, out, _ = self.run_main(["--chunk", "ABC-21", "ABC-12"], fake, MODELS)
|
||||
self.assertEqual(code, 2, out)
|
||||
outcomes = [path.read_text(encoding="utf-8") for path in (self.home / ".claude/do-epic-transcripts/ABC-12").glob("*/*.outcomes.md")]
|
||||
self.assertTrue(any("Z Stepped up\n" in text for text in outcomes) and any("Z Stopped: " in text for text in outcomes), outcomes)
|
||||
self.assertEqual([text for text in outcomes if not text.startswith("Task: Work the Jira issue ABC-21 of the epic ABC-12 as one chunk")], [])
|
||||
|
||||
def test_a_finished_chunk_moves_its_issue_to_done_before_the_chunk_it_blocks_starts(self) -> None:
|
||||
store = MemoryEpic("ABC-12", [self.issues[0], self.issues[1], issue("ABC-22", "do-epic-claude", blockers=("ABC-21",))])
|
||||
self.backend = lambda config, key: (store, EpicRecord(Description(self.description))) # type: ignore[method-assign,arg-type]
|
||||
@@ -507,6 +525,13 @@ class AChunksRun(DoEpicTest):
|
||||
self.assertEqual(code, 0, err)
|
||||
self.assertIn("=== cycle 1, worker on claude-fable-5-2 at low effort ===\n", out)
|
||||
|
||||
def test_a_chunk_in_a_repo_without_a_saved_model_stops_off_a_terminal_naming_do_epic_as_what_to_rerun(self) -> None:
|
||||
self.repo_chunk()
|
||||
code, out, err = self.run_main(["--chunk", "ABC-20", "ABC-12"], FakeEffects(git=UNREAD, on_terminal=False), {"TMUX_PANE": "%1"})
|
||||
self.assertEqual((code, out), (2, ""))
|
||||
self.assertIn("pick api's model", err)
|
||||
self.assertIn("rerun do-epic on a terminal", err)
|
||||
|
||||
def test_a_chunk_in_a_repo_stops_where_the_repos_ladder_or_records_cannot_be_read(self) -> None:
|
||||
folder = self.repo_chunk()
|
||||
(folder / "routing-ladder.json").write_text("[", encoding="utf-8")
|
||||
|
||||
@@ -296,6 +296,10 @@ class StartingAnEpicsChunks(unittest.TestCase):
|
||||
self.assertTrue((self.home / ".local/state/loop-claude/api/starting").is_file())
|
||||
self.assertTrue((self.home / ".local/state/do-epic/ABC-12/starting").is_file())
|
||||
|
||||
def test_a_parked_chunk_resumes_under_the_starting_lock_of_its_repos_checkout(self) -> None:
|
||||
self.assertIsNone(self.resumed(self.epic(1, api=1), Tmux(("epic-ABC-12", "ABC-20 awaits an approval", False, ""))))
|
||||
self.assertEqual([lock.parent.name for lock in (self.home / ".local/state/loop-claude").glob("*/starting")], ["api"])
|
||||
|
||||
def test_the_waits_keep_the_trackers_rank_order(self) -> None:
|
||||
run = Tmux(("epic-ABC-12", "ABC-20", True, str(self.home / "code/api")), ("epic-ABC-12", "ABC-22", False, str(self.home / "code/api")))
|
||||
found = self.start(self.epic(1, api=1), [issue("ABC-20", "repo:api"), issue("ABC-21"), issue("ABC-22", "repo:api")], run, own="ABC-22")
|
||||
|
||||
@@ -34,8 +34,14 @@ class ThePullRequestAsViewed(unittest.TestCase):
|
||||
printed = json.dumps(PULL | {"reviews": [ASKED, pending], "comments": [{"author": {"login": "me"}, "createdAt": "2026-11-02T11:00:00Z"}, {"author": {"login": "rev"}, "createdAt": "2026-11-02T12:00:00Z"}]})
|
||||
self.assertEqual(reviews.pull_view(printed), PullView(False, CHANGES_REQUESTED, (Review("rev", CHANGES_REQUESTED, "2026-11-02T10:00:00Z", "abc"), Review("me", "PENDING", "", "")), ("", "2026-11-02T11:00:00Z")))
|
||||
|
||||
def test_keeps_each_comment_of_the_authors_whoever_commented_before_it(self):
|
||||
printed = json.dumps(PULL | {"comments": [{"author": {"login": "rev"}, "createdAt": "2026-11-02T12:00:00Z"}, {"author": {"login": "me"}, "createdAt": "2026-11-02T13:00:00Z"}]})
|
||||
viewed = reviews.pull_view(printed)
|
||||
assert isinstance(viewed, PullView)
|
||||
self.assertEqual(viewed.said, ("2026-11-02T13:00:00Z",))
|
||||
|
||||
def test_an_answer_in_another_shape_is_a_failure_naming_what_gh_printed(self):
|
||||
unshaped = ("not json", "[]", json.dumps(PULL | {"reviews": None}), json.dumps(PULL | {"author": None}), json.dumps(PULL | {"reviews": [ASKED | {"commit": None}]}), json.dumps(PULL | {"reviews": [ASKED | {"submittedAt": 7}]}), json.dumps(PULL | {"comments": [{"author": {"login": 7}, "createdAt": "2026-11-02T11:00:00Z"}]}), json.dumps(PULL | {"comments": [{"author": {"login": PULL["author"]["login"]}, "createdAt": None}]}), json.dumps(PULL | {"reviews": [{key: value for key, value in ASKED.items() if key != "submittedAt"}]}), json.dumps({key: value for key, value in PULL.items() if key != "isDraft"}))
|
||||
unshaped = ("not json", "x" * 300, "[]", json.dumps(PULL | {"reviews": [ASKED | {"author": {"login": 7}}]}), json.dumps(PULL | {"reviews": None}), json.dumps(PULL | {"author": None}), json.dumps(PULL | {"reviews": [ASKED | {"commit": None}]}), json.dumps(PULL | {"reviews": [ASKED | {"submittedAt": 7}]}), json.dumps(PULL | {"comments": [{"author": {"login": 7}, "createdAt": "2026-11-02T11:00:00Z"}]}), json.dumps(PULL | {"comments": [{"author": {"login": PULL["author"]["login"]}, "createdAt": None}]}), json.dumps(PULL | {"reviews": [{key: value for key, value in ASKED.items() if key != "submittedAt"}]}), json.dumps({key: value for key, value in PULL.items() if key != "isDraft"}))
|
||||
for printed in unshaped:
|
||||
with self.subTest(printed=printed):
|
||||
self.assertEqual(reviews.pull_view(printed), Failure(f"gh pr view printed no review decision: {printed[:200]}"))
|
||||
@@ -51,6 +57,7 @@ class WhetherTheWorkerAnswered(unittest.TestCase):
|
||||
self.assertTrue(reviews.answered(self.view(), "def"))
|
||||
self.assertTrue(reviews.answered(self.view(said=("2026-11-02T10:30:00Z",)), "abc"))
|
||||
self.assertFalse(reviews.answered(self.view(said=("2026-11-02T09:00:00Z", "")), "abc"))
|
||||
self.assertFalse(reviews.answered(self.view(said=("2026-11-02T10:00:00Z",)), "abc"), "a word at the review's own instant is not after it")
|
||||
self.assertTrue(reviews.answered(self.view(Review("me", "COMMENTED", "2026-11-02T10:30:00Z", "")), "abc"))
|
||||
self.assertFalse(reviews.answered(PullView(False, "", (), ()), "abc"))
|
||||
|
||||
@@ -78,7 +85,7 @@ class TheThreadsThatWait(unittest.TestCase):
|
||||
self.assertEqual(reviews.waiting_threads("7", lambda args: printed), ["a.py", "b.py"])
|
||||
|
||||
def test_an_answer_in_another_shape_is_a_failure_naming_what_gh_printed(self):
|
||||
for printed in ("not json", "{}", json.dumps({"data": {"repository": {"pullRequest": {"author": {"login": "me"}, "reviewThreads": {"nodes": [{"isResolved": False}]}}}}}), json.dumps({"data": {"repository": {"pullRequest": {"author": {"login": "me"}, "reviewThreads": {"nodes": [{"isResolved": False, "path": "a.py", "comments": {"nodes": [{"author": {"login": 7}}]}}]}}}}}), json.dumps({"data": {"repository": {"pullRequest": {"author": {"login": "me"}, "reviewThreads": {"nodes": [{"path": "a.py", "comments": {"nodes": []}}]}}}}})):
|
||||
for printed in ("not json", "x" * 300, "{}", json.dumps({"data": {"repository": {"pullRequest": {"author": {"login": 7}, "reviewThreads": {"nodes": []}}}}}), json.dumps({"data": {"repository": {"pullRequest": {"author": {"login": "me"}, "reviewThreads": {"nodes": [{"isResolved": False}]}}}}}), json.dumps({"data": {"repository": {"pullRequest": {"author": {"login": "me"}, "reviewThreads": {"nodes": [{"isResolved": False, "path": "a.py", "comments": {"nodes": [{"author": {"login": 7}}]}}]}}}}}), json.dumps({"data": {"repository": {"pullRequest": {"author": {"login": "me"}, "reviewThreads": {"nodes": [{"path": "a.py", "comments": {"nodes": []}}]}}}}})):
|
||||
with self.subTest(printed=printed):
|
||||
self.assertEqual(reviews.waiting_threads("7", lambda args: printed), Failure(f"gh api graphql printed no review threads: {printed[:200]}"))
|
||||
|
||||
@@ -96,6 +103,24 @@ class TheDecisionOnGitea(unittest.TestCase):
|
||||
self.assertEqual(self.decision({"title": "Fix it"}), "")
|
||||
self.assertEqual(self.decision({"title": 7}), Failure("tea api printed no title of pull request 7: {'title': 7}"))
|
||||
self.assertEqual(self.decision([]), Failure("tea api printed no title of pull request 7: []"))
|
||||
self.assertEqual(self.decision("y" * 300), Failure(f"tea api printed no title of pull request 7: {'y' * 200}"))
|
||||
|
||||
|
||||
class TheDecisionOnGitHub(unittest.TestCase):
|
||||
def test_reads_the_review_decision_and_empty_where_no_review_is_asked_for(self):
|
||||
asked = []
|
||||
self.assertEqual(reviews.github_decision("7", lambda args: asked.append(args) or '{"reviewDecision": "APPROVED"}'), "APPROVED")
|
||||
self.assertEqual(asked, [["gh", "pr", "view", "7", "--json", "reviewDecision"]])
|
||||
self.assertEqual(reviews.github_decision("7", printing({"reviewDecision": None})), "")
|
||||
self.assertEqual(reviews.github_decision("7", printing({"reviewDecision": ""})), "")
|
||||
|
||||
def test_an_answer_without_a_decision_is_a_failure_naming_the_first_200_characters_gh_printed(self):
|
||||
for printed in ("not json", "{}", "[]", " " + "x" * 300):
|
||||
with self.subTest(printed=printed):
|
||||
self.assertEqual(reviews.github_decision("7", lambda args: printed), Failure(f"gh pr view printed no review decision: {printed.strip()[:200]}"))
|
||||
|
||||
def test_a_command_that_fails_is_that_failure(self):
|
||||
self.assertEqual(reviews.github_decision("7", lambda args: Failure("gh cannot start")), Failure("gh cannot start"))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
||||
@@ -1,4 +1,5 @@
|
||||
import contextlib
|
||||
import os
|
||||
import pathlib
|
||||
import subprocess
|
||||
import sys
|
||||
@@ -35,6 +36,14 @@ class Git(unittest.TestCase):
|
||||
self.assertTrue(done.reason.startswith("git log could not start: "), done.reason)
|
||||
self.assertIn("/code/gone", done.reason)
|
||||
|
||||
def test_runs_git_in_the_environment_given_and_only_guarded_stops_the_fetch_of_missing_objects(self):
|
||||
shown = ("-c", "alias.shown=!echo \"$SHOWN_TO_GIT/$GIT_NO_LAZY_FETCH\"", "shown")
|
||||
given = {**{name: value for name, value in os.environ.items() if name != "GIT_NO_LAZY_FETCH"}, "SHOWN_TO_GIT": "given"}
|
||||
self.assertEqual(git_repo.git(*shown, env=given), "given/\n")
|
||||
self.assertEqual(git_repo.git(*shown, env=given, guarded=True), "given/1\n")
|
||||
self.assertNotIn("SHOWN_TO_GIT", os.environ)
|
||||
self.assertEqual(git_repo.git(*shown, guarded=True), "/1\n")
|
||||
|
||||
|
||||
class Guarded(unittest.TestCase):
|
||||
"""A checkout whose own config may name a program for git to run."""
|
||||
|
||||
@@ -5,6 +5,7 @@ import pathlib
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
import time
|
||||
import unittest
|
||||
|
||||
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
|
||||
@@ -134,11 +135,13 @@ class Main(unittest.TestCase):
|
||||
(chunk / f"t{n}.outcomes.md").write_text(f"Task: Do it.\n\n2026-10-14T10:00:0{n}Z {verdict}\n\nEvidence:\n> e\n")
|
||||
self.calls = []
|
||||
self.prompts = []
|
||||
self.schemas = []
|
||||
|
||||
def run_main(self, argv, reply):
|
||||
def claude(args, cwd, prompt):
|
||||
self.calls.append((args[args.index("--model") + 1], args[args.index("--effort") + 1], cwd))
|
||||
self.prompts.append(prompt)
|
||||
self.schemas.append(args[args.index("--json-schema") + 1])
|
||||
result = reply(Rung(args[args.index("--model") + 1], args[args.index("--effort") + 1]), "said Verdict: interrupt" in prompt.rsplit("latest last:", 1)[-1])
|
||||
return subprocess.CompletedProcess(args, 0, json.dumps(result), "")
|
||||
|
||||
@@ -224,6 +227,48 @@ class Main(unittest.TestCase):
|
||||
runs = [json.loads(path.read_text(encoding="utf-8").splitlines()[0]) for path in folder.glob("*.jsonl")]
|
||||
self.assertEqual({run["prompt"] for run in runs}, set(self.prompts))
|
||||
|
||||
def test_says_where_it_could_not_keep_a_run_and_still_prints_the_report(self):
|
||||
replays = self.home / ".claude" / "loop-claude-transcripts" / "replays"
|
||||
replays.write_text("")
|
||||
code, out, err = self.run_main(["claude-opus-5-5"], lambda rung, interrupted: self.verdict(interrupted, f"said {INTERRUPTED if interrupted else FINISHED}"))
|
||||
self.assertEqual(code, 0, err)
|
||||
self.assertIn(f"could not keep the run in {replays}/judge-replay-claude-opus-5-5-20260921T141320Z: ", err)
|
||||
self.assertIn("The reference judge, claude-opus-5-5 at xhigh effort, reproduced 2.", out)
|
||||
|
||||
def test_says_how_many_verdicts_it_replays_on_each_rung(self):
|
||||
code, _, err = self.run_main(["claude-opus-5-5"], lambda rung, interrupted: self.verdict(interrupted, f"said {INTERRUPTED if interrupted else FINISHED}"))
|
||||
self.assertEqual(code, 0, err)
|
||||
self.assertEqual(err.splitlines()[:2], ["replaying 2 verdicts on claude-opus-5-5 at xhigh effort", "replaying 2 verdicts on claude-fable-5-2 at low effort"])
|
||||
|
||||
def test_replays_four_verdicts_at_once(self):
|
||||
chunk = self.home / ".claude" / "loop-claude-transcripts" / "proj" / "c1"
|
||||
for n in range(2, 8):
|
||||
(chunk / f"t{n}.jsonl").write_text(json.dumps({"type": "assistant", "message": {"content": [{"type": "text", "text": f"said {FINISHED} {n}"}]}}) + "\n")
|
||||
(chunk / f"t{n}.outcomes.md").write_text(f"Task: Do it.\n\n2026-10-14T10:00:0{n}Z {FINISHED}\n\nEvidence:\n> e\n")
|
||||
running, most = [], []
|
||||
|
||||
def reply(rung, interrupted):
|
||||
running.append(rung)
|
||||
most.append(len(running))
|
||||
time.sleep(0.05)
|
||||
running.remove(rung)
|
||||
return self.verdict(interrupted, f"said {INTERRUPTED if interrupted else FINISHED}")
|
||||
|
||||
code, _, err = self.run_main(["claude-opus-5-5"], reply)
|
||||
self.assertEqual(code, 0, err)
|
||||
self.assertIn("replaying 8 verdicts on ", err)
|
||||
self.assertEqual(max(most), 4)
|
||||
|
||||
def test_the_prompt_and_the_reply_schema_of_a_rebuilt_run_name_loop_claude_and_the_records_and_show_the_transcript_once(self):
|
||||
code, _, err = self.run_main(["claude-opus-5-5"], lambda rung, interrupted: self.verdict(interrupted, f"said {INTERRUPTED if interrupted else FINISHED}"))
|
||||
self.assertEqual(code, 0, err)
|
||||
for prompt, schema in zip(self.prompts, self.schemas, strict=True):
|
||||
self.assertIn("\n\nThe records: the project's working rules and decisions, then the human's rules for every project:\n", prompt)
|
||||
self.assertIn("what loop-claude told it on [loop] lines, latest last:\n", prompt)
|
||||
self.assertEqual(prompt.count("said Verdict: "), 1)
|
||||
self.assertIn("loop-claude", schema)
|
||||
self.assertNotIn("None", schema)
|
||||
|
||||
def test_hands_the_judge_the_prompt_the_archive_kept_and_rebuilds_the_prompt_of_a_verdict_with_none(self):
|
||||
kept = self.home / ".claude" / "loop-claude-transcripts" / "proj" / "c1"
|
||||
prompt = "From the goals file, OLD premises\n\nThe records: none\n\nThe task the worker was given:\nDo it.\n\nWhat the worker did and said, what the human typed on [human] lines and what loop-claude told it on [loop] lines, latest last:\nsaid Verdict: finished\n\nOLD rules"
|
||||
@@ -235,6 +280,8 @@ class Main(unittest.TestCase):
|
||||
self.assertIn("The reference judge, claude-opus-5-5 at xhigh effort, reproduced 2.", out)
|
||||
# The first replay, on the finished verdict, reads the archived prompt; the second, on the interrupt, is rebuilt from the records of today.
|
||||
self.assertEqual(self.prompts[0], prompt)
|
||||
# The reply's schema names loop-claude to the judge of either prompt.
|
||||
self.assertEqual([schema for schema in self.schemas if "loop-claude" not in schema or "None" in schema], [])
|
||||
self.assertEqual(self.calls[0][2], self.calls[1][2])
|
||||
self.assertTrue(self.calls[0][2].endswith("/code/proj"))
|
||||
self.assertIn("The task the worker was given:\nDo it.", self.prompts[1])
|
||||
|
||||
@@ -177,6 +177,51 @@ class WindowStarts(unittest.TestCase):
|
||||
self.assertEqual(cycles, [(main.LoopRun(1, "/r", "do it", "", chunk="item-3"), loop), (main.LoopRun(2, "/r", "do it", "", chunk="item-3"), loop)])
|
||||
self.assertEqual(started, [(main.LoopRun(2, "/r", "do it", "", chunk="item-3"), True, loop.paths, env, launcher, effects)])
|
||||
|
||||
def window_loop(self, cycles, env, **doubles):
|
||||
"""run_loop's stop for item-3's window loop, and each step it took with what it handed that step. Each step answers as its double in `doubles` does, else as a cycle without a stop: next_cycle answers the next of `cycles`, run_cycle an unfinished verdict, and closed_cycle the run with one more unfinished verdict."""
|
||||
fake, calls, cycles = FakeEffects(git=["/r\n"]), [], list(cycles)
|
||||
effects, launcher, home = fake.effects(), pathlib.Path("/b/loop-claude"), paths.paths_from(self.HOME)
|
||||
self.unfinished = unittest.mock.Mock(verdict=unittest.mock.Mock(spec=Unfinished))
|
||||
answers = {"fingerprint": lambda *args: "print-1", "exec_if_edited": lambda *args: None, "next_cycle": lambda *args: cycles.pop(0), "run_cycle": lambda *args: self.unfinished,
|
||||
"closed_cycle": lambda run, *args: dataclasses.replace(run, unfinished_run=run.unfinished_run + 1), "check_routing": lambda *args: None, **doubles}
|
||||
|
||||
def step(name):
|
||||
return lambda *args: calls.append((name, *args)) or answers[name](*args)
|
||||
|
||||
stop = main.run_loop(["--chunk", "item-3", "do it"], env, home, launcher, CWD, effects, steps(lambda *args: self.fail(args), **{name: step(name) for name in answers}))
|
||||
self.loop = this_loop.Loop(root="/r", session=session.session_named("A r loop-claude item-3", self.HOME / ".claude" / "projects"), window=tmux.Window("loop-r", "item-3", "%4"), paths=home, env=env, launcher=launcher, effects=effects)
|
||||
return stop, calls
|
||||
|
||||
def test_a_window_loop_hands_each_step_of_a_cycle_what_the_steps_before_it_made(self):
|
||||
env = {"TMUX_PANE": "%4", "LOOP_CLAUDE_TRANSCRIPTS": "/t"}
|
||||
on_ladder = unittest.mock.Mock(project=OPUS_PROJECT, project_archive=pathlib.Path("/t/r"))
|
||||
off_ladder = unittest.mock.Mock(project=None, project_archive=pathlib.Path("/t/r"), route=unittest.mock.Mock(rung=Rung("my-model")))
|
||||
stop, calls = self.window_loop([on_ladder, off_ladder, Stop(2, "the human is needed")], env)
|
||||
self.assertEqual(stop, Stop(2, "the human is needed"))
|
||||
before, first, second, third = (main.LoopRun(number, "/r", "do it", "", unfinished_run=max(number - 1, 0), chunk="item-3") for number in range(4))
|
||||
self.assertEqual(calls, [
|
||||
("fingerprint", pathlib.Path("/b/loop-claude")),
|
||||
("exec_if_edited", self.loop, "print-1", before),
|
||||
("next_cycle", first, self.loop),
|
||||
("run_cycle", on_ladder),
|
||||
("closed_cycle", first, OPUS_PROJECT, self.unfinished, pathlib.Path("/t/r"), "loop-claude", self.loop),
|
||||
("check_routing", pathlib.Path("/t"), Rung("claude-opus-5-5", "medium"), self.loop),
|
||||
("exec_if_edited", self.loop, "print-1", dataclasses.replace(first, unfinished_run=1)),
|
||||
("next_cycle", second, self.loop),
|
||||
("run_cycle", off_ladder),
|
||||
("closed_cycle", second, None, self.unfinished, pathlib.Path("/t/r"), "loop-claude", self.loop),
|
||||
("check_routing", pathlib.Path("/t"), Rung("my-model"), self.loop),
|
||||
("exec_if_edited", self.loop, "print-1", dataclasses.replace(second, unfinished_run=2)),
|
||||
("next_cycle", third, self.loop),
|
||||
])
|
||||
|
||||
def test_a_window_loop_stops_with_the_stop_of_the_step_that_made_one(self):
|
||||
cycle = unittest.mock.Mock(project=OPUS_PROJECT, project_archive=pathlib.Path("/t/r"))
|
||||
for name, taken in (("exec_if_edited", 2), ("run_cycle", 4), ("closed_cycle", 5), ("check_routing", 6)):
|
||||
with self.subTest(step=name):
|
||||
stop, calls = self.window_loop([cycle], {"TMUX_PANE": "%4"}, **{name: lambda *args: Stop(1, f"{name} stopped")})
|
||||
self.assertEqual((stop, len(calls), calls[-1][0]), (Stop(1, f"{name} stopped"), taken, name))
|
||||
|
||||
def test_a_window_loop_given_no_task_prints_the_help(self):
|
||||
self.assertEqual(main.loop_run_from(["--chunk", "item-3"], CWD, FakeEffects(git=["/r\n"]).effects()), Stop(1, usage.HELP))
|
||||
|
||||
|
||||
@@ -119,6 +119,18 @@ class TmuxEffect(unittest.TestCase):
|
||||
pathlib.Path(folder, "tmux").write_text(f"#!{sys.executable}\nimport sys\nsys.stdout.buffer.write(b'caf\\xe9')\n")
|
||||
self.assertEqual(effects.tmux(["list-windows"]).stdout, "caf\ufffd")
|
||||
|
||||
def test_runs_tmux_without_this_processs_input(self):
|
||||
with tempfile.TemporaryDirectory() as folder:
|
||||
effects = self.fake_tmux(folder)
|
||||
pathlib.Path(folder, "tmux").write_text(f"#!{sys.executable}\nimport sys\nprint(repr(sys.stdin.read()))\n")
|
||||
pathlib.Path(folder, "typed").write_text("what the human types\n")
|
||||
kept = os.dup(0)
|
||||
self.addCleanup(os.close, kept)
|
||||
self.addCleanup(os.dup2, kept, 0)
|
||||
with open(pathlib.Path(folder, "typed")) as typed:
|
||||
os.dup2(typed.fileno(), 0)
|
||||
self.assertEqual(effects.tmux(["list-windows"]).stdout, "''\n")
|
||||
|
||||
def test_reads_a_tmux_that_cannot_start_as_exit_127(self):
|
||||
with tempfile.TemporaryDirectory() as folder:
|
||||
done = system_effects(pathlib.Path.home(), os.environ | {"PATH": folder}).tmux(["-V"])
|
||||
|
||||
@@ -180,6 +180,11 @@ class JiraPlan(unittest.TestCase):
|
||||
self.assertIsInstance(failure, Failure)
|
||||
self.assertTrue(failure.reason.startswith("ABC-1 is not in the shape Jira Cloud's REST API version 3 documents: "), failure) # type: ignore[union-attr]
|
||||
|
||||
def test_an_issue_that_lacks_a_field_fails_the_read_naming_the_field(self) -> None:
|
||||
good = issue("ABC-1")
|
||||
lacking = good | {"fields": {name: value for name, value in good["fields"].items() if name != "fixVersions"}}
|
||||
self.assertEqual(self.read(lacking), Failure("ABC-1 is not in the shape Jira Cloud's REST API version 3 documents: KeyError('fixVersions')")) # type: ignore[arg-type]
|
||||
|
||||
def test_converts_every_description_in_one_run_and_none_for_an_issue_without_one(self):
|
||||
found = self.items(issue("ABC-1", description=adf("One.")), issue("ABC-2"), issue("ABC-3", description=adf("Three.")), issue("ABC-4", description=adf("Four.")))
|
||||
self.assertEqual([item.detail for item in found], ["One.", "", "Three.", "Four."])
|
||||
|
||||
@@ -9,6 +9,7 @@ import shutil
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
import time
|
||||
import unittest
|
||||
|
||||
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
|
||||
@@ -284,6 +285,43 @@ class Main(unittest.TestCase):
|
||||
self.assertEqual({run["prompt"] for run in runs if "--agent" in run["args"]}, {prompt for *_, prompt, _ in self.reviews})
|
||||
self.assertTrue(any("--json-schema" in run["args"] for run in runs))
|
||||
|
||||
def test_says_where_it_could_not_keep_a_run_and_still_prints_the_report(self):
|
||||
(self.archive / "replays").write_text("")
|
||||
code, out, err = self.run_main(["stability", "claude-opus-5-5"], lambda rung: {"found": [0, 1]})
|
||||
self.assertEqual(code, 0, err)
|
||||
self.assertIn(f"could not keep the run in {self.archive}/replays/review-replay-stability-claude-opus-5-5-20260921T141320Z: ", err)
|
||||
self.assertTrue(out.startswith("Replayed 1 stability rounds"), out)
|
||||
|
||||
def test_makes_each_clone_in_the_scratch_folder_under_a_name_that_says_whose_it_is(self):
|
||||
scratch = pathlib.Path(self.enterContext(tempfile.TemporaryDirectory()))
|
||||
self.limits["scratch"] = scratch
|
||||
for argv, replays in ((["stability", "claude-opus-5-5"], 4), (["stability", "claude-opus-5-5", "--omit-claude-md"], 4)):
|
||||
with self.subTest(argv=argv):
|
||||
self.reviews.clear()
|
||||
code, _, err = self.run_main(argv, lambda rung: {"found": [0, 1]})
|
||||
self.assertEqual(code, 0, err)
|
||||
clones = [pathlib.Path(cwd) for *_, cwd in self.reviews]
|
||||
self.assertEqual(([clone.parent for clone in clones], [clone.name[:14] for clone in clones]), ([scratch] * replays, ["review-replay-"] * replays))
|
||||
self.assertEqual(list(scratch.iterdir()), [], "each clone is removed")
|
||||
|
||||
def test_replays_no_more_rounds_at_once_than_asked_on_any_rung(self):
|
||||
self.write_chunk("proj", "c2", "2026-10-14T10:30:00Z")
|
||||
self.limits["at_once"] = 1
|
||||
for argv, rungs in ((["stability", "claude-opus-5-5"], {REFERENCE, Rung("claude-opus-5-5", "low"), Rung("claude-sonnet-5-5", "high")}), (["stability", "claude-opus-5-5", "--omit-claude-md"], {REFERENCE})):
|
||||
with self.subTest(argv=argv):
|
||||
running, most = [], {}
|
||||
|
||||
def review(rung):
|
||||
running.append(rung)
|
||||
most[rung] = max(most.get(rung, 0), len(running))
|
||||
time.sleep(0.05)
|
||||
running.remove(rung)
|
||||
return {"type": "result", "result": f"review on {rung.model} {rung.effort}"}
|
||||
|
||||
code, _, err = self.run_main(argv, lambda rung: {"found": [0, 1]}, review=review)
|
||||
self.assertEqual(code, 0, err)
|
||||
self.assertEqual(most, dict.fromkeys(rungs, 1))
|
||||
|
||||
def test_without_claude_md_replays_each_round_three_times_with_it_and_once_without_on_the_project_rung(self):
|
||||
finds = iter(([0, 1], [0], [0, 1], [1]))
|
||||
code, out, err = self.run_main(["stability", "claude-opus-5-5", "--omit-claude-md"], lambda rung: {"found": next(finds)})
|
||||
|
||||
@@ -490,6 +490,14 @@ class Archive(unittest.TestCase):
|
||||
self.assertIsNone(state.mark_raised(self.root, [a], "2026-10-15T02:00:00Z", replace_file))
|
||||
self.assertEqual(state.raised(self.root), state.Raised("2026-10-15T01:00:00Z", frozenset({a})))
|
||||
|
||||
def test_adds_a_raised_call_after_the_files_text_less_only_the_newlines_that_end_it(self):
|
||||
call = Call("reports", ("Explore",))
|
||||
for ending in ("what the human wrote XX", "a line that breaks in markdown ", "a line that ends in a tab\t"):
|
||||
with self.subTest(ending=ending):
|
||||
(self.root / state.RAISED).write_text(f"# Routing calls raised\n\n{ending}\n\n\n")
|
||||
self.assertIsNone(state.mark_raised(self.root, [call], "2026-10-15T00:00:00Z", replace_file))
|
||||
self.assertEqual((self.root / state.RAISED).read_text(), f"# Routing calls raised\n\n{ending}\n\n- 2026-10-15T00:00:00Z {call.sentence()}\n")
|
||||
|
||||
def test_fails_when_it_cannot_keep_the_state(self):
|
||||
assert_not_root(self)
|
||||
self.root.chmod(0o555)
|
||||
|
||||
@@ -5,6 +5,7 @@ import pathlib
|
||||
import subprocess
|
||||
import sys
|
||||
import tempfile
|
||||
import time
|
||||
import unittest
|
||||
|
||||
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
|
||||
@@ -60,6 +61,21 @@ class Replayed(unittest.TestCase):
|
||||
self.assertNotIn(("b", high), asked)
|
||||
self.assertEqual(search(["a"], [MIDDLE], {REFERENCE: {"a": set()}}, [high]), (Replay([set()], [], None, []), [("a", REFERENCE)]))
|
||||
|
||||
def test_says_what_it_replays_on_each_rung_and_replays_no_more_cases_at_once_than_asked(self):
|
||||
high = Rung("claude-fable-5-2", "low")
|
||||
said, running, most = [], [], {}
|
||||
|
||||
def replay_one(case, rung):
|
||||
running.append(case)
|
||||
most[rung] = max(most.get(rung, 0), len(running))
|
||||
time.sleep(0.02)
|
||||
running.remove(case)
|
||||
return {0}
|
||||
|
||||
replayed(["a", "b", "c"], REFERENCE, [MIDDLE], replay_one, lambda _, reply: sorted(reply), "verdicts", said.append, 1, [high])
|
||||
self.assertEqual(said, [f"replaying 3 verdicts on {REFERENCE}", f"replaying 3 verdicts on {high}", f"replaying 3 verdicts on {MIDDLE}"])
|
||||
self.assertEqual(most, {REFERENCE: 1, high: 1, MIDDLE: 1})
|
||||
|
||||
def test_stops_at_a_usage_limit(self):
|
||||
limit = Limited(None, "limit")
|
||||
self.assertEqual(search(["a"], [MIDDLE], {REFERENCE: {"a": {0}}, MIDDLE: {"a": {0}}, CHEAP: limit}, [CHEAP])[0], limit)
|
||||
|
||||
@@ -1,4 +1,4 @@
|
||||
"""What the suites that compress a file share: compress, bound to what really compresses, writes and flushes."""
|
||||
"""What the suites that compress a file share: compress with gzip.compress, replace_file and os.fsync bound."""
|
||||
import functools
|
||||
import gzip
|
||||
import os
|
||||
|
||||
@@ -26,6 +26,19 @@ class Compress(unittest.TestCase):
|
||||
self.assertEqual(packed.read_bytes(), gzip.compress(b'{"a": 1}\n', mtime=0))
|
||||
self.assertEqual(packed.stat().st_mtime, 2000)
|
||||
|
||||
def test_asks_for_a_gzip_whose_header_holds_no_time_whatever_the_packer_would_write_unasked(self):
|
||||
with tempfile.TemporaryDirectory() as root:
|
||||
plain = pathlib.Path(root, "t.jsonl")
|
||||
plain.write_bytes(b"a\n")
|
||||
asked = []
|
||||
|
||||
def pack(data, **kwargs):
|
||||
asked.append(kwargs)
|
||||
return gzip.compress(data, **kwargs)
|
||||
|
||||
self.assertIsNone(compress(plain, pack=pack))
|
||||
self.assertEqual(asked, [{"mtime": 0}])
|
||||
|
||||
def test_syncs_the_gzip_and_its_folder_before_removing_the_file(self):
|
||||
with tempfile.TemporaryDirectory() as root:
|
||||
plain = pathlib.Path(root, "t.jsonl")
|
||||
|
||||
Reference in New Issue
Block a user