From ec41de033967c68acf7fb733eceedb3e2d2c0111 Mon Sep 17 00:00:00 2001 From: Jean-Pierre Martineau Date: Thu, 16 Jul 2026 21:04:58 -0400 Subject: [PATCH] Route graph: draw the featured path in plain white, and give the packet viewer one MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Two related passes on THE route graph (ui/pathgraph). 1. **Featured path is always white.** The Message paths dialog and the Trophy case coloured their selected/scored path by reception SNR (theme.snr_rgb). But on a graph that draws only *one* real path over a grey backdrop, colour carried no comparison — it just competed with the node-name hues on the same canvas. Drop the SNR tint: the selected/walked path reads white (the single-walk convention), the unused paths grey. Removes the now-unused theme.snr_rgb / _SNR_RGB and updates both captions. 2. **The packet viewer draws a relayed packet's route.** A `packet` frame that actually crossed a relay now slots the fan-lane graph between its parsed detail (heard/from/class/via) and its extras — origin → relays → us, the same picture Message paths and the Trophy case draw. A direct arrival skips it (its `direct — no relays` via row already says all there is). render_body splits into head/tail grids sharing one label-lane width so the rows stay aligned across the graph; the dashboard threads a node-type resolver through so relays wear their map marker (▲, …). Full suite green (806). Co-Authored-By: Claude Opus 4.8 --- meshterm/ui/dashboard_screen.py | 10 +- meshterm/ui/message_paths_screen.py | 35 +++---- meshterm/ui/packet_viewer.py | 139 +++++++++++++++++++++++----- meshterm/ui/records_screen.py | 23 ++--- meshterm/ui/theme.py | 15 --- tests/test_message_paths_screen.py | 14 +-- tests/test_packet_viewer.py | 32 +++++++ 7 files changed, 190 insertions(+), 78 deletions(-) diff --git a/meshterm/ui/dashboard_screen.py b/meshterm/ui/dashboard_screen.py index 04a3286..5e3d3e0 100644 --- a/meshterm/ui/dashboard_screen.py +++ b/meshterm/ui/dashboard_screen.py @@ -50,7 +50,7 @@ from ..core.models import NODE_TYPE_REPEATER, Observation, utcnow from ..persistence.repository import ACTIVITY_WINDOW from .braillechart import axis_chart, meter, timeline_rows from .menus import fit_cells -from .widgets import path_text +from .widgets import TypeOf, path_text from .packet_viewer import ( KIND_STYLES, PacketEntry, @@ -136,6 +136,7 @@ class DashboardScreen(Screen): prefix_bytes: int = 0, self_name: Optional[str] = None, channels: Sequence[tuple[str, bytes]] = (), + type_of: Optional[TypeOf] = None, ) -> None: """Create the dashboard over its data feeds. @@ -153,6 +154,8 @@ class DashboardScreen(Screen): channels: The device's configured channels, as ``(name, secret)`` pairs, handed to each opened :class:`~meshterm.ui.packet_viewer.PacketViewer` so it can attempt to decrypt an overheard channel-text packet. + type_of: Maps a relay hash to its node type, handed to the packet viewer so a + relayed packet's route graph marks a repeater ``▲`` (etc.) over a dot. """ super().__init__() self.title = "Dashboard — mesh overview" @@ -165,6 +168,7 @@ class DashboardScreen(Screen): self._prefix_bytes = prefix_bytes self._self_name = self_name self._channels = channels + self._type_of = type_of #: The trailing window of observations (stored seed + live), oldest first. self._window: deque[Observation] = deque(window, maxlen=4000) #: The feed: latest events of every class as data, newest first — rendered @@ -293,7 +297,7 @@ class DashboardScreen(Screen): list(self._feed), self._selected, resolve=self._resolve, prefix_bytes=self._prefix_bytes, self_name=self._self_name, on_navigate=follow, - channels=self._channels, + channels=self._channels, type_of=self._type_of, # The live feed itself (newest first), so the viewer keeps up with packets # that arrive while it is open instead of freezing at this snapshot. source=lambda: list(self._feed), @@ -685,6 +689,7 @@ async def open_dashboard(ctx: "AppContext") -> None: # Contacts first, every name the recorder ever overheard as the fallback — the # app-wide rule that a node we can name never renders as a bare hash. resolve = trace_runner.make_node_resolver(contacts, ctx.repo.node_names()) + type_of = trace_runner.make_node_type_resolver(contacts) prefix_bytes = await _routing_prefix_bytes(ctx) window = ctx.repo.recent_observations(since=utcnow() - ACTIVITY_WINDOW) @@ -699,6 +704,7 @@ async def open_dashboard(ctx: "AppContext") -> None: prefix_bytes=prefix_bytes, self_name=self_name, channels=channels, + type_of=type_of, ) unsubscribe = ctx.events.subscribe(screen.on_event) diff --git a/meshterm/ui/message_paths_screen.py b/meshterm/ui/message_paths_screen.py index e2454c2..be03f0d 100644 --- a/meshterm/ui/message_paths_screen.py +++ b/meshterm/ui/message_paths_screen.py @@ -7,13 +7,12 @@ detail read together: * a **graph** up top draws every distinct path the message took through the shared route-graph widget (:mod:`~meshterm.ui.pathgraph`): the currently selected path - coloured by its reception SNR (the SNR palette), the unused paths gray beneath it. - The origin sits at the left, we sit at the right, and every relay in between gets its - own node-type marker (``▲`` repeater, …) plus the first byte of its hash — set straight - above or below the marker, in the mesh name's own colour, so the byte reads as that node - and never crowds the line running through it. A node-type key sits under the fan. The row - list carries the full names, so the graph's labels stay two cells wide and a - many-path graph stays readable. + white, the unused paths gray beneath it. The origin sits at the left, we sit at the + right, and every relay in between gets its own node-type marker (``▲`` repeater, …) + plus the first byte of its hash — set straight above or below the marker, in the mesh + name's own colour, so the byte reads as that node and never crowds the line running + through it. A node-type key sits under the fan. The row list carries the full names, + so the graph's labels stay two cells wide and a many-path graph stays readable. * the **arrival list** beneath is one row per logged copy — time, reception SNR, and the relay chain through the shared compact path widget, each named hop annotated with the hash byte it is addressed by (``YUL-Poly (3d)``, the trace presentation); @@ -36,7 +35,7 @@ from rich.text import Text from ..core.models import ChatMessage from ..services.message_paths import Arrival from .pathgraph import PathLayer, render_path_graph -from .theme import snr_rgb, snr_style +from .theme import snr_style from .tui.render import crop_cells, render_to_ansi from .tui.screen import Screen from .widgets import NodeResolver, TypeOf, node_type_legend, path_text, route_graph_style @@ -44,8 +43,7 @@ from .widgets import NodeResolver, TypeOf, node_type_legend, path_text, route_gr #: Cells one ←/→ press shifts the selected row by. _HSTEP = 4 -#: Edge colours: the selected path draws in its arrival's SNR hue (white when it carried no -#: reading) over the unused paths' gray. +#: Edge colours: the selected path draws white over the unused paths' gray. _EDGE_SELECTED = (255, 255, 255) _EDGE_UNUSED = (110, 110, 110) @@ -175,7 +173,7 @@ class MessagePathsScreen(Screen): lines.append("") lines.extend(self._graph_lines(width)) - caption = Text("origin → you · colour = SNR of selected · labels = hash byte", + caption = Text("origin → you · white = selected path · labels = hash byte", style="faint") lines.append(render_to_ansi(caption, width, no_wrap=True)) lines.append(render_to_ansi(node_type_legend(), width, no_wrap=True)) @@ -258,24 +256,21 @@ class MessagePathsScreen(Screen): return seen def _graph_lines(self, width: int) -> list[str]: - """Draw every distinct path origin → us, the selected one in its SNR hue over gray. + """Draw every distinct path origin → us, the selected one white over gray. The shared route-graph widget does the layout (lanes fanned from the centre in first-heard order, shared relays averaged together); this just maps each distinct path to a :class:`~meshterm.ui.pathgraph.PathLayer` — the selected - one on top coloured by the selected arrival's reception SNR (the SNR palette, - white when it carried no reading), the rest gray beneath — and hands it the shared - route-graph callbacks (:func:`~meshterm.ui.widgets.route_graph_style`): endpoints - named, relays their own map marker where the type is known, each labelled by its + one white on top, the rest gray beneath — and hands it the shared route-graph + callbacks (:func:`~meshterm.ui.widgets.route_graph_style`): endpoints named, + relays their own map marker where the type is known, each labelled by its first hash byte in the node's own hue. """ - arrival = self._arrivals[self._index] - selected = arrival.hops - selected_color = snr_rgb(arrival.snr) if arrival.snr is not None else _EDGE_SELECTED + selected = self._arrivals[self._index].hops layers = [ PathLayer( hops=path, - color=selected_color if path == selected else _EDGE_UNUSED, + color=_EDGE_SELECTED if path == selected else _EDGE_UNUSED, priority=3 if path == selected else 2, ) for path in self._paths() diff --git a/meshterm/ui/packet_viewer.py b/meshterm/ui/packet_viewer.py index 0626a5b..192ee02 100644 --- a/meshterm/ui/packet_viewer.py +++ b/meshterm/ui/packet_viewer.py @@ -6,9 +6,12 @@ class — and every row can open into the same viewer: a centered dialog over th that lays the packet out in full, flavoured by kind. An advert shows the node's identity, type, and location; telemetry shows the node and its reported values; an RX-logged packet shows its parsed class and route plus the relay path it rode in on — -and, for an overheard channel-text frame naming a channel we hold the key for, the -decrypted text too (see :func:`~meshterm.core.channels.decrypt_channel_text`), even -though the radio itself never decoded it for us; a message shows the sender, the +as a ``via`` chain and, when it actually crossed a relay, as THE route graph +(:mod:`~meshterm.ui.pathgraph`): origin → relays → us, the same fan-lane picture the +Message paths dialog and the Trophy case draw — and, for an overheard channel-text frame +naming a channel we hold the key for, the decrypted text too (see +:func:`~meshterm.core.channels.decrypt_channel_text`), even though the radio itself never +decoded it for us; a message shows the sender, the conversation, and the text; an ack shows its code. Common to all: the timestamp, the node (name coloured by the app-wide palette, hash in the hash widget), reception quality on the shared SNR bar, and any leftover raw field the flavoured layout doesn't @@ -34,11 +37,20 @@ from rich.text import Text from ..core.channels import decrypt_channel_text from ..core.models import NODE_TYPE_LABELS, Observation from ..services.trace_runner import NodeResolver +from .pathgraph import PathLayer, render_path_graph from .theme import name_style, snr_style from .trace_screen import snr_bar -from .tui.render import render_lines +from .tui.render import render_lines, render_to_ansi from .tui.screen import Screen -from .widgets import _age_seconds, format_ago, highlighted_hash, path_text +from .widgets import ( + TypeOf, + _age_seconds, + format_ago, + highlighted_hash, + node_type_legend, + path_text, + route_graph_style, +) #: Friendly gloss for a raw packet's parsed payload class (mirrors the meshcore #: library's own ``PAYLOAD_TYPENAMES``), shown on a ``packet`` entry's "class" row. @@ -57,8 +69,8 @@ _PAYLOAD_GLOSS = { "CONTROL": "control", } -#: Raw-payload fields already folded into a flavoured row elsewhere in :meth:`_rows` -#: (frame plumbing parsed into "class"/"route", the channel crypto handled by +#: Raw-payload fields already folded into a flavoured row elsewhere (frame plumbing +#: parsed into "class"/"route", the channel crypto handled by #: :meth:`PacketViewer._decrypt_rows`, or an advert field duplicating ``node``/ #: ``lat``/``lon``/etc.) — skipped so the generic dump doesn't repeat them. _RAW_ROW_SKIP = frozenset({ @@ -93,6 +105,11 @@ KIND_ICONS = { } DEFAULT_ICON = "❔" +#: The colour a relayed packet's route draws in on THE route graph. It is the only path +#: on the canvas, so white just reads as "the route the packet rode" (the Trophy case's +#: single-walk convention). +_ROUTE_EDGE = (255, 255, 255) + @dataclass(slots=True) class PacketEntry: @@ -236,6 +253,7 @@ class PacketViewer(Screen): on_navigate: Optional[Callable[[PacketEntry], None]] = None, channels: Sequence[tuple[str, bytes]] = (), source: Optional[Callable[[], Sequence[PacketEntry]]] = None, + type_of: Optional[TypeOf] = None, ) -> None: """Open the viewer over a packet list. @@ -256,6 +274,9 @@ class PacketViewer(Screen): keypress and re-locates the packet being viewed by identity, so packets that arrive while the dialog is open become reachable (``↑`` walks up into them) instead of the view being frozen at its opening snapshot. + type_of: Maps a relay hash to its node type, so a relayed packet's route + graph marks a repeater ``▲`` (etc.) instead of a generic dot; ``None`` + keeps the plain named-dot / unknown-ring fallback. """ super().__init__() self._entries = list(entries) @@ -266,6 +287,7 @@ class PacketViewer(Screen): self._on_navigate = on_navigate self._channels = channels self._source = source + self._type_of = type_of #: The packet currently shown, tracked by identity so a live prepend to the #: source (which shifts every index) never slides the view onto another packet. self._current: Optional[PacketEntry] = ( @@ -355,34 +377,66 @@ class PacketViewer(Screen): # --- rendering ------------------------------------------------------------- def render_body(self, width: int) -> list[str]: - """Lay the current entry out as labelled rows, flavoured by its kind.""" + """Lay the current entry out as labelled rows, flavoured by its kind. + + A relayed ``packet`` slots THE route graph (:mod:`~meshterm.ui.pathgraph`) between + its parsed detail (heard/from/class/via) and its extras (location/text/raw): the + via row names each hop precisely, the graph shows the same relay chain as a shape — + origin at the left, us at the right. The two label/value grids around it share one + label-lane width so their rows still line up across the picture. + """ # Fold in any packets that arrived since the last paint, keeping the view on the # same packet, so the title's ``n/total`` and the reachable range stay current. self._sync() entry = self._entries[self._index] - rows = self._rows(entry) - # The label lane is one fixed width for the whole grid so wrapped values align with - # their own block (the app-wide hanging-indent rule), never with column zero. Size it - # to the widest label actually present — a raw payload field's full name included, so - # none is clipped — plus a one-cell gutter, but never so wide it leaves the value - # column under 20 cells (a pathological key then ellipsises instead of crushing it). + head, tail = self._head_rows(entry), self._tail_rows(entry) + label_w = self._label_width(head + tail, width) + + lines = self._grid_lines(head, width, label_w) + graph = self._graph_lines(entry, width) + if graph: + lines.append("") + lines.extend(graph) + caption = Text("origin → you · labels = hash byte", style="faint") + lines.append(render_to_ansi(caption, width, no_wrap=True)) + lines.append(render_to_ansi(node_type_legend(), width, no_wrap=True)) + if tail: + lines.append("") + lines.extend(self._grid_lines(tail, width, label_w)) + self._scroll_total = max(1, len(lines)) + return lines + + @staticmethod + def _label_width(rows: list[tuple[str, RenderableType]], width: int) -> int: + """The shared label-lane width so wrapped values hang under their own block. + + One fixed width for every grid on the card (the app-wide hanging-indent rule), never + column zero — sized to the widest label present (a raw payload field's full name + included, so none is clipped) plus a one-cell gutter, but never so wide it leaves the + value column under 20 cells (a pathological key then ellipsises instead of crushing it). + """ widest = max((len(label) for label, _ in rows), default=0) - label_w = max(10, min(widest + 1, width - 20)) + return max(10, min(widest + 1, width - 20)) + + @staticmethod + def _grid_lines( + rows: list[tuple[str, RenderableType]], width: int, label_w: int + ) -> list[str]: + """Render one label/value grid to ANSI lines (empty rows → no lines).""" + if not rows: + return [] grid = Table( box=None, show_header=False, show_edge=False, pad_edge=False, padding=(0, 0), expand=False, ) grid.add_column(width=label_w, no_wrap=True) grid.add_column(overflow="fold", max_width=max(20, width - label_w)) - for label, value in rows: grid.add_row(Text(label, style="muted"), value) - lines = render_lines(grid, width) - self._scroll_total = max(1, len(lines)) - return lines + return render_lines(grid, width) - def _rows(self, entry: PacketEntry) -> list[tuple[str, RenderableType]]: - """The labelled rows for one entry: the common core plus its kind's extras.""" + def _head_rows(self, entry: PacketEntry) -> list[tuple[str, RenderableType]]: + """The rows above the route graph: the common core plus a packet's parsed frame.""" rows: list[tuple[str, RenderableType]] = [] secs = _age_seconds(entry.when) @@ -406,6 +460,11 @@ class PacketViewer(Screen): rows.append(("snr", self._reception(entry))) if entry.kind == "packet": rows.extend(self._packet_rows(entry)) + return rows + + def _tail_rows(self, entry: PacketEntry) -> list[tuple[str, RenderableType]]: + """The rows below the route graph: location, the message/ack fields, the raw dump.""" + rows: list[tuple[str, RenderableType]] = [] if entry.lat is not None and entry.lon is not None: rows.append(("location", Text(f"{entry.lat:.5f}, {entry.lon:.5f}"))) @@ -418,6 +477,44 @@ class PacketViewer(Screen): rows.extend(self._raw_rows(entry)) return rows + def _graph_lines(self, entry: PacketEntry, width: int) -> list[str]: + """Draw a relayed packet's origin → relays → us route on THE route graph. + + Only a ``packet`` frame that actually crossed a relay draws one — a direct + arrival's ``via`` row (``direct — no relays``) already says all there is to say, so + a two-node graph would waste the height. The relay chain is the packet's path + (originator-nearest first), the left endpoint the origin when the frame named one + (an advert's ``adv_key``; other classes arrive origin-less, drawn ``?``), the right + endpoint always us — the same fan-lane widget the Message paths dialog and the + Trophy case draw, in a single white path. + """ + if entry.kind != "packet": + return [] + hops = tuple(hop for hop in (entry.path or "").split(",") if hop) + if not hops: + return [] + glyph_of, label_of, label_rgb_of = route_graph_style( + resolve=self._resolve, self_name=self._self_name, + source=self._graph_source(entry), type_of=self._type_of, + ) + return render_path_graph( + [PathLayer(hops=hops, color=_ROUTE_EDGE, priority=3)], + width, glyph_of=glyph_of, label_of=label_of, label_rgb_of=label_rgb_of, + ) + + def _graph_source(self, entry: PacketEntry) -> Optional[str]: + """The origin's display name for the graph's left endpoint, or ``None`` if unknown. + + The naming rule the ``from`` row follows (a resolved contact wins, then the name the + frame carried), but a nameless origin returns ``None`` so the graph draws a plain + ``?`` endpoint rather than passing a bare hash off as a named node. + """ + if entry.node: + resolved = self._resolve(entry.node) + if resolved and resolved != entry.node: + return resolved + return entry.name or None + def _reception(self, entry: PacketEntry) -> Text: """SNR (with the shared quality bar) and RSSI on one line.""" line = Text() diff --git a/meshterm/ui/records_screen.py b/meshterm/ui/records_screen.py index ac8464e..642defe 100644 --- a/meshterm/ui/records_screen.py +++ b/meshterm/ui/records_screen.py @@ -40,7 +40,7 @@ from ..services.records import CATEGORIES, CATEGORY_BY_ID, Category, _local_xy from .mapcanvas import RGB, MapCanvas from .menus import back_rows, section_heading from .pathgraph import PathLayer, render_path_graph -from .theme import name_style, snr_rgb, snr_style +from .theme import name_style, snr_style from .tui.render import render_hanging, render_to_ansi from .tui.screen import Screen from .widgets import ( @@ -111,8 +111,8 @@ class RecordDialog(Screen): history, the far point named with the node it reached — with the walk's enclosed area drawn beside them on a braille mini-map (us at the origin, every positioned hop pinned in its own name hue, no labels) when the terminal has the room; below, the walk on THE - route graph (us at both ends, coloured by its weakest link, relays wearing their map - marker over a node-type key), the route in full (wrapped, never truncated), and the + route graph (us at both ends, relays wearing their map marker over a node-type key), + the route in full (wrapped, never truncated), and the record's provenance — when it was set and by which app version. The card scrolls (PgUp/PgDn/Home/End) when it outgrows the frame, while the arrows drive the actions. Two actions besides Back: *Trace this path* reopens Trace path with the record's route @@ -216,14 +216,13 @@ class RecordDialog(Screen): """Draw the walked route as one path on THE route graph — us at both ends. A scored walk leaves home and comes back, so it draws us (left) → its relays → - us (right) as a single path through the shared fan-lane widget + us (right) as a single white path through the shared fan-lane widget (:func:`~meshterm.ui.pathgraph.render_path_graph`), the same shape the Message - paths dialog draws a delivery over. The path is coloured by the walk's weakest link - (the SNR palette), so the loop reads red when a hop barely carried; relays wear - their own map marker (``▲`` repeater, …) where the type is known. Nodes the walk - passed through more than once — a boomerang's mirrored return leg — collapse to - their first appearance: the depth-ordered graph can only seat a node once, and the - route line below still carries every hop, revisits and all. + paths dialog draws a delivery over. Relays wear their own map marker (``▲`` + repeater, …) where the type is known. Nodes the walk passed through more than once + — a boomerang's mirrored return leg — collapse to their first appearance: the + depth-ordered graph can only seat a node once, and the route line below still + carries every hop, revisits and all. """ seen: set[str] = set() hops: list[str] = [] @@ -237,10 +236,8 @@ class RecordDialog(Screen): source=self._device_label, type_of=self._type_of, ) - min_snr = self._record.stats.get("min_snr") - color = snr_rgb(min_snr) if min_snr is not None else _WALK_EDGE return render_path_graph( - [PathLayer(hops=tuple(hops), color=color, priority=3)], + [PathLayer(hops=tuple(hops), color=_WALK_EDGE, priority=3)], width, glyph_of=glyph_of, label_of=label_of, label_rgb_of=label_rgb_of, ) diff --git a/meshterm/ui/theme.py b/meshterm/ui/theme.py index 5204c0a..d9528f6 100644 --- a/meshterm/ui/theme.py +++ b/meshterm/ui/theme.py @@ -176,18 +176,3 @@ def snr_style(snr: float | None) -> str: if snr >= -5: return "snr.ok" return "snr.bad" - - -#: The truecolour behind each :func:`snr_style` band, matching its ``snr.*`` theme hue, for -#: rasters that plot SNR directly (the route graph colouring a path by its link quality). -_SNR_RGB: dict[str, tuple[int, int, int]] = { - "snr.good": (74, 222, 128), # #4ade80 - "snr.ok": (251, 191, 36), # #fbbf24 - "snr.bad": (248, 113, 113), # #f87171 - "muted": (148, 163, 184), # #94a3b8 -} - - -def snr_rgb(snr: float | None) -> tuple[int, int, int]: - """The ``(r, g, b)`` of an SNR reading's quality band (see :func:`snr_style`).""" - return _SNR_RGB[snr_style(snr)] diff --git a/tests/test_message_paths_screen.py b/tests/test_message_paths_screen.py index 85f4bcc..7421ef4 100644 --- a/tests/test_message_paths_screen.py +++ b/tests/test_message_paths_screen.py @@ -49,7 +49,7 @@ def test_paths_screen_renders_graph_rows_and_cursor() -> None: assert "Alice" in body and "Homestead" in body # origin and us, on the graph assert body.count("via") == 2 # one row per arrival assert "❯" in body - assert "colour = SNR of selected" in body # the graph caption + assert "white = selected path" in body # the graph caption assert "★ you" in body and "▲ repeater" in body # the node-type legend assert screen.cursor_line() is not None @@ -85,15 +85,15 @@ def test_paths_screen_shows_unknown_relay_as_grey_mode_width_hash() -> None: assert "e8" in graph # the row's byte still cross-references the graph label -def test_paths_screen_colours_selected_path_by_snr_over_gray() -> None: - """The selected path's edges take its arrival's SNR hue; the unused path stays gray.""" - screen = _screen(_arrivals()) # selected arrival's SNR is +4.0 dB → the "ok" band +def test_paths_screen_draws_selected_path_white_over_gray() -> None: + """The selected path's edges render white; the unused path's edges gray.""" + screen = _screen(_arrivals()) raw = "\n".join(screen.render_body(76)).split("origin →")[0] - assert "38;2;251;191;36" in raw # snr.ok amber — the selected path, by SNR + assert "38;2;255;255;255" in raw # the selected path, white assert "38;2;110;110;110" in raw # the other path, gray beneath it - screen.handle("down") # select the weaker arrival (−2.0 dB, still "ok") + screen.handle("down") # move the selection to the other path raw2 = "\n".join(screen.render_body(76)).split("origin →")[0] - assert "38;2;251;191;36" in raw2 # the newly selected path recolours + assert "38;2;255;255;255" in raw2 and "38;2;110;110;110" in raw2 def test_paths_screen_marks_a_repeater_relay_with_its_triangle() -> None: diff --git a/tests/test_packet_viewer.py b/tests/test_packet_viewer.py index 472dd90..5bfd434 100644 --- a/tests/test_packet_viewer.py +++ b/tests/test_packet_viewer.py @@ -139,3 +139,35 @@ def test_packet_viewer_shows_full_raw_field_labels() -> None: }) body = _plain(_viewer(entry).render_body(80)) assert "battery_millivolts" in body # the 18-char key is not clipped to 8 + + +def test_packet_viewer_draws_a_relayed_packets_route_graph() -> None: + """A packet that crossed relays gets THE route graph — braille edges, caption, legend.""" + entry = PacketEntry(when=utcnow(), kind="packet", path="3d63,a1b2") + body = _plain(_viewer(entry).render_body(80)) + assert "origin → you" in body # the graph caption + assert "★ you" in body and "▲ repeater" in body # the node-type legend + assert any("⠀" <= ch <= "⣿" for ch in body) # braille edges are drawn + assert "3d" in body and "a1" in body # each relay labelled by its hash byte + + +def test_packet_viewer_skips_the_graph_for_a_direct_packet() -> None: + """A packet with no relays says so in the via row and draws no (pointless) two-node graph.""" + entry = PacketEntry(when=utcnow(), kind="packet", path="") + body = _plain(_viewer(entry).render_body(80)) + assert "direct — no relays" in body + assert "origin → you" not in body + assert not any("⠀" <= ch <= "⣿" for ch in body) + + +def test_packet_viewer_graph_names_a_known_origin_else_a_question_mark() -> None: + """The graph's left endpoint is the resolved origin name, or ``?`` when the frame named none.""" + known = PacketEntry(when=utcnow(), kind="packet", node="c0ffee", path="3d63") + body = _plain( + PacketViewer([known], 0, resolve=lambda h: "Base" if h == "c0ffee" else "").render_body(80) + ) + assert "Base" in body # the origin, resolved to its contact name + + nameless = PacketEntry(when=utcnow(), kind="packet", path="3d63") + body2 = _plain(_viewer(nameless).render_body(80)) + assert "?" in body2 # an origin-less flood draws a plain "?" endpoint