294 lines
21 KiB
Python
294 lines
21 KiB
Python
import pathlib
|
|
import subprocess
|
|
import sys
|
|
import tempfile
|
|
import unittest
|
|
|
|
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
|
|
|
|
from failure import Failure
|
|
from record_store.stores import FileStore
|
|
from test_env import isolated_env
|
|
from release_plan import release_standing
|
|
from release_plan import todo_table
|
|
from release_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 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(release_standing.next_release(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(release_standing.next_release([one((1, 3, 0))], cut(4)), release_standing.Upcoming((1, 3, 0), True, True))
|
|
self.assertEqual(release_standing.next_release([one((1, 3, 0))], cut(0)), release_standing.Upcoming((1, 3, 0), True, False))
|
|
self.assertEqual(release_standing.next_release([one((1, 3, 0))], cut(Failure("count unreadable"))), release_standing.Upcoming((1, 3, 0), True, Failure("count unreadable")))
|
|
|
|
|
|
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), {(1, 2, 4)}, release_standing.Cut((1, 2, 2))),
|
|
("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.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), [])
|
|
|
|
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), 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), True)
|
|
self.assertIs(release_standing.release_reviewed(None, "main", repo), True)
|
|
self.assertIsInstance(release_standing.release_reviewed("v9.9.9", "main", repo), Failure)
|
|
self.assertEqual(release_standing.default_plan(repo, "main", "todo.md", changelog_of(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", "todo.md", changelog_of(repo)).cut.reviewed, False, "that review reviewed 0.0.1, which is cut")
|
|
self.assertEqual(release_standing.default_plan(repo, "main", "todo.md", changelog_of(repo)).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", "todo.md", changelog_of(repo)).cut), release_standing.Unplanned(None))
|
|
run("commit", "-q", "--allow-empty", "-m", "Ship item 2")
|
|
self.assertEqual(release_standing.default_plan(repo, "main", "todo.md", changelog_of(repo)).cut.commits, 1)
|
|
run("commit", "-q", "--allow-empty", "-m", "Release review of 0.1.0")
|
|
self.assertIs(release_standing.default_plan(repo, "main", "todo.md", changelog_of(repo)).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", "todo.md", changelog_of(repo)).cut.commits, 2, "the commits 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", "todo.md", changelog_of(repo)).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", "todo.md", changelog_of(repo))
|
|
self.assertEqual(held.todo, 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", folder / "todo.md", FileStore(folder / "CHANGELOG.md", None))
|
|
self.assertEqual((held.todo, held.cut), ("", release_standing.LastCut(None, "", 1, [""], False)), "neither file exists yet")
|
|
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", folder / "todo.md", FileStore(folder / "CHANGELOG.md", None))
|
|
self.assertEqual(held.todo, plan)
|
|
self.assertEqual(held.cut, release_standing.LastCut(None, "# Changelog\n\n## 0.1.0 - 2026-10-03\n", 1, [plan], False))
|
|
(folder / "todo.md").write_bytes(b"\xff")
|
|
unreadable = release_standing.default_plan(repo, "main", folder / "todo.md", changelog_of(repo))
|
|
assert isinstance(unreadable.todo, Failure) and isinstance(unreadable.cut.todos_since, Failure), unreadable
|
|
self.assertTrue(unreadable.todo.reason.startswith(f"cannot read {folder}/todo.md: "), unreadable.todo.reason)
|
|
self.assertEqual(unreadable.cut.todos_since, unreadable.todo)
|
|
|
|
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", "todo.md", changelog_of("/nowhere"), there)
|
|
self.assertEqual(held, release_standing.DefaultPlan(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"))
|
|
|
|
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)
|