251 lines
13 KiB
Python
251 lines
13 KiB
Python
import dataclasses
|
|
import decimal
|
|
import pathlib
|
|
import sys
|
|
import tempfile
|
|
import unittest
|
|
|
|
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
|
|
|
|
from test_env import assert_not_root
|
|
from project_config.settings import DEFAULT_FLOOR, Epic, Finish, JiraScoring, ProjectConfig, SETTINGS
|
|
from failure import Failure
|
|
from record_store.stores import FileStore, goals_store, store as record_store
|
|
from plan_store.contract import FIRST, MOVES, PlanStoreContract, SECOND
|
|
from plan_store.jira_epic import JiraPlan
|
|
from plan_store.fakes import MemoryPlan
|
|
from record_store.fakes import MemoryStore
|
|
from plan.todo_table import NoItemsTable
|
|
from plan_store import plans, scoring, stores, todo_md
|
|
from plan.doubles import README, SCORED, VOID
|
|
from plan.release import release_of
|
|
|
|
EMPTY = "# todo\n\n## Scoring\n\n`Score = 100 * V / 2**S`\n\n`Bar = 2`\n\n`Next ID = 1`\n\n## Items\n\n| ID | Release | Blocked by | Exempt | Item | L | E | I | R | S | Moves | Score |\n|---|---|---|---|---|---|---|---|---|---|---|---|\n"
|
|
|
|
|
|
class MemoryPlanContract(PlanStoreContract, unittest.TestCase):
|
|
def new_store(self) -> plans.PlanStore:
|
|
return MemoryPlan()
|
|
|
|
|
|
class FilePlanContract(PlanStoreContract, unittest.TestCase):
|
|
def setUp(self) -> None:
|
|
self.folder = pathlib.Path(self.enterContext(tempfile.TemporaryDirectory()))
|
|
|
|
def new_store(self) -> todo_md.FilePlan:
|
|
(self.folder / "todo.md").write_text(EMPTY)
|
|
(self.folder / "README.md").write_text(README)
|
|
return todo_md.FilePlan(self.folder / "todo.md", "todo.md", FileStore(self.folder / "README.md", None), MemoryStore(), MemoryStore(), DEFAULT_FLOOR)
|
|
|
|
|
|
class FilePlan(FilePlanContract):
|
|
def test_supplies_its_items_by_release_then_score(self):
|
|
store = self.new_store()
|
|
later, low, high = self.filed(store, SECOND), self.filed(store, FIRST | {"S": "4"}), self.filed(store, FIRST)
|
|
plan = store.read()
|
|
self.assertEqual([item.id for item in plan.items], [high, low, later])
|
|
|
|
def test_refuses_an_item_that_scores_under_the_bar_and_says_so(self):
|
|
store = self.new_store()
|
|
refused = store.add(FIRST | {"S": "10"}, "")
|
|
self.assertIsInstance(refused, Failure)
|
|
self.assertIn("under the bar", refused.reason)
|
|
self.assertEqual((self.folder / "todo.md").read_text(), EMPTY)
|
|
|
|
def test_an_edit_that_puts_the_item_under_the_bar_is_refused(self):
|
|
store = self.new_store()
|
|
id_ = self.filed(store, FIRST)
|
|
before = (self.folder / "todo.md").read_text()
|
|
self.assertIsInstance(store.edit(id_, {"S": "10"}, None), Failure)
|
|
self.assertEqual((self.folder / "todo.md").read_text(), before)
|
|
|
|
def test_an_edited_tagline_heads_the_detail_too(self):
|
|
store = self.new_store()
|
|
id_ = self.filed(store, FIRST, "Why it counts.")
|
|
store.edit(id_, {plans.TAGLINE: "Count `a | b` runs."}, None)
|
|
text = (self.folder / "todo.md").read_text()
|
|
self.assertIn("| **Count `a \\| b` runs.** |", text)
|
|
self.assertIn(f"### {id_}. Count `a | b` runs.\n\nWhy it counts.\n", text)
|
|
self.assertNotIn("Count the runs.", text)
|
|
|
|
def test_a_write_notes_what_ranking_says_under_the_files_path(self):
|
|
store = self.new_store()
|
|
self.filed(store, FIRST)
|
|
(self.folder / "todo.md").write_text((self.folder / "todo.md").read_text().replace("| 4 | 1 | 1 by 9 |", "| 4 | 10 | 1 by 9 |"))
|
|
written = store.add(SECOND, "")
|
|
self.assertEqual([note.split(": ")[0] for note in written.notes], [str(self.folder / "todo.md")])
|
|
self.assertIn("item 1 ", written.notes[0])
|
|
|
|
def test_only_the_item_written_refuses_the_write(self):
|
|
store = self.new_store()
|
|
first = self.filed(store, FIRST)
|
|
todo = self.folder / "todo.md"
|
|
todo.write_text(todo.read_text().replace("`Next ID = 2`", "`Next ID = 10`"))
|
|
self.assertEqual(self.filed(store, FIRST), 10)
|
|
todo.write_text("".join(line.replace("| 4 | 1 | 1 by 9 |", "| 4 | 10 | 1 by 9 |") if line.startswith("| 10 ") else line for line in todo.read_text().splitlines(keepends=True)))
|
|
written = store.edit(first, {"E": "2"}, None)
|
|
assert isinstance(written, plans.Written), written
|
|
self.assertIn("item 10 ", written.notes[0])
|
|
|
|
def test_an_id_it_holds_no_item_for_fails_naming_the_file(self):
|
|
store = self.new_store()
|
|
missing = Failure(f"{self.folder / 'todo.md'} holds no item 99")
|
|
self.assertEqual((store.edit(99, {"L": "1"}, None), store.finish(99)), (missing, missing))
|
|
|
|
def test_a_missing_file_fails_naming_it(self):
|
|
store = self.new_store()
|
|
(self.folder / "todo.md").unlink()
|
|
for failed in (store.read(), store.add(FIRST, ""), store.finish(1)):
|
|
self.assertIsInstance(failed, Failure)
|
|
self.assertIn(f"{self.folder / 'todo.md'}: not found", failed.reason)
|
|
|
|
def test_a_file_without_an_items_table_reads_as_no_plan(self):
|
|
store = self.new_store()
|
|
(self.folder / "todo.md").write_text("# todo\n")
|
|
self.assertIsInstance(store.read(), NoItemsTable)
|
|
|
|
def test_a_write_to_a_file_without_an_items_table_fails_naming_the_file(self):
|
|
store = self.new_store()
|
|
(self.folder / "todo.md").write_text(EMPTY.split("## Items")[0])
|
|
tableless = Failure(f"{self.folder / 'todo.md'} holds no items table; rank_todo.py --help shows one")
|
|
self.assertEqual((store.add(FIRST, ""), store.edit(1, {"L": "1"}, None), store.finish(1)), (tableless,) * 3)
|
|
|
|
def test_an_edit_of_a_cell_the_table_has_no_column_for_fails_naming_the_file(self):
|
|
store = self.new_store()
|
|
(self.folder / "todo.md").write_text("## 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(store.edit(3, {"L": "1", "E": "2"}, None), Failure(f"{self.folder / 'todo.md'}'s items table has no L, E column"))
|
|
|
|
def test_reads_the_releases_marked_renamed(self):
|
|
store = self.new_store()
|
|
(self.folder / "todo.md").write_text(EMPTY + "\n## Renamed\n\n- 0.2.1 renamed to 0.3.0\n")
|
|
self.assertEqual(store.read(), plans.Plan([], frozenset({release_of("0.2.1")})))
|
|
|
|
def test_a_field_it_does_not_know_is_a_programming_error(self):
|
|
with self.assertRaises(ValueError):
|
|
self.new_store().add(FIRST | {"Score": "9"}, "")
|
|
|
|
|
|
def test_refuses_a_tagline_with_a_line_break_and_a_detail_with_a_heading(self):
|
|
store = self.new_store()
|
|
id_ = self.filed(store, FIRST)
|
|
before = (self.folder / "todo.md").read_text()
|
|
broken, split = "the tagline holds a line break; keep it on one line", "the detail holds a ## or ### heading, which would split ## Details; use #### or drop the #s"
|
|
self.assertEqual(store.add(FIRST | {plans.TAGLINE: "Count\nthe runs."}, ""), Failure(broken))
|
|
self.assertEqual(store.add(FIRST, "## Why\n"), Failure(split))
|
|
self.assertEqual(store.edit(id_, {plans.TAGLINE: "Count\nthe runs."}, None), Failure(broken))
|
|
self.assertEqual(store.edit(id_, {}, "### Why\n"), Failure(split))
|
|
self.assertEqual((self.folder / "todo.md").read_text(), before)
|
|
|
|
def test_a_file_it_cannot_write_fails_naming_it(self):
|
|
assert_not_root(self)
|
|
store = self.new_store()
|
|
self.folder.chmod(0o555)
|
|
self.addCleanup(self.folder.chmod, 0o755)
|
|
written = store.add(FIRST, "")
|
|
assert isinstance(written, Failure), written
|
|
self.assertTrue(written.reason.startswith(f"{self.folder / 'todo.md'}: "), written.reason)
|
|
|
|
def test_a_history_it_cannot_read_fails_every_write(self):
|
|
store = dataclasses.replace(self.new_store(), history=MemoryStore(fails="no history"))
|
|
self.assertEqual(store.add(FIRST, ""), Failure("no history"))
|
|
|
|
|
|
def test_ranks_every_write_with_its_floor(self):
|
|
# At an overall of 6.50 code health weighs 4 times under the default floor of 7.0, and once at a floor of 6.0.
|
|
def health_row(floor):
|
|
store = dataclasses.replace(self.new_store(), history=MemoryStore(SCORED.format(overall="6.50")), floor=decimal.Decimal(floor))
|
|
(self.folder / "README.md").write_text(README.replace(VOID, ""))
|
|
kept, finished = self.filed(store, FIRST | {MOVES: "code health by 1"}), self.filed(store, SECOND)
|
|
row = [line for line in (self.folder / "todo.md").read_text().splitlines() if line.startswith(f"| {kept} ")]
|
|
self.assertIsInstance(store.finish(finished), plans.Written)
|
|
self.assertIn(row[0], (self.folder / "todo.md").read_text())
|
|
return row[0]
|
|
self.assertNotEqual(health_row("6.0"), health_row("7.0"))
|
|
|
|
class HeldAt(unittest.TestCase):
|
|
def test_reads_the_revisions_file_where_commits_hold_the_plan(self):
|
|
shown = []
|
|
|
|
def run(*args, cwd):
|
|
if args[0] != "show":
|
|
return "plans/todo.md\n"
|
|
shown.append((args, cwd))
|
|
return EMPTY.replace("`Next ID = 1`", "`Next ID = 2`") + "| 1 | 0.1.0 | | | **Count the runs.** | 1 | 2 | 3 | 4 | 1 | 1 by 9 | 0 |\n"
|
|
|
|
plan = stores.held_at("origin/main", MemoryPlan(tracked="plans/todo.md"), "/checkout", run)
|
|
self.assertEqual([item.id for item in plan.items], [1])
|
|
self.assertEqual(shown, [(("show", "origin/main:plans/todo.md"), "/checkout")])
|
|
|
|
def test_reads_the_plan_as_it_stands_where_no_commit_holds_it(self):
|
|
held = MemoryPlan()
|
|
held.add(FIRST, "")
|
|
|
|
def run(*args, cwd):
|
|
raise AssertionError("git has no version of this plan")
|
|
|
|
self.assertEqual(stores.held_at("origin/main", held, "/checkout", run), held.read())
|
|
|
|
def test_fails_where_the_revision_cannot_be_read(self):
|
|
def run(*args, cwd):
|
|
return Failure("no git") if args[0] == "ls-tree" else "a commit\n"
|
|
|
|
self.assertEqual(stores.held_at("origin/main", MemoryPlan(tracked="todo.md"), "/checkout", run), Failure("no git"))
|
|
|
|
|
|
class Store(unittest.TestCase):
|
|
def config(self, **named) -> ProjectConfig:
|
|
paths = {name: pathlib.Path("/checkout", name) for name in SETTINGS[1:]}
|
|
return ProjectConfig("acme", pathlib.Path("/folder"), pathlib.Path("/checkout"), paths, **named)
|
|
|
|
def test_a_path_picks_the_markdown_file(self):
|
|
config = self.config()
|
|
picked = stores.store(dataclasses.replace(config, paths=config.paths | {"plan": pathlib.Path("/checkout/todo.md")}))
|
|
self.assertEqual((type(picked), picked.label, picked.tracked), (todo_md.FilePlan, "/checkout/todo.md", "todo.md"))
|
|
|
|
def test_the_markdown_file_ranks_with_the_configs_floor(self):
|
|
self.assertEqual(stores.file_plan(self.config(readability_floor=decimal.Decimal("6.5")), pathlib.Path("/checkout/todo.md")).floor, decimal.Decimal("6.5"))
|
|
|
|
def test_an_epic_picks_jira_with_the_env_files_credentials(self):
|
|
epic = Epic("https://acme.atlassian.net", "ABC-12")
|
|
picked = stores.store(self.config(epic=epic, env_file=pathlib.Path("/secrets/acme.env"), jira_scoring=JiraScoring("V", 1)))
|
|
self.assertEqual(picked, JiraPlan(epic, pathlib.Path("/secrets/acme.env"), picked.http, scoring=picked.scoring))
|
|
|
|
def test_an_epic_files_an_item_as_the_issue_type_the_config_names(self):
|
|
picked = stores.store(self.config(epic=Epic("https://acme.atlassian.net", "ABC-12"), env_file=pathlib.Path("/secrets/acme.env"), jira_finding_type="Feature", jira_scoring=JiraScoring("V", 1)))
|
|
self.assertEqual(picked.finding_type, "Feature")
|
|
|
|
def test_an_epic_finishes_an_item_as_the_config_says(self):
|
|
finish = Finish("Mark as done", "Done")
|
|
picked = stores.store(self.config(epic=Epic("https://acme.atlassian.net", "ABC-12"), env_file=pathlib.Path("/secrets/acme.env"), jira_finish=finish, jira_scoring=JiraScoring("V", 1)))
|
|
self.assertEqual(picked.finish_by, finish)
|
|
|
|
def test_an_epic_scores_by_the_configs_formula_and_bar_and_the_projects_records(self):
|
|
config = self.config(epic=Epic("https://acme.atlassian.net", "ABC-12"), env_file=pathlib.Path("/secrets/acme.env"), jira_scoring=JiraScoring("V / 2**S", 1.5), readability_floor=decimal.Decimal("6.5"))
|
|
picked = stores.store(config)
|
|
self.assertEqual(picked.scoring, scoring.StatedScoring(JiraScoring("V / 2**S", 1.5), goals_store(config), record_store(config, "decisions"), record_store(config, "comprehension-history"), decimal.Decimal("6.5")))
|
|
|
|
|
|
class StatedScoring(unittest.TestCase):
|
|
def test_weighs_the_goals_the_goals_file_holds(self):
|
|
weighed = scoring.StatedScoring(JiraScoring("V / 2**S", 1.5), MemoryStore(README), MemoryStore(), MemoryStore(), DEFAULT_FLOOR).read()
|
|
assert not isinstance(weighed, Failure), weighed
|
|
self.assertEqual((weighed.bar, list(weighed.goals)), (1.5, ["1", "2", "2.1"]))
|
|
|
|
def test_weighs_code_health_by_the_history_and_the_floor_it_is_given(self):
|
|
for floor, under in ((DEFAULT_FLOOR, True), (decimal.Decimal("6.0"), False)):
|
|
with self.subTest(floor=floor):
|
|
weighed = scoring.StatedScoring(JiraScoring("V", 1), MemoryStore("## Goals\n\n1. **Achieve:** A.\n"), MemoryStore(), MemoryStore(SCORED.format(overall="6.99")), floor).read()
|
|
assert not isinstance(weighed, Failure), weighed
|
|
self.assertEqual(weighed.weights["code health"] > weighed.weights["1"] * 2, under)
|
|
|
|
def test_a_goals_file_that_is_empty_or_cannot_be_read_fails(self):
|
|
for goals, reason in ((MemoryStore(), "the record in memory: missing or empty"), (MemoryStore(fails="Jira answered 403"), "Jira answered 403")):
|
|
with self.subTest(reason=reason):
|
|
read = scoring.StatedScoring(JiraScoring("V", 1), goals, MemoryStore(), MemoryStore(), DEFAULT_FLOOR).read()
|
|
assert isinstance(read, Failure), read
|
|
self.assertTrue(read.reason.startswith(reason), read.reason)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|