199 lines
10 KiB
Python
199 lines
10 KiB
Python
import dataclasses
|
|
import pathlib
|
|
import shutil
|
|
import sys
|
|
import unittest
|
|
|
|
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
|
|
|
|
from project_config.doubles import configured
|
|
from do_epic.test_main import DESCRIPTION, Description, DoEpicTest, MODELS, UNREAD
|
|
from do_epic.epic_record import EpicRecord
|
|
from failure import Failure
|
|
from loop_effects.doubles import FakeEffects
|
|
from do_epic.human_tasks import holds_up
|
|
from do_epic.scheduler import HUMAN_WAIT
|
|
from do_epic.test_scheduler import issue
|
|
from do_epic.backend.fake import MemoryEpic
|
|
|
|
# The window of ABC-19, a human's task that blocks ABC-21.
|
|
WINDOW = "ABC-19\t0\t@9\n"
|
|
|
|
|
|
class AHumanTaskThatBlocksAnIssue(DoEpicTest):
|
|
def setUp(self) -> None:
|
|
super().setUp()
|
|
self.issues = [issue("ABC-19", "do-epic-human"), issue("ABC-21", "repo:api", blockers=("ABC-19",))]
|
|
self.issues[0] = dataclasses.replace(self.issues[0], summary="Order the test certificate")
|
|
self.epic = MemoryEpic("ABC-12", self.issues)
|
|
self.backend = lambda config, key: (self.epic, EpicRecord(Description(self.description))) # type: ignore[method-assign, arg-type]
|
|
self.api = self.repo("api", notifier=True)
|
|
|
|
def repo(self, name: str, notifier: bool) -> pathlib.Path:
|
|
"""Makes the checkout of the repo called name that a project config names, with a notifier where notifier."""
|
|
checkout = self.home / "code" / name
|
|
folder = configured(self, checkout, home=self.home)
|
|
if notifier:
|
|
with (folder / "config.toml").open("a") as config:
|
|
config.write('env-file = "~/.claude-projects/notifier.env"\nnotifier = "slack"\n')
|
|
return checkout
|
|
|
|
def awaited(self, fake: FakeEffects, closes_after: int) -> tuple[int, str, str]:
|
|
"""The window's run, where the human closes the task once the window has slept closes_after times."""
|
|
slept: list[int] = []
|
|
|
|
def sleep(seconds: int) -> None:
|
|
slept.append(seconds)
|
|
if len(slept) == closes_after:
|
|
self.epic.change("ABC-19", done=True, status="Done")
|
|
fake.effects = lambda made=fake.effects(): dataclasses.replace(made, sleep=sleep) # type: ignore[method-assign]
|
|
self.slept = slept
|
|
return self.run_main(["--chunk", "ABC-19", "ABC-12"], fake, MODELS)
|
|
|
|
def moved_to_an_unblocking_status(self, switch: str, frees: tuple[str, dict[str, object]] = ("ABC-19", {"status": "Release Ready"}), starts: str = "ABC-21") -> bool:
|
|
"""Whether Jira counts the task done after its window's run, where the config ends with switch. frees is the change in Jira that ends the wait: by default the human moves the task to an unblocking status. starts is what the window then starts."""
|
|
with (self.home / ".claude-projects" / "do-epic" / "config.toml").open("a") as config:
|
|
config.write('jira-unblocking-statuses = ["Release Ready"]\n' + switch)
|
|
fake = FakeEffects(git=UNREAD, windows=WINDOW)
|
|
slept: list[int] = []
|
|
|
|
def sleep(seconds: int) -> None:
|
|
slept.append(seconds)
|
|
self.assertLess(len(slept), 5, "the window still waits")
|
|
if len(slept) == 2:
|
|
self.epic.change(frees[0], **frees[1])
|
|
fake.effects = lambda made=fake.effects(): dataclasses.replace(made, sleep=sleep) # type: ignore[method-assign]
|
|
code, out, err = self.run_main(["--chunk", "ABC-19", "ABC-12"], fake, MODELS)
|
|
self.assertEqual((code, err, slept), (0, "", [60, 60]))
|
|
self.assertIn(f"the chunk finished; started {starts}\n", out)
|
|
return next(each.done for each in self.epic.issues if each.key == "ABC-19")
|
|
|
|
def test_a_task_the_human_moves_to_an_unblocking_status_no_longer_holds_up_an_issue_and_moves_to_done(self) -> None:
|
|
self.assertTrue(self.moved_to_an_unblocking_status(""))
|
|
|
|
def test_where_the_teams_automation_moves_issues_the_humans_task_stays_where_the_human_moved_it(self) -> None:
|
|
self.assertFalse(self.moved_to_an_unblocking_status("jira-automation-moves-issues = true\n"))
|
|
|
|
def test_where_the_teams_automation_moves_issues_a_task_that_blocks_no_open_issue_any_more_ends_its_window_unmoved(self) -> None:
|
|
self.assertFalse(self.moved_to_an_unblocking_status("jira-automation-moves-issues = true\n", ("ABC-21", {"done": True}), starts="no other"))
|
|
|
|
def test_a_task_holds_up_only_the_issues_no_unblocking_status_settles(self) -> None:
|
|
issues = [issue("ABC-19", "do-epic-human"), issue("ABC-20", "do-epic-claude", blockers=("ABC-19",), status="Release Ready"), issue("ABC-21", "do-epic-claude", blockers=("ABC-19",))]
|
|
self.assertEqual(holds_up("ABC-19", issues, {}, ("Release Ready",)), ["ABC-21"])
|
|
|
|
def test_dms_the_human_once_parks_its_window_and_polls_until_the_issue_closes_then_starts_the_next(self) -> None:
|
|
fake = FakeEffects(git=UNREAD, windows=WINDOW)
|
|
code, out, err = self.awaited(fake, closes_after=3)
|
|
self.assertEqual((code, err), (0, ""))
|
|
self.assertEqual(self.slept, [60, 60, 60])
|
|
self.assertEqual(len(fake.dms), 1)
|
|
for fact in ("ABC-12", "ABC-19", "Order the test certificate", "ABC-21"):
|
|
self.assertIn(fact, fake.dms[0])
|
|
self.assertEqual([args for args in fake.tmux_calls if args[0] == "rename-window"], [["rename-window", "-t", "%1", "ABC-19 awaits a human's task"]])
|
|
self.assertIn("the chunk finished; started ABC-21\n", out)
|
|
self.assertEqual([seam for seam, _ in fake.calls if seam == "stream_claude"], [])
|
|
self.assertEqual(fake.dm_directories, [str(self.api)])
|
|
self.assertIn(fake.dms[0], out)
|
|
|
|
def test_a_dm_that_failed_is_sent_again_on_the_next_read(self) -> None:
|
|
fake = FakeEffects(git=UNREAD, windows=WINDOW, dm_failures=[Failure("the notifier answered 503")])
|
|
self.awaited(fake, closes_after=2)
|
|
self.assertEqual(len(fake.dms), 2)
|
|
|
|
def test_the_dm_goes_through_the_notifier_of_the_repo_of_an_issue_it_holds_up_before_any_other_repo(self) -> None:
|
|
self.repo("web", notifier=True)
|
|
self.epic.issues.append(issue("ABC-40", "repo:web"))
|
|
fake = FakeEffects(git=UNREAD, windows=WINDOW)
|
|
self.awaited(fake, closes_after=1)
|
|
self.assertEqual(fake.dm_directories, [str(self.api)])
|
|
|
|
def test_the_dm_goes_through_the_notifier_of_another_open_issues_repo_where_the_held_up_issue_has_none(self) -> None:
|
|
self.epic.change("ABC-21", labels=("do-epic-claude",))
|
|
self.epic.issues.append(issue("ABC-40", "repo:api"))
|
|
fake = FakeEffects(git=UNREAD, windows=WINDOW)
|
|
self.awaited(fake, closes_after=1)
|
|
self.assertEqual(fake.dm_directories, [str(self.api)])
|
|
|
|
def test_says_in_the_window_that_no_dm_went_out_where_no_repo_of_the_epic_names_a_notifier(self) -> None:
|
|
self.epic.change("ABC-21", labels=("repo:web",))
|
|
self.repo("web", notifier=False)
|
|
shutil.rmtree(self.api)
|
|
fake = FakeEffects(git=UNREAD, windows=WINDOW)
|
|
code, out, err = self.awaited(fake, closes_after=1)
|
|
self.assertEqual((code, err, fake.dms), (0, "", []))
|
|
self.assertEqual(out.count("<1790000000> no DM went out"), 1, out)
|
|
|
|
def test_the_window_of_a_closed_task_goes_on_while_another_human_task_still_holds_an_issue_up(self) -> None:
|
|
self.epic.issues.extend([issue("ABC-30", "do-epic-human"), issue("ABC-31", "do-epic-claude", blockers=("ABC-30",))])
|
|
fake = FakeEffects(git=UNREAD, windows=WINDOW)
|
|
code, out, err = self.awaited(fake, closes_after=1)
|
|
self.assertEqual((code, err), (0, ""))
|
|
self.assertEqual(len(fake.dms), 1)
|
|
self.assertIn("the chunk finished; started ABC-21, ABC-30\n", out)
|
|
|
|
def test_the_window_leaves_itself_out_of_the_running_chunks_when_it_starts_the_next(self) -> None:
|
|
self.description = DESCRIPTION.replace("2", "1")
|
|
fake = FakeEffects(git=UNREAD, windows=WINDOW)
|
|
code, out, err = self.awaited(fake, closes_after=1)
|
|
self.assertEqual((code, err), (0, ""))
|
|
self.assertIn("the chunk finished; started ABC-21\n", out)
|
|
|
|
def test_the_status_says_that_a_task_without_a_window_starts_at_once(self) -> None:
|
|
fake = FakeEffects(windows="")
|
|
code, out, err = self.run_main(["ABC-12", "--status"], fake)
|
|
self.assertEqual((code, err), (0, ""))
|
|
self.assertEqual(out.replace("<1790000000> ", "").splitlines()[0], "ABC-19 waits: it has not started; `do-epic ABC-12` starts it")
|
|
|
|
def test_a_task_that_blocks_two_issues_names_both(self) -> None:
|
|
self.epic.issues.append(issue("ABC-22", "do-epic-claude", blockers=("ABC-19",)))
|
|
fake = FakeEffects(git=UNREAD, windows=WINDOW)
|
|
self.awaited(fake, closes_after=1)
|
|
self.assertIn("blocks ABC-21 and ABC-22. ", fake.dms[0])
|
|
|
|
def test_goes_on_where_the_task_blocks_nothing_any_more(self) -> None:
|
|
fake = FakeEffects(git=UNREAD, windows=WINDOW)
|
|
fake.effects = lambda made=fake.effects(): dataclasses.replace(made, sleep=lambda seconds: self.epic.change("ABC-21", blockers=())) # type: ignore[method-assign]
|
|
code, out, err = self.run_main(["--chunk", "ABC-19", "ABC-12"], fake, MODELS)
|
|
self.assertEqual((code, err), (0, ""))
|
|
self.assertIn("the chunk finished; started ABC-21\n", out)
|
|
|
|
def test_says_once_why_a_read_failed_and_keeps_polling(self) -> None:
|
|
fake = FakeEffects(git=UNREAD, windows=WINDOW)
|
|
slept: list[int] = []
|
|
|
|
def sleep(seconds: int) -> None:
|
|
slept.append(seconds)
|
|
self.epic.fails = "Jira answered 503" if len(slept) < 3 else None
|
|
if len(slept) == 4:
|
|
self.epic.change("ABC-19", done=True)
|
|
fake.effects = lambda made=fake.effects(): dataclasses.replace(made, sleep=sleep) # type: ignore[method-assign]
|
|
code, out, err = self.run_main(["--chunk", "ABC-19", "ABC-12"], fake, MODELS)
|
|
self.assertEqual((code, err), (0, ""))
|
|
self.assertEqual(out.count("Jira answered 503"), 1, out)
|
|
self.assertEqual(len(fake.dms), 1)
|
|
|
|
def test_a_task_that_holds_nothing_up_at_its_start_hands_on_without_a_dm(self) -> None:
|
|
self.epic.change("ABC-21", blockers=())
|
|
fake = FakeEffects(git=UNREAD, windows=WINDOW)
|
|
code, out, err = self.run_main(["--chunk", "ABC-19", "ABC-12"], fake, MODELS)
|
|
self.assertEqual((code, err, fake.dms), (0, "", []))
|
|
self.assertIn("the chunk finished; started ABC-21\n", out)
|
|
|
|
def test_the_status_says_that_the_task_is_awaited(self) -> None:
|
|
fake = FakeEffects(windows="ABC-19 awaits a human's task\t0\t@9\n")
|
|
code, out, err = self.run_main(["ABC-12", "--status"], fake)
|
|
self.assertEqual((code, err), (0, ""))
|
|
self.assertEqual(out.replace("<1790000000> ", "").splitlines(), [f"ABC-19 waits: {HUMAN_WAIT}", "ABC-21 waits: ABC-19 blocks it"])
|
|
|
|
def test_the_epic_starts_a_window_for_the_task_and_none_for_the_issue_it_blocks(self) -> None:
|
|
fake = FakeEffects(windows="")
|
|
code, out, err = self.run_main(["ABC-12"], fake, {"TMUX_PANE": "%1"})
|
|
self.assertEqual((code, err), (0, ""))
|
|
self.assertIn("started ABC-19 in the tmux session epic-ABC-12\n", out)
|
|
self.assertIn("ABC-21 waits: ABC-19 blocks it\n", out)
|
|
self.assertEqual(fake.dms, [])
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|