mirror of
https://github.com/kevinveenbirkenbach/computer-playbook.git
synced 2026-11-08 19:56:53 +00:00
kevinveenbirkenbachandClaude Opus 5.5
621a492ec3
The chunk jobs read `🧱 Chunk N` and every priority row carried its own trailing ⭐, so a priority sweep repeated the star down the whole job list while the chunk that held those rows looked like any other. - The four chunk jobs are named `0️⃣ Batch` to `3️⃣ Batch`, with ` ⭐` when the batch holds priority rows, and their discover job reads `🔍 Batch N ⭐` through the existing `marker` input. - call-validation counts those batches once per run (scripts/github/resolve/priority_batches.sh, which runs `cli.meta.ci.matrix --priority-chunks`) and exposes the count as the `starred` output. chunks.plan cuts the priority chunks from the priority rows alone, so offset and the regular line cannot move them; the orchestrator hands validation the same sweep and chunk size it hands the chunk jobs. - The row label drops its own star. report_failures and the job-name parsers still accept a starred title from an older run. - The glossary names the unit `batch` (`#️⃣`) instead of `chunk` (`📦`), `ci plan` prints the batch column as the keycap the job name leads with, and the name lint accepts a leading keycap emoji. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
192 lines
7.8 KiB
Python
192 lines
7.8 KiB
Python
from __future__ import annotations
|
|
|
|
import unittest
|
|
|
|
from cli.meta.ci import plan
|
|
from utils.symbol_glossary import keycap, to_emoji
|
|
|
|
|
|
def _entry(
|
|
app: str,
|
|
variant: str,
|
|
mode: str,
|
|
*,
|
|
network: str = "clearnet",
|
|
priority: bool = False,
|
|
identifier: str = "0",
|
|
covered: str = "0",
|
|
clone: bool = False,
|
|
instructions: str = "",
|
|
) -> dict:
|
|
return {
|
|
"apps": app,
|
|
"variant": variant,
|
|
"mode": mode,
|
|
"network": network,
|
|
"vpn": "true" if mode == "swarm" else "false",
|
|
"disable": "",
|
|
"priority": "true" if priority else "false",
|
|
"instructions": instructions,
|
|
"id": identifier,
|
|
"covered": covered,
|
|
"clone": "true" if clone else "false",
|
|
"distro": "debian",
|
|
"filesystem": "zfs",
|
|
"architecture": "arm64",
|
|
"label": f"{to_emoji(mode)}{app} {variant}",
|
|
}
|
|
|
|
|
|
_PRIORITY = [
|
|
_entry("web-app-a", "0", "compose", network="tor", priority=True, identifier="3")
|
|
]
|
|
_REGULAR = [
|
|
_entry("web-app-b", "0", "swarm", network="multi", identifier="5"),
|
|
_entry("web-app-b", "1", "compose", identifier="9"),
|
|
]
|
|
_CUT = [_entry("web-app-c", "0", "compose", identifier="11", covered="5")]
|
|
_ENTRIES = _PRIORITY + _REGULAR + _CUT
|
|
|
|
|
|
class TestCells(unittest.TestCase):
|
|
def test_a_row_in_a_chunk_reports_that_batch_as_its_keycap(self) -> None:
|
|
rows = plan.cells(_ENTRIES, [_PRIORITY, _REGULAR])
|
|
batch = plan._COLUMNS.index("batch")
|
|
self.assertEqual(
|
|
[row[batch] for row in rows], [keycap(0), keycap(1), keycap(1), ""]
|
|
)
|
|
|
|
def test_a_priority_row_is_starred_not_ticked(self) -> None:
|
|
rows = plan.cells(_ENTRIES, [_PRIORITY, _REGULAR])
|
|
status = plan._COLUMNS.index("triggered")
|
|
self.assertEqual(rows[0][status], to_emoji("priority"))
|
|
self.assertEqual(rows[1][status], to_emoji("enabled"))
|
|
|
|
def test_a_row_outside_the_sweep_is_marked_disabled(self) -> None:
|
|
rows = plan.cells(_ENTRIES, [_PRIORITY])
|
|
self.assertEqual(
|
|
rows[1][plan._COLUMNS.index("triggered")], to_emoji("disabled")
|
|
)
|
|
self.assertEqual(rows[1][plan._COLUMNS.index("batch")], "")
|
|
|
|
def test_a_priority_row_the_budget_missed_keeps_its_star(self) -> None:
|
|
rows = plan.cells(_ENTRIES, [_REGULAR])
|
|
status = plan._COLUMNS.index("triggered")
|
|
self.assertEqual(rows[0][status], to_emoji("priority") + to_emoji("disabled"))
|
|
self.assertEqual(rows[0][plan._COLUMNS.index("batch")], "")
|
|
|
|
def test_a_clone_is_named_in_its_own_column(self) -> None:
|
|
entries = [*_ENTRIES, _entry("web-app-d", "0", "compose", clone=True)]
|
|
rows = plan.cells(entries, [_PRIORITY, _REGULAR])
|
|
clone = plan._COLUMNS.index("clone")
|
|
self.assertEqual(rows[0][clone], "")
|
|
self.assertEqual(rows[-1][clone], to_emoji("clone"))
|
|
|
|
def test_the_instructions_column_names_the_mode_the_replay_runs_in(self) -> None:
|
|
entries = [
|
|
*_ENTRIES,
|
|
_entry("web-app-d", "0", "swarm", instructions="compose"),
|
|
]
|
|
rows = plan.cells(entries, [_PRIORITY, _REGULAR])
|
|
column = plan._COLUMNS.index("instructions")
|
|
self.assertEqual(rows[0][column], "")
|
|
self.assertEqual(rows[-1][column], to_emoji("compose"))
|
|
|
|
def test_the_mode_is_rendered_as_its_glyph(self) -> None:
|
|
rows = plan.cells(_ENTRIES, [_PRIORITY, _REGULAR])
|
|
mode = plan._COLUMNS.index("mode")
|
|
self.assertEqual(rows[0][mode], to_emoji("compose"))
|
|
self.assertEqual(rows[1][mode], to_emoji("swarm"))
|
|
|
|
def test_a_covered_row_names_the_row_number_that_covers_it(self) -> None:
|
|
covered = plan._COLUMNS.index("covered_by")
|
|
rows = plan.cells(_ENTRIES, [_PRIORITY, _REGULAR])
|
|
self.assertEqual(rows[0][covered], "")
|
|
self.assertEqual(rows[3][covered], "2")
|
|
|
|
def test_a_covered_row_is_cut_instead_of_deployed(self) -> None:
|
|
rows = plan.cells(_ENTRIES, [_PRIORITY, _REGULAR])
|
|
self.assertEqual(
|
|
rows[3][plan._COLUMNS.index("triggered")], to_emoji("redundant")
|
|
)
|
|
self.assertEqual(rows[3][plan._COLUMNS.index("batch")], "")
|
|
|
|
def test_a_clone_is_cut_as_well(self) -> None:
|
|
entries = [*_ENTRIES, _entry("web-app-d", "0", "compose", clone=True)]
|
|
rows = plan.cells(entries, [_PRIORITY, _REGULAR])
|
|
self.assertEqual(
|
|
rows[-1][plan._COLUMNS.index("triggered")], to_emoji("redundant")
|
|
)
|
|
|
|
def test_a_pinned_clone_stays_in_the_run(self) -> None:
|
|
entries = [_entry("web-app-d", "0", "compose", priority=True, clone=True)]
|
|
rows = plan.cells(entries, [entries])
|
|
self.assertEqual(
|
|
rows[0][plan._COLUMNS.index("triggered")], to_emoji("priority")
|
|
)
|
|
|
|
def test_the_id_counts_the_rows_even_when_discovery_ids_repeat(self) -> None:
|
|
identifier = plan._COLUMNS.index("id")
|
|
entries = [*_ENTRIES, _entry("web-app-a", "0", "swarm", identifier="3")]
|
|
rows = plan.cells(entries, [_PRIORITY, _REGULAR])
|
|
self.assertEqual([row[identifier] for row in rows], ["1", "2", "3", "4", "5"])
|
|
|
|
def test_the_network_mode_is_rendered_as_its_glyph(self) -> None:
|
|
rows = plan.cells(_ENTRIES, [_PRIORITY, _REGULAR])
|
|
network = plan._COLUMNS.index("network")
|
|
self.assertEqual(rows[0][network], to_emoji("tor"))
|
|
self.assertEqual(rows[1][network], to_emoji("multi"))
|
|
self.assertEqual(rows[2][network], to_emoji("clearnet"))
|
|
|
|
def test_each_network_mode_of_one_row_reports_its_own_chunk(self) -> None:
|
|
tor = _entry("web-app-a", "0", "compose", network="tor", priority=True)
|
|
multi = _entry("web-app-a", "0", "compose", network="multi", priority=True)
|
|
rows = plan.cells([tor, multi], [[tor]])
|
|
batch = plan._COLUMNS.index("batch")
|
|
self.assertEqual([row[batch] for row in rows], [keycap(0), ""])
|
|
|
|
def test_every_row_carries_its_own_distro_and_filesystem_glyph(self) -> None:
|
|
rows = plan.cells(_ENTRIES, [_PRIORITY, _REGULAR])
|
|
distro = plan._COLUMNS.index("distro")
|
|
filesystem = plan._COLUMNS.index("filesystem")
|
|
self.assertTrue(all(row[distro] == to_emoji("debian") for row in rows))
|
|
self.assertTrue(all(row[filesystem] == to_emoji("zfs") for row in rows))
|
|
|
|
def test_every_row_carries_its_architecture_glyph(self) -> None:
|
|
rows = plan.cells(_ENTRIES, [_PRIORITY, _REGULAR])
|
|
architecture = plan._COLUMNS.index("architecture")
|
|
self.assertTrue(all(row[architecture] == to_emoji("arm64") for row in rows))
|
|
|
|
|
|
class TestRender(unittest.TestCase):
|
|
def _rows(self) -> list[tuple[str, ...]]:
|
|
return plan.cells(_ENTRIES, [_PRIORITY, _REGULAR])
|
|
|
|
def test_markdown_is_one_table_with_a_batch_column(self) -> None:
|
|
out = plan.render_markdown("sweep 0", self._rows())
|
|
self.assertEqual(out.count("| ---"), 0)
|
|
self.assertEqual(out.count("\n|---"), 1)
|
|
self.assertIn(f"{to_emoji('batch')} Batch", out)
|
|
self.assertIn("web-app-a", out)
|
|
|
|
def test_the_network_column_is_headed_by_the_multi_glyph(self) -> None:
|
|
out = plan.render_markdown("sweep 0", self._rows())
|
|
self.assertIn(f"{to_emoji('multi')} Network", out)
|
|
|
|
def test_markdown_keeps_one_line_per_row(self) -> None:
|
|
out = plan.render_markdown("sweep 0", self._rows())
|
|
body = [line for line in out.splitlines() if line.startswith("| web")]
|
|
self.assertEqual(len(body), 0)
|
|
self.assertEqual(len([ln for ln in out.splitlines() if ln.startswith("| ")]), 5)
|
|
|
|
def test_cli_pads_to_display_width(self) -> None:
|
|
out = plan.render_cli("sweep 0", self._rows())
|
|
lines = out.splitlines()
|
|
self.assertEqual(lines[0], "sweep 0")
|
|
self.assertTrue(lines[2].startswith("---"))
|
|
self.assertEqual(len(lines), 3 + len(_ENTRIES))
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|