"""P4 chrome contracts: borderless frame, slim header, the F-key lane, dialog gate.""" from __future__ import annotations from rich.cells import cell_len from rich.text import Text from meshterm.platforms import PICOCALC, REGULAR, set_platform from meshterm.ui.tui import frame from meshterm.ui.tui.fkeys import ( DEFAULT_LANE, FPair, action_for, default_lane, lane_text, ) from meshterm.ui.tui.screen import ScrollScreen from tests.conftest import plain as _plain def _screen(lines: int = 40) -> ScrollScreen: body = Text("\n".join(f"row {i}" for i in range(lines))) screen = ScrollScreen(body, title="Chrome probe", floating=False) return screen def _slot_style(row: Text, index: int) -> str: """The style the lane painted onto slot ``index``'s chip (slots are 9 cells + 2 gap).""" start = index * 11 return next(str(span.style) for span in row.spans if span.start <= start < span.end) def test_borderless_frame_swaps_the_panel_for_a_title_bar() -> None: set_platform(PICOCALC) composed = frame.compose_base(Text("hdr"), _screen(), "hint", 53, 26).split("\n") assert len(composed) == 26 plain = [_plain(line) for line in composed] # Row 1 (under the one-line header) is the title bar: rule + title + clip arrow. assert "Chrome probe" in plain[1] and "─" in plain[1] assert "↓" in plain[1] # 40 rows into a 23-row viewport: more below # No Panel borders anywhere — the body owns the full width. assert not any("│" in line or "╭" in line for line in plain) assert all(cell_len(line) <= 53 for line in plain) # The body's first row starts at column 0 of row 2 (no panel padding). assert plain[2].startswith("row 0") def test_bordered_frame_is_unchanged_on_regular() -> None: set_platform(REGULAR) composed = frame.compose_base(Text("hdr"), _screen(), "hint", 72, 24).split("\n") plain = [_plain(line) for line in composed] assert any("╭" in line or "┌" in line for line in plain), "regular keeps its Panel" def test_picocalc_header_brands_the_app_not_the_device() -> None: """The header_atoms wiring, per JP's spec: picocalc shows ``MeshTerm vX`` (a soldered radio's port never changes, so the device segment earns nothing), regular keeps both.""" from meshterm.ui.menu import _header_segments class _Badges: def unread_total(self) -> int: return 0 def unacked_count(self) -> int: return 0 class _Ctx: mock = True chat = _Badges() watchtower = _Badges() set_platform(PICOCALC) text = "".join(seg.plain for seg in _header_segments(_Ctx(), {})) assert "MeshTerm" in text assert "simulator" not in text # the device atom is composed out assert "pulse" in PICOCALC.header_atoms # the sparkline takes the remaining room set_platform(REGULAR) text = "".join(seg.plain for seg in _header_segments(_Ctx(), {})) assert "MeshTerm" in text and "simulator" in text def test_fkey_lane_resolution_and_banks() -> None: lane = DEFAULT_LANE # F4/F5 (paging — no physical key at all) carry the pager, and each jump rides the # Shift half of the very pager heading for it: Home behind Page ↑, End behind Page ↓. assert action_for(lane, 4) == "pagedown" and action_for(lane, 9) == "end" assert action_for(lane, 5) == "pageup" and action_for(lane, 10) == "home" # F1-F3 are free on every screen — the shared lane claims none of them. for number in (1, 2, 3, 6, 7, 8): assert action_for(lane, number) is None # Enter/Esc never occupy a slot — both keys are already close at hand. assert "enter" not in {action_for(lane, n) for n in range(1, 11)} assert "escape" not in {action_for(lane, n) for n in range(1, 11)} def test_fkey_lane_text_fits_and_flips() -> None: primary = lane_text(DEFAULT_LANE) shifted = lane_text(DEFAULT_LANE, shifted=True) assert cell_len(primary.plain) == 53 and cell_len(shifted.plain) == 53 # A directional pair rises to the right: down/out left, up/in right — and each # companion keeps its slot's end of that axis. assert "F4 Page ↓" in primary.plain and "F5 Page ↑" in primary.plain assert "F9 Bottom" in shifted.plain and "10 Top" in shifted.plain # The free bank renders as bare, unfilled key numbers in both banks. for number in (1, 2, 3): assert f"F{number} " in primary.plain assert f"F{number + 5} " in shifted.plain wide = [FPair("Muchtoolonglabel", "a", "Muchtoolonglabel", "b")] * 5 assert cell_len(lane_text(wide).plain) == 53 # clipped to the slot budget assert cell_len(lane_text(wide, shifted=True).plain) == 53 def test_fkey_slot_dims_when_its_action_is_unavailable() -> None: """An unavailable slot keeps its label and drops its fill — it never offers a dead key.""" lane = [FPair("Paths", "paths", "Retry", "retry", enabled=False)] + [None] * 4 primary = lane_text(lane) shifted = lane_text(lane, shifted=True) # The label survives: the lane still says what F1 is for, just not that it acts now. assert "F1 Paths" in primary.plain and _slot_style(primary, 0) == "muted" # Its Shift companion is untouched — the two banks gate independently. assert "F6 Retry" in shifted.plain and _slot_style(shifted, 0) == "fkey.chip.shift" # The row is still exactly the lane's width, dim chips and all. assert cell_len(primary.plain) == 53 and cell_len(shifted.plain) == 53 # Dimming is presentational: the key still resolves, and the screen's handler no-ops. assert action_for(lane, 1) == "paths" def test_default_lane_dims_every_nav_slot_when_nothing_moves() -> None: """A screen with nothing to move gets the shared lane back inert, not absent.""" assert default_lane() is DEFAULT_LANE # the live lane is the constant itself dim = default_lane(nav=False) assert [pair.label for pair in dim if pair] == ["Page ↓", "Page ↑"] assert not any(pair.enabled or pair.opp_enabled for pair in dim if pair) row = lane_text(dim) assert cell_len(row.plain) == 53 and "F4 Page ↓" in row.plain and "F5 Page ↑" in row.plain assert {str(span.style) for span in row.spans} == {"muted"} # Both banks dim together: the jump behind a dead pager is just as dead. assert {str(span.style) for span in lane_text(dim, shifted=True).spans} == {"muted"} def test_lane_is_built_after_the_body_renders() -> None: """The frame defers the lane, so its gates read this paint's metrics, not the last one's.""" set_platform(PICOCALC) screen = _screen() # 40 body rows into a 23-row viewport: it overflows seen: dict[str, bool] = {} def build() -> Text: seen["nav"] = all(pair.enabled for pair in screen.fkey_lane if pair) return lane_text(screen.fkey_lane) composed = frame.compose_base(Text("hdr"), screen, "hint", 53, 26, footer_lane=build) assert seen["nav"] is True # lit on the very first paint, with no stale frame to lag assert "F4 Page ↓" in _plain(composed.split("\n")[-1]) def test_scroll_screen_lane_tracks_whether_its_body_overflows() -> None: """The result window's nav slots light only once there is something to scroll to.""" screen = _screen() screen.note_metrics(4, 20) # the whole body fits the viewport assert not any(pair.enabled for pair in screen.fkey_lane if pair) screen.note_metrics(80, 20) # taller than the viewport assert all(pair.enabled for pair in screen.fkey_lane if pair) def test_select_lane_promotes_the_section_jumps_only_where_there_are_sections() -> None: """Ctrl+PgUp/PgDn is unreachable on a keyboard with no PgUp, so a grouped list lanes it.""" from meshterm.ui.tui.select import Choice, Separator, SelectScreen flat = SelectScreen("Flat", [Choice("one", 1), Choice("two", 2)]) # No headings anywhere: sections are not a thing on this list, so the slots are empty # rather than dim — and F1/F2 resolve to nothing at all. assert flat.fkey_lane[0] is None and flat.fkey_lane[1] is None assert action_for(flat.fkey_lane, 1) is None grouped = SelectScreen("Grouped", [ Separator("── Near ──"), Choice("alpha", 1), Choice("beta", 2), Separator("── Far ──"), Choice("gamma", 3), ]) lane = grouped.fkey_lane assert [pair.label for pair in lane[:2]] == ["Sect ↑", "Sect ↓"] # A pair rises toward its outer key: on this left-edge pair, up takes F1. assert action_for(lane, 1) == "ctrl_pageup" and action_for(lane, 2) == "ctrl_pagedown" assert all(pair.enabled for pair in lane[:2]) # A filter that collapses the list onto one section keeps the labels and dims them: # the sections are still a thing here, they just have nowhere to jump right now. for ch in "gam": grouped.handle("text", ch) dim = grouped.fkey_lane assert [pair.label for pair in dim[:2]] == ["Sect ↑", "Sect ↓"] assert not any(pair.enabled for pair in dim[:2]) def test_dialogs_draw_no_lane_at_all() -> None: """A prompt has nothing to page, so it shows bare key numbers, not a dim pager.""" from meshterm.ui.tui.fkeys import EMPTY_LANE from meshterm.ui.tui.prompt import ButtonDialog, ConfirmScreen, TextScreen for screen in ( TextScreen("Name", prompt="Call it what?"), ConfirmScreen("Sure?"), ButtonDialog("Reboot the node?", ["Cancel", "Reboot"]), ): assert list(screen.fkey_lane) == list(EMPTY_LANE) row = lane_text(screen.fkey_lane) assert cell_len(row.plain) == 53 assert {str(span.style) for span in row.spans} == {"muted"} def test_map_locate_is_reachable_from_both_control_keys() -> None: """``locate`` is bound as a chord app-wide, so both Ctrl keys and F2 reach the same action.""" from prompt_toolkit.keys import Keys from meshterm.ui.tui.session import _CTRL_LETTER_CHORDS, _KEY_ACTIONS assert _CTRL_LETTER_CHORDS["l"] == "locate" # the right-Ctrl rescue's half assert _KEY_ACTIONS[Keys.ControlL] == "locate" # the ordinary binding, generated from it def test_host_battery_reads_the_sysfs_supply(tmp_path, monkeypatch) -> None: """The PicoCalc battery path: a true percent and charging flag straight from sysfs.""" from meshterm.services import battery_service (tmp_path / "capacity").write_text("53\n") (tmp_path / "status").write_text("Discharging\n") (tmp_path / "voltage_now").write_text("4012000\n") monkeypatch.setattr(battery_service, "_HOST_SUPPLY", tmp_path) service = battery_service.BatteryService(ctx=None) service._poll_host() reading = service.reading() assert reading is not None assert (reading.percent, reading.charging, reading.millivolts) == (53, False, 4012) (tmp_path / "status").write_text("Charging\n") service._poll_host() assert service.reading().charging is True monkeypatch.setattr(battery_service, "_HOST_SUPPLY", tmp_path / "gone") service._poll_host() assert service.reading() is None # unreadable supply = absent, header draws nothing def test_dialog_gate_shrinks_on_picocalc() -> None: from meshterm.ui.surface import _dialog_max_cells set_platform(PICOCALC) assert _dialog_max_cells() == 43 set_platform(REGULAR) assert _dialog_max_cells() == 76