Files
claude-config/bin/plan_store/test_stores.py
T

247 lines
12 KiB
Python

import dataclasses
import decimal
import os
import pathlib
import sys
import tempfile
import unittest
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
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.test_ranking 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)
@unittest.skipIf(os.geteuid() == 0, "root writes into a read-only directory")
def test_a_file_it_cannot_write_fails_naming_it(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_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()