Files
claude-config/bin/todo_item/test_todo_item.py
T

510 lines
25 KiB
Python

import contextlib
import io
import pathlib
import sys
import tempfile
import unittest
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent.parent))
from project_config.test_project_config import configured
from plan.test_ranking import DECISIONS, README, TODO
from project_config.settings import DEFAULT_FLOOR
from todo_item import edits, main
from failure import Failure
from plan_store.stores import file_plan
from project_config.main import located
from plan_store.fakes import MemoryPlan
from plan_store.todo_md import plan_of
from plan import ranking
from todo_item.table import table
ADD = ["add", "--release", "0.1.0", "--l", "1", "--e", "1", "--i", "1", "--s", "1", "--moves", "1 by 9", "Count the `a | b` runs."]
CHANGELOG = "# Changelog\n\n## Unreleased\n\n- Older news.\n\n## 0.1.0\n\n- First.\n"
# ## Details of the ranked fixture, without the trailing ## Notes.
HEADER = "| ID | Release | Blocked by | Exempt | Item | L | E | I | R | S | Moves |\n|---|---|---|---|---|---|---|---|---|---|---|\n"
DETAILS = "## Details\n\n### 3. Make it fast, `a | b`.\n\nFast detail.\n\n### 1. Ship the later thing.\n\nLater detail.\n\n"
class Terminal(io.StringIO):
"""A stdin that reads as a terminal, so add must not read it."""
def isatty(self):
return True
class TodoItem(unittest.TestCase):
def setUp(self):
temp = tempfile.TemporaryDirectory()
self.addCleanup(temp.cleanup)
self.folder = pathlib.Path(temp.name)
self.config = configured(self, self.folder) / "config.toml"
self.todo = self.folder / "todo.md"
self.changelog = self.folder / "CHANGELOG.md"
(self.folder / "README.md").write_text(README)
(self.folder / "docs").mkdir()
(self.folder / "docs" / "decisions.md").write_text(DECISIONS)
ranked = ranking.rank(TODO, README, DECISIONS, "", DEFAULT_FLOOR)
assert not isinstance(ranked, ranking.Failure)
self.todo.write_text(ranked.text)
def run_main(self, *argv, stdin: str | io.StringIO = ""):
with contextlib.redirect_stdout(io.StringIO()) as out, contextlib.redirect_stderr(io.StringIO()) as err:
code = main.main(list(argv), self.folder, io.StringIO(stdin) if isinstance(stdin, str) else stdin)
return code, out.getvalue(), err.getvalue()
def exit_code(self, *argv):
with contextlib.redirect_stdout(io.StringIO()), contextlib.redirect_stderr(io.StringIO()), self.assertRaises(SystemExit) as raised:
main.main(list(argv), self.folder, io.StringIO())
return raised.exception.code
def assert_ranked(self):
self.assertEqual(file_plan(located(str(self.folder), pathlib.Path.home()), self.todo).check(), [])
def details(self):
text = self.todo.read_text()
return text[text.index("## Details"):text.index("## Notes")]
def lower_item_2_under_the_bar(self):
self.todo.write_text(self.todo.read_text().replace("**Tighten the tests.** | 1 | 2 | 1 | 2 | 4 |", "**Tighten the tests.** | 1 | 2 | 1 | 2 | 9 |"))
class Help(TodoItem):
def test_prints_the_whole_docstring_and_exits_0(self):
for flag in ("-h", "--help"):
with self.subTest(flag):
code, out, err = self.run_main(flag)
self.assertEqual((code, out, err), (0, main.__doc__.strip() + "\n", ""))
for fact in ("stdin", "--changelog", "--no-changelog", "Exit 2"):
self.assertIn(fact, out)
class BadArguments(TodoItem):
def test_exit_2(self):
for argv in ([], ADD[:1] + ADD[3:], ADD[:3] + ADD[5:], ["finish"], ["show"], ["edit"], ["move", "3"], ["move", "3", "0.2.0"], ["list", "0.1.0"], ["edit", "3", "--detail", "--clear-detail"], ["edit", "3", "--release", "0.2.0"]):
with self.subTest(argv):
self.assertEqual(self.exit_code(*argv), 2)
def test_a_checkout_no_config_names_exits_1_with_the_reason(self):
self.config.unlink()
code, out, err = self.run_main("show", "1")
self.assertEqual((code, out), (1, ""))
self.assertIn("no config names the checkout", err)
class Add(TodoItem):
def test_takes_next_id_and_raises_it(self):
self.assertEqual(self.run_main(*ADD)[:2], (0, f"Filed item 6 in {self.todo}.\n"))
self.assertIn("`Next ID = 7`", self.todo.read_text())
def test_writes_the_row_with_the_tagline_bold_and_its_pipes_escaped(self):
self.run_main(*ADD)
self.assertIn("| 6 | 0.1.0 | | | **Count the `a \\| b` runs.** | 1 | 1 | 1 | 1 | 1 | 1 by 9 |", self.todo.read_text())
def test_takes_a_bold_tagline_upper_case_letters_blockers_and_exempt(self):
argv = ["add", "--release", "0.1.0", "--blocked-by", "2", "--exempt", "owner", "--L", "1", "--E", "1", "--I", "1", "--S", "1", "**Count the runs.**"]
self.assertEqual(self.run_main(*argv)[0], 0)
self.assertIn("| 6 | 0.1.0 | 2 | owner | **Count the runs.** | 1 | 1 | 1 | 1 | 1 | |", self.todo.read_text())
def test_writes_the_detail_from_stdin_into_the_one_details_section(self):
self.run_main(*ADD, stdin="What the tagline leaves out.\n")
self.assertEqual(self.details(), DETAILS.replace("### 3.", "### 6. Count the `a | b` runs.\n\nWhat the tagline leaves out.\n\n### 3."))
def test_leaves_the_file_ranked(self):
self.run_main(*ADD, stdin="Detail.")
self.assert_ranked()
def test_files_no_detail_from_empty_stdin(self):
self.assertEqual(self.run_main(*ADD)[0], 0)
self.assertEqual(self.details(), DETAILS)
def test_reads_no_detail_from_a_terminal(self):
self.assertEqual(self.run_main(*ADD, stdin=Terminal("Detail."))[0], 0)
self.assertEqual(self.details(), DETAILS)
def test_creates_details_where_todo_has_none(self):
self.todo.write_text(self.todo.read_text().split("## Details")[0].rstrip("\n") + "\n")
self.assertEqual(self.run_main(*ADD, stdin="Detail.")[0], 0)
self.assertTrue(self.todo.read_text().endswith("| 1 by 9 | 228.4 |\n\n## Details\n\n### 6. Count the `a | b` runs.\n\nDetail.\n"))
self.assert_ranked()
def test_takes_a_detail_holding_a_one_or_four_hash_line(self):
self.assertEqual(self.run_main(*ADD, stdin="Run it so:\n\n# run as root\n\n#### Why\n\nBecause.")[0], 0)
self.assertIn("### 6. Count the `a | b` runs.\n\nRun it so:\n\n# run as root\n\n#### Why\n\nBecause.\n", self.todo.read_text())
def test_reports_ranking_lines_on_stderr_prefixed_with_todo_md(self):
self.lower_item_2_under_the_bar()
_, _, err = self.run_main(*ADD)
self.assertTrue(err.startswith(f"{self.todo}: item 2 "), err)
def test_writes_nothing_where_it_refuses(self):
refused = {
"under the bar": ADD[:-3] + ["Count the runs."],
"a score ranking rejects": ADD[:4] + ["9"] + ADD[5:],
"a tagline with a line break": ADD[:-1] + ["Count\nthe runs."],
}
for case, argv in refused.items():
with self.subTest(case):
before = self.todo.read_text()
code, out, err = self.run_main(*argv)
self.assertEqual((code, out), (1, ""))
self.assertTrue(err.startswith("not filed: "), err)
self.assertEqual(self.todo.read_text(), before)
self.assertIn("item 6", self.run_main(*refused["under the bar"])[2])
def test_writes_nothing_for_a_detail_holding_a_two_or_three_hash_line(self):
for detail in ("## Goals", "### Why", "### 2. Other"):
with self.subTest(detail):
before = self.todo.read_text()
code, _, err = self.run_main(*ADD, stdin=f"Detail.\n\n{detail}\n")
self.assertEqual(code, 1)
self.assertTrue(err.startswith("not filed: "), err)
self.assertEqual(self.todo.read_text(), before)
class Finish(TodoItem):
def test_removes_the_row(self):
self.assertEqual(self.run_main("finish", "3", "--no-changelog"), (0, f"Finished item 3 in {self.todo}.\n", ""))
self.assertNotRegex(self.todo.read_text(), r"(?m)^\| 3 \|")
def test_removes_the_detail_and_keeps_the_others(self):
self.run_main("finish", "3", "--no-changelog")
self.assertEqual(self.details(), "## Details\n\n### 1. Ship the later thing.\n\nLater detail.\n\n")
def test_removes_a_detail_holding_a_sub_heading_whole(self):
self.todo.write_text(self.todo.read_text().replace("Fast detail.\n", "Fast detail.\n\n### Why\n\nFast tail.\n").replace("Later detail.\n", "Later detail.\n\n### Why\n\nLater tail.\n"))
self.assertEqual(self.run_main("finish", "3", "--no-changelog")[0], 0)
self.assertEqual(self.details(), "## Details\n\n### 1. Ship the later thing.\n\nLater detail.\n\n### Why\n\nLater tail.\n\n")
def test_leaves_the_file_ranked(self):
self.run_main("finish", "3", "--no-changelog")
self.assert_ranked()
def test_adds_the_bullet_first_under_unreleased(self):
self.changelog.write_text(CHANGELOG)
self.assertEqual(self.run_main("finish", "3", "--changelog", "Runs are fast."), (0, f"Finished item 3 in {self.todo}.\n", ""))
self.assertEqual(self.changelog.read_text(), "# Changelog\n\n## Unreleased\n\n- Runs are fast.\n- Older news.\n\n## 0.1.0\n\n- First.\n")
def test_creates_unreleased_above_the_first_release(self):
self.changelog.write_text("# Changelog\n\n## 0.1.0\n\n- First.\n")
self.assertEqual(self.run_main("finish", "3", "--changelog", "- Runs are fast.")[0], 0)
self.assertEqual(self.changelog.read_text(), "# Changelog\n\n## Unreleased\n\n- Runs are fast.\n\n## 0.1.0\n\n- First.\n")
def test_creates_the_changelog_where_missing(self):
self.assertEqual(self.run_main("finish", "2", "--changelog", "Tests are tight.")[0], 0)
self.assertEqual(self.changelog.read_text(), "# Changelog\n\n## Unreleased\n\n- Tests are tight.\n")
def test_needs_no_changelog_choice_where_the_project_has_no_changelog(self):
self.assertEqual(self.run_main("finish", "2"), (0, f"Finished item 2 in {self.todo}.\n", ""))
self.assertFalse(self.changelog.exists())
def test_needs_a_changelog_choice_where_a_changelog_exists(self):
self.changelog.write_text(CHANGELOG)
before = self.todo.read_text()
code, _, err = self.run_main("finish", "2")
self.assertEqual(code, 1)
self.assertTrue(err.startswith("not finished: "), err)
for fact in ("CHANGELOG.md", "--changelog", "--no-changelog"):
self.assertIn(fact, err)
self.assertEqual(self.todo.read_text(), before)
def test_leaves_the_changelog_as_is_with_no_changelog(self):
self.changelog.write_text(CHANGELOG)
self.assertEqual(self.run_main("finish", "2", "--no-changelog")[0], 0)
self.assertEqual(self.changelog.read_text(), CHANGELOG)
def test_reports_ranking_lines_on_stderr_prefixed_with_todo_md(self):
self.lower_item_2_under_the_bar()
_, _, err = self.run_main("finish", "3", "--no-changelog")
self.assertTrue(err.startswith(f"{self.todo}: item 2 "), err)
def test_writes_nothing_for_an_item_a_decision_cites(self):
before = self.todo.read_text()
code, _, err = self.run_main("finish", "5", "--changelog", "Writes moved out.")
self.assertEqual(code, 1)
self.assertTrue(err.startswith("not finished: "), err)
self.assertIn("item 5", err)
self.assertEqual(self.todo.read_text(), before)
self.assertFalse(self.changelog.exists())
def test_fails_on_an_item_the_table_does_not_hold(self):
code, out, err = self.run_main("finish", "9", "--no-changelog")
self.assertEqual((code, out), (1, ""))
self.assertTrue(err.startswith("not finished: "), err)
self.assertIn("9", err)
def test_fails_on_a_todo_md_without_an_items_table(self):
self.todo.write_text("# todo\n")
code, _, err = self.run_main("finish", "3", "--no-changelog")
self.assertEqual(code, 1)
self.assertIn("no items table", err)
self.assertEqual(self.todo.read_text(), "# todo\n")
def test_writes_neither_file_for_a_bullet_it_refuses(self):
changelogs = {
"an empty bullet": (CHANGELOG, ""),
"a whitespace bullet": (CHANGELOG, " \t "),
"a bullet with a line break": (CHANGELOG, "Runs\nare fast."),
"an Unreleased section with ### subsections": ("# Changelog\n\n## Unreleased\n\n### Security\n\n- Older news.\n", "Runs are fast."),
}
for case, (changelog, bullet) in changelogs.items():
with self.subTest(case):
self.changelog.write_text(changelog)
before = self.todo.read_text()
code, _, err = self.run_main("finish", "3", "--changelog", bullet)
self.assertEqual(code, 1)
self.assertTrue(err.startswith("not finished: "), err)
self.assertEqual((self.todo.read_text(), self.changelog.read_text()), (before, changelog))
def test_fails_on_a_changelog_that_is_not_utf_8(self):
self.changelog.write_bytes(b"# Changelog\n\n\xff\n")
before = self.todo.read_text()
code, _, err = self.run_main("finish", "3", "--changelog", "Runs are fast.")
self.assertEqual(code, 1)
self.assertTrue(err.startswith("not finished: "), err)
self.assertIn(str(self.changelog), err)
self.assertEqual(self.todo.read_text(), before)
class Show(TodoItem):
def test_prints_the_header_the_row_and_the_detail(self):
row = "| 3 | 0.1.0 | | | **Make it fast, `a \\| b`.** | 2 | 1 | 2 | 3 | 7 | 2.1 by 8, 1 by 6 |"
self.assertEqual(self.run_main("show", "3"), (0, f"From {self.todo}:\n\n{HEADER}{row}\n\n### 3. Make it fast, `a | b`.\n\nFast detail.\n", ""))
def test_works_on_the_plan_and_the_changelog_where_the_config_puts_them(self):
folder = self.config.parent
self.config.write_text(self.config.read_text().replace('"checkout:todo.md"', '"folder:todo.md"').replace('"checkout:CHANGELOG.md"', '"folder:news/CHANGELOG.md"').replace('"checkout:docs/decisions.md"', '"folder:decisions.md"'))
(folder / "decisions.md").write_text(DECISIONS)
self.todo.rename(folder / "todo.md")
self.todo.write_text("the project owners' own notes\n")
(folder / "news").mkdir()
(folder / "news" / "CHANGELOG.md").write_text("# Changelog\n")
self.assertEqual(self.run_main("show", "3")[1].split("\n")[0], f"From {folder}/todo.md:")
self.assertEqual(self.run_main(*ADD)[:2], (0, f"Filed item 6 in {folder}/todo.md.\n"))
self.assertEqual(self.run_main("finish", "3"), (1, "", f"not finished: {folder}/news/CHANGELOG.md exists; pass --changelog <bullet>, or --no-changelog where the repo doesn't publish anything or no chunk built the item\n"))
self.assertEqual(self.run_main("finish", "3", "--changelog", "Runs are fast."), (0, f"Finished item 3 in {folder}/todo.md.\n", ""))
self.assertIn("- Runs are fast.", (folder / "news" / "CHANGELOG.md").read_text())
self.assertEqual(self.todo.read_text(), "the project owners' own notes\n")
self.assertFalse(self.changelog.exists())
def test_prints_the_row_alone_where_the_item_has_no_detail(self):
code, out, err = self.run_main("show", "4")
self.assertEqual((code, err), (0, ""))
self.assertEqual(out.split("\n")[4:], ["| 4 | 0.1.0 | | security | **Rotate the leaked key.** | 3 | 3 | 5 | 9 | 2 | 2.1 by 1 |", ""])
def test_prints_a_detail_with_a_sub_heading_whole_and_no_other_detail(self):
self.todo.write_text(self.todo.read_text().replace("Fast detail.\n", "Fast detail.\n\n### Why\n\nFast tail.\n"))
_, out, _ = self.run_main("show", "3")
self.assertTrue(out.endswith("Fast detail.\n\n### Why\n\nFast tail.\n"), out)
def test_fails_where_the_id_has_no_row(self):
self.assertEqual(self.run_main("show", "99"), (1, "", f"{self.todo} holds no item 99\n"))
def test_prints_the_row_where_todo_md_has_no_details_section(self):
text = self.todo.read_text()
self.todo.write_text(text[:text.index("## Details")] + text[text.index("## Notes"):])
code, out, _ = self.run_main("show", "3")
self.assertEqual(code, 0)
self.assertTrue(out.endswith("| 2.1 by 8, 1 by 6 |\n"), out)
def test_fails_where_todo_md_cannot_be_read(self):
self.todo.unlink()
code, out, err = self.run_main("show", "3")
self.assertEqual((code, out), (1, ""))
self.assertIn("todo.md", err)
def test_fails_where_todo_md_is_not_utf_8(self):
self.todo.write_bytes(b"# todo\n\n\xff\n")
code, out, err = self.run_main("show", "3")
self.assertEqual((code, out), (1, ""))
self.assertEqual(err, f"{self.todo}: not UTF-8\n")
def test_reads_todo_md_alone(self):
(self.folder / "README.md").unlink()
self.assertEqual(self.run_main("show", "3")[0], 0)
def test_fails_where_a_detail_holds_a_fenced_block(self):
self.todo.write_text(self.todo.read_text().replace("Fast detail.\n", "Fast detail.\n\n```\n## Goals\n```\n"))
code, out, err = self.run_main("show", "3")
self.assertEqual((code, out), (1, ""))
self.assertIn("fenced", err)
def test_takes_a_whole_number_as_the_id(self):
self.assertEqual(self.exit_code("show", "three"), 2)
def test_changes_no_file(self):
before = self.todo.read_text()
self.run_main("show", "3")
self.assertEqual(self.todo.read_text(), before)
def test_is_a_command_of_its_own_in_the_docstring(self):
self.assertIn("todo-item show <ID>", main.__doc__)
class List(TodoItem):
def rows(self, *argv):
code, out, err = self.run_main("list", *argv)
self.assertEqual((code, err), (0, ""))
self.assertTrue(out.startswith(f"From {self.todo}, in its order:\n\n{HEADER}"), out)
return out.split("\n")[4:-1]
def test_prints_every_item_in_the_plans_order_without_details(self):
ranked = [line.split(" | ")[0] for line in self.todo.read_text().split("\n") if line.startswith("| ") and line[2].isdigit()]
rows = self.rows()
self.assertEqual([row.split(" | ")[0] for row in rows], ranked)
self.assertEqual(len(rows), 5)
self.assertIn("| 4 | 0.1.0 | | security | **Rotate the leaked key.** | 3 | 3 | 5 | 9 | 2 | 2.1 by 1 |", rows)
def test_prints_one_releases_items_with_release(self):
self.assertEqual(self.rows("--release", "0.2.0"), ["| 1 | 0.2.0 | | | **Ship the later thing.** | 1 | 1 | 1 | 1 | 1 | 1 by 9 |"])
def test_says_so_where_it_holds_no_item(self):
self.assertEqual(self.run_main("list", "--release", "0.9.0"), (0, f"{self.todo} holds no item for release 0.9.0.\n", ""))
for id_ in (1, 2, 3, 4):
self.run_main("finish", str(id_))
(self.folder / "docs" / "decisions.md").write_text("")
self.run_main("finish", "5")
self.assertEqual(self.run_main("list"), (0, f"{self.todo} holds no item.\n", ""))
def test_fails_on_a_release_that_is_no_version(self):
errors = io.StringIO()
with contextlib.redirect_stderr(errors), self.assertRaises(SystemExit) as raised:
main.main(["list", "--release", "next"], self.folder, io.StringIO())
self.assertEqual(raised.exception.code, 2)
self.assertIn("argument --release: 'next' is not a semver version", errors.getvalue())
def test_changes_no_file(self):
before = self.todo.read_text()
self.run_main("list")
self.assertEqual(self.todo.read_text(), before)
class Edit(TodoItem):
def test_sets_the_cells_whose_flag_is_given_and_leaves_the_rest(self):
self.assertEqual(self.run_main("edit", "3", "--l", "3", "--S", "6", "--blocked-by", "2", "--exempt", "owner", "--moves", "1 by 7")[:2], (0, f"Edited item 3 in {self.todo}.\n"))
self.assertIn("| 3 | 0.1.0 | 2 | owner | **Make it fast, `a \\| b`.** | 3 | 1 | 2 | 4 | 6 | 1 by 7 |", self.todo.read_text())
self.assertIn("### 3. Make it fast, `a | b`.\n\nFast detail.\n", self.todo.read_text())
def test_an_empty_value_empties_the_cell(self):
self.run_main("edit", "3", "--blocked-by", "2")
self.run_main("edit", "3", "--blocked-by", "")
self.assertIn("| 3 | 0.1.0 | | | **Make it fast", self.todo.read_text())
def test_rewrites_the_tagline_in_the_row_and_over_the_detail(self):
self.run_main("edit", "3", "--tagline", "Make it `a | b` fast.")
self.assertIn("| **Make it `a \\| b` fast.** |", self.todo.read_text())
self.assertIn("### 3. Make it `a | b` fast.\n\nFast detail.\n", self.todo.read_text())
def test_replaces_the_detail_with_stdin_under_detail(self):
self.assertEqual(self.run_main("edit", "3", "--detail", stdin="Faster detail.\n")[0], 0)
self.assertEqual(self.details(), DETAILS.replace("Fast detail.", "Faster detail."))
def test_removes_the_detail_with_clear_detail(self):
self.assertEqual(self.run_main("edit", "3", "--clear-detail")[0], 0)
self.assertEqual(self.details(), DETAILS.replace("### 3. Make it fast, `a | b`.\n\nFast detail.\n\n", ""))
def test_refuses_detail_without_text_on_stdin(self):
before = self.todo.read_text()
for stdin in ("", " \n", Terminal()):
with self.subTest(stdin):
self.assertEqual(self.run_main("edit", "3", "--l", "3", "--detail", stdin=stdin), (1, "", "not edited: --detail got no text on stdin; pass the new detail in a heredoc, or --clear-detail to remove the detail\n"))
self.assertEqual(self.todo.read_text(), before)
def test_refuses_text_on_stdin_without_detail(self):
before = self.todo.read_text()
self.assertEqual(self.run_main("edit", "3", "--l", "3", stdin="Faster detail.\n"), (1, "", "not edited: stdin holds text; pass --detail to replace item 3's detail with it\n"))
self.assertEqual(self.todo.read_text(), before)
def test_refuses_an_edit_that_changes_nothing(self):
self.assertEqual(self.run_main("edit", "3"), (1, "", "not edited: no flag names a change; todo-item --help lists them\n"))
self.assertEqual(self.run_main("edit", "3", "--comment", "Why.")[::2], (1, "not edited: no flag names a change; todo-item --help lists them\n"))
def test_an_edit_hands_the_comment_to_the_plan(self):
for argv, comments in ((["--comment", "A small change."], {3: ["A small change."]}), ([], {})):
with self.subTest(argv=argv):
plan = MemoryPlan({3: {"Release": "0.1.0", "Item": "**Count the runs.**", "L": "1", "E": "2", "I": "3", "S": "1"}})
self.assertEqual(main.edit(main.parser().parse_args(["edit", "3", "--l", "3", *argv]), plan, ""), "Edited item 3 in the plan in memory.")
self.assertEqual((plan.rows[3]["L"], plan.comments), ("3", comments))
def test_a_plan_in_a_file_takes_an_edit_with_a_comment_and_keeps_no_comment(self):
self.assertEqual(self.run_main("edit", "3", "--l", "3", "--comment", "A small change.")[:2], (0, f"Edited item 3 in {self.todo}.\n"))
self.assertNotIn("A small change.", self.todo.read_text())
def test_leaves_the_file_ranked(self):
self.run_main("edit", "1", "--s", "2", "--moves", "1 by 10")
self.assert_ranked()
def test_reports_ranking_lines_on_stderr_prefixed_with_todo_md(self):
self.lower_item_2_under_the_bar()
_, _, err = self.run_main("edit", "1", "--s", "2")
self.assertTrue(err.startswith(f"{self.todo}: item 2 "), err)
def test_writes_nothing_where_it_refuses(self):
before = self.todo.read_text()
for argv, reason in ((["99", "--l", "1"], f"{self.todo} holds no item 99"), (["3", "--l", "7"], "item 3's L '7' is not a whole number from 1 to 4"), (["3", "--s", "10"], "item 3 scores")):
with self.subTest(argv):
code, out, err = self.run_main("edit", *argv)
self.assertEqual((code, out), (1, ""))
self.assertTrue(err.startswith(f"not edited: {reason}"), err)
self.assertEqual(self.todo.read_text(), before)
class Move(TodoItem):
def test_sets_the_items_release_and_keeps_the_rest(self):
self.assertEqual(self.run_main("move", "3", "--release", "0.2.0"), (0, f"Moved item 3 to release 0.2.0 in {self.todo}.\n", ""))
self.assertIn("| 3 | 0.2.0 | | | **Make it fast, `a \\| b`.** | 2 | 1 | 2 | 3 | 7 | 2.1 by 8, 1 by 6 |", self.todo.read_text())
self.assertIn("### 3. Make it fast, `a | b`.\n\nFast detail.\n", self.todo.read_text())
self.assert_ranked()
def test_writes_nothing_where_it_refuses(self):
before = self.todo.read_text()
self.assertEqual(self.run_main("move", "3", "--release", "soon"), (1, "", "not moved: item 3's Release 'soon' is not a semver version, such as 1.2.0\n"))
self.assertEqual(self.run_main("move", "99", "--release", "0.2.0"), (1, "", f"not moved: {self.todo} holds no item 99\n"))
self.assertEqual(self.todo.read_text(), before)
class OtherFile(TodoItem):
def test_ranking_works_on_the_file_it_is_given_not_the_configured_plan(self):
config = located(str(self.folder), pathlib.Path.home())
other = self.folder / "other.md"
other.write_text("not a plan\n")
self.assertNotEqual(file_plan(config, other).check(), [])
self.assertIsInstance(file_plan(config, other).rank(), Failure)
self.assertEqual(file_plan(config, self.todo).check(), [])
class Table(unittest.TestCase):
def test_a_plan_not_yet_reshaped_lists_under_its_own_columns(self):
old = plan_of("## Items\n\n| ID | Release | Exempt | Item | R | S | C | A | G | Goals | Score |\n|---|---|---|---|---|---|---|---|---|---|---|\n| 3 | 0.2.0 | | **Do the next thing.** | 5 | 2 | 1 | 2 | 3 | 1 | 1.0 |\n")
self.assertEqual(table(old.items).split("\n")[0], "| ID | Release | Blocked by | Exempt | Item | R | S | C | A | G | Goals |")
self.assertEqual(table(old.items).split("\n")[2], "| 3 | 0.2.0 | | | **Do the next thing.** | 5 | 2 | 1 | 2 | 3 | 1 |")
def test_a_row_lists_the_items_that_block_it_and_leaves_a_score_it_lacks_empty(self):
old = plan_of("## Items\n\n| ID | Release | Blocked by | Exempt | Item | R | S | A | G | Goals | Score |\n|---|---|---|---|---|---|---|---|---|---|---|\n| 3 | 0.2.0 | 1, 2 | | **Do the next thing.** | 5 | 2 | 2 | 3 | 1 | 1.0 |\n")
self.assertEqual(table(old.items).split("\n")[2], "| 3 | 0.2.0 | 1, 2 | | **Do the next thing.** | 5 | 2 | | 2 | 3 | 1 |")
class WithBullet(unittest.TestCase):
def test_keeps_a_blank_line_before_prose_under_unreleased(self):
self.assertEqual(edits.with_bullet("# Changelog\n\n## Unreleased\n\nSome note.\n", "New."), "# Changelog\n\n## Unreleased\n\n- New.\n\nSome note.\n")
def test_appends_unreleased_to_a_changelog_without_a_release(self):
self.assertEqual(edits.with_bullet("# Changelog\n", "New."), "# Changelog\n\n## Unreleased\n\n- New.\n")
def test_takes_a_release_heading_marked_unreleased_as_the_section(self):
self.assertEqual(edits.with_bullet("# Changelog\n\n## 0.6.0 (Unreleased)\n\n- Old.\n\n## 0.5.0\n", "New."), "# Changelog\n\n## 0.6.0 (Unreleased)\n\n- New.\n- Old.\n\n## 0.5.0\n")
def test_refuses_an_unreleased_section_with_subsections_and_says_to_add_by_hand(self):
refused = edits.with_bullet("# Changelog\n\n## Unreleased\n\n### Security\n\n- Old.\n\n## 0.5.0\n", "New.")
self.assertIsInstance(refused, Failure)
assert isinstance(refused, Failure)
self.assertIn("by hand", refused.reason)
def test_takes_subsections_of_a_release_below_unreleased(self):
self.assertEqual(edits.with_bullet("## Unreleased\n\n- Old.\n\n## 0.5.0\n\n### Security\n", "New."), "## Unreleased\n\n- New.\n- Old.\n\n## 0.5.0\n\n### Security\n")
if __name__ == "__main__":
unittest.main()