A companion, a room server, or a sensor does not relay a trace with the firmware defaults (allowPacketForward in Mesh.cpp: client repeat is off, and allowed only on 433.000, 869.495, and 918.000 MHz; disable_fwd is on). A walk that turned at one of them never came home: the history held 36 companion traces and no reply from a real one. The route to such a node is the same. Only the walk changes: it turns at the last relay of the route, and the node is not in the spec. The route out of a walk that comes home is still the full route to the node, so the Device route row can offer it for DMs and admin. - relays_traces() in models states the rule. render_forced_spec takes relays=False, and forced_outbound reads the route back from a walk. - services/trace_plan holds the route choice that the trace screen made inline (radio route, outbound paths, best observed, last trace, direct), so the CLI uses the same one. - The trace screen names the relay where the walk turns, in a line under the route. With no relay to turn at, Trace is dim. A neighbour that does not relay gets "no relays" offered on the Device route row, with the packets heard directly as its proof. - The trace session turns a caller's spec (node page, Message paths) at the last relay, so the callers do not need the rule. A sender that is not a contact gets its type from its stored adverts. - The composer and Explore paths turn the walk at the last hop. - `meshterm trace -t NAME` with no --path walks the menu's route and says on stderr where it turns. With no known relay, it is a usage error. - The connection turns a device-routed trace at the last learned relay. The simulator now stops a walk at a node that does not relay, as the mesh does, and the tests that walked through Alice walk repeaters. The picker keeps one list with no mark, sorted as before (JP's choice). Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
368 lines
14 KiB
Python
368 lines
14 KiB
Python
# SPDX-License-Identifier: Apache-2.0
|
||
"""Tests for the Device route popup of the node page: its row, its pages, and its actions."""
|
||
|
||
from __future__ import annotations
|
||
|
||
from contextlib import asynccontextmanager
|
||
from types import SimpleNamespace
|
||
|
||
from meshterm.core.models import Contact, DiscoveredRoute, utcnow
|
||
from meshterm.core.outbound_store import SOURCE_DEVICE, SOURCE_SITE, RouteOwner
|
||
from meshterm.services.device_routes import (
|
||
ORIGIN_FLOOD,
|
||
ORIGIN_KEPT,
|
||
ORIGIN_LEARNED,
|
||
ORIGIN_SET,
|
||
RouteStatus,
|
||
)
|
||
from meshterm.services.topology import build_topology
|
||
from meshterm.ui.device_route_screen import (
|
||
RouteEnv,
|
||
_action_rows,
|
||
_apply,
|
||
_discover,
|
||
_picker_rows,
|
||
row_label,
|
||
)
|
||
from meshterm.ui.tui.select import Choice
|
||
|
||
HOME = RouteOwner(SOURCE_SITE, "Home")
|
||
HUB = "3d63c6429436"
|
||
ALICE_KEY = "f2c24f54551e" + "0" * 52
|
||
|
||
|
||
def _env() -> RouteEnv:
|
||
hub = Contact(name="Hilltop", public_key=HUB + "0" * 52, key_prefix=HUB)
|
||
alice = Contact(name="Alice", public_key=ALICE_KEY, key_prefix=ALICE_KEY[:12])
|
||
topo = build_topology(
|
||
self_id="aaaaaaaaaaaa",
|
||
contacts=[hub, alice],
|
||
trace_paths=[],
|
||
packet_paths=[],
|
||
neighbour_links=[],
|
||
)
|
||
return RouteEnv(
|
||
contact=alice,
|
||
label="Alice",
|
||
target="f2c24f54551e",
|
||
topology=topo,
|
||
self_key="aa" * 32,
|
||
width_bytes=1,
|
||
resolve=lambda hop: None,
|
||
scenarios=[],
|
||
suggested=SimpleNamespace(hops=(HUB,), source="outbound", rank=1, samples=0),
|
||
)
|
||
|
||
|
||
def _values(rows: list) -> list:
|
||
return [row.value for row in rows if isinstance(row, Choice)]
|
||
|
||
|
||
def test_the_row_says_what_the_radio_holds() -> None:
|
||
"""Flood, learned, set by you, and kept read differently, and a skipped kept route shows."""
|
||
assert row_label(RouteStatus(None, ORIGIN_FLOOD)) == "Device route · none, it floods…"
|
||
assert row_label(RouteStatus((), ORIGIN_LEARNED)) == "Device route · no relays, learned…"
|
||
assert row_label(RouteStatus(("3d",), ORIGIN_SET)) == "Device route · 1 hop, set by you…"
|
||
kept = RouteStatus(("3d", "27"), ORIGIN_KEPT, kept=("3d", "27"), owner=HOME)
|
||
assert row_label(kept) == "Device route · 2 hops, kept at Home…"
|
||
skipped = RouteStatus(("27",), ORIGIN_LEARNED, kept=("3d",), owner=HOME, skipped_since=utcnow())
|
||
assert row_label(skipped).endswith("learned · kept route skipped…")
|
||
|
||
|
||
def test_the_actions_follow_the_state_of_the_route() -> None:
|
||
"""Keep needs a site, a kept route offers Stop keeping, and a flood has nothing to forget."""
|
||
assert _values(_action_rows(RouteStatus(None, ORIGIN_FLOOD))) == ["set", "discover"]
|
||
learned = RouteStatus(("3d",), ORIGIN_LEARNED, owner=HOME)
|
||
assert _values(_action_rows(learned)) == ["set", "keep", "forget", "discover"]
|
||
no_site = RouteStatus(("3d",), ORIGIN_LEARNED)
|
||
assert _values(_action_rows(no_site)) == ["set", "site", "forget", "discover"]
|
||
kept = RouteStatus(("3d",), ORIGIN_KEPT, kept=("3d",), owner=HOME)
|
||
assert _values(_action_rows(kept)) == ["set", "unkeep", "forget", "discover"]
|
||
fixed = RouteStatus(("3d",), ORIGIN_LEARNED, owner=RouteOwner(SOURCE_DEVICE, "Roof"))
|
||
labels = [row.title for row in _action_rows(fixed) if isinstance(row, Choice)]
|
||
assert "this radio (Roof)" in str(labels[1])
|
||
|
||
|
||
def test_the_picker_puts_the_suggested_route_first_and_compose_last() -> None:
|
||
"""The suggested route, no relays, then Compose. A route never repeats."""
|
||
env = _env()
|
||
env.scenarios = [SimpleNamespace(hops=(HUB,), source="observed", rank=0, samples=4)]
|
||
values = _values(_picker_rows(env, RouteStatus(None, ORIGIN_FLOOD)))
|
||
assert values == [("hops", (HUB,)), ("hops", ()), "compose"]
|
||
|
||
|
||
class _Routes:
|
||
"""The route service, as the popup calls it."""
|
||
|
||
def __init__(self, found: DiscoveredRoute | None = None) -> None:
|
||
self.calls: list[tuple[str, tuple]] = []
|
||
self.found = found
|
||
|
||
async def set(self, contact: Contact, hops: tuple) -> tuple:
|
||
self.calls.append(("set", tuple(hops)))
|
||
return tuple(hops)
|
||
|
||
async def keep(self, contact: Contact, hops: tuple) -> RouteOwner:
|
||
self.calls.append(("keep", tuple(hops)))
|
||
return HOME
|
||
|
||
async def discover(self, contact: Contact) -> DiscoveredRoute | None:
|
||
self.calls.append(("discover", ()))
|
||
return self.found
|
||
|
||
|
||
def _ctx(routes: _Routes, answer: object = None): # noqa: ANN202
|
||
prompts: list = []
|
||
|
||
async def dialog(prompt, buttons, **kwargs): # noqa: ANN001, ANN003, ANN202
|
||
prompts.append(prompt)
|
||
return answer
|
||
|
||
@asynccontextmanager
|
||
async def busy_dialog(message: str = "", *, title: str = ""): # noqa: ANN202
|
||
yield None
|
||
|
||
ui = SimpleNamespace(dialog=dialog, busy_dialog=busy_dialog, session=None)
|
||
return SimpleNamespace(routes=routes, ui=ui), prompts
|
||
|
||
|
||
async def test_a_picked_route_replaces_a_kept_route() -> None:
|
||
"""With a kept route, Set keeps the new route. Without one, it only sets it."""
|
||
routes = _Routes()
|
||
ctx, _ = _ctx(routes)
|
||
kept = RouteStatus(("3d",), ORIGIN_KEPT, kept=("3d",), owner=HOME)
|
||
assert await _apply(ctx, _env(), kept, (HUB, "27d4"))
|
||
assert await _apply(ctx, _env(), RouteStatus(None, ORIGIN_FLOOD), ())
|
||
assert routes.calls == [("keep", (HUB, "27d4")), ("set", ())]
|
||
|
||
|
||
async def test_discover_shows_both_routes_and_uses_the_route_out() -> None:
|
||
"""One discovery, a dialog with the route each way, and Use sets the route out."""
|
||
routes = _Routes(DiscoveredRoute(out_hops=("3d",), in_hops=("27", "3d")))
|
||
ctx, prompts = _ctx(routes, answer="use")
|
||
assert await _discover(ctx, _env(), RouteStatus(None, ORIGIN_FLOOD))
|
||
assert routes.calls == [("discover", ()), ("set", (HUB,))]
|
||
text = prompts[0].plain
|
||
assert "Out, to Alice (1 hop)" in text
|
||
assert "Back, to you (2 hops)" in text
|
||
|
||
|
||
async def test_no_answer_to_a_discovery_changes_nothing() -> None:
|
||
"""With no answer, the popup says so and sets nothing."""
|
||
routes = _Routes(None)
|
||
ctx, prompts = _ctx(routes)
|
||
assert not await _discover(ctx, _env(), RouteStatus(("3d",), ORIGIN_LEARNED))
|
||
assert routes.calls == [("discover", ())]
|
||
assert "No answer from Alice" in prompts[0]
|
||
|
||
|
||
def test_the_route_row_follows_the_routes_on_the_node_page() -> None:
|
||
"""The row comes after the routes, and a refresh keeps the highlight on it."""
|
||
from rich.text import Text
|
||
|
||
from meshterm.ui.node_detail_screen import NodeDetailScreen, _Action, _RoutesView, _Tab
|
||
|
||
row = _Action("device_route", "🧭", "", "Device route · none, it floods…")
|
||
trace = _Action("trace", "🎯", "", "Trace — auto route …")
|
||
view = _RoutesView(routes=[], note="no route observed yet")
|
||
screen = NodeDetailScreen(
|
||
title="Node — Alice",
|
||
header=Text("Alice"),
|
||
info_rows=[],
|
||
tabs=[_Tab(name="Routes", kind="routes")],
|
||
routes=view,
|
||
trace_action=trace,
|
||
route_action=row,
|
||
)
|
||
focus = [payload for _kind, payload in screen._focusables()]
|
||
assert focus == [trace, row]
|
||
newer = _Action("device_route", "🧭", "", "Device route · 1 hop, set by you…")
|
||
screen.replace_routes(view, route_action=newer, trace_action=trace)
|
||
assert screen._focusables()[screen._row_index][1] is newer
|
||
|
||
|
||
# -- Trace target ----------------------------------------------------------------------
|
||
|
||
|
||
def _row(hops: tuple[str, ...] | None, opened: list | None = None): # noqa: ANN202
|
||
"""A RouteRow over a route service that reports ``hops``, and records each open."""
|
||
from meshterm.ui.device_route_screen import RouteRow
|
||
|
||
routes = SimpleNamespace(
|
||
status=lambda contact, device_key: RouteStatus(hops, ORIGIN_LEARNED),
|
||
)
|
||
|
||
class _Row(RouteRow):
|
||
async def open(self, proven): # noqa: ANN001, ANN201
|
||
if opened is not None:
|
||
opened.append(proven)
|
||
|
||
return _Row(
|
||
SimpleNamespace(routes=routes),
|
||
Contact(name="Alice", public_key=ALICE_KEY),
|
||
device_key="",
|
||
build_env=lambda contact: _env(),
|
||
)
|
||
|
||
|
||
def test_the_trace_row_lights_only_for_a_route_that_is_a_change() -> None:
|
||
"""A traced route that the radio lacks is offered. The same route says so, quietly."""
|
||
from meshterm.ui.device_route_screen import ProvenRoute
|
||
|
||
proven = ProvenRoute(hops=("27d4",), home=4, sent=5, worst_snr=2.5)
|
||
assert proven.evidence() == "came home 4 of 5 · worst +2.5 dB"
|
||
text, lit = _row(("3d",)).text(proven)
|
||
assert lit
|
||
assert text == "Use this route for DMs and admin — 4/5 came home…"
|
||
text, lit = _row(("27",)).text(proven)
|
||
assert not lit
|
||
assert text == "Device route — 1 hop, learned · same as the trace…"
|
||
text, lit = _row(None).text(None)
|
||
assert (text, lit) == ("Device route — none, it floods…", False)
|
||
failed = ProvenRoute(hops=("27d4",), home=0, sent=2)
|
||
assert not _row(("3d",)).text(failed)[1]
|
||
|
||
|
||
def test_a_neighbour_that_does_not_relay_is_offered_no_relays() -> None:
|
||
"""A companion heard directly has no relay at which a walk turns. Its proof is the packets.
|
||
|
||
The row offers no relays at once, and the popup's first row says so. A radio that
|
||
already holds no relays offers nothing. A route with relays needs a trace as its proof.
|
||
"""
|
||
from meshterm.ui.device_route_screen import ProvenRoute
|
||
|
||
heard = ProvenRoute(hops=(), home=0, sent=0, heard=4)
|
||
assert heard.proved and heard.evidence() == "heard directly 4×"
|
||
assert _row(("3d",)).text(heard) == (
|
||
"Use no relays for DMs and admin — heard directly 4×…",
|
||
True,
|
||
)
|
||
assert not _row(()).text(heard)[1]
|
||
assert not ProvenRoute(hops=("3d",), home=0, sent=0, heard=4).proved
|
||
learned = RouteStatus(("3d",), ORIGIN_LEARNED, owner=HOME)
|
||
rows = [row for row in _action_rows(learned, heard) if isinstance(row, Choice)]
|
||
assert rows[0].value == "traced"
|
||
assert "Use no relays" in str(rows[0].title)
|
||
|
||
|
||
def test_the_popup_offers_the_traced_route_first() -> None:
|
||
"""Use the traced route, then Use and keep it (with a site), then the usual rows."""
|
||
from meshterm.ui.device_route_screen import ProvenRoute
|
||
|
||
proven = ProvenRoute(hops=("27d4",), home=3, sent=3)
|
||
learned = RouteStatus(("3d",), ORIGIN_LEARNED, owner=HOME)
|
||
assert _values(_action_rows(learned, proven)) == [
|
||
"traced",
|
||
"traced+keep",
|
||
"set",
|
||
"keep",
|
||
"forget",
|
||
"discover",
|
||
]
|
||
same = RouteStatus(("27",), ORIGIN_LEARNED, owner=HOME)
|
||
assert _values(_action_rows(same, proven))[0] == "set"
|
||
|
||
|
||
async def test_trace_target_has_the_row_and_hands_it_the_traced_route() -> None:
|
||
"""The row follows Explore paths, turns green after a trace home, and opens with it."""
|
||
import asyncio
|
||
|
||
from meshterm.ui.device_route_screen import ProvenRoute
|
||
from meshterm.ui.trace_screen import TraceScreen
|
||
from tests.conftest import plain
|
||
from tests.test_live_screens import _FakeSession, _trace
|
||
|
||
opened: list = []
|
||
session = _FakeSession()
|
||
|
||
async def flow(current): # noqa: ANN001, ANN202
|
||
return current
|
||
|
||
async def trace(spec, on_trace): # noqa: ANN001, ANN202
|
||
on_trace(_trace(5.0, 2.0))
|
||
|
||
def prove(traces: list) -> ProvenRoute | None:
|
||
home = [t for t in traces if t.success]
|
||
return ProvenRoute(("27d4",), len(home), len(traces), 2.0) if home else None
|
||
|
||
screen = TraceScreen(
|
||
"Alice",
|
||
device_label="Us",
|
||
device_hash="aabb" + "00" * 30,
|
||
resolve=lambda label: label,
|
||
session=session,
|
||
trace=trace,
|
||
compose_path=flow,
|
||
explore=flow,
|
||
pick_width=flow,
|
||
pick_samples=flow,
|
||
width_bytes=lambda: 1,
|
||
sample_count=lambda: 1,
|
||
pace_s=0.0,
|
||
route_row=_row(("3d",), opened),
|
||
prove=prove,
|
||
)
|
||
screen.note_viewport(40)
|
||
assert screen._actions == ("compose", "explore", "route", "width", "samples", "trace")
|
||
before = "\n".join(plain(line) for line in screen.render_body(72))
|
||
assert "Device route — 1 hop, learned…" in before
|
||
screen._on_trace(_trace(5.0, 2.0))
|
||
after = "\n".join(plain(line) for line in screen.render_body(72))
|
||
assert "Use this route for DMs and admin — 1/1 came home…" in after
|
||
screen._index = screen._actions.index("route")
|
||
screen.handle("enter")
|
||
await asyncio.sleep(0)
|
||
assert opened == [ProvenRoute(("27d4",), 1, 1, 2.0)]
|
||
assert len(screen._traces) == 1 # the popup changes no path of the screen
|
||
|
||
|
||
async def test_an_adopted_probe_route_starts_with_its_probe_traces() -> None:
|
||
"""Adopting a probed route keeps its probe trace, so the row offers it at once."""
|
||
import asyncio
|
||
|
||
from meshterm.ui.device_route_screen import ProvenRoute
|
||
from meshterm.ui.trace_screen import TraceScreen
|
||
from tests.test_live_screens import _FakeSession, _trace
|
||
|
||
probed = _trace(4.0, 1.0)
|
||
adopted = "3d63,f2c2,3d63"
|
||
|
||
async def flow(current): # noqa: ANN001, ANN202
|
||
return current
|
||
|
||
async def explore(current): # noqa: ANN001, ANN202
|
||
return adopted
|
||
|
||
async def trace(spec, on_trace): # noqa: ANN001, ANN202
|
||
raise AssertionError("an adopted probe route needs no new trace")
|
||
|
||
def prove(traces: list) -> ProvenRoute | None:
|
||
home = [t for t in traces if t.success]
|
||
return ProvenRoute(("3d63",), len(home), len(traces)) if home else None
|
||
|
||
screen = TraceScreen(
|
||
"Alice",
|
||
device_label="Us",
|
||
device_hash="aabb" + "00" * 30,
|
||
resolve=lambda label: label,
|
||
session=_FakeSession(),
|
||
trace=trace,
|
||
compose_path=flow,
|
||
explore=explore,
|
||
pick_width=flow,
|
||
pick_samples=flow,
|
||
width_bytes=lambda: 2,
|
||
sample_count=lambda: 1,
|
||
pace_s=0.0,
|
||
route_row=_row(None),
|
||
prove=prove,
|
||
seed_traces=lambda spec: [probed] if spec == adopted else [],
|
||
)
|
||
screen._index = screen._actions.index("explore")
|
||
screen.handle("enter")
|
||
await asyncio.sleep(0)
|
||
await asyncio.sleep(0)
|
||
assert screen._traces == [probed]
|
||
assert screen.proven() == ProvenRoute(("3d63",), 1, 1)
|
||
assert screen._actions[screen._index] == "trace" # the highlight moved, as after Explore
|