Files
claude-config/bin/chunk_preflight/test_chunk_preflight.py
T

570 lines
30 KiB
Python

import os
import pathlib
import shutil
import subprocess
import sys
import tempfile
import unittest
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
from failure import Failure
from chunk_preflight.choices import forge_of, planned, worktree_add
from chunk_preflight.gathered import Gathered, ItemFacts, NamedPath, NoItem, Ran, Worktree
from test_env import isolated_env
from release_plan.release_standing import LastCut
from chunk_preflight.main import line_count, ran, seconds, TIMEOUT
from chunk_preflight.facts import open_pulls, render
BIN = pathlib.Path(__file__).resolve().parents[1]
README = "# Project\n\n## Goals\n\n**Void:** code health, since the plan's scores weigh goal 1 alone.\n\n1. **Achieve:** Work.\n\n## Audience\n\nMe.\n"
# Item 3 is the next release's first item that does not wait; 7 waits only on 3, 5 is a question, 8 waits on 5, 9 is in a later release.
TODO = """# todo
## Scoring
`Score = 100 * V / (2**S + 8)`
`Bar = 0.1`
`Next ID = 10`
## Items
| ID | Release | Blocked by | Exempt | Item | L | E | I | R | S | Moves | Score |
|---|---|---|---|---|---|---|---|---|---|---|---|
| 5 | 0.2.0 | | question | **Ask first.** | 1 | 1 | 1 | 1 | 1 | 1 by 9 | 90.0 |
| 3 | 0.2.0 | | | **Do the next thing.** | 2 | 2 | 3 | 5 | 3 | 1 by 9 | 56.2 |
| 7 | 0.2.0 | 3 | | **Do the thing after.** | 1 | 1 | 1 | 1 | 1 | 1 by 1 | 10.0 |
| 8 | 0.2.0 | 5 | | **Do the answered thing.** | 1 | 1 | 1 | 1 | 1 | 1 by 1 | 10.0 |
| 9 | 0.3.0 | | | **Do a later thing.** | 1 | 1 | 1 | 1 | 1 | 1 by 9 | 90.0 |
## Details
### 3. Do the next thing.
Change `src/app.py`'s `run` and the files under `src`, not `gone.py`.
"""
# The plan once item 3 has shipped: item 7 no longer waits, and its detail names the files.
SHIPPED = TODO.replace("| 3 | 0.2.0 | | | **Do the next thing.** | 2 | 2 | 3 | 5 | 3 | 1 by 9 | 56.2 |\n", "").replace("| 7 | 0.2.0 | 3 |", "| 7 | 0.2.0 | |").replace("### 3. Do the next thing.", "### 7. Do the thing after.")
# The plan once release 0.2.0 has shipped all its items: only release 0.3.0's item 9 is left.
LATER = TODO[:TODO.index("| 5 |")] + "| 9 | 0.3.0 | | | **Do a later thing.** | 1 | 1 | 1 | 1 | 1 | 1 by 9 | 90.0 |\n"
# An items table that holds no row.
EMPTY = TODO[:TODO.index("| 5 |")]
CHANGELOG = "# Changelog\n\n## Unreleased\n\n- One.\n - A nested line.\n- Two.\n\n## 0.1.0\n\n- Old.\n"
# What the preflight reads of the last release: tag v0.1.0, two entries under ## Unreleased, and 4 commits since the tag.
CUT = LastCut("v0.1.0", CHANGELOG, 4, [])
# Two open pull requests, as `tea pulls list --fields index,head,url --output tsv` prints them; anything else exits 1.
FAKE_TEA = "#!/bin/sh\n[ \"$*\" = 'pulls list --fields index,head,url --output tsv' ] || exit 1\nprintf 'index\\thead\\turl\\n12\\titem-7\\thttps://forge/pulls/12\\n13\\tother\\thttps://forge/pulls/13\\n'\n"
# Item 3's open pull request, as `gh pr list` prints it through the preflight's template; any other arguments exit 1.
FAKE_GH = """#!PYTHON
import sys
if sys.argv[1:] != ["pr", "list", "--head", "item-3", "--json", "number,url", "--template", "{{range .}}{{.number}}\\t{{.url}}\\n{{end}}"]:
sys.exit(1)
print("12\\thttps://github.com/o/r/pull/12")
""".replace("PYTHON", sys.executable)
class Repo:
"""An origin with a tagged release, a clone of it at <temp>/proj, and a fake tea and gh on PATH."""
def __init__(self, test, todo=TODO, origin="origin.git", changelog=CHANGELOG):
temp = tempfile.TemporaryDirectory()
test.addCleanup(temp.cleanup)
self.temp = pathlib.Path(os.path.realpath(temp.name))
self.origin = self.temp / origin
self.root = self.temp / "proj"
self.fake = self.temp / "fake-bin"
self.fake.mkdir()
for name, script in (("gh", FAKE_GH), ("tea", FAKE_TEA)):
(self.fake / name).write_text(script)
(self.fake / name).chmod(0o755)
(self.fake / "git").symlink_to(shutil.which("git"))
self.env = {**isolated_env(), "GIT_CONFIG_GLOBAL": os.devnull, "GIT_CONFIG_NOSYSTEM": "1", "HOME": str(self.temp / "home"), "PATH": str(self.fake), "LOOP_CLAUDE_TRANSCRIPTS": str(self.temp / "archive")}
self.git(self.temp, "init", "--quiet", "--bare", "--initial-branch=main", str(self.origin))
self.git(self.temp, "clone", "--quiet", str(self.origin), str(self.root))
self.write(self.root, "README.md", README)
self.write(self.root, "src/app.py", "def run():\n\treturn 1\n\n")
self.commit(self.root, "start")
self.git(self.root, "tag", "v0.1.0")
self.write(self.root, "CHANGELOG.md", changelog)
if todo:
self.write(self.root, "todo.md", todo)
self.commit(self.root, "plan")
self.git(self.root, "push", "--quiet", "origin", "main", "v0.1.0")
def git(self, cwd, *args):
return subprocess.run(["git", "-c", "user.name=t", "-c", "user.email=t@example.com", *args], capture_output=True, check=True, cwd=cwd, env=self.env, text=True).stdout
def write(self, root, path, text):
(root / path).parent.mkdir(parents=True, exist_ok=True)
(root / path).write_text(text)
def commit(self, root, title):
self.git(root, "add", "-A")
self.git(root, "commit", "--quiet", "-m", title)
def push_from_elsewhere(self, path, text):
"""Pushes a change to path from another clone, leaving the checkout behind origin."""
other = self.temp / "other"
self.git(self.temp, "clone", "--quiet", str(self.origin), str(other))
self.write(other, path, text)
self.commit(other, "elsewhere")
self.git(other, "push", "--quiet", "origin", "main")
def stub_git(self, arm):
"""Puts a git on PATH that runs arm, a shell case arm, on its arguments, and the real git on any others."""
stub = self.fake / "git"
stub.unlink()
stub.write_text(f'#!/bin/sh\ncase "$*" in\n{arm}\nesac\nexec {shutil.which("git")} "$@"\n')
stub.chmod(0o755)
def preflight(self, *args, **env):
return subprocess.run([sys.executable, str(BIN / "chunk-preflight"), *args], capture_output=True, cwd=self.root, env={**self.env, **env}, text=True, timeout=120)
class ChunkPreflightTool(unittest.TestCase):
def test_reads_the_fetched_default_branchs_plan_and_makes_the_items_worktree_off_it_leaving_the_checkout_as_it_was(self):
repo = Repo(self)
repo.push_from_elsewhere("todo.md", SHIPPED)
# Claude Code rewrites tracked files, such as settings.json, so a checkout behind origin often holds changes.
repo.write(repo.root, "todo.md", TODO + "\nA change of the checkout's own.\n")
head = repo.git(repo.root, "rev-parse", "HEAD")
done = repo.preflight("--worktree")
self.assertEqual(done.returncode, 0, done.stderr)
self.assertEqual(repo.git(repo.root, "rev-parse", "HEAD"), head)
worktree = repo.temp / "proj-item-7"
self.assertEqual(repo.git(worktree, "rev-parse", "--abbrev-ref", "HEAD").strip(), "item-7")
self.assertEqual(repo.git(worktree, "rev-parse", "HEAD"), repo.git(repo.root, "rev-parse", "origin/main"))
for fact in (
"item 7, L 1, E + I 2",
str(worktree),
"item-7, made off origin/main",
"#12 https://forge/pulls/12",
"`src/app.py`: 3 lines",
"`src`: 1 file",
"`rank_todo.py --check todo.md` exited 0",
"`larv-review needs-scoring-run 7` exited 0",
"`reading-cost` exited 0",
"`larv-review places` exited 0",
f"{worktree}/docs/reading-cost.md",
):
with self.subTest(fact=fact):
self.assertIn(fact, done.stdout)
self.assertNotIn("#13", done.stdout)
self.assertNotIn("`gone.py`:", done.stdout)
def test_names_no_item_and_makes_no_worktree_where_the_release_after_the_last_cut_has_emptied(self):
for changelog, reviewed, fact in ((CHANGELOG, False, "release review is due"), (CHANGELOG, True, "finished and ready to cut"), ("# Changelog\n\n## Unreleased\n\n## 0.1.0\n\n- Old.\n", False, "planned first")):
with self.subTest(fact=fact):
repo = Repo(self, changelog=changelog)
repo.write(repo.root, "todo.md", LATER)
repo.commit(repo.root, "ship 0.2.0")
if reviewed:
repo.git(repo.root, "commit", "--quiet", "--allow-empty", "-m", "Release review of 0.2.0")
repo.git(repo.root, "push", "--quiet", "origin", "main")
done = repo.preflight("--worktree")
self.assertEqual(done.returncode, 0, done.stderr)
self.assertIn(fact, done.stdout)
self.assertNotIn("item 9", done.stdout)
self.assertFalse((repo.temp / "proj-item-9").exists())
def test_takes_the_next_item_where_the_plan_marks_the_release_after_the_last_cut_renamed_and_calls_it_finished_where_it_does_not(self):
for mark, fact, absent in (("\n## Renamed\n\n- 0.2.0 renamed to 0.3.0\n", "item 3", "release review"), ("", "release review is due", "item 3")):
with self.subTest(mark=mark):
repo = Repo(self)
repo.write(repo.root, "todo.md", TODO.replace("| 0.3.0 |", "| 0.4.0 |").replace("| 0.2.0 |", "| 0.3.0 |") + mark)
repo.commit(repo.root, "move 0.2.0's items to 0.3.0")
repo.git(repo.root, "push", "--quiet", "origin", "main")
done = repo.preflight()
self.assertEqual(done.returncode, 0, done.stderr)
self.assertIn(fact, done.stdout)
self.assertNotIn(absent, done.stdout)
def test_weighs_todo_md_at_the_last_cut_and_on_the_default_branch_after_it_alone(self):
"""Each case's plans: before the tag, at it, on a side branch merged after it, and after it, each committed in turn where given."""
cases = (
("a release named only before the cut", TODO, LATER, None, None, "item 9"),
("a release named at the cut", None, TODO, None, LATER, "release review is due"),
("a release named only on a side branch", None, LATER, TODO, None, "item 9"),
)
for name, before, at, side, after, fact in cases:
with self.subTest(name):
repo = Repo(self, todo="")
for todo, title in ((before, "before"), (at, "at")):
if todo is not None:
repo.write(repo.root, "todo.md", todo)
repo.commit(repo.root, title)
repo.git(repo.root, "tag", "--force", "v0.1.0")
if side is not None:
repo.git(repo.root, "switch", "--quiet", "-c", "side")
# The branch ends on a plan main never held, so the merge changes todo.md.
for todo in (side, LATER + "| 10 | 0.3.0 | | | **Do another later thing.** | 1 | 1 | 1 | 1 | 1 | 1 by 9 | 90.0 |\n"):
repo.write(repo.root, "todo.md", todo)
repo.commit(repo.root, "side")
repo.git(repo.root, "switch", "--quiet", "main")
repo.git(repo.root, "merge", "--quiet", "--no-ff", "-m", "merge side", "side")
if after is not None:
repo.write(repo.root, "todo.md", after)
repo.commit(repo.root, "after")
repo.git(repo.root, "push", "--quiet", "--force", "origin", "main", "v0.1.0")
done = repo.preflight()
self.assertEqual(done.returncode, 0, done.stderr)
self.assertIn(fact, done.stdout)
def test_continues_the_items_worktree_and_else_its_pushed_branch(self):
repo = Repo(self)
repo.preflight("--worktree")
worktree = repo.temp / "proj-item-3"
continued = repo.preflight("--worktree").stdout
self.assertIn(str(worktree), continued)
self.assertIn("continued", continued)
(worktree / "work.txt").write_text("work\n")
repo.git(worktree, "add", "work.txt")
repo.git(worktree, "commit", "--quiet", "-m", "work")
repo.git(worktree, "push", "--quiet", "origin", "item-3")
repo.git(repo.root, "worktree", "remove", "--force", str(worktree))
repo.git(repo.root, "branch", "--quiet", "-D", "item-3")
pushed = repo.preflight("--worktree").stdout
self.assertIn(str(worktree), pushed)
self.assertIn("made off origin/item-3", pushed)
self.assertTrue((worktree / "work.txt").exists())
def test_makes_no_worktree_where_its_path_holds_something_else_and_runs_no_tool(self):
repo = Repo(self)
(repo.temp / "proj-item-3").mkdir()
done = repo.preflight("--worktree")
self.assertIn(f"none made, since {repo.temp / 'proj-item-3'} exists", done.stdout)
self.assertNotIn("`reading-cost`", done.stdout)
def test_makes_no_worktree_and_runs_no_tool_where_git_cannot_add_it(self):
repo = Repo(self)
repo.temp.chmod(0o555)
self.addCleanup(repo.temp.chmod, 0o755)
done = repo.preflight("--worktree")
self.assertEqual(done.returncode, 0, done.stderr)
self.assertIn("Worktree: none made: git worktree add", done.stdout)
self.assertNotIn("`reading-cost`", done.stdout)
self.assertFalse((repo.temp / "proj-item-3").exists())
def test_makes_no_worktree_and_runs_no_tool_where_git_cannot_list_the_worktrees(self):
repo = Repo(self)
repo.stub_git('"worktree list --porcelain") echo "listing broke" >&2; exit 1;;')
done = repo.preflight("--worktree")
self.assertEqual(done.returncode, 0, done.stderr)
self.assertIn("listing broke", done.stdout)
self.assertNotIn("`reading-cost`", done.stdout)
self.assertFalse((repo.temp / "proj-item-3").exists())
def test_reads_origin_as_last_fetched_where_the_fetch_stalls_and_still_states_the_other_facts(self):
repo = Repo(self)
repo.stub_git(f'"fetch --quiet origin") exec {shutil.which("sleep")} 10;;')
done = repo.preflight("--worktree", CHUNK_PREFLIGHT_TIMEOUT="1")
self.assertEqual(done.returncode, 0, done.stderr)
self.assertIn("as last fetched", done.stdout)
self.assertIn("item 3, L 2, E + I 5", done.stdout)
self.assertIn("`reading-cost` exited 0", done.stdout)
def test_without_worktree_states_the_items_facts_and_makes_no_worktree_and_runs_no_tool(self):
repo = Repo(self)
done = repo.preflight()
self.assertEqual(done.returncode, 0, done.stderr)
self.assertIn("item 3, L 2, E + I 5", done.stdout)
self.assertIn("Worktree: none made, since it ran without --worktree.", done.stdout)
self.assertIn("Open pull requests from item-3: none.", done.stdout)
self.assertIn("`src/app.py`: 3 lines", done.stdout)
self.assertNotIn("`reading-cost`", done.stdout)
self.assertFalse((repo.temp / "proj-item-3").exists())
self.assertNotIn("item-3", repo.git(repo.root, "branch", "--list"))
def test_exits_1_on_an_argument_other_than_worktree(self):
done = Repo(self).preflight("--start")
self.assertEqual(done.returncode, 1)
self.assertIn("unknown arguments --start", done.stderr)
self.assertEqual(done.stdout, "")
def test_lists_the_open_pull_requests_with_gh_on_a_github_origin(self):
repo = Repo(self, origin="github.com/o/r.git")
self.assertIn("#12 https://github.com/o/r/pull/12", repo.preflight().stdout)
def test_without_a_plan_states_the_release_facts_and_makes_no_worktree(self):
repo = Repo(self, todo="")
done = repo.preflight("--worktree")
self.assertEqual(done.returncode, 0, done.stderr)
self.assertIn("v0.1.0", done.stdout)
self.assertIn("no items table", done.stdout)
self.assertFalse((repo.temp / "proj-item-3").exists())
def test_states_its_timeout_in_its_help(self):
done = subprocess.run([sys.executable, str(BIN / "chunk-preflight"), "--help"], capture_output=True, env=isolated_env(), text=True)
self.assertEqual(done.returncode, 0, done.stderr)
self.assertIn(f"after {TIMEOUT} seconds", done.stdout)
def test_exits_1_on_a_timeout_setting_that_is_no_number_of_seconds(self):
done = Repo(self).preflight(CHUNK_PREFLIGHT_TIMEOUT="soon")
self.assertEqual(done.returncode, 1)
self.assertIn("CHUNK_PREFLIGHT_TIMEOUT", done.stderr)
self.assertEqual(done.stdout, "")
def test_exits_1_without_a_default_branch(self):
with tempfile.TemporaryDirectory() as temp:
env = {**isolated_env(), "GIT_CONFIG_GLOBAL": os.devnull, "GIT_CONFIG_NOSYSTEM": "1"}
subprocess.run(["git", "init", "--quiet", "--initial-branch=trunk", temp], check=True, env=env)
done = subprocess.run([sys.executable, str(BIN / "chunk-preflight")], capture_output=True, cwd=temp, env=env, text=True)
self.assertEqual(done.returncode, 1)
self.assertIn("main or master", done.stderr)
self.assertEqual(done.stdout, "")
def test_exits_1_outside_a_checkout(self):
with tempfile.TemporaryDirectory() as temp:
done = subprocess.run([sys.executable, str(BIN / "chunk-preflight")], capture_output=True, cwd=temp, env={**isolated_env(), "GIT_CONFIG_NOSYSTEM": "1"}, text=True)
self.assertEqual(done.returncode, 1)
self.assertIn("git rev-parse --show-toplevel", done.stderr)
def item_facts(todo=TODO, **fields):
"""The facts of todo's next item, its worktree made, with fields given replacing the rest."""
return ItemFacts(**{"plan": planned(todo, CUT, "origin/main"), "worktree": Worktree(pathlib.Path("/c/proj-item-3"), "added on the new branch item-3, made off origin/main."), "pulls": None, "named": [], "tools": [], **fields})
def rendered(item, release=CUT, note=None):
return "\n".join(render(Gathered("origin/main", note, release, item)))
class Render(unittest.TestCase):
def test_states_the_earliest_releases_first_item_its_levels_and_detail_and_each_item_that_may_join_its_chunk(self):
said = rendered(item_facts())
self.assertIn("origin/main's todo.md: 0.2.0", said)
self.assertIn("item 3, L 2, E + I 5", said)
self.assertIn("> Change `src/app.py`'s `run` and the files under `src`, not `gone.py`.", said)
self.assertIn("item 7, L 1, E + I 2, S 1: **Do the thing after.**", said)
self.assertNotIn("item 8,", said)
def test_quotes_the_detail_of_each_item_that_may_join_the_chunk(self):
said = rendered(item_facts(TODO + "\n### 7. Do the thing after.\n\nTouch `src/other.py`.\n\nRun the e2e leg.\n\n### 8. Do the answered thing.\n\nNot quoted.\n"))
self.assertIn("Item 7's detail:\n\n> Touch `src/other.py`.\n> \n> Run the e2e leg.", said)
self.assertNotIn("Not quoted", said)
def test_states_that_a_joining_item_has_no_detail(self):
said = rendered(item_facts())
self.assertIn("Item 7 has no detail.", said)
self.assertNotIn("Item 7's detail", said)
def test_states_that_the_joining_items_details_cannot_be_read(self):
said = rendered(item_facts(TODO + "\n```\nx\n```\n"))
self.assertIn("The details of the items that may join cannot be read: ## Details holds a fenced code block", said)
self.assertNotIn("has no detail", said)
def test_quotes_the_details_of_the_first_ten_joining_items_and_names_the_rest(self):
rows = "".join(f"| {id_} | 0.2.0 | | | **Do thing {id_}.** | 1 | 1 | 1 | 1 | 1 | 1 by 1 | 10.0 |\n" for id_ in range(20, 32))
details = "".join(f"\n### {id_}. Do thing {id_}.\n\nDetail {id_}.\n" for id_ in range(7, 8)) + "".join(f"\n### {id_}. Do thing {id_}.\n\nDetail {id_}.\n" for id_ in range(20, 32))
said = rendered(item_facts(TODO.replace("\n## Details", rows + "\n## Details") + details))
self.assertIn("> Detail 28.", said)
self.assertNotIn("Detail 29.", said)
self.assertIn("The details of items 29, 30 and 31 are not quoted: only the first 10 are. Open `todo.md` for them.", said)
def test_states_the_items_worktree_or_why_none_was_made(self):
self.assertIn("/c/proj-item-3", rendered(item_facts()))
self.assertIn("none made: path taken", rendered(item_facts(worktree=Failure("none made: path taken"))))
def test_states_that_no_other_item_may_join_the_chunk(self):
said = rendered(item_facts(TODO.replace("| 7 | 0.2.0 | 3 |", "| 7 | 0.2.0 | 5 |")))
self.assertIn("No other item", said)
self.assertNotIn("item 7,", said)
def test_states_that_an_item_above_r_5_ships_alone(self):
said = rendered(item_facts(TODO.replace("| 2 | 2 | 3 | 5 | 3 |", "| 3 | 2 | 3 | 6 | 3 |")))
self.assertIn("Item 3 has R above 5, so it ships alone.", said)
self.assertNotIn("item 7,", said)
def test_states_an_unscored_level_as_unscored(self):
unscored = TODO.replace("| L | E | I | R | S |", "| R | S |").replace("|---|---|---|---|---|---|---|---|---|---|---|---|", "|---|---|---|---|---|---|---|---|---|").replace("| 2 | 2 | 3 | 5 | 3 |", "| 5 | 3 |").replace("| 1 | 1 | 1 | 1 | 1 |", "| 1 | 1 |")
self.assertIn("item 3, L unscored, E + I unscored", rendered(item_facts(unscored)))
def test_states_the_unreleased_entries_and_else_the_commits_since_the_last_cut(self):
self.assertIn("v0.1.0. Unreleased: 2 entries", rendered(NoItem("x.")))
self.assertIn("1 entry", rendered(NoItem("x."), LastCut("v0.1.0", "## Unreleased\n\n- One.\n", 4, [])))
without = rendered(NoItem("x."), LastCut("v0.1.0", "# Changelog\n", 4, []))
self.assertIn("4 commits since v0.1.0", without)
self.assertIn("no ## Unreleased", without)
untagged = rendered(NoItem("x."), LastCut(None, "", 1, []))
self.assertIn("cut: none", untagged)
self.assertIn("1 commit on origin/main", untagged)
headed = rendered(NoItem("x."), LastCut(None, "## 0.0.1 - 2026-10-03\n", 1, []))
self.assertIn("cut: 0.0.1 (dated in CHANGELOG.md).", headed)
self.assertIn("1 commit since CHANGELOG.md dated 0.0.1", headed)
def test_states_why_the_changelog_and_the_commits_since_the_last_cut_cannot_be_read(self):
said = rendered(NoItem("x."), LastCut("v0.1.0", Failure("changelog unreadable"), Failure("count unreadable"), []))
self.assertIn("changelog unreadable", said)
self.assertIn("cannot be counted: count unreadable", said)
self.assertNotIn("no ## Unreleased", said)
def test_states_why_origin_reads_as_last_fetched_and_nothing_after_a_fetch(self):
self.assertIn("- reading origin as last fetched: fetch stalled", rendered(NoItem("x."), note="reading origin as last fetched: fetch stalled"))
fetched = rendered(NoItem("x."))
self.assertNotIn("last fetched", fetched)
self.assertNotIn("None", fetched)
def test_states_why_there_is_no_plan_item(self):
said = rendered(NoItem("every item waits."))
self.assertIn("every item waits.", said)
self.assertNotIn("Worktree", said)
def test_states_the_open_pull_requests_from_the_items_branch_or_why_none_are_listed(self):
cases = (
(("tea", Ran(0, "index\thead\turl\n12\titem-3\thttps://forge/pulls/12\n", "")), ("#12 https://forge/pulls/12",)),
(("gh", Ran(0, "12\thttps://github.com/o/r/pull/12\n14\thttps://github.com/o/r/pull/14\n", "")), ("#12 https://github.com/o/r/pull/12, #14 https://github.com/o/r/pull/14",)),
(("gh", Ran(0, "", "")), ("item-3: none.",)),
(None, ("item-3: none", "no origin remote")),
(("tea", Ran(1, "", "no login\n")), ("`tea pulls list`", "exited 1", "no login")),
(("gh", Ran(1, "", "not logged in\n")), ("`gh pr list`", "exited 1", "not logged in")),
(("gh", Failure("could not finish: timed out")), ("`gh pr list`", "could not finish: timed out")),
)
for pulls, facts in cases:
with self.subTest(pulls=pulls):
said = rendered(item_facts(pulls=pulls))
for fact in facts:
self.assertIn(fact, said)
def test_states_each_named_files_lines_and_each_named_folders_files(self):
said = rendered(item_facts(named=[NamedPath("src/app.py", 1, 3), NamedPath("src", 2, None), NamedPath("bad.py", 1, Failure("not UTF-8")), NamedPath("one.py", 1, 1), NamedPath("docs", 1, None)]))
self.assertIn("`src/app.py`: 3 lines", said)
self.assertIn("`src`: 2 files", said)
self.assertIn("`bad.py`: cannot be read: not UTF-8", said)
self.assertIn("`one.py`: 1 line\n", said)
self.assertIn("`docs`: 1 file\n", said)
def test_states_that_the_item_names_no_tracked_file_or_why_they_cannot_be_listed(self):
self.assertIn("no file", rendered(item_facts(named=[])))
self.assertIn("ls-files broke", rendered(item_facts(named=Failure("ls-files broke"))))
def test_states_what_each_tool_printed_and_its_exit_code(self):
said = rendered(item_facts(tools=[("rank_todo.py --check todo.md", Ran(0, "ranked\n", "")), ("reading-cost", Ran(1, "", "")), ("larv-review needs-scoring-run 3", Ran(1, "out\n", "err\n")), ("larv-review places", Failure("could not finish: timed out"))]))
self.assertIn("`rank_todo.py --check todo.md` exited 0", said)
self.assertIn("> ranked", said)
self.assertIn("`reading-cost` exited 1, printing no output", said)
self.assertIn("> out\n> err", said)
self.assertIn("`larv-review places` could not finish: timed out", said)
class OpenPulls(unittest.TestCase):
def test_lists_gh_rows_as_they_come_and_only_teas_rows_from_the_branch(self):
self.assertEqual(open_pulls("12\thttps://github.com/o/r/pull/12\n14\thttps://github.com/o/r/pull/14\n", "gh", "item-3"), ["#12 https://github.com/o/r/pull/12", "#14 https://github.com/o/r/pull/14"])
self.assertEqual(open_pulls("index\thead\turl\n12\titem-3\thttps://forge/pulls/12\n13\tother\thttps://forge/pulls/13\n", "tea", "item-3"), ["#12 https://forge/pulls/12"])
class Plans(unittest.TestCase):
def test_picks_the_earliest_releases_first_item_that_does_not_wait_or_says_why_there_is_none(self):
self.assertEqual(planned(TODO, CUT, "origin/main").first.id, 3)
waits = planned(TODO.replace("| 3 | 0.2.0 | | |", "| 3 | 0.2.0 | | question |"), CUT, "origin/main")
self.assertIn("waits", waits.why)
self.assertIn("0.2.0", waits.why)
self.assertIn("Permission denied", planned(Failure("Permission denied"), CUT, "origin/main").why)
self.assertIn("L 'x'", planned(TODO.replace("| 2 | 2 | 3 | 5 |", "| x | 2 | 3 | 5 |"), CUT, "origin/main").why)
self.assertIn("details cannot be read", planned(TODO + "```\n", CUT, "origin/main").text)
def test_tells_a_plan_with_no_items_table_from_one_whose_table_holds_no_item(self):
without = planned("", CUT, "origin/main").why
self.assertIn("origin/main", without)
self.assertIn("no items table", without)
self.assertNotIn("cannot be read", without)
empty = planned(EMPTY, LastCut(None, "", 4, []), "origin/main").why
self.assertIn("holds no item", empty)
self.assertNotIn("no items table", empty)
def test_names_a_release_cut_under_a_dated_heading_as_the_last_cut_on_a_branch_with_no_tag(self):
said = planned(EMPTY, LastCut(None, "## 0.0.1 - 2026-10-03\n", 0, []), "origin/main").why
self.assertIn("the next release after the last cut, 0.0.1 (dated in CHANGELOG.md)", said)
def test_says_the_tags_cannot_be_read_with_gits_reason_and_names_no_cut(self):
said = planned(EMPTY, LastCut(Failure("git exited 128: not a git repository"), "", 4, []), "origin/main").why
self.assertIn("origin/main's tags cannot be read: git exited 128: not a git repository.", said)
self.assertIn("Find the next release yourself.", said)
self.assertNotIn("no release is cut yet", said)
def test_names_the_start_as_the_last_cut_where_nothing_is_cut(self):
said = planned(EMPTY, LastCut(None, "", 4, [TODO]), "origin/main").why
self.assertIn("release 0.2.0, the next after the start, since no release is cut yet,", said)
self.assertIn("has landed yet.", said)
self.assertIn("since the cut.", planned(EMPTY, LastCut(None, "## 0.1.0 - 2026-10-03\n", 4, [TODO]), "origin/main").why)
def test_finds_the_release_after_the_last_cut_finished_or_to_be_planned_where_the_plan_holds_no_item_for_it(self):
named = "release 0.2.0, the next after the last cut, v0.1.0"
unnamed = "the next release after the last cut, v0.1.0"
cases = (
(LATER, 4, [TODO], False, "release review is due", named),
(LATER, 4, [TODO], True, "finished and ready to cut", named),
(LATER, 0, [TODO], False, "planned first", named),
(EMPTY, 4, [TODO], True, "finished and ready to cut", named),
(EMPTY, 0, [TODO], False, "planned first", named),
(EMPTY, 4, [EMPTY], True, "finished and ready to cut", unnamed),
(LATER, Failure("count unreadable"), [TODO], False, "cannot be read", unnamed),
)
for todo, commits, todos, reviewed, fact, release in cases:
with self.subTest(todo=todo, commits=commits, todos=todos, reviewed=reviewed):
why = planned(todo, LastCut("v0.1.0", "", commits, todos, reviewed), "origin/main").why
self.assertIn(fact, why)
self.assertIn(release, why)
def test_says_what_todo_md_named_since_the_last_cut_cannot_be_read(self):
self.assertIn("cannot be read", planned(LATER, LastCut("v0.1.0", "", 4, Failure("log unreadable")), "origin/main").why)
def test_takes_the_earliest_release_where_no_earlier_one_was_named_since_the_last_cut(self):
self.assertEqual(planned(LATER, LastCut("v0.1.0", "", 4, [LATER]), "origin/main").first.id, 9)
def test_says_the_plan_files_items_under_a_release_already_cut(self):
why = planned(TODO, LastCut("v0.2.0", "", 4, []), "origin/main").why
self.assertIn("release 0.2.0", why)
self.assertIn("v0.2.0", why)
self.assertIn("not after", why)
def test_takes_an_item_without_a_detail_as_its_tagline_alone(self):
self.assertEqual(planned(TODO[:TODO.index("## Details")], CUT, "origin/main").text, "**Do the next thing.**")
class Gathering(unittest.TestCase):
def test_adds_the_worktree_on_the_local_branch_else_on_a_new_one_tracking_origins_else_on_a_new_one_off_the_default_branch(self):
path = pathlib.Path("/c/proj-item-3")
self.assertEqual(worktree_add("item-3", path, "origin/main", True, True)[0], ["worktree", "add", "--quiet", "/c/proj-item-3", "item-3"])
self.assertEqual(worktree_add("item-3", path, "origin/main", False, True)[0], ["worktree", "add", "--quiet", "--track", "-b", "item-3", "/c/proj-item-3", "origin/item-3"])
self.assertEqual(worktree_add("item-3", path, "origin/main", False, False)[0], ["worktree", "add", "--quiet", "--no-track", "-b", "item-3", "/c/proj-item-3", "origin/main"])
def test_lists_pull_requests_with_gh_on_a_github_origin_and_with_tea_elsewhere(self):
self.assertEqual(forge_of("git@github.com:o/r.git"), "gh")
self.assertEqual(forge_of("https://gitea.larvit.se/o/r.git"), "tea")
def test_reads_the_timeout_setting_as_seconds_above_0_and_else_takes_the_default(self):
self.assertEqual(seconds(None), TIMEOUT)
self.assertEqual(seconds("2.5"), 2.5)
for setting in ("soon", "0", "-1", "1e3", ""):
with self.subTest(setting=setting):
self.assertIn("CHUNK_PREFLIGHT_TIMEOUT", seconds(setting).reason)
class Running(unittest.TestCase):
def test_says_why_a_command_could_not_finish(self):
with tempfile.TemporaryDirectory() as cwd:
cases = (([str(pathlib.Path(cwd, "missing"))], 60, "missing"), ([sys.executable, "-c", "import time; time.sleep(5)"], 0.2, "0.2"))
for command, timeout, fact in cases:
with self.subTest(fact=fact):
done = ran(command, pathlib.Path(cwd), timeout)
self.assertIsInstance(done, Failure)
self.assertIn(fact, done.reason)
def test_counts_a_files_lines_says_why_they_cannot_be_read_and_counts_none_for_a_folder(self):
with tempfile.TemporaryDirectory() as temp:
folder = pathlib.Path(temp)
(folder / "two.txt").write_text("a\nb\n")
(folder / "latin.txt").write_bytes(b"caf\xe9\n")
(folder / "locked.txt").write_text("a\n")
(folder / "locked.txt").chmod(0)
self.assertEqual(line_count(folder / "two.txt"), 2)
self.assertIn("utf-8", line_count(folder / "latin.txt").reason)
self.assertIn("locked.txt", line_count(folder / "locked.txt").reason)
self.assertIsNone(line_count(folder))
if __name__ == "__main__":
unittest.main()