From c4a7e2d69f2d93c1d9e2887735f48a0923f3485b Mon Sep 17 00:00:00 2001 From: Jean-Pierre Martineau Date: Sun, 8 Nov 2026 23:03:27 -0500 Subject: [PATCH] Message paths traces a sender with no key in Trace target Enter on a received channel message whose sender has no known key opened Trace path, out to the first relay and back. The sender is a companion (only a companion sends channel text), so it is the target of the walk, and the rules of a target that does not relay apply. The dialog now opens Trace target under the name of the sender: - The walk turns at the relay that heard the sender, and the line under the route says so. - The composer mirrors the route at its last hop. It has no Auto row, because the session has no route to plan for a node with no key. - The screen has no Explore row, because the evidence graph keeps nodes by key. - A sender with a key but no stored type is also a companion now. A sender with no key and no name, and a direct message from a peer with no key, offer no trace. Refs: #34 Co-Authored-By: Claude Opus 5.5 --- meshterm/services/message_paths.py | 27 ++++++----- meshterm/ui/chat.py | 51 +++++++++++++++++---- meshterm/ui/path_composer.py | 20 ++++++--- meshterm/ui/trace_screen.py | 72 ++++++++++++++++++++++-------- tests/test_chat.py | 31 ++++++++++--- tests/test_live_screens.py | 38 ++++++++++++++++ tests/test_message_paths.py | 9 ++-- tests/test_topology.py | 19 ++++++++ 8 files changed, 212 insertions(+), 55 deletions(-) diff --git a/meshterm/services/message_paths.py b/meshterm/services/message_paths.py index ddcbaaf..58b4831 100644 --- a/meshterm/services/message_paths.py +++ b/meshterm/services/message_paths.py @@ -477,15 +477,20 @@ class TraceWalk: """The trace that walks the route of one arrival again, from our node. Attributes: - target: The key of the node at which the trace turns back home (a *Trace target* - session), or ``None`` for a walk with no target (a *Trace path* session). - hops: With a target: the leg from our node out to the target, without the two - ends. The trace comes back on the mirror of this leg. With no target: the full + target: The key of the node that the route goes to (a *Trace target* session), or + ``None`` when no key names it. A walk to a node with no key can turn only at + the last relay of the route, because no hash can address the node. + hops: For a walk to a node: the route from our node out to the node, without the + two ends. The trace turns at the node, or at the last relay before a node that + does not relay, and comes back on the mirror of the route. For a loop: the full walk, which ends at a node that our node heard. + loop: Whether the route comes back to our node (a sent channel message), and not to + a node (a *Trace path* session). """ target: str | None hops: tuple[str, ...] + loop: bool = False def trace_walk( @@ -506,9 +511,9 @@ def trace_walk( there (``far_key``). A channel message came back to our node, and the relays are the full walk: the last relay is a node that our node heard. * **A message that our node received** ends at our node. The trace walks the relays - in the reverse order, back to the sender (``origin_key``), and turns back there. - When no key names the sender, the trace turns back at the first relay, the last - node of the route that MeshTerm can address. + in the reverse order, back to the sender (``origin_key``). When no key names the + sender, the walk still goes to the sender, and the caller names it. Such a walk can + turn only at the first relay of the message, the relay that heard the sender. A direct-routed copy gives no trace. Its hops are the part of a route that the packet still had to go through, not where it went. Thus a trace on them starts at a node that @@ -531,11 +536,9 @@ def trace_walk( if outbound: if far_key: return TraceWalk(far_key, hops) - return TraceWalk(None, hops) if hops else None + return TraceWalk(None, hops, loop=True) if hops else None back = tuple(reversed(hops)) if origin_key: return TraceWalk(origin_key, back) - if not hops: - return None - # Out to the first relay, and back on the same relays (refer to render_forced_spec). - return TraceWalk(None, back + hops[1:]) + # With no key and no relay, the walk has no hop at which it can turn. + return TraceWalk(None, back) if hops else None diff --git a/meshterm/ui/chat.py b/meshterm/ui/chat.py index 2623e08..f90b216 100644 --- a/meshterm/ui/chat.py +++ b/meshterm/ui/chat.py @@ -30,6 +30,7 @@ from ..core.channels import MENTION, split_channel_sender from ..core.connection import ContactNotOnDeviceError from ..core.events import EventKind, MeshEvent from ..core.models import ( + NODE_TYPE_CHAT, ChatMessage, Contact, Conversation, @@ -2107,15 +2108,19 @@ async def _trace_walk( *, contacts: list[Contact], label: str | None, + node_type: int | None = None, ) -> None: """Open the trace screen armed on the walk of one arrival, and run it until the user leaves. The screen opens idle, armed on the route. Nothing transmits until the user starts a - trace there. A walk with a target opens *Trace target*. The spec is the leg out to the - target, the target, and the mirror of the leg back - (:func:`~meshterm.services.topology.render_forced_spec`). A walk with no target opens - *Trace path* on the walk as given. The width of each hop is the routing width of the - device, collapsed to what a trace can encode, the same as the trace screen uses. + trace there. A walk to a node opens *Trace target* on that node. Thus the rules for a + target apply: a node that does not relay a trace (a companion) is not the turn of the + walk, and the walk turns at the last relay before it (refer to + :func:`~meshterm.core.models.relays_traces`). The spec is the route out, the turn, and + the mirror of the route back (:func:`~meshterm.services.topology.render_forced_spec`). + A loop opens *Trace path* on the walk as given. The width of each hop is the routing + width of the device, collapsed to what a trace can encode, the same as the trace + screen uses. Args: ctx: The shared application context. @@ -2124,7 +2129,11 @@ async def _trace_walk( contacts: The contacts of the device. A target that is a contact opens under the name of that contact, the same as from its node page. Thus the history of its traces stays in one place. - label: The name of the target node, for a target that is not a contact. + label: The name of the target node, for a target that is not a contact. A walk to + a node with no key opens under this name, so it must have one. + node_type: The type of the target, when the caller knows it from the message (the + sender of channel text is a companion). The screen uses it when MeshTerm has no + stored type for the target. """ from ..services.topology import render_custom_spec, render_forced_spec from .trace_screen import collapse_trace_width, open_trace, open_trace_path @@ -2133,9 +2142,21 @@ async def _trace_walk( width = collapse_trace_width(int(await ctx.devstate.path_hash_mode())) except Exception: # noqa: BLE001 - an optional read. The 1-byte default always works. width = 1 - if walk.target is None: + if walk.loop: await open_trace_path(ctx, render_custom_spec(walk.hops, width)) return + if walk.target is None: + assert label, "a walk to a node with no key opens under its name" + # No hash addresses a node with no key, so the walk turns at the last relay of the + # route. The caller offers such a walk only for a node that does not relay. + await open_trace( + ctx, + label, + initial_spec=render_custom_spec((*walk.hops, *reversed(walk.hops[:-1])), width), + label=label, + node_type=node_type, + ) + return key = walk.target.lower() def holds(contact: Contact) -> bool: @@ -2149,6 +2170,7 @@ async def _trace_walk( contact.name if contact is not None else key, initial_spec=render_forced_spec(walk.hops, key, width), label=label, + node_type=node_type, ) @@ -2294,11 +2316,20 @@ async def _make_paths_presenter( far_key = None else: origin_key, far_key = peer_key, None + # Only a companion sends channel text. Thus the sender of a channel message does + # not relay a trace, also when MeshTerm never heard its advert. + sender_type = NODE_TYPE_CHAT if conversation.is_channel and not message.outbound else None def walk_of(arrival: Arrival) -> TraceWalk | None: - return trace_walk( + walk = trace_walk( arrival, outbound=message.outbound, origin_key=origin_key, far_key=far_key ) + # A walk to a sender with no key turns at its last relay. That is correct only + # for a node that does not relay, and the screen must have a name to show. + if walk is not None and walk.target is None and not walk.loop: + if sender_type is None or not source: + return None + return walk screen = MessagePathsScreen( message, @@ -2326,6 +2357,8 @@ async def _make_paths_presenter( walk = walk_of(chosen) if walk is not None: label = destination if message.outbound else source - await _trace_walk(ctx, walk, contacts=contacts, label=label or None) + await _trace_walk( + ctx, walk, contacts=contacts, label=label or None, node_type=sender_type + ) return present diff --git a/meshterm/ui/path_composer.py b/meshterm/ui/path_composer.py index a1cc457..0c5b41c 100644 --- a/meshterm/ui/path_composer.py +++ b/meshterm/ui/path_composer.py @@ -235,7 +235,9 @@ class PathComposerScreen(Screen): A pinned target (all three ``target_*`` arguments) selects target mode. The suggestions do not include the target (the path turns at it implicitly), and the - returned spec adds the target and the mirrored return at its end. With no target, + returned spec adds the target and the mirrored return at its end. A target that + does not relay also selects target mode with only its label, because its walk + turns at the last composed hop. With no target, the composer is in path mode: the user composes the full walk by hand, and the composer returns it exactly. ``outbound`` selects outbound mode, which also has no target. @@ -323,8 +325,13 @@ class PathComposerScreen(Screen): @property def _mirrored(self) -> bool: - """Whether the return leg is a mirror at the pinned target (target mode).""" - return self._target_id is not None + """Whether the return leg is a mirror of the route (target mode). + + A target that does not relay is target mode also with no ``target_id`` (a node + that is known by name only), because the walk turns at the last composed hop and + never addresses the target. + """ + return self._target_id is not None or not self._target_relays def _anchor(self) -> str: """The node to the left of the insertion slot (our node when the slot is at the start). @@ -445,7 +452,8 @@ class PathComposerScreen(Screen): :data:`_MAX_SUGGESTIONS` items. """ if self._mirrored: - exclude = frozenset({self._topology.self_id, self._target_id, *self._hops}) + target = {self._target_id} if self._target_id is not None else set() + exclude = frozenset({self._topology.self_id, *target, *self._hops}) elif self._outbound: # a node can be in an outbound path only one time exclude = frozenset({self._topology.self_id, *self._hops}) else: @@ -513,7 +521,9 @@ class PathComposerScreen(Screen): rows.append(("fetch", self._anchor())) # Use is the last row, so End goes to it, and the user leaves with the path # (JP, 2026-11-07). Auto comes before it. - if self._mirrored: # a path walk has no target for the device to route to + # A path walk has no target for the device to route to, and a target that is known + # by name only has no route for the session to plan. + if self._mirrored and self._target_id is not None: rows.append(("action", _AUTO)) rows.append(("action", _USE)) return rows diff --git a/meshterm/ui/trace_screen.py b/meshterm/ui/trace_screen.py index 14187a9..a660d5f 100644 --- a/meshterm/ui/trace_screen.py +++ b/meshterm/ui/trace_screen.py @@ -555,7 +555,8 @@ class TraceScreen(Screen): rows and for the number of traces that one Trace action runs. explore: Opens the scenario browser and probe flow over this screen (target mode only). Resolves to an adopted spec, or to ``None`` to keep the - current spec. + current spec. ``None`` leaves out the Explore row (a target that is known + by name only). pace_s: The cooldown that sleeps between the traces of a run with more than one sample. Thus a sample session is never a burst for the repeaters. previous: The most recent stored trace, if one exists. Its route is the @@ -666,7 +667,12 @@ class TraceScreen(Screen): # act in target mode (with no path, the device routes), and in path mode when a # path is available. A path walk with no path has nothing to trace, so there the # highlight starts on Compose (GitHub #29: Enter then opens the composer). - actions = ["compose", "explore"] if mode == "target" else ["compose", "reverse"] + # A target that is known by name only has no Explore (the session gives none). + actions = ["compose"] + if mode != "target": + actions.append("reverse") + elif explore is not None: + actions.append("explore") if self._route_row is not None: actions.append("route") actions += ["width", "samples", "trace"] @@ -1153,11 +1159,10 @@ class TraceScreen(Screen): if selected: self._cursor = len(lines) lines.append(render_to_ansi(text, width)) - # Put a gap before the next group: after the build-path group (the Device - # route row when there is one, else Explore in target mode or Reverse in path - # mode) and after the trace-settings group. - closes = ("route",) if self._route_row is not None else ("explore", "reverse") - if key in (*closes, "samples"): + # Put a gap before the next group: after the build-path group (its last row + # is the row before Width) and after the trace-settings group. + closes = self._actions[self._actions.index("width") - 1] + if key in (closes, "samples"): lines.append("") # The results are page, not a list window of their own. Nothing highlights them. # Thus a private list window hides its rows from the arrows, and gives the frame @@ -1754,7 +1759,12 @@ def _scenario_detail(scenario: Any) -> Text: async def open_trace( - ctx: AppContext, target: str, *, initial_spec: str = "", label: str | None = None + ctx: AppContext, + target: str, + *, + initial_spec: str = "", + label: str | None = None, + node_type: int | None = None, ) -> int: """Open the live *Trace target* screen for ``target``, and run it until the user leaves. @@ -1774,6 +1784,9 @@ async def open_trace( label: The name that the screen shows for a target that is not a contact (the Message paths dialog gives the name of the sender with its key). ``None`` shows the target as given. A contact always shows its own name. + node_type: The type of the target, when the caller knows it and MeshTerm possibly + has no stored type (the sender of channel text is a companion). The type of a + contact, or of the last advert of the node, comes first. Returns: The number of traces that ran while the screen was open. @@ -1781,7 +1794,9 @@ async def open_trace( Raises: RuntimeError: If called outside the interactive menu (no full-screen session). """ - return await _open_session(ctx, target, initial_spec=initial_spec, label=label) + return await _open_session( + ctx, target, initial_spec=initial_spec, label=label, node_type=node_type + ) async def open_trace_path(ctx: AppContext, spec: str = "") -> int: @@ -1810,7 +1825,12 @@ async def open_trace_path(ctx: AppContext, spec: str = "") -> int: async def _open_session( - ctx: AppContext, target: str | None, *, initial_spec: str = "", label: str | None = None + ctx: AppContext, + target: str | None, + *, + initial_spec: str = "", + label: str | None = None, + node_type: int | None = None, ) -> int: """Connect and run one live trace session (the two features share this code). @@ -1834,9 +1854,12 @@ async def _open_session( screen opens armed, instead of idle on the history. *Trace this path* in the trophy case gives it. In target mode, it arms only when the target can be addressed (a contact or a hex key), because a forced path must turn at a real - hash. The Node detail screen and the Message paths dialog give it there. + hash, or when the target does not relay, because then the walk turns at the + last relay. The Node detail screen and the Message paths dialog give it there. label: The name to show for a target that is not a contact. ``None`` shows the target as given. + node_type: The type of the target, for a target with no stored type (refer to + :func:`open_trace`). Returns: The number of traces that ran while the screen was open. @@ -1895,8 +1918,9 @@ async def _open_session( # The target as a hash that can be addressed: the full key of a known contact, or # the typed hex prefix. An unknown target that is not hex can still be traced with # device routing. But to compose or explore, a destination hash is necessary on - # which to pin the path. A path walk has no target: each target_* stays None, and - # the composer runs with a route by hand. + # which to pin the path, except for a target that does not relay (refer to by_name + # below). A path walk has no target: each target_* stays None, and the composer runs + # with a route by hand. target_contact: Contact | None = None target_hash: str | None = None target_label: str | None = None @@ -1921,12 +1945,18 @@ async def _open_session( # Whether the target relays a trace (refer to relays_traces). A contact gives its type. # A node that is not a contact (the sender of a message, opened from Message paths) - # gives the type of its last advert that MeshTerm heard. A node with no known type is - # traced itself, as before. + # gives the type of its last advert that MeshTerm heard, or else the type that the + # caller knows. A node with no known type is traced itself, as before. target_type = target_contact.node_type if target_contact is not None else None if target_type is None and target_hash is not None and target_contact is None: target_type = ctx.repo.node_type(target_hash[:12]) + if target_type is None: + target_type = node_type target_relays = mode == "path" or relays_traces(target_type) + # A target with no hash that does not relay (the sender of a channel message with no + # known key): each walk to it turns at the last relay, so no walk has to address it. + # Only the evidence of its route is not there, because the graph keeps nodes by key. + by_name = mode == "target" and target_hash is None and not target_relays def fresh_topology() -> MeshTopology: """Build the evidence graph from all the data that is stored now and on the device.""" @@ -2141,7 +2171,7 @@ async def _open_session( composer again exactly where the user was (the same hops and insertion slot, with refreshed suggestions). """ - if mode == "target" and target_hash is None: + if mode == "target" and target_hash is None and not by_name: await unaddressable() return None topo = fresh_topology() @@ -2729,7 +2759,9 @@ async def _open_session( session=session, trace=trace_once, compose_path=compose, - explore=explore if mode == "target" else None, + # Explore ranks the routes to a node in the graph, which keeps nodes by key. Thus a + # target that is known by name only has no Explore row. + explore=explore if mode == "target" and not by_name else None, pick_width=pick_width, pick_samples=pick_samples, width_bytes=lambda: width_bytes, @@ -2741,8 +2773,10 @@ async def _open_session( # A spec from the caller arms the two modes: the stored route of a path walk, or # the suggested best path that the Node detail screen gives to a target trace. In # target mode, it arms only when the target can be addressed, because a forced - # path must end at a real hash. - initial_spec=initial_spec if (mode == "path" or target_hash is not None) else "", + # path must end at a real hash, or when the walk turns before the target. + initial_spec=( + initial_spec if (mode == "path" or target_hash is not None or by_name) else "" + ), open_trophy_case=_trophy_case_opener(ctx), route_row=route_row, prove=prove, diff --git a/tests/test_chat.py b/tests/test_chat.py index b7a2430..eeb0473 100644 --- a/tests/test_chat.py +++ b/tests/test_chat.py @@ -3737,8 +3737,8 @@ def _capture_traces(monkeypatch) -> list: # noqa: ANN001 calls: list = [] - async def open_trace(ctx, target, *, initial_spec="", label=None): # noqa: ANN001, ANN202 - calls.append(("target", target, initial_spec, label)) + async def open_trace(ctx, target, *, initial_spec="", label=None, node_type=None): # noqa: ANN001, ANN202 + calls.append(("target", target, initial_spec, label, node_type)) return 0 async def open_trace_path(ctx, spec=""): # noqa: ANN001, ANN202 @@ -3759,7 +3759,7 @@ def test_a_traced_route_opens_trace_target_under_the_contacts_name(monkeypatch) alice = Contact(name="Alice", public_key="d4e5f6a7" + "0" * 56, key_prefix="d4e5f6a7") walk = TraceWalk("d4e5f6a7", ("cc", "bb")) asyncio.run(_trace_walk(_trace_ctx(), walk, contacts=[alice], label="Alice")) - assert calls == [("target", "Alice", "cc,bb,d4,bb,cc", "Alice")] + assert calls == [("target", "Alice", "cc,bb,d4,bb,cc", "Alice", None)] def test_a_traced_route_to_a_stranger_opens_on_its_key_with_its_name(monkeypatch) -> None: # noqa: ANN001 @@ -3770,15 +3770,34 @@ def test_a_traced_route_to_a_stranger_opens_on_its_key_with_its_name(monkeypatch calls = _capture_traces(monkeypatch) walk = TraceWalk("A3A3A3A3", ("cc",)) asyncio.run(_trace_walk(_trace_ctx(), walk, contacts=[], label="bob_caribou")) - assert calls == [("target", "a3a3a3a3", "cc,a3,cc", "bob_caribou")] + assert calls == [("target", "a3a3a3a3", "cc,a3,cc", "bob_caribou", None)] -def test_a_walk_with_no_target_opens_trace_path(monkeypatch) -> None: # noqa: ANN001 +def test_a_loop_opens_trace_path(monkeypatch) -> None: # noqa: ANN001 """A channel message that came back to our node walks its relays again in Trace path.""" from meshterm.services.message_paths import TraceWalk from meshterm.ui.chat import _trace_walk calls = _capture_traces(monkeypatch) - walk = TraceWalk(None, ("aabb", "ccdd")) + walk = TraceWalk(None, ("aabb", "ccdd"), loop=True) asyncio.run(_trace_walk(_trace_ctx(mode=1), walk, contacts=[], label=None)) assert calls == [("path", "aabb,ccdd")] + + +def test_a_sender_with_no_key_opens_trace_target_under_its_name(monkeypatch) -> None: # noqa: ANN001 + """A channel sender that no key names is still the target, and the walk turns at its relay. + + Only a companion sends channel text, and a companion does not relay a trace. Thus the + screen is Trace target on the name of the sender, with the companion rules: the walk + goes out to the relay that heard the sender, and back. + """ + from meshterm.core.models import NODE_TYPE_CHAT + from meshterm.services.message_paths import TraceWalk + from meshterm.ui.chat import _trace_walk + + calls = _capture_traces(monkeypatch) + walk = TraceWalk(None, ("3d", "51", "1b", "40")) + asyncio.run( + _trace_walk(_trace_ctx(), walk, contacts=[], label="Lindsay", node_type=NODE_TYPE_CHAT) + ) + assert calls == [("target", "Lindsay", "3d,51,1b,40,1b,51,3d", "Lindsay", NODE_TYPE_CHAT)] diff --git a/tests/test_live_screens.py b/tests/test_live_screens.py index 9d8f95c..0895926 100644 --- a/tests/test_live_screens.py +++ b/tests/test_live_screens.py @@ -295,6 +295,44 @@ def test_trace_screen_names_the_relay_where_a_companions_walk_turns() -> None: assert screen._actions[screen._index] == "trace" # a turn: Enter traces at once +def test_trace_screen_for_a_sender_known_by_name_only_has_no_explore_row() -> None: + """A target with no key has no node in the graph to rank routes to, so Explore is gone. + + The screen still opens armed on the walk that turns at the relay of the sender, and the + groups of rows keep their gaps. + """ + keyed, _ = _trace_screen(initial_spec="3d63,f2c2,3d63", relays=False) + assert "explore" in keyed._actions # a target with a key keeps it + bare = TraceScreen( + "Lindsay", + mode="target", + device_label="Us", + device_hash="aabb" + "00" * 30, + resolve=lambda label: label, + session=_FakeSession(), + trace=None, # type: ignore[arg-type] + compose_path=None, # type: ignore[arg-type] + explore=None, + pick_width=None, # type: ignore[arg-type] + pick_samples=None, # type: ignore[arg-type] + width_bytes=lambda: 2, + sample_count=lambda: 1, + pace_s=0.0, + previous=None, + auto_spec=lambda: "", + initial_spec="3d63,f2c2,3d63", + relays=False, + ) + bare.note_viewport(40) + assert bare.title == "Trace — Lindsay" + assert bare._actions == ("compose", "width", "samples", "trace") + assert bare._actions[bare._index] == "trace" # armed: Enter traces at once + lines = _plain(bare.render_body(72)).splitlines() + assert "Lindsay can't relay a trace, so the trace turns at f2c2" in " ".join(lines) + compose = next(i for i, line in enumerate(lines) if "Compose" in line) + assert lines[compose + 1].strip() == "" # the build group ends on Compose + + def test_trace_screen_wraps_the_turn_line_under_the_route_lane() -> None: """The line is a sentence, so it wraps at 53 cells, and no line of the page is wider.""" from rich.cells import cell_len diff --git a/tests/test_message_paths.py b/tests/test_message_paths.py index d2643df..37d7141 100644 --- a/tests/test_message_paths.py +++ b/tests/test_message_paths.py @@ -425,11 +425,12 @@ def test_a_received_message_is_traced_back_to_its_sender() -> None: assert walk == TraceWalk("5e", ("cc", "bb", "aa")) -def test_a_sender_with_no_key_is_traced_to_the_first_relay_and_back() -> None: - """With no key for the sender, the trace turns back at the first relay.""" +def test_a_sender_with_no_key_is_still_the_end_of_the_walk() -> None: + """With no key for the sender, the walk still goes to the sender, not around a loop.""" arrival = Arrival(when=utcnow(), hops=("aa", "bb", "cc"), snr=1.0) walk = trace_walk(arrival, outbound=False, origin_key=None, far_key=None) - assert walk == TraceWalk(None, ("cc", "bb", "aa", "bb", "cc")) + assert walk == TraceWalk(None, ("cc", "bb", "aa")) + assert walk is not None and not walk.loop direct = Arrival(when=utcnow(), hops=(), snr=1.0) assert trace_walk(direct, outbound=False, origin_key=None, far_key=None) is None # A sender that we heard direct and that has a key: a trace with no relays. @@ -447,7 +448,7 @@ def test_a_sent_channel_message_walks_its_loop_again() -> None: """Our broadcast came back to our node, so its relays are the full walk.""" arrival = Arrival(when=utcnow(), hops=("aa", "bb"), snr=1.0) assert trace_walk(arrival, outbound=True, origin_key=None, far_key=None) == TraceWalk( - None, ("aa", "bb") + None, ("aa", "bb"), loop=True ) diff --git a/tests/test_topology.py b/tests/test_topology.py index c7f4f73..a3993be 100644 --- a/tests/test_topology.py +++ b/tests/test_topology.py @@ -1290,3 +1290,22 @@ def test_composer_for_a_target_that_does_not_relay_turns_at_the_last_hop() -> No assert screen._walk_nodes() == ["3d63c6429436", "27d4396a2967", "3d63c6429436"] assert "Far" not in screen._route_preview().text().plain assert _composer(_topo(), relays=False)._spec() == "" # no relay: nothing to walk + + +def test_composer_for_a_target_known_by_name_only_still_mirrors_the_route() -> None: + """A sender with no key is target mode by its label: the route mirrors, with no Auto row.""" + screen = PathComposerScreen( + device_label="Us", + device_hash=US + "0" * 52, + topology=_topo(), + width_bytes=1, + target_label="Lindsay", + target_relays=False, + hops=["3d63c6429436", "27d4396a2967"], + ) + assert screen.title == "Compose path — Lindsay" + assert screen._spec() == "3d,27,3d" + assert screen._walk_nodes() == ["3d63c6429436", "27d4396a2967", "3d63c6429436"] + actions = [payload for kind, payload in screen._rows() if kind == "action"] + assert "auto" not in actions # no key: the session has no route to plan + assert actions == ["use"]