Every board tab read "Bench — task board", so the moment a second bench existed the tab bar stopped saying which was which. The title now leads with the project — "<project> · bench" — because tab truncation eats the tail and the tail is the same in every bench tab. The project is config.PROJECT: the repo directory's name, or BOARD_TITLE from local/.env for people whose checkouts are all called "app". The server renders it into the served page's <title>, so the tab is right on first paint with no flicker from generic to named; /api/state carries it too, and renderTitle() keeps it in step when the view switcher swaps the tail (sessions, focus). The project stays the first word regardless, and nothing else writes document.title. Tests: tests/test_board_title.py covers the server half in fresh interpreters (BOARD_TITLE resolution, the rendered title, escaping, the rest of the page untouched) and the browser half as source invariants, the same way the other board.html tests work. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
169 lines
7.3 KiB
Python
169 lines
7.3 KiB
Python
"""The tab names its project (task 22): the title is "<project> · bench",
|
|
project first, so two benches side by side are told apart at tab-bar width.
|
|
|
|
Two halves are tested here. The server half — config resolving the project
|
|
name and httpd rendering it into the served page — runs in fresh
|
|
interpreters, because config reads its settings at import and BOARD_TITLE
|
|
is the thing under test. The browser half lives in board.html's inline JS
|
|
with no frontend test runner, so it is checked as source-level invariants:
|
|
the ones that, if broken, would let the tab drift back to a generic string
|
|
or put the view name before the project.
|
|
|
|
python3 -m unittest discover -s tests -v
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import os
|
|
import re
|
|
import subprocess
|
|
import sys
|
|
import unittest
|
|
from pathlib import Path
|
|
|
|
REPO = Path(__file__).resolve().parents[1]
|
|
CORE = REPO / "manager" / "core"
|
|
BOARD = CORE / "board.html"
|
|
|
|
# BOARD_TITLE unset in the process environment is "nothing configured":
|
|
# process env beats local/.env, so this also neutralizes a developer's own
|
|
# override leaking into the defaults test.
|
|
UNSET = {"BOARD_TITLE": ""}
|
|
|
|
|
|
def _probe(expression: str, settings: dict) -> object:
|
|
"""Evaluate an expression against config/httpd in a fresh interpreter,
|
|
with the given settings in the environment config reads at import."""
|
|
env = dict(os.environ)
|
|
env.update(UNSET)
|
|
env.update(settings)
|
|
out = subprocess.check_output(
|
|
[sys.executable, "-c",
|
|
"import sys, json; sys.path.insert(0, sys.argv[1]); "
|
|
"import config, httpd; print(json.dumps(eval(sys.argv[2])))",
|
|
str(CORE), expression],
|
|
env=env, text=True)
|
|
return json.loads(out)
|
|
|
|
|
|
def _title_of(settings: dict) -> str:
|
|
"""The <title> text of the page the board would serve."""
|
|
page = _probe("httpd.page_bytes().decode('utf-8')", settings)
|
|
match = re.search(r"<title>(.*?)</title>", page, re.DOTALL)
|
|
assert match, "the served page lost its <title>"
|
|
return match.group(1)
|
|
|
|
|
|
class ProjectName(unittest.TestCase):
|
|
def test_defaults_to_the_repo_directory_name(self):
|
|
"""The name nobody has to configure: what the checkout is called."""
|
|
self.assertEqual(_probe("config.PROJECT", {}), REPO.name)
|
|
|
|
def test_board_title_overrides_it(self):
|
|
"""For people whose checkout directories are all called "app"."""
|
|
self.assertEqual(_probe("config.PROJECT", {"BOARD_TITLE": "payments"}),
|
|
"payments")
|
|
|
|
def test_a_blank_setting_is_not_a_blank_title(self):
|
|
"""An empty or whitespace-only value means "not configured", not
|
|
"call this board nothing"."""
|
|
self.assertEqual(_probe("config.PROJECT", {"BOARD_TITLE": " "}),
|
|
REPO.name)
|
|
|
|
def test_the_state_payload_carries_it(self):
|
|
"""The browser needs it too — the view switcher rewrites the title
|
|
without refetching the page."""
|
|
self.assertEqual(_probe("httpd.state_payload()['project']",
|
|
{"BOARD_TITLE": "payments"}), "payments")
|
|
|
|
|
|
class ServedTitle(unittest.TestCase):
|
|
def test_the_title_is_rendered_into_the_page(self):
|
|
"""Server-rendered, so the tab is right on first paint rather than
|
|
flickering from generic to named on every refresh."""
|
|
self.assertEqual(_title_of({"BOARD_TITLE": "payments"}),
|
|
"payments · bench")
|
|
|
|
def test_two_projects_get_two_titles(self):
|
|
"""The whole point: distinguishable in the tab bar, in cmd-tab and
|
|
in history — and distinguishable by their *first* word."""
|
|
a = _title_of({"BOARD_TITLE": "projectA"})
|
|
b = _title_of({"BOARD_TITLE": "projectB"})
|
|
self.assertNotEqual(a, b)
|
|
self.assertTrue(a.startswith("projectA") and b.startswith("projectB"),
|
|
f"the project must lead the title, got {a!r} / {b!r}")
|
|
|
|
def test_the_default_title_names_this_checkout(self):
|
|
self.assertEqual(_title_of({}), f"{REPO.name} · bench")
|
|
|
|
def test_a_project_name_cannot_inject_markup(self):
|
|
"""The name comes from a directory or a settings file, both of which
|
|
can hold anything — it is escaped, not spliced."""
|
|
title = _title_of({"BOARD_TITLE": "<script>x</script>"})
|
|
self.assertNotIn("<script>", title)
|
|
self.assertIn("<script>", title)
|
|
|
|
def test_nothing_else_in_the_page_is_disturbed(self):
|
|
"""Only the title element is rewritten; the rest is the file."""
|
|
page = _probe("httpd.page_bytes().decode('utf-8')",
|
|
{"BOARD_TITLE": "payments"})
|
|
source = BOARD.read_text(encoding="utf-8")
|
|
strip = lambda s: re.sub(r"<title>.*?</title>", "", s, count=1,
|
|
flags=re.DOTALL)
|
|
self.assertEqual(strip(page), strip(source))
|
|
|
|
|
|
class PageInvariants(unittest.TestCase):
|
|
"""board.html's own half: the fallback title and the code that keeps it
|
|
in step with the view switcher."""
|
|
|
|
@classmethod
|
|
def setUpClass(cls):
|
|
cls.html = BOARD.read_text(encoding="utf-8")
|
|
|
|
def test_the_shipped_title_is_not_the_old_generic_string(self):
|
|
""""Bench — task board" in two tabs was the bug."""
|
|
self.assertNotIn("task board", self.html.lower())
|
|
|
|
def test_the_title_is_only_ever_written_from_the_project(self):
|
|
"""One writer, and it starts with the project — so no code path can
|
|
put the view name first or revert to the generic string."""
|
|
writes = re.findall(r"document\.title\s*=\s*([^\n;]+)", self.html)
|
|
self.assertEqual(len(writes), 1,
|
|
f"expected one document.title assignment, got {writes}")
|
|
self.assertTrue(writes[0].startswith("S.state.project"),
|
|
f"the project must lead the title, got {writes[0]!r}")
|
|
|
|
def test_a_stateless_page_keeps_the_served_title(self):
|
|
"""Before the first state load there is nothing better to say than
|
|
what the server already rendered."""
|
|
body = re.search(r"function renderTitle\(\)\s*\{(.*?)\n\}",
|
|
self.html, re.DOTALL)
|
|
self.assertIsNotNone(body, "board.html lost renderTitle()")
|
|
self.assertIn("if (!S.state?.project) return;", body.group(1),
|
|
"renderTitle must bail out rather than write a "
|
|
"project-less title")
|
|
|
|
def test_every_view_has_a_tail(self):
|
|
"""The switcher may suffix, but the board view keeps the name people
|
|
bookmarked: "<project> · bench"."""
|
|
table = re.search(r"const VIEW_TITLES = \{(.*?)\};", self.html, re.DOTALL)
|
|
self.assertIsNotNone(table, "board.html lost VIEW_TITLES")
|
|
tails = dict(re.findall(r"(\w+): '([^']+)'", table.group(1)))
|
|
views = set(re.findall(r'data-view="(\w+)"', self.html))
|
|
self.assertEqual(set(tails), views,
|
|
"every view in the switcher needs a title tail")
|
|
self.assertEqual(tails["board"], "bench")
|
|
|
|
def test_the_title_follows_every_render(self):
|
|
"""render() runs on state loads and on view switches alike, so
|
|
hanging renderTitle off it covers both."""
|
|
body = re.search(r"function render\(\)\s*\{(.*?)\n\}", self.html, re.DOTALL)
|
|
self.assertIsNotNone(body, "board.html lost render()")
|
|
self.assertIn("renderTitle();", body.group(1))
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|