392 lines
28 KiB
Python
392 lines
28 KiB
Python
import dataclasses
|
|
import pathlib
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
import unittest
|
|
|
|
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
|
|
|
|
from project_config.templates import BARE, Titles
|
|
from project_config.settings import DEFAULT_FLOOR, ProjectConfig, SETTINGS
|
|
from failure import Failure
|
|
from plan_store.todo_md import FilePlan, plan_of
|
|
from record_store.stores import FileStore
|
|
from test_env import isolated_env
|
|
from record_store.fakes import MemoryStore
|
|
from release_plan import next_chunk, release_standing
|
|
from plan.todo_table import NoItemsTable
|
|
from plan_store.plans import Plan
|
|
from plan import todo_table
|
|
from plan.release import version
|
|
|
|
|
|
HEADER = "## Items\n\n| ID | Release | Blocked by | Exempt | Item | L | E | I | R | S | Moves | Score |\n|---|---|---|---|---|---|---|---|---|---|---|---|\n"
|
|
ROW = "| {id} | {release} | | | **Do {id}.** | 1 | 1 | 1 | 1 | 1 | 1 by 1 | 10.0 |\n"
|
|
|
|
|
|
def next_of(found: list[todo_table.Item], cut: release_standing.LastCut) -> release_standing.Upcoming | release_standing.Cut | release_standing.Unknown:
|
|
return release_standing.next_release(release_standing.standing_of(found, cut), cut)
|
|
|
|
|
|
def carried_of(found: list[todo_table.Item], cut: release_standing.LastCut) -> list[todo_table.Item]:
|
|
return release_standing.standing_of(found, cut).carried
|
|
|
|
|
|
def plan_at(path: pathlib.Path, tracked: str | None) -> FilePlan:
|
|
"""The markdown plan at path, which these tests only read."""
|
|
return FilePlan(path, tracked, FileStore(path.parent / "README.md", None), MemoryStore(), MemoryStore(), DEFAULT_FLOOR)
|
|
|
|
|
|
def plan_in(repo: str) -> FilePlan:
|
|
return plan_at(pathlib.Path(repo, "todo.md"), "todo.md")
|
|
|
|
|
|
def changelog_of(repo: str) -> FileStore:
|
|
"""The changelog at its usual path in the checkout at repo."""
|
|
return FileStore(pathlib.Path(repo, "CHANGELOG.md"), "CHANGELOG.md")
|
|
|
|
|
|
def naming(named: set[tuple[int, int, int]] | Failure) -> list[str] | Failure:
|
|
"""LastCut.todos_since holding one todo.md text that files an item under each release in named."""
|
|
if isinstance(named, Failure):
|
|
return named
|
|
return [HEADER + "".join(ROW.format(id=id_, release=version(release)) for id_, release in enumerate(sorted(named), 1))]
|
|
|
|
|
|
def one(release: tuple[int, int, int]) -> todo_table.Item:
|
|
"""The plan's only item, filed under release."""
|
|
return todo_table.Item(1, release, "", "**Do 1.**", {}, (), ())
|
|
|
|
|
|
def plan_under(earliest: tuple[int, int, int] | None) -> list[todo_table.Item]:
|
|
"""A plan holding one item under earliest, or none where earliest is None."""
|
|
return [] if earliest is None else [one(earliest)]
|
|
|
|
|
|
class NextRelease(unittest.TestCase):
|
|
def test_names_the_earliest_release_after_the_last_cut_that_todo_md_named_since_it_or_the_plan_holds(self):
|
|
cases = (
|
|
("v1.2.3", (1, 3, 0), {(1, 2, 4), (1, 3, 0)}, release_standing.Upcoming((1, 2, 4), False, True)),
|
|
("v1.2.3", (1, 2, 4), {(1, 3, 0)}, release_standing.Upcoming((1, 2, 4), True, True)),
|
|
("v1.2.3", None, {(1, 2, 2), (1, 3, 0)}, release_standing.Upcoming((1, 3, 0), False, True)),
|
|
("v1.2.3", None, set(), release_standing.Upcoming(None, False, True)),
|
|
(None, (0, 2, 0), set(), release_standing.Upcoming((0, 2, 0), True, True)),
|
|
(None, None, set(), release_standing.Upcoming(None, True, True)),
|
|
("v1.2.3-rc.1", (1, 2, 3), set(), release_standing.Upcoming((1, 2, 3), True, True)),
|
|
)
|
|
for tag, earliest, named, upcoming in cases:
|
|
with self.subTest(tag=tag, earliest=earliest, named=named):
|
|
self.assertEqual(next_of(plan_under(earliest), release_standing.LastCut(tag, "", 4, naming(named))), upcoming)
|
|
|
|
def test_says_work_has_landed_towards_it_where_a_change_is_unreleased(self):
|
|
cut = lambda changes: release_standing.LastCut("v1.2.3", "", changes, naming({(1, 3, 0)}))
|
|
self.assertEqual(next_of([one((1, 3, 0))], cut(4)), release_standing.Upcoming((1, 3, 0), True, True))
|
|
self.assertEqual(next_of([one((1, 3, 0))], cut(0)), release_standing.Upcoming((1, 3, 0), True, False))
|
|
self.assertEqual(next_of([one((1, 3, 0))], cut(Failure("count unreadable"))), release_standing.Upcoming((1, 3, 0), True, Failure("count unreadable")))
|
|
|
|
|
|
class Carried(unittest.TestCase):
|
|
def test_files_each_item_of_a_release_already_cut_under_the_earliest_release_the_plan_names_after_the_cut(self):
|
|
held = [dataclasses.replace(one((1, 2, 3)), id=1), dataclasses.replace(one((1, 2, 0)), id=2), dataclasses.replace(one((1, 4, 0)), id=3), dataclasses.replace(one((1, 3, 0)), id=4)]
|
|
carried = carried_of(held, release_standing.LastCut("v1.2.3", "", 4, []))
|
|
self.assertEqual([(item.id, item.release) for item in carried], [(1, (1, 3, 0)), (2, (1, 3, 0)), (3, (1, 4, 0)), (4, (1, 3, 0))])
|
|
|
|
def test_leaves_the_plan_as_it_is_where_nothing_is_cut_or_it_names_no_release_after_the_cut(self):
|
|
held = [one((1, 2, 3))]
|
|
for tag in ("v1.2.3", "v1.2.2", None, Failure("tags unreadable")):
|
|
with self.subTest(tag=tag):
|
|
self.assertIs(carried_of(held, release_standing.LastCut(tag, "", 4, [])), held)
|
|
|
|
def test_files_them_under_a_release_todo_md_named_since_the_cut_though_the_plan_holds_no_item_of_it(self):
|
|
held = [one((1, 2, 3)), dataclasses.replace(one((1, 4, 0)), id=2)]
|
|
cut = release_standing.LastCut("v1.2.3", "", 4, naming({(1, 2, 3), (1, 3, 0)}))
|
|
self.assertEqual([item.release for item in carried_of(held, cut)], [(1, 3, 0), (1, 4, 0)])
|
|
self.assertEqual(release_standing.standing_of(held, cut).moved, (held[0].id,))
|
|
self.assertEqual(release_standing.chunk_item(held, cut), release_standing.Next((1, 3, 0), dataclasses.replace(held[0], release=(1, 3, 0))))
|
|
self.assertEqual(carried_of(held[:1], dataclasses.replace(cut, todos_since=Failure("log unreadable"))), held[:1])
|
|
|
|
def test_takes_the_cut_releases_item_first_as_the_next_releases(self):
|
|
held = [dataclasses.replace(one((1, 2, 3)), id=1), dataclasses.replace(one((1, 3, 0)), id=2)]
|
|
cut = release_standing.LastCut("v1.2.3", "", 4, [])
|
|
self.assertEqual(release_standing.chunk_item(held, cut), release_standing.Next((1, 3, 0), dataclasses.replace(held[0], release=(1, 3, 0))))
|
|
self.assertEqual(next_of(held, cut), release_standing.Upcoming((1, 3, 0), True, True))
|
|
self.assertEqual(next_of(held[:1], cut), release_standing.Cut((1, 2, 3)))
|
|
|
|
|
|
class ChunkItem(unittest.TestCase):
|
|
def test_takes_the_earliest_release_where_it_is_the_next_and_else_says_whether_the_next_is_ready_to_cut_or_to_plan(self):
|
|
cases = (
|
|
("v1.2.3", 4, (1, 2, 4), set(), release_standing.Next((1, 2, 4), one((1, 2, 4)))),
|
|
("v1.2.3", 4, (1, 3, 0), {(1, 3, 0)}, release_standing.Next((1, 3, 0), one((1, 3, 0)))),
|
|
("v1.2.3", 4, (1, 2, 4), {(1, 3, 0)}, release_standing.Next((1, 2, 4), one((1, 2, 4)))),
|
|
("v1.2.3", 4, (1, 3, 0), {(1, 2, 3), (1, 3, 0)}, release_standing.Next((1, 3, 0), one((1, 3, 0)))),
|
|
("v0.2.0", 4, (0, 4, 0), set(), release_standing.Next((0, 4, 0), one((0, 4, 0)))),
|
|
(None, 4, (0, 2, 0), set(), release_standing.Next((0, 2, 0), one((0, 2, 0)))),
|
|
(None, 4, None, set(), release_standing.Next(None, None)),
|
|
("v1.2.3-rc.1", 4, (1, 2, 3), set(), release_standing.Next((1, 2, 3), one((1, 2, 3)))),
|
|
(Failure("tags unreadable"), 4, (0, 2, 0), set(), release_standing.Unknown()),
|
|
(Failure("tags unreadable"), 4, None, set(), release_standing.Unknown()),
|
|
("v1.2.3", 4, (1, 2, 3), set(), release_standing.Cut((1, 2, 3))),
|
|
("v1.2.3", 4, (1, 2, 2), set(), release_standing.Cut((1, 2, 2))),
|
|
("v1.2.3", 4, (1, 2, 2), {(1, 2, 4)}, release_standing.Next((1, 2, 4), one((1, 2, 4)))),
|
|
("v1.2.3", 4, (1, 3, 0), {(1, 2, 4), (1, 3, 0)}, release_standing.ReadyToCut((1, 2, 4))),
|
|
("v0.9.2", 4, (1, 0, 0), {(0, 9, 3)}, release_standing.ReadyToCut((0, 9, 3))),
|
|
("v1.2.3", 4, (1, 4, 0), {(1, 2, 2), (1, 3, 0)}, release_standing.ReadyToCut((1, 3, 0))),
|
|
("v1.2.3", 4, None, {(1, 3, 0)}, release_standing.ReadyToCut((1, 3, 0))),
|
|
("v1.2.3", 4, None, set(), release_standing.ReadyToCut(None)),
|
|
("v1.2.3", 0, (1, 3, 0), {(1, 2, 4)}, release_standing.Unplanned((1, 2, 4))),
|
|
("v1.2.3", 0, None, set(), release_standing.Unplanned(None)),
|
|
("v1.2.3", Failure("count unreadable"), None, set(), release_standing.Unknown()),
|
|
("v1.2.3", Failure("count unreadable"), (1, 3, 0), {(1, 3, 0)}, release_standing.Next((1, 3, 0), one((1, 3, 0)))),
|
|
("v1.2.3", 4, (1, 3, 0), Failure("log unreadable"), release_standing.Unknown()),
|
|
("v1.2.3", 4, (1, 2, 3), Failure("log unreadable"), release_standing.Cut((1, 2, 3))),
|
|
)
|
|
for tag, changes, earliest, named, stands in cases:
|
|
with self.subTest(tag=tag, changes=changes, earliest=earliest, named=named):
|
|
self.assertEqual(release_standing.chunk_item(plan_under(earliest), release_standing.LastCut(tag, "", changes, naming(named), reviewed=True)), stands)
|
|
|
|
def test_calls_a_release_review_due_where_the_next_release_holds_no_item_and_none_landed_since_the_cut(self):
|
|
cut = lambda reviewed: release_standing.LastCut("v1.2.3", "", 4, naming({(1, 3, 0)}), reviewed)
|
|
self.assertEqual(release_standing.chunk_item([], cut(False)), release_standing.ReviewDue((1, 3, 0)))
|
|
self.assertEqual(release_standing.chunk_item([], cut(True)), release_standing.ReadyToCut((1, 3, 0)))
|
|
self.assertEqual(release_standing.chunk_item([], cut(Failure("log unreadable"))), release_standing.Unknown())
|
|
self.assertEqual(release_standing.chunk_item(plan_under((1, 3, 0)), cut(False)), release_standing.Next((1, 3, 0), one((1, 3, 0))), "a review matters only once the release's items run out")
|
|
self.assertEqual(release_standing.chunk_item([], release_standing.LastCut("v1.2.3", "", 0, naming({(1, 3, 0)}))), release_standing.Unplanned((1, 3, 0)))
|
|
|
|
def test_takes_an_item_of_any_release_on_a_branch_with_no_tag(self):
|
|
for release in ((0, 0, 0), (0, 0, 1), (0, 1, 0)):
|
|
with self.subTest(release=release):
|
|
self.assertEqual(release_standing.chunk_item(plan_under(release), release_standing.LastCut(None, "", 4, naming(set()))), release_standing.Next(release, one(release)))
|
|
|
|
def test_calls_a_release_0_0_0_finished_on_a_branch_with_no_tag(self):
|
|
history = [HEADER + ROW.format(id=1, release="0.0.0"), HEADER]
|
|
self.assertEqual(release_standing.chunk_item([], release_standing.LastCut(None, "", 4, history)), release_standing.ReviewDue((0, 0, 0)))
|
|
|
|
def test_calls_a_release_that_never_had_a_tag_finished_once_the_plan_files_no_item_under_it(self):
|
|
history = [HEADER + ROW.format(id=1, release="0.1.0") + ROW.format(id=2, release="0.1.1"), HEADER + ROW.format(id=2, release="0.1.1")]
|
|
cut = lambda reviewed: release_standing.LastCut(None, "", 4, history, reviewed)
|
|
self.assertEqual(release_standing.chunk_item(plan_under((0, 1, 1)), cut(False)), release_standing.ReviewDue((0, 1, 0)))
|
|
self.assertEqual(release_standing.chunk_item(plan_under((0, 1, 1)), cut(True)), release_standing.ReadyToCut((0, 1, 0)))
|
|
self.assertEqual(release_standing.chunk_item(plan_under((0, 1, 0)), cut(False)), release_standing.Next((0, 1, 0), one((0, 1, 0))))
|
|
|
|
def test_counts_a_dated_changelog_heading_as_cut_on_a_branch_with_no_tag(self):
|
|
changelog = "# Changelog\n\n## Unreleased\n\n## 0.0.1 - 2026-10-03\n\n- Shipped.\n"
|
|
history = [HEADER + ROW.format(id=1, release="0.0.1"), HEADER]
|
|
self.assertEqual(release_standing.chunk_item([], release_standing.LastCut(None, changelog, 4, history)), release_standing.Unplanned(None))
|
|
without_unreleased = release_standing.LastCut(None, "# Changelog\n\n## 0.0.1 - 2026-10-03\n", 4, history)
|
|
self.assertNotEqual(release_standing.chunk_item([], without_unreleased), release_standing.ReviewDue((0, 0, 1)), "0.0.1 is cut under its dated heading")
|
|
later = [HEADER + ROW.format(id=1, release="0.0.1") + ROW.format(id=2, release="0.1.0"), HEADER + ROW.format(id=2, release="0.1.0")]
|
|
self.assertEqual(release_standing.chunk_item(plan_under((0, 1, 0)), release_standing.LastCut(None, changelog, 4, later)), release_standing.Next((0, 1, 0), one((0, 1, 0))))
|
|
self.assertEqual(release_standing.chunk_item(plan_under((0, 0, 1)), release_standing.LastCut(None, changelog, 4, later)), release_standing.Next((0, 1, 0), one((0, 1, 0))))
|
|
self.assertEqual(release_standing.chunk_item(plan_under((0, 0, 1)), release_standing.LastCut(None, changelog, 4, history)), release_standing.Cut((0, 0, 1)))
|
|
|
|
def test_counts_neither_an_undated_heading_nor_a_heading_behind_a_tag_as_cut(self):
|
|
history = [HEADER + ROW.format(id=1, release="0.0.1"), HEADER]
|
|
undated = release_standing.LastCut(None, "# Changelog\n\n## 0.0.1\n\n- Shipped.\n", 4, history)
|
|
self.assertEqual(release_standing.chunk_item([], undated), release_standing.ReviewDue((0, 0, 1)))
|
|
tagged = release_standing.LastCut("v0.1.0", "# Changelog\n\n## 0.2.0 - 2026-10-03\n", 4, [HEADER + ROW.format(id=1, release="0.2.0")])
|
|
self.assertEqual(release_standing.chunk_item(plan_under((0, 2, 0)), tagged), release_standing.Next((0, 2, 0), one((0, 2, 0))))
|
|
|
|
def test_reads_every_version_of_todo_md_where_the_branch_has_no_tag(self):
|
|
repo = tempfile.mkdtemp()
|
|
self.addCleanup(subprocess.run, ["rm", "-rf", repo])
|
|
run = lambda *args: subprocess.run(["git", "-c", "user.name=t", "-c", "user.email=t@t", *args], capture_output=True, check=True, cwd=repo, env=isolated_env(), text=True)
|
|
run("init", "-q", "-b", "main")
|
|
first, newest = HEADER + ROW.format(id=1, release="0.1.0"), HEADER + ROW.format(id=2, release="0.1.1")
|
|
pathlib.Path(repo, "todo.md").write_text(first)
|
|
run("add", "todo.md")
|
|
run("commit", "-q", "-m", "Plan")
|
|
run("commit", "-q", "--allow-empty", "-m", "Ship item 1")
|
|
pathlib.Path(repo, "todo.md").write_text(newest)
|
|
run("commit", "-q", "-a", "-m", "Ship item 1 for good")
|
|
self.assertEqual(release_standing.todos_since(None, "main", "todo.md", repo), [first, newest])
|
|
self.assertEqual(release_standing.todos_since(Failure("tags unreadable"), "main", "todo.md", repo), [])
|
|
self.assertEqual(release_standing.todos_since(None, "main", None, repo), [], "no commit holds a plan outside the checkout")
|
|
|
|
def test_finds_a_release_review_among_the_commits_since_the_cut(self):
|
|
repo = tempfile.mkdtemp()
|
|
self.addCleanup(subprocess.run, ["rm", "-rf", repo])
|
|
run = lambda *args: subprocess.run(["git", "-c", "user.name=t", "-c", "user.email=t@t", *args], capture_output=True, check=True, cwd=repo, env=isolated_env(), text=True)
|
|
run("init", "-q", "-b", "main")
|
|
run("commit", "-q", "--allow-empty", "-m", "Release review of 0.1.0")
|
|
run("tag", "v0.1.0")
|
|
run("commit", "-q", "--allow-empty", "-m", "Ship item 4")
|
|
self.assertIs(release_standing.release_reviewed("v0.1.0", "main", repo, BARE), False, "a review before the cut reviewed that release")
|
|
run("commit", "-q", "--allow-empty", "-m", "Release review of 0.2.0")
|
|
run("commit", "-q", "--allow-empty", "-m", "Answer architecture round 1: 0 🔴, 1 🟡 (0 misread); split loader")
|
|
self.assertIs(release_standing.release_reviewed("v0.1.0", "main", repo, BARE), True)
|
|
self.assertIs(release_standing.release_reviewed(None, "main", repo, BARE), True)
|
|
self.assertIsInstance(release_standing.release_reviewed("v9.9.9", "main", repo, BARE), Failure)
|
|
self.assertEqual(release_standing.default_plan(repo, "main", plan_in(repo), changelog_of(repo), BARE).cut.reviewed, True)
|
|
run("tag", "v0.2.0")
|
|
run("commit", "-q", "--allow-empty", "-m", "PAY-9 - Release review of 0.3.0")
|
|
self.assertIs(release_standing.release_reviewed("v0.2.0", "main", repo, BARE), False)
|
|
self.assertIs(release_standing.release_reviewed("v0.2.0", "main", repo, Titles("PAY-{id} - {summary}", "{summary}")), True)
|
|
self.assertIs(release_standing.release_reviewed("v0.2.0", "main", repo, Titles("{summary}", "PAY-{id} - {summary}")), True, "a squash merge titles the commit as the pull request")
|
|
self.assertEqual(release_standing.default_plan(repo, "main", plan_in(repo), changelog_of(repo), Titles("PAY-{id} - {summary}", "{summary}")).cut.reviewed, True)
|
|
paths = {setting: pathlib.Path(repo, setting) for setting in SETTINGS} | {"plan": pathlib.Path(repo, "todo.md"), "changelog": pathlib.Path(repo, "CHANGELOG.md")}
|
|
config = ProjectConfig("acme", pathlib.Path(repo, "folder"), pathlib.Path(repo), paths)
|
|
self.assertIs(release_standing.project_plan(config, "main", repo).cut.reviewed, False)
|
|
self.assertIs(release_standing.project_plan(dataclasses.replace(config, commit_title="PAY-{id} - {summary}"), "main", repo).cut.reviewed, True)
|
|
self.assertIs(release_standing.project_plan(dataclasses.replace(config, pull_request_title="PAY-{id} - {summary}"), "main", repo).cut.reviewed, True)
|
|
|
|
def test_counts_no_release_review_of_a_release_cut_under_a_dated_heading_on_a_branch_with_no_tag(self):
|
|
repo = tempfile.mkdtemp()
|
|
self.addCleanup(subprocess.run, ["rm", "-rf", repo])
|
|
run = lambda *args: subprocess.run(["git", "-c", "user.name=t", "-c", "user.email=t@t", *args], capture_output=True, check=True, cwd=repo, env=isolated_env(), text=True)
|
|
run("init", "-q", "-b", "main")
|
|
run("commit", "-q", "--allow-empty", "-m", "Release review of 0.0.1")
|
|
pathlib.Path(repo, "CHANGELOG.md").write_text("# Changelog\n\n## 0.0.1 - 2026-10-03\n")
|
|
run("add", "CHANGELOG.md")
|
|
run("commit", "-q", "-m", "Cut 0.0.1")
|
|
self.assertIs(release_standing.default_plan(repo, "main", plan_in(repo), changelog_of(repo), BARE).cut.reviewed, False, "that review reviewed 0.0.1, which is cut")
|
|
self.assertEqual(release_standing.default_plan(repo, "main", plan_in(repo), changelog_of(repo), BARE).cut.commits, 0, "no commit follows the one that cut 0.0.1")
|
|
self.assertEqual(release_standing.chunk_item([], release_standing.default_plan(repo, "main", plan_in(repo), changelog_of(repo), BARE).cut), release_standing.Unplanned(None))
|
|
run("commit", "-q", "--allow-empty", "-m", "Ship item 2")
|
|
self.assertEqual(release_standing.default_plan(repo, "main", plan_in(repo), changelog_of(repo), BARE).cut.commits, 1)
|
|
run("commit", "-q", "--allow-empty", "-m", "Release review of 0.1.0")
|
|
self.assertIs(release_standing.default_plan(repo, "main", plan_in(repo), changelog_of(repo), BARE).cut.reviewed, True)
|
|
|
|
def test_counts_from_the_commit_on_the_named_branch_that_first_added_the_dated_heading_to_changelog_md(self):
|
|
repo = tempfile.mkdtemp()
|
|
self.addCleanup(subprocess.run, ["rm", "-rf", repo])
|
|
run = lambda *args: subprocess.run(["git", "-c", "user.name=t", "-c", "user.email=t@t", *args], capture_output=True, check=True, cwd=repo, env=isolated_env(), text=True)
|
|
changelog = pathlib.Path(repo, "CHANGELOG.md")
|
|
run("init", "-q", "-b", "main")
|
|
pathlib.Path(repo, "notes.md").write_text("## 0.0.1 - 2026-10-01\n")
|
|
changelog.write_text("# Changelog\n\n## Unreleased\n\n- Quote `## 0.0.1 - 2026-10-02`.\n")
|
|
run("add", ".")
|
|
run("commit", "-q", "-m", "Notes and a quoted heading")
|
|
changelog.write_text("# Changelog\n\n## 0.0.1 - 2026-10-03\n")
|
|
run("commit", "-q", "-am", "Cut 0.0.1")
|
|
changelog.write_text("# Changelog\n\n## 0.0.1 - 2026-10-04\n")
|
|
run("commit", "-q", "-am", "Fix 0.0.1's date")
|
|
run("commit", "-q", "--allow-empty", "-m", "Ship item 2")
|
|
run("checkout", "-q", "-b", "side")
|
|
run("commit", "-q", "--allow-empty", "-m", "Side work")
|
|
self.assertEqual(release_standing.default_plan(repo, "main", plan_in(repo), changelog_of(repo), BARE).cut.commits, 2, "the commits after Cut 0.0.1 on main")
|
|
|
|
def test_reads_the_changelog_and_its_cut_on_the_named_branch_whatever_is_checked_out(self):
|
|
repo = tempfile.mkdtemp()
|
|
self.addCleanup(subprocess.run, ["rm", "-rf", repo])
|
|
run = lambda *args: subprocess.run(["git", "-c", "user.name=t", "-c", "user.email=t@t", *args], capture_output=True, check=True, cwd=repo, env=isolated_env(), text=True)
|
|
changelog = pathlib.Path(repo, "CHANGELOG.md")
|
|
run("init", "-q", "-b", "main")
|
|
changelog.write_text("# Changelog\n\n## Unreleased\n")
|
|
run("add", ".")
|
|
run("commit", "-q", "-m", "Start")
|
|
run("checkout", "-q", "-b", "side")
|
|
changelog.write_text("# Changelog\n\n## 0.0.1 - 2026-10-02\n\n- Side.\n")
|
|
run("commit", "-q", "-am", "Cut 0.0.1 on the side")
|
|
run("checkout", "-q", "main")
|
|
changelog.write_text("# Changelog\n\n## 0.0.1 - 2026-10-03\n")
|
|
run("commit", "-q", "-am", "Cut 0.0.1")
|
|
run("commit", "-q", "--allow-empty", "-m", "Ship item 2")
|
|
run("checkout", "-q", "side")
|
|
changelog.write_text("# Changelog\n\nAn edit nobody committed.\n")
|
|
cut = release_standing.default_plan(repo, "main", plan_in(repo), changelog_of(repo), BARE).cut
|
|
self.assertEqual((cut.changelog, cut.commits), ("# Changelog\n\n## 0.0.1 - 2026-10-03\n", 1), "main's changelog, and the commit after Cut 0.0.1 on main")
|
|
|
|
def test_takes_the_tag_over_a_dated_heading_and_counts_every_commit_without_either(self):
|
|
repo = tempfile.mkdtemp()
|
|
self.addCleanup(subprocess.run, ["rm", "-rf", repo])
|
|
run = lambda *args: subprocess.run(["git", "-c", "user.name=t", "-c", "user.email=t@t", *args], capture_output=True, check=True, cwd=repo, env=isolated_env(), text=True)
|
|
run("init", "-q", "-b", "main")
|
|
pathlib.Path(repo, "todo.md").write_text(HEADER + ROW.format(id=1, release="0.2.0"))
|
|
run("add", "todo.md")
|
|
run("commit", "-q", "-m", "Plan")
|
|
self.assertEqual(release_standing.default_plan(repo, "main", plan_in(repo), changelog_of(repo), BARE).cut, release_standing.LastCut(None, "", 1, [HEADER + ROW.format(id=1, release="0.2.0")], False))
|
|
run("tag", "v0.1.0")
|
|
pathlib.Path(repo, "CHANGELOG.md").write_text("# Changelog\n\n## 0.2.0 - 2026-10-03\n")
|
|
run("add", "CHANGELOG.md")
|
|
run("commit", "-q", "-m", "Date 0.2.0")
|
|
held = release_standing.default_plan(repo, "main", plan_in(repo), changelog_of(repo), BARE)
|
|
self.assertEqual(held.plan, plan_of(HEADER + ROW.format(id=1, release="0.2.0")))
|
|
self.assertEqual(held.cut, release_standing.LastCut("v0.1.0", "# Changelog\n\n## 0.2.0 - 2026-10-03\n", 1, [HEADER + ROW.format(id=1, release="0.2.0")], False))
|
|
self.assertEqual(release_standing.chunk_item(plan_under((0, 2, 0)), held.cut), release_standing.Next((0, 2, 0), one((0, 2, 0))))
|
|
|
|
def test_reads_a_plan_and_a_changelog_outside_the_checkout_as_they_stand(self):
|
|
repo, folder = tempfile.mkdtemp(), pathlib.Path(tempfile.mkdtemp())
|
|
self.addCleanup(subprocess.run, ["rm", "-rf", repo, str(folder)])
|
|
run = lambda *args: subprocess.run(["git", "-c", "user.name=t", "-c", "user.email=t@t", *args], capture_output=True, check=True, cwd=repo, env=isolated_env(), text=True)
|
|
run("init", "-q", "-b", "main")
|
|
pathlib.Path(repo, "todo.md").write_text(HEADER + ROW.format(id=1, release="0.9.0"))
|
|
run("add", "todo.md")
|
|
run("commit", "-q", "-m", "A todo.md the project's owners keep")
|
|
held = release_standing.default_plan(repo, "main", plan_at(folder / "todo.md", None), FileStore(folder / "CHANGELOG.md", None), BARE)
|
|
self.assertIsInstance(held.plan, NoItemsTable, "neither file exists yet")
|
|
self.assertEqual(held.cut, release_standing.LastCut(None, "", 1, [], False))
|
|
plan = HEADER + ROW.format(id=2, release="0.2.0")
|
|
(folder / "todo.md").write_text(plan)
|
|
(folder / "CHANGELOG.md").write_text("# Changelog\n\n## 0.1.0 - 2026-10-03\n")
|
|
held = release_standing.default_plan(repo, "main", plan_at(folder / "todo.md", None), FileStore(folder / "CHANGELOG.md", None), BARE)
|
|
self.assertEqual(held.plan, plan_of(plan))
|
|
self.assertEqual(held.cut, release_standing.LastCut(None, "# Changelog\n\n## 0.1.0 - 2026-10-03\n", 1, [], False), "no commit holds an earlier plan")
|
|
(folder / "todo.md").write_bytes(b"\xff")
|
|
unreadable = release_standing.default_plan(repo, "main", plan_at(folder / "todo.md", None), changelog_of(repo), BARE)
|
|
self.assertEqual((unreadable.plan, unreadable.cut.todos_since), (Failure(f"{folder}/todo.md: not UTF-8"), []))
|
|
|
|
def test_reads_the_checkout_only_through_the_git_it_is_given(self):
|
|
repo = tempfile.mkdtemp()
|
|
self.addCleanup(subprocess.run, ["rm", "-rf", repo])
|
|
run = lambda *args: subprocess.run(["git", "-c", "user.name=t", "-c", "user.email=t@t", *args], capture_output=True, check=True, cwd=repo, env=isolated_env(), text=True)
|
|
run("init", "-q", "-b", "main")
|
|
plan = HEADER + ROW.format(id=1, release="0.2.0")
|
|
pathlib.Path(repo, "todo.md").write_text(plan)
|
|
pathlib.Path(repo, "CHANGELOG.md").write_text("# Changelog\n\n## 0.1.0 - 2026-10-03\n")
|
|
run("add", ".")
|
|
run("commit", "-q", "-m", "Cut 0.1.0")
|
|
# Only this git knows where the checkout is, so a read that goes round it fails.
|
|
there = lambda *args, cwd: release_standing.git(*args, cwd=repo)
|
|
held = release_standing.default_plan("/nowhere", "main", plan_in("/nowhere"), changelog_of("/nowhere"), BARE, there)
|
|
self.assertEqual(held, release_standing.DefaultPlan(plan_of(plan), release_standing.LastCut(None, "# Changelog\n\n## 0.1.0 - 2026-10-03\n", 0, [plan], False)))
|
|
|
|
def test_counts_the_changes_unreleased_since_the_last_cut_by_unreleased_entries_and_else_by_commits(self):
|
|
changelog = "# Changelog\n\n## Unreleased\n\n- One.\n - A nested line.\n- Two.\n\n## 0.1.0\n\n- Old.\n"
|
|
self.assertEqual(release_standing.unreleased_changes(release_standing.LastCut("v0.1.0", changelog, 5, [])), 2)
|
|
self.assertEqual(release_standing.unreleased_changes(release_standing.LastCut("v0.1.0", "# Changelog\n\n## Unreleased\n\n## 0.1.0\n", 5, [])), 0)
|
|
self.assertEqual(release_standing.unreleased_changes(release_standing.LastCut("v0.1.0", "# Changelog\n\n## 0.1.0\n", 5, [])), 5)
|
|
self.assertEqual(release_standing.unreleased_changes(release_standing.LastCut("v0.1.0", Failure("unreadable"), 5, [])), 5)
|
|
|
|
def test_counts_the_top_level_entries_under_unreleased(self):
|
|
self.assertEqual(release_standing.unreleased_entries("# Changelog\n\n## Unreleased\n\n- One.\n - A nested line.\n- Two.\n\n## 0.1.0\n\n- Old.\n"), 2)
|
|
self.assertEqual(release_standing.unreleased_entries("# Changelog\n\n## Unreleased\n\n## 0.1.0\n\n- Old.\n"), 0)
|
|
self.assertIsNone(release_standing.unreleased_entries("# Changelog\n\n## 0.1.0\n\n- Old.\n"))
|
|
# A heading inside a code fence doesn't end the section.
|
|
self.assertEqual(release_standing.unreleased_entries("# Changelog\n\n## Unreleased\n\n- One.\n\n```\n## 0.1.0\n```\n\n- Two.\n\n## 0.1.0\n\n- Old.\n"), 2)
|
|
# The section todo-item finish files a bullet under, as a project's own changelog may head it.
|
|
self.assertEqual(release_standing.unreleased_entries("# Changelog\n\n## 0.6.0 (unreleased)\n\n- One.\n\n## 0.5.0\n\n- Old.\n"), 1)
|
|
|
|
def test_names_each_release_a_todo_md_since_the_last_cut_filed_items_under(self):
|
|
texts = [HEADER + ROW.format(id=1, release="0.2.0"), "", "not a table | x |", HEADER + ROW.format(id=2, release="0.3.0")]
|
|
self.assertEqual(release_standing.named_releases(texts), {(0, 2, 0), (0, 3, 0)})
|
|
self.assertEqual(release_standing.named_releases(Failure("log unreadable")), Failure("log unreadable"))
|
|
|
|
def test_leaves_out_a_release_the_plan_marks_renamed_and_keeps_one_whose_items_moved_unmarked(self):
|
|
plan = lambda *rows, renamed=(): HEADER + "".join(ROW.format(id=id_, release=release) for id_, release in rows) + ("\n## Renamed\n\n" + "".join(f"- {old} renamed to {new}\n" for old, new in renamed) if renamed else "")
|
|
cases = (
|
|
("renamed", [plan((1, "0.2.1")), plan((1, "0.3.0"), renamed=[("0.2.1", "0.3.0")])], {(0, 3, 0)}),
|
|
("deferred: its items moved without a mark", [plan((1, "0.2.1"), (2, "0.3.0")), plan((1, "0.3.0"), (2, "0.3.0"))], {(0, 2, 1), (0, 3, 0)}),
|
|
("renamed in a change that also dropped one of its items", [plan((1, "0.2.1"), (3, "0.2.1")), plan((1, "0.3.0"), renamed=[("0.2.1", "0.3.0")])], {(0, 3, 0)}),
|
|
("the plan shifted one minor", [plan((1, "0.2.1"), (2, "0.3.0")), plan((1, "0.3.0"), (2, "0.4.0"), renamed=[("0.2.1", "0.3.0"), ("0.3.0", "0.4.0")])], {(0, 3, 0), (0, 4, 0)}),
|
|
("the mark stays in later plans", [plan((1, "0.2.1")), plan((1, "0.3.0"), renamed=[("0.2.1", "0.3.0")]), plan((1, "0.3.0"), (2, "0.3.0"), renamed=[("0.2.1", "0.3.0")])], {(0, 3, 0)}),
|
|
("renamed, then named again", [plan((1, "0.2.1")), plan((1, "0.3.0"), renamed=[("0.2.1", "0.3.0")]), plan((1, "0.3.0"), (3, "0.2.1"), renamed=[("0.2.1", "0.3.0")])], {(0, 2, 1), (0, 3, 0)}),
|
|
("an older plan's mark that does not parse", [plan((1, "0.2.1")), plan((1, "0.3.0")) + "\n## Renamed\n\nsoon\n", plan((1, "0.3.0"))], {(0, 2, 1), (0, 3, 0)}),
|
|
)
|
|
for name, texts, named in cases:
|
|
with self.subTest(name):
|
|
self.assertEqual(release_standing.named_releases(texts), named)
|
|
|
|
def test_fails_to_name_releases_when_the_newest_plan_marks_one_in_a_form_it_cannot_read(self):
|
|
plan = "## Items\n\n| ID | Release | Blocked by | Exempt | Item | L | E | I | R | S | Moves | Score |\n|---|---|---|---|---|---|---|---|---|---|---|---|\n| 1 | 0.3.0 | | | **Do 1.** | 1 | 1 | 1 | 1 | 1 | 1 by 1 | 10.0 |\n"
|
|
self.assertIsInstance(release_standing.named_releases([plan, plan + "\n## Renamed\n\nsoon\n"]), Failure)
|
|
|
|
|
|
class NextChunk(unittest.TestCase):
|
|
def test_names_the_release_a_carried_item_moved_to_not_another_items(self):
|
|
later, carried, next_one = (dataclasses.replace(one(release), id=id_) for id_, release in ((9, (0, 4, 0)), (5, (0, 2, 0)), (3, (0, 3, 0))))
|
|
planned = next_chunk.planned(Plan([later, carried, next_one]), release_standing.LastCut("v0.2.0", "", 4, []), "origin/main", "item-{id}")
|
|
assert isinstance(planned, next_chunk.NextChunk), planned
|
|
self.assertEqual(planned.carried, next_chunk.CarriedOver((0, 3, 0), (5,)))
|