Jean-Pierre MartineauandClaude Opus 5
6a12104cf7
Two fixes to what a path line shows at its edges and at its ends. The edges: the crack only reached the two surfaces that drew their own marks. Everywhere else a path still met render_to_ansi(no_wrap=True) or a plain truncate, both of which ellipsize — so the Message paths rows you were not on trailed off in dots while the one you were on cracked. Those cuts now go through cut_to, which reads the line and decides: a chip breaks off on the crack, prose keeps its ellipsis. That covers the unselected arrival rows, every select-list row (the trophy walks and probe candidates), the TX sweep action rows, and the composer's suggestion rows. The generic surfaces are safe to convert precisely because the fallback is the old behaviour. The ends: a path's ends are the nodes it went between, so a line that opens on its first *relay* is naming a node that only passed the message on. The Message paths rows now run origin → relays → us — the same two endpoints the graph one row up already drew between, so the row and the picture finally cross-read. A hopless arrival stops collapsing to the word "direct": Alice ▶ ★ is what direct delivery looks like, on the same rails as every relayed row. And our own end is the ★ everywhere, not our name — it was already so on the trace lane, the trophy card and the composer, and now also on the node detail Routes rows, the TX sweep route, the mesh walk trail and the live feed's subject lane. It is the one node the reader never has to be told, and in an 18-cell feed lane or a width-starved trail the cells it gives back are hops that stay in view. Left alone deliberately: the packet viewer's `via` row (the dialog has a `from` row naming the origin, so `via` really is just the relay chain), the verbatim wire spec, and widgets._link_text — a table of FROM → TO *links*, still on the legacy path_text builder. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
270 lines
13 KiB
Python
270 lines
13 KiB
Python
"""Message-paths dialog tests: the graph-over-rows view behind the chat's ^P.
|
||
|
||
Driven headless like the mesh walk tests: render_body is pure lines-out, handle() pure
|
||
state, so the selection cursor, the horizontal line scroll, and the selected-path
|
||
labelling are all assertable without a terminal.
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
from datetime import timedelta
|
||
|
||
import meshterm.ui.pathline as pathline
|
||
from meshterm.core.models import ChatMessage, utcnow
|
||
from meshterm.services.message_paths import Arrival
|
||
from meshterm.ui.message_paths_screen import MessagePathsScreen
|
||
from meshterm.ui.pathline import CRACK_HEAD, CRACK_TAIL
|
||
|
||
|
||
def _resolve(hop: str) -> str:
|
||
return {"3d63": "YUL-Cartierville", "a1b2": "Waymarker"}.get(hop, hop)
|
||
|
||
|
||
from tests.conftest import plain as _plain # THE strip-and-join screen reader
|
||
|
||
|
||
def _screen(arrivals: list[Arrival], **kwargs) -> MessagePathsScreen:
|
||
message = ChatMessage(text="on my way", is_channel=True, created_at=utcnow())
|
||
defaults = dict(
|
||
matched=True, resolve=_resolve, prefix_bytes=1, self_name="Homestead",
|
||
summary="heard twice", source="Alice",
|
||
)
|
||
defaults.update(kwargs)
|
||
return MessagePathsScreen(message, arrivals, **defaults)
|
||
|
||
|
||
def _arrivals() -> list[Arrival]:
|
||
now = utcnow()
|
||
return [
|
||
Arrival(when=now, hops=("3d63",), snr=4.0),
|
||
Arrival(when=now + timedelta(seconds=2), hops=("a1b2", "77aa"), snr=-2.0),
|
||
]
|
||
|
||
|
||
def test_paths_screen_renders_graph_rows_and_cursor() -> None:
|
||
"""The quoted text, the graph endpoints, and two lines per arrival: the route you
|
||
pick, and the reception facts hanging under it."""
|
||
screen = _screen(_arrivals())
|
||
body = _plain(screen.render_body(76))
|
||
assert "“on my way”" in body
|
||
assert "Alice" in body and "Homestead" in body # origin and us, on the graph
|
||
assert "via" not in body # the route lane holds nothing but the route
|
||
rows = body.split("sensor\n\n")[1].split("\n")
|
||
assert len(rows) == 2 * len(_arrivals())
|
||
assert rows[0].startswith("❯ ") and "YUL-Cartierville" in rows[0] # the picked route
|
||
assert rows[1].strip().startswith(_arrivals()[0].when.astimezone().strftime("%H:%M"))
|
||
assert "+4.0 dB" in rows[1] # …with its time and SNR tucked beneath it
|
||
assert "❯" in body
|
||
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
|
||
|
||
|
||
def test_paths_screen_warns_once_for_a_path_that_revisits_a_hop() -> None:
|
||
"""A path touching one hop twice draws it twice, warned about once for the whole fan.
|
||
|
||
The note belongs to the picture, not to the arrival ↑↓ rest on, so it names every hop
|
||
repeated anywhere in the fan and says so a single time under the legend.
|
||
"""
|
||
now = utcnow()
|
||
screen = _screen([
|
||
Arrival(when=now, hops=("3d63", "a1b2", "77aa", "3d63"), snr=4.0),
|
||
Arrival(when=now + timedelta(seconds=2), hops=("a1b2",), snr=-2.0),
|
||
])
|
||
body = _plain(screen.render_body(76))
|
||
assert body.count("⚠") == 1
|
||
assert "YUL-Cartierville repeats — a loop, or two nodes sharing one hash" in body
|
||
graph = body.split("origin →")[0]
|
||
assert graph.count("3d") == 2 # both visits marked
|
||
assert graph.count("a1") == 1 # the relay the two paths *share* stays one marker
|
||
|
||
|
||
def test_paths_screen_stays_quiet_when_no_path_revisits() -> None:
|
||
"""Two paths crossing the same relay is sharing, not revisiting — nothing to warn about."""
|
||
body = _plain(_screen(_arrivals()).render_body(76))
|
||
assert "⚠" not in body
|
||
|
||
|
||
def test_paths_screen_labels_every_relay_with_its_hash_byte() -> None:
|
||
"""Graph relays carry their first hash byte, both paths at once; the rows carry the
|
||
names alone — no hash repeated after one, the two tied together by the node's hue."""
|
||
screen = _screen(_arrivals())
|
||
body = _plain(screen.render_body(76))
|
||
graph = body.split("origin →")[0]
|
||
for byte in ("3d", "a1", "77"): # every relay labelled, selected or not
|
||
assert byte in graph
|
||
assert "YUL-Cartier" not in graph and "Waymarker" not in graph
|
||
assert "YUL-Cartierville" in body and "Waymarker" in body
|
||
assert "(3d)" not in body and "(a1)" not in body # the hex lives on the graph
|
||
|
||
|
||
def test_paths_screen_shows_unknown_relay_as_grey_mode_width_hash() -> None:
|
||
"""An unnamed relay stands in its own hash at the device's path-hash width, muted
|
||
grey — not the bare one-byte prefix, lit, and never a hash annotated onto itself."""
|
||
now = utcnow()
|
||
arrivals = [
|
||
Arrival(when=now, hops=("3d63",), snr=4.0), # selected: a named relay
|
||
Arrival(when=now + timedelta(seconds=2), hops=("e839f2ab",), snr=-2.0),
|
||
]
|
||
screen = _screen(arrivals, prefix_bytes=3) # 3-byte routing → e839f2
|
||
lines = screen.render_body(76)
|
||
row = next(ln for ln in lines if "e839f2" in _plain([ln]))
|
||
assert "(e8)" not in _plain([row]) # the mode-width identity stands alone
|
||
assert "38;2;148;163;184" in row # muted grey over the hash
|
||
assert "38;2;94;234;212" not in row # never the brand highlight
|
||
graph = _plain(lines).split("origin →")[0]
|
||
assert "e8" in graph # the row's byte still cross-references the graph label
|
||
|
||
|
||
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;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") # move the selection to the other path
|
||
raw2 = "\n".join(screen.render_body(76)).split("origin →")[0]
|
||
assert "38;2;255;255;255" in raw2 and "38;2;110;110;110" in raw2
|
||
|
||
|
||
def test_paths_screen_graph_geometry_holds_still_across_the_selection() -> None:
|
||
"""↑↓ repaint the fan's colours, never its shape — the Routes tab's rule.
|
||
|
||
Layout rank is first-heard order, so only ``emphasis`` follows the pick; the drawn
|
||
glyphs/lanes are byte-identical from every selection.
|
||
"""
|
||
now = utcnow()
|
||
arrivals = [
|
||
Arrival(when=now, hops=("3d63",), snr=4.0),
|
||
Arrival(when=now + timedelta(seconds=2), hops=("a1b2", "77aa"), snr=-2.0),
|
||
Arrival(when=now + timedelta(seconds=4), hops=("a1b2", "5c5c", "77aa"), snr=1.0),
|
||
]
|
||
screen = _screen(arrivals)
|
||
shapes = []
|
||
for _ in range(len(arrivals)):
|
||
shapes.append(_plain(screen._graph_lines(76)))
|
||
screen.handle("down")
|
||
assert len(set(shapes)) == 1, "the graph's shape moved when the selection did"
|
||
assert shapes[0].count("\n") > 1 # a genuine multi-lane fan, not one flat line
|
||
|
||
|
||
def test_paths_screen_marks_a_repeater_relay_with_its_triangle() -> None:
|
||
"""A relay whose type resolves to a repeater draws ▲, not the generic dot."""
|
||
screen = _screen(_arrivals(), type_of=lambda h: 2 if h == "3d63" else None)
|
||
graph = _plain(screen.render_body(76)).split("origin →")[0]
|
||
assert "▲" in graph # the repeater relay wears its map glyph
|
||
screen.handle("down")
|
||
raw = "\n".join(screen.render_body(76)).split("origin →")[0]
|
||
assert "38;2;255;255;255" in raw and "38;2;110;110;110" in raw
|
||
|
||
|
||
def test_paths_screen_scrolls_the_selected_route_sideways() -> None:
|
||
"""→ shifts the selected *route* under a leading …; ↑↓ snap it back.
|
||
|
||
The reception facts under it never move — they always fit, and a lane that slid
|
||
with the route would make a long path look like it had lost its timestamp.
|
||
"""
|
||
now = utcnow()
|
||
long = Arrival(when=now, hops=tuple(f"{i:02x}{i:02x}" for i in range(12)), snr=1.0)
|
||
screen = _screen([long, Arrival(when=now, hops=(), snr=None)])
|
||
narrow = 40
|
||
before = _plain(screen.render_body(narrow))
|
||
selected_before = next(ln for ln in before.split("\n") if ln.startswith("❯"))
|
||
assert screen._hmax > 0 # the route genuinely overflows at this width
|
||
assert "00" in selected_before and "0b" not in selected_before # head shown, tail cut
|
||
for _ in range(3):
|
||
screen.handle("right")
|
||
after = _plain(screen.render_body(narrow))
|
||
selected_after = next(ln for ln in after.split("\n") if ln.startswith("❯"))
|
||
assert selected_after != selected_before
|
||
assert "…" in selected_after # the left edge marks the hidden head
|
||
stamp = long.when.astimezone().strftime("%H:%M:%S")
|
||
assert stamp in after and stamp not in selected_after # the facts hold their lane
|
||
screen.handle("down")
|
||
assert screen._hshift == 0 # only the selected route stays scrolled
|
||
|
||
|
||
def test_paths_screen_cracks_the_chips_the_scroll_cuts(monkeypatch) -> None: # noqa: ANN001
|
||
"""Where the terminal draws chips, each edge the route runs past breaks the chip off
|
||
on a half block in its own colour rather than behind an ellipsis: the row is sliding
|
||
over a route that continues, not shortening a word."""
|
||
monkeypatch.setattr(pathline, "powerline_enabled", lambda: True)
|
||
now = utcnow()
|
||
long = Arrival(when=now, hops=tuple(f"{i:02x}{i:02x}" for i in range(12)), snr=1.0)
|
||
screen = _screen([long, Arrival(when=now, hops=(), snr=None)])
|
||
narrow = 40
|
||
|
||
def selected() -> str:
|
||
return next(
|
||
ln for ln in _plain(screen.render_body(narrow)).split("\n") if ln.startswith("❯")
|
||
)
|
||
|
||
row = selected()
|
||
assert row.rstrip().endswith(CRACK_TAIL) and "…" not in row # only the tail runs on
|
||
for _ in range(3):
|
||
screen.handle("right")
|
||
row = selected()
|
||
assert row.startswith("❯ " + CRACK_HEAD) # …and now the head is off to the left too
|
||
assert row.rstrip().endswith(CRACK_TAIL) and "…" not in row
|
||
|
||
|
||
def test_paths_screen_route_runs_origin_to_us_not_relay_to_relay() -> None:
|
||
"""A row is the whole route, not the relay chain it rode.
|
||
|
||
A path's ends are the nodes it went *between*, so the sender leads the line and we
|
||
close it on the ★ — the same two endpoints the graph one row up draws between, which
|
||
is what lets the row and the picture cross-read. A chain that opened on its first
|
||
relay read as a route from a node that had only passed the message on.
|
||
"""
|
||
screen = _screen(_arrivals())
|
||
rows = _plain(screen.render_body(76)).split("sensor\n\n")[1].split("\n")
|
||
assert rows[0] == "❯ Alice → YUL-Cartierville → ★"
|
||
assert rows[2] == " Alice → Waymarker → 77 → ★" # an unnamed relay still stands in its hash
|
||
|
||
|
||
def test_paths_screen_origin_is_a_star_for_us_and_a_question_for_nobody() -> None:
|
||
"""The head is named exactly as the graph's left endpoint is: our own ``★`` on a
|
||
message we sent, a bare ``?`` where the frame named nobody — never a guessed name."""
|
||
now = utcnow()
|
||
one = [Arrival(when=now, hops=("3d63",), snr=1.0)]
|
||
ours = _plain(_screen(one, source="Homestead").render_body(76))
|
||
assert "❯ ★ → YUL-Cartierville → ★" in ours
|
||
nameless = _plain(_screen(one, source=None).render_body(76))
|
||
assert "❯ ? → YUL-Cartierville → ★" in nameless
|
||
|
||
|
||
def test_paths_screen_cuts_unselected_rows_the_same_way(monkeypatch) -> None: # noqa: ANN001
|
||
"""A row you are not on runs off the lane exactly as the selected one does, so it owes
|
||
the reader the same cracked chip — it just cannot slide to read the rest."""
|
||
monkeypatch.setattr(pathline, "powerline_enabled", lambda: True)
|
||
now = utcnow()
|
||
long = tuple(f"{i:02x}{i:02x}" for i in range(12))
|
||
screen = _screen([
|
||
Arrival(when=now, hops=long, snr=1.0),
|
||
Arrival(when=now + timedelta(seconds=2), hops=long[::-1], snr=2.0),
|
||
])
|
||
lines = _plain(screen.render_body(40)).split("\n")
|
||
rows = lines[next(i for i, ln in enumerate(lines) if ln.startswith("❯")):]
|
||
assert rows[0].rstrip().endswith(CRACK_TAIL) # the selected row
|
||
unselected = rows[2] # row 1 is the selected row's hanging reception facts
|
||
assert unselected.rstrip().endswith(CRACK_TAIL) and "…" not in unselected
|
||
|
||
|
||
def test_paths_screen_direct_arrival_and_empty_state() -> None:
|
||
"""A hop-less arrival draws its two endpoints and nothing between; no arrivals at all
|
||
explain themselves.
|
||
|
||
The route no longer collapses to the word *direct*: with both ends on the line,
|
||
``Alice → ★`` **is** what a direct delivery looks like, and it reads on the same rails
|
||
as every relayed row instead of swapping the picture for a caption.
|
||
"""
|
||
now = utcnow()
|
||
screen = _screen([Arrival(when=now, hops=(), snr=2.5)])
|
||
body = _plain(screen.render_body(76))
|
||
assert "❯ Alice → ★" in body
|
||
assert "direct" not in body
|
||
empty = _screen([], matched=False)
|
||
body = _plain(empty.render_body(76))
|
||
assert "No direct-message frames logged in the window." in body
|
||
assert empty.footer_hint == "Esc close"
|