The companion keeps one route for each contact and never forgets a dead one, so each retry on it was lost with no error. Now ^R on a direct message that went along the learned route asks: Cancel, On route, or By flood. By flood forgets the route (nothing is transmitted), flushes the contact cache, and sends the one retry. A message that already went by flood keeps the plain ^R. The admin login offers Try by flood the same way after a silence from a node that has a route, one time for each flow. Nothing floods unless the user chooses it. Refs: #34 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
1007 lines
40 KiB
Python
1007 lines
40 KiB
Python
# SPDX-License-Identifier: Apache-2.0
|
|
"""A repeater that says nothing has not said that the password is wrong.
|
|
|
|
The bug: a user administered a repeater that was down, and MeshTerm forgot the admin
|
|
password of that repeater. The login returned ``False``. Each caller read ``False`` as
|
|
"wrong password", and MeshTerm deleted the credential for a node that never answered.
|
|
|
|
Two faults caused this. First, the ``meshcore`` library function ``send_login_sync`` waits
|
|
for ``LOGIN_SUCCESS`` and for nothing else. The companion does send a refusal (a
|
|
``LOGIN_FAILED`` frame) when a node says no, but the function times out on it in the same
|
|
way as on silence, and returns the same ``None``. Second, the credential policy was in five
|
|
places, at the call sites.
|
|
|
|
A stock repeater never says no: it sends no reply for a wrong password. Thus a password
|
|
that the owner changed is also a silence, and the menu offers a new password when a stored
|
|
one gets no reply (GitHub issue 28). The simulator does the same, and only a node in its
|
|
``_refusing`` set refuses.
|
|
|
|
Now the device listens for the refusal frame itself and returns a three-way
|
|
:class:`~meshterm.core.models.LoginResult`. One method,
|
|
:meth:`~meshterm.core.admin_store.AdminStore.record`, decides what the result means for the
|
|
stored password. It remembers the password on accepted, forgets it on refused, and does
|
|
not change it on silence.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import asyncio
|
|
import io
|
|
from pathlib import Path
|
|
|
|
import pytest
|
|
from rich.console import Console
|
|
|
|
from meshterm.context import AppContext
|
|
from meshterm.core.admin_store import AdminStore
|
|
from meshterm.core.config import Settings
|
|
from meshterm.core.connection import DeviceCommandError, MeshCoreDevice, MockDevice
|
|
from meshterm.core.device_store import DeviceStore
|
|
from meshterm.core.models import Contact, LoginResult
|
|
from meshterm.persistence.repository import Repository
|
|
|
|
_NODE = Contact(name="Yagi-Repeater", public_key="a1b2c3d4" * 8, key_prefix="a1b2c3d4")
|
|
|
|
|
|
# --- what the three outcomes mean -----------------------------------------------------
|
|
|
|
|
|
def test_only_an_accepted_login_is_truthy() -> None:
|
|
"""``if not await device.admin_login(...)`` keeps the meaning "we are not logged in".
|
|
|
|
The three-way result replaced a bool. A call site that only asks "am I logged in?" reads
|
|
the result in the same way as before. A call site that acts on the failure must name
|
|
the failure that it acts on.
|
|
"""
|
|
assert LoginResult.ACCEPTED
|
|
assert not LoginResult.REFUSED
|
|
assert not LoginResult.NO_REPLY
|
|
|
|
|
|
def test_the_two_failures_are_distinguishable() -> None:
|
|
"""The two failures were the same ``False``. The fix is that a caller can tell them apart."""
|
|
assert LoginResult.REFUSED is not LoginResult.NO_REPLY
|
|
|
|
|
|
# --- the credential policy, in the only place that owns it ----------------------------
|
|
|
|
|
|
@pytest.fixture()
|
|
def store(tmp_path: Path) -> AdminStore:
|
|
"""An admin store with a password already remembered for the node."""
|
|
store = AdminStore(tmp_path / "admin.json")
|
|
store.remember(_NODE, "hunter2")
|
|
return store
|
|
|
|
|
|
def test_silence_leaves_the_remembered_password_exactly_where_it_was(store) -> None: # noqa: ANN001
|
|
"""The main regression. The node was down, so it never gave a verdict on the password."""
|
|
store.record(_NODE, "hunter2", LoginResult.NO_REPLY)
|
|
|
|
assert store.get(_NODE) == "hunter2"
|
|
|
|
|
|
def test_a_refusal_clears_the_password_because_the_node_said_so(store) -> None: # noqa: ANN001
|
|
"""Only a node that answered "no" can say that the password is wrong."""
|
|
store.record(_NODE, "hunter2", LoginResult.REFUSED)
|
|
|
|
assert store.get(_NODE) is None
|
|
|
|
|
|
def test_a_successful_login_remembers_the_password_that_worked(store) -> None: # noqa: ANN001
|
|
"""This includes a password that the user just typed. That is how MeshTerm stores one."""
|
|
store.forget(_NODE)
|
|
|
|
store.record(_NODE, "correct-horse", LoginResult.ACCEPTED)
|
|
|
|
assert store.get(_NODE) == "correct-horse"
|
|
|
|
|
|
def test_silence_does_not_invent_a_password_either(tmp_path: Path) -> None:
|
|
"""A no-reply from a node with no stored password leaves no stored password."""
|
|
store = AdminStore(tmp_path / "admin.json")
|
|
|
|
store.record(_NODE, "typed-once", LoginResult.NO_REPLY)
|
|
|
|
assert store.get(_NODE) is None
|
|
|
|
|
|
def test_a_node_that_goes_quiet_after_working_keeps_its_password(store) -> None: # noqa: ANN001
|
|
"""A real sequence: the login worked yesterday, the node is down today, it works tomorrow."""
|
|
store.record(_NODE, "hunter2", LoginResult.ACCEPTED)
|
|
store.record(_NODE, "hunter2", LoginResult.NO_REPLY)
|
|
store.record(_NODE, "hunter2", LoginResult.NO_REPLY)
|
|
|
|
assert store.get(_NODE) == "hunter2"
|
|
|
|
|
|
# --- reading the wire: which listeners are active, and for how long -------------------
|
|
|
|
|
|
class _Subscription:
|
|
"""A replacement for the Subscription handle of meshcore, with its unsubscribe method."""
|
|
|
|
def __init__(self, mc, event_type, callback) -> None: # noqa: ANN001
|
|
self.mc = mc
|
|
self.event_type = event_type
|
|
self.callback = callback
|
|
|
|
def unsubscribe(self) -> None:
|
|
if self in self.mc.subscriptions:
|
|
self.mc.subscriptions.remove(self)
|
|
|
|
|
|
class _Event:
|
|
def __init__(self, type_, payload=None) -> None: # noqa: ANN001
|
|
self.type = type_
|
|
self.payload = payload or {}
|
|
|
|
|
|
class _FakeCommands:
|
|
"""``send_login_sync`` with the behaviour of the real library.
|
|
|
|
It waits for LOGIN_SUCCESS and for nothing else. It returns a success that it heard,
|
|
and ``None`` for all other results, a refusal included. The ``late`` argument models
|
|
the case that broke a healthy node: the answer arrives after the function gave up.
|
|
Only a listener that lives longer than the function can catch it.
|
|
"""
|
|
|
|
def __init__( # noqa: ANN003
|
|
self, mc, *, answer=None, late=None, late_delay: float = 0.0, send_delay: float = 0.0
|
|
) -> None: # noqa: ANN001
|
|
self._mc = mc
|
|
self._answer = answer
|
|
self._late = late
|
|
self._late_delay = late_delay
|
|
# How long the send takes to return. The time is the mesh-request lock of the
|
|
# library, then a MSG_SENT that it matches by event type only. None of it is the
|
|
# time of the node.
|
|
self._send_delay = send_delay
|
|
|
|
async def send_login_sync(self, pubkey, password): # noqa: ANN001
|
|
from meshcore import EventType
|
|
|
|
self._mc.sent.append((pubkey, password))
|
|
self._mc.armed = [sub.event_type for sub in self._mc.subscriptions]
|
|
await asyncio.sleep(self._send_delay)
|
|
if self._answer is not None:
|
|
self._mc.dispatch(self._answer)
|
|
if self._answer.type is EventType.LOGIN_SUCCESS:
|
|
return self._answer
|
|
return None # the function never waits for a refusal
|
|
if self._late is not None:
|
|
asyncio.get_running_loop().call_later(self._late_delay, self._mc.dispatch, self._late)
|
|
return None
|
|
|
|
|
|
class _FakeMeshCore:
|
|
def __init__(self, **commands) -> None: # noqa: ANN003
|
|
self.subscriptions: list[_Subscription] = []
|
|
self.sent: list[tuple] = []
|
|
self.armed: list = [] # the event types that were subscribed when the send went out
|
|
self.commands = _FakeCommands(self, **commands)
|
|
|
|
def subscribe(self, event_type, callback, attribute_filters=None): # noqa: ANN001
|
|
sub = _Subscription(self, event_type, callback)
|
|
self.subscriptions.append(sub)
|
|
return sub
|
|
|
|
def dispatch(self, event) -> None: # noqa: ANN001
|
|
for sub in list(self.subscriptions):
|
|
if sub.event_type is event.type:
|
|
sub.callback(event)
|
|
|
|
|
|
@pytest.fixture()
|
|
def quick_budget(monkeypatch): # noqa: ANN001
|
|
"""Make the reply budget short, so that a no-reply test does not wait ten seconds."""
|
|
# The patch is where the device reads the budget. The budget calculation is in
|
|
# ``core.tracing``, and ``core.connection`` binds the name at import. Thus that
|
|
# binding is the one that the device uses.
|
|
import meshterm.core.connection as connection
|
|
|
|
monkeypatch.setattr(connection, "trace_timeout", lambda hops: 0.05)
|
|
|
|
|
|
def _device(mc) -> MeshCoreDevice: # noqa: ANN001
|
|
device = MeshCoreDevice(port="mock")
|
|
device._mc = mc
|
|
return device
|
|
|
|
|
|
def _login_success(prefix: str | None = "a1b2c3d4a1b2"):
|
|
from meshcore import EventType
|
|
|
|
return _Event(EventType.LOGIN_SUCCESS, {"pubkey_prefix": prefix} if prefix else {})
|
|
|
|
|
|
def _login_failed(prefix: str | None = "a1b2c3d4a1b2"):
|
|
from meshcore import EventType
|
|
|
|
return _Event(EventType.LOGIN_FAILED, {"pubkey_prefix": prefix} if prefix else {})
|
|
|
|
|
|
def test_a_login_the_node_accepts_reads_as_accepted(quick_budget) -> None: # noqa: ANN001
|
|
"""The normal case: the session is open."""
|
|
mc = _FakeMeshCore(answer=_login_success())
|
|
|
|
assert asyncio.run(_device(mc).admin_login(_NODE, "hunter2")) is LoginResult.ACCEPTED
|
|
assert mc.sent == [(_NODE.public_key, "hunter2")]
|
|
|
|
|
|
def test_an_answer_that_lands_after_the_library_gave_up_is_still_the_answer() -> None:
|
|
"""The reported regression: a healthy node, the right password, a no-reply dialog.
|
|
|
|
``send_login_sync`` does not start to listen until its own send returns. That send
|
|
waits for a MSG_SENT that the library matches by event type only. Thus a scheduled
|
|
advert or the courier can use our MSG_SENT, and the send stalls. Each answer that
|
|
arrives during the stall goes to no listener and is lost. The device owns the wait and
|
|
arms it before the send. Thus a login that the repeater accepted reads as accepted.
|
|
"""
|
|
mc = _FakeMeshCore(late=_login_success(), late_delay=0.05)
|
|
|
|
assert asyncio.run(_device(mc).admin_login(_NODE, "hunter2")) is LoginResult.ACCEPTED
|
|
|
|
|
|
def test_a_late_refusal_is_still_a_refusal() -> None:
|
|
"""The same window, the other verdict. This verdict must also clear the password."""
|
|
mc = _FakeMeshCore(late=_login_failed(), late_delay=0.05)
|
|
|
|
assert asyncio.run(_device(mc).admin_login(_NODE, "wrong")) is LoginResult.REFUSED
|
|
|
|
|
|
def test_a_refusal_frame_reads_as_refused(quick_budget) -> None: # noqa: ANN001
|
|
"""The wait of the library times out on a refusal, so the app must hear the frame itself.
|
|
|
|
Without this, a wrong password would report no-reply and MeshTerm would keep it for
|
|
ever. This is the opposite of the reported bug. It is also the reason that the code does
|
|
not assume a refusal.
|
|
"""
|
|
mc = _FakeMeshCore(answer=_login_failed())
|
|
|
|
assert asyncio.run(_device(mc).admin_login(_NODE, "wrong")) is LoginResult.REFUSED
|
|
|
|
|
|
def test_silence_reads_as_no_reply(quick_budget) -> None: # noqa: ANN001
|
|
"""The case that started this work: nothing came back, so nothing is known."""
|
|
mc = _FakeMeshCore()
|
|
|
|
assert asyncio.run(_device(mc).admin_login(_NODE, "hunter2")) is LoginResult.NO_REPLY
|
|
|
|
|
|
def test_a_terse_answer_with_no_key_prefix_still_counts(quick_budget) -> None: # noqa: ANN001
|
|
"""The firmware adds the key prefix of the answering node only when the frame has one.
|
|
|
|
If the filter demanded a key prefix, each answer from terse firmware would become a
|
|
no-reply. This path exists to stop that failure, so the filter must not cause it again.
|
|
"""
|
|
mc = _FakeMeshCore(answer=_login_failed(prefix=None))
|
|
|
|
assert asyncio.run(_device(mc).admin_login(_NODE, "wrong")) is LoginResult.REFUSED
|
|
|
|
|
|
def test_an_answer_meant_for_a_different_node_is_not_ours(quick_budget) -> None: # noqa: ANN001
|
|
"""Two admin flows can overlap. The rejection from another node must not clear our password."""
|
|
mc = _FakeMeshCore(answer=_login_failed("ffeeddccbbaa"))
|
|
|
|
assert asyncio.run(_device(mc).admin_login(_NODE, "hunter2")) is LoginResult.NO_REPLY
|
|
|
|
|
|
def test_the_listener_is_armed_before_the_request_goes_out(quick_budget) -> None: # noqa: ANN001
|
|
"""Both answers are subscribed before the send, so an answer during the send has a listener."""
|
|
from meshcore import EventType
|
|
|
|
mc = _FakeMeshCore(answer=_login_success())
|
|
|
|
asyncio.run(_device(mc).admin_login(_NODE, "hunter2"))
|
|
|
|
assert EventType.LOGIN_SUCCESS in mc.armed
|
|
assert EventType.LOGIN_FAILED in mc.armed
|
|
|
|
|
|
def test_a_companion_error_is_watched_for_because_the_library_erases_it() -> None:
|
|
"""``send_login_sync`` changes its own ERROR to a bare ``None``, so the reason is lost.
|
|
|
|
A companion that refuses to send and a node that never answers both give
|
|
:attr:`LoginResult.NO_REPLY`. This is correct, because neither says anything about the
|
|
password. But the two faults are different, and a user repairs them in different ways.
|
|
Only the frame shows which fault it is. The frame has no correlation to the login, so
|
|
the device logs it and never reads it as a verdict.
|
|
"""
|
|
from meshcore import EventType
|
|
|
|
mc = _FakeMeshCore(answer=_login_success())
|
|
|
|
asyncio.run(_device(mc).admin_login(_NODE, "hunter2"))
|
|
|
|
assert EventType.ERROR in mc.armed
|
|
|
|
|
|
def test_the_node_gets_its_whole_budget_even_when_the_send_was_slow(quick_budget) -> None: # noqa: ANN001
|
|
"""The regression that this fix is for: the node paid for the queue before it.
|
|
|
|
The budget is the time for the answer of the node. But the count once started before
|
|
``send_login_sync``. That function waits for the mesh-request lock of the library
|
|
before it transmits. Each telemetry poll and each courier retry holds the lock for a
|
|
whole round trip. Thus a send that took longer than the budget left the node no time to
|
|
answer. A repeater that was up, listening, and ready to answer was recorded as silent.
|
|
"""
|
|
mc = _FakeMeshCore(late=_login_success(), late_delay=0.01, send_delay=0.2)
|
|
|
|
assert asyncio.run(_device(mc).admin_login(_NODE, "hunter2")) is LoginResult.ACCEPTED
|
|
|
|
|
|
def test_the_listeners_are_released_even_when_the_send_blows_up() -> None:
|
|
"""Each attempt makes one pair of subscriptions. Leaked pairs would collect in a session."""
|
|
|
|
class _Exploding(_FakeCommands):
|
|
async def send_login_sync(self, pubkey, password): # noqa: ANN001
|
|
raise RuntimeError("the companion dropped the link")
|
|
|
|
mc = _FakeMeshCore()
|
|
mc.commands = _Exploding(mc)
|
|
|
|
with pytest.raises(RuntimeError):
|
|
asyncio.run(_device(mc).admin_login(_NODE, "hunter2"))
|
|
assert mc.subscriptions == []
|
|
|
|
|
|
def test_a_companion_side_error_is_silence_not_a_denial(quick_budget) -> None: # noqa: ANN001
|
|
"""The request never left the radio, so the node cannot have rejected it."""
|
|
from meshcore import EventType
|
|
|
|
mc = _FakeMeshCore()
|
|
|
|
async def _errored(pubkey, password): # noqa: ANN001
|
|
return _Event(EventType.ERROR, {"reason": "timeout"})
|
|
|
|
mc.commands.send_login_sync = _errored
|
|
|
|
assert asyncio.run(_device(mc).admin_login(_NODE, "hunter2")) is LoginResult.NO_REPLY
|
|
|
|
|
|
def test_the_reply_budget_is_sized_to_the_route_the_login_has_to_walk() -> None:
|
|
"""A budget of one or two seconds for a neighbour would stop a multi-hop repeater too soon.
|
|
|
|
The login goes out along the route of the contact, and the answer comes back along it.
|
|
Thus the wire carries twice the stored one-way hops. ``run_trace`` makes its budget in
|
|
the same way.
|
|
"""
|
|
import meshterm.core.connection as connection
|
|
|
|
asked: list[int] = []
|
|
real = connection.trace_timeout
|
|
|
|
def spy(hops): # noqa: ANN001
|
|
asked.append(hops)
|
|
return 0.01
|
|
|
|
connection.trace_timeout = spy
|
|
try:
|
|
two_hops = Contact(name="Hub-Far", public_key="a1b2c3d4" * 8, route_hops=("3d", "f2"))
|
|
asyncio.run(_device(_FakeMeshCore()).admin_login(two_hops, "hunter2"))
|
|
asyncio.run(_device(_FakeMeshCore()).admin_login(_NODE, "hunter2"))
|
|
finally:
|
|
connection.trace_timeout = real
|
|
|
|
# Each login asks twice: for its own walk, and for the floor of a contact with no route
|
|
# (hops ``0``). The budget is never less than the floor.
|
|
assert asked == [4, 0, 0, 0]
|
|
assert real(4) > real(2) > real(1) # also, the budget grows with the walk
|
|
|
|
|
|
def test_a_known_short_route_never_buys_less_patience_than_no_route_at_all() -> None:
|
|
"""A known route to a node must not make MeshTerm stop waiting for it sooner.
|
|
|
|
A trace budget is for one small packet on an explicit path. A login is an admin
|
|
exchange, out and back. If the code used the trace budget as it is, a contact with a
|
|
one-hop route would get a shorter window than a contact with no route, which floods.
|
|
Thus the flood budget is the floor, and the route can only make the budget longer.
|
|
"""
|
|
import meshterm.core.connection as connection
|
|
import meshterm.core.tracing as tracing
|
|
|
|
budgets: list[float] = []
|
|
real = connection.trace_timeout
|
|
|
|
def spy(hops): # noqa: ANN001
|
|
# The real shape, made smaller so that the no-reply that it causes is not a long wait.
|
|
budget = real(hops) / 1000
|
|
budgets.append(budget)
|
|
return budget
|
|
|
|
connection.trace_timeout = spy
|
|
try:
|
|
near = Contact(name="Hub-Near", public_key="a1b2c3d4" * 8, route_hops=("3d",))
|
|
asyncio.run(_device(_FakeMeshCore()).admin_login(near, "hunter2"))
|
|
finally:
|
|
connection.trace_timeout = real
|
|
|
|
walked, floor = budgets
|
|
assert walked < floor # the trace budget as it is gives the shorter of the two
|
|
assert real(2) < real(0) == tracing.TRACE_TIMEOUT_FLOOD_S # the same at full scale
|
|
|
|
|
|
# --- the simulator gives the same three results ---------------------------------------
|
|
|
|
|
|
async def test_the_simulator_answers_a_wrong_password_as_stock_firmware_does() -> None:
|
|
"""A stock repeater sends nothing for a wrong password. Only a ``_refusing`` node says no.
|
|
|
|
The simulator once refused a wrong password. Thus ``--mock`` and the tests never walked
|
|
the path of GitHub issue 28: a password that the owner changed, which comes back as
|
|
silence on a real mesh.
|
|
"""
|
|
device = MockDevice(admin_password="secret")
|
|
await device.connect()
|
|
node = (await device.get_contacts())[0]
|
|
|
|
assert await device.admin_login(node, "wrong") is LoginResult.NO_REPLY
|
|
device._refusing.add(node.name)
|
|
assert await device.admin_login(node, "wrong") is LoginResult.REFUSED
|
|
assert await device.admin_login(node, "secret") is LoginResult.ACCEPTED
|
|
|
|
|
|
async def test_the_simulator_can_model_a_node_that_is_simply_down() -> None:
|
|
"""``--mock`` must be able to follow the path of a down repeater, or nobody sees the dialog."""
|
|
device = MockDevice(admin_password="secret")
|
|
await device.connect()
|
|
node = (await device.get_contacts())[0]
|
|
device._unreachable.add(node.name)
|
|
|
|
assert await device.admin_login(node, "secret") is LoginResult.NO_REPLY
|
|
assert await device.admin_login(node, "wrong") is LoginResult.NO_REPLY # it is still silence
|
|
|
|
|
|
# --- the callers ----------------------------------------------------------------------
|
|
|
|
|
|
@pytest.fixture()
|
|
def ctx(tmp_path: Path):
|
|
"""A context with the simulator as its device and an admin store on disk."""
|
|
settings = Settings(config_dir=tmp_path, db_path=tmp_path / "admin.db")
|
|
context = AppContext(
|
|
console=Console(file=io.StringIO()),
|
|
settings=settings,
|
|
repo=Repository(settings.db_path),
|
|
device_store=DeviceStore(tmp_path / "devices.json"),
|
|
admin_store=AdminStore(tmp_path / "admin.json"),
|
|
mock=True,
|
|
)
|
|
yield context
|
|
context.repo.close()
|
|
|
|
|
|
async def _mock_node(ctx, *, down: bool, refusing: bool = False) -> Contact: # noqa: ANN001
|
|
"""The simulated repeater, with a stored password.
|
|
|
|
It is unreachable if ``down`` is true. If ``refusing`` is true, it refuses a wrong
|
|
password, as firmware other than stock MeshCore can. Else it does not answer one.
|
|
"""
|
|
device = await ctx.device()
|
|
node = next(c for c in await device.get_contacts() if c.name == "Yagi-Repeater")
|
|
if down:
|
|
device._unreachable.add(node.name)
|
|
if refusing:
|
|
device._refusing.add(node.name)
|
|
ctx.admin_store.remember(node, "admin")
|
|
return node
|
|
|
|
|
|
async def test_the_scripted_tool_keeps_the_password_when_the_node_is_down(ctx) -> None: # noqa: ANN001
|
|
"""``meshterm repeater-admin <node> <cmd>`` for a repeater that is off the air."""
|
|
from meshterm.tools.repeater_admin import RepeaterAdminTool
|
|
|
|
node = await _mock_node(ctx, down=True)
|
|
|
|
with pytest.raises(DeviceCommandError, match="did not answer"):
|
|
await RepeaterAdminTool().run(ctx, {"node": node.name, "command": "get tx"})
|
|
|
|
assert ctx.admin_store.get(node) == "admin"
|
|
|
|
|
|
async def test_the_scripted_tool_says_how_to_give_a_changed_password(ctx) -> None: # noqa: ANN001
|
|
"""A script cannot get a "New password…" offer, so the error names ``--password``."""
|
|
from meshterm.tools.repeater_admin import RepeaterAdminTool
|
|
|
|
node = await _mock_node(ctx, down=True)
|
|
|
|
with pytest.raises(DeviceCommandError) as raised:
|
|
await RepeaterAdminTool().run(ctx, {"node": node.name, "command": "get tx"})
|
|
|
|
message = str(raised.value)
|
|
assert "its password changed" in message
|
|
assert "if the password changed, run again with --password" in message
|
|
|
|
|
|
async def test_an_explicit_password_with_no_reply_names_no_flag(ctx) -> None: # noqa: ANN001
|
|
"""The user already gave ``--password``. The error says that it can be wrong, and no more."""
|
|
from meshterm.tools.repeater_admin import RepeaterAdminTool
|
|
|
|
node = await _mock_node(ctx, down=True)
|
|
|
|
with pytest.raises(DeviceCommandError) as raised:
|
|
await RepeaterAdminTool().run(
|
|
ctx, {"node": node.name, "command": "get tx", "password": "typed"}
|
|
)
|
|
|
|
message = str(raised.value)
|
|
assert "the password is wrong" in message and "Any saved password was kept." in message
|
|
assert "--password" not in message
|
|
assert ctx.admin_store.get(node) == "admin"
|
|
|
|
|
|
async def test_the_tx_optimizer_says_how_to_give_a_changed_password(ctx) -> None: # noqa: ANN001
|
|
"""The same advice from the other scripted login, in its own words for a new run."""
|
|
from meshterm.tools.tx_optimize import TxOptimizeTool
|
|
|
|
node = await _mock_node(ctx, down=True)
|
|
|
|
with pytest.raises(DeviceCommandError, match="re-run with --password"):
|
|
await TxOptimizeTool()._login(ctx, node, {})
|
|
|
|
|
|
async def test_the_scripted_tool_clears_the_password_the_node_rejected(ctx) -> None: # noqa: ANN001
|
|
"""The other half: a node that is reachable and says no has a bad password."""
|
|
from meshterm.tools.repeater_admin import RepeaterAdminTool
|
|
|
|
node = await _mock_node(ctx, down=False, refusing=True)
|
|
ctx.admin_store.remember(node, "not-the-password")
|
|
|
|
with pytest.raises(DeviceCommandError, match="wrong password"):
|
|
await RepeaterAdminTool().run(ctx, {"node": node.name, "command": "get tx"})
|
|
|
|
assert ctx.admin_store.get(node) is None
|
|
|
|
|
|
async def test_the_tx_optimizer_keeps_the_password_when_the_node_is_down(ctx) -> None: # noqa: ANN001
|
|
"""The sweep logs in before it tunes. A down node must not cost the credential."""
|
|
from meshterm.tools.tx_optimize import TxOptimizeTool
|
|
|
|
node = await _mock_node(ctx, down=True)
|
|
|
|
with pytest.raises(DeviceCommandError, match="did not answer"):
|
|
await TxOptimizeTool()._login(ctx, node, {})
|
|
|
|
assert ctx.admin_store.get(node) == "admin"
|
|
|
|
|
|
async def test_the_tx_optimizer_clears_the_password_the_node_rejected(ctx) -> None: # noqa: ANN001
|
|
"""The optimizer also forgets a password that the node refused."""
|
|
from meshterm.tools.tx_optimize import TxOptimizeTool
|
|
|
|
node = await _mock_node(ctx, down=False, refusing=True)
|
|
ctx.admin_store.remember(node, "not-the-password")
|
|
|
|
with pytest.raises(DeviceCommandError, match="wrong password"):
|
|
await TxOptimizeTool()._login(ctx, node, {})
|
|
|
|
assert ctx.admin_store.get(node) is None
|
|
|
|
|
|
# --- the interactive flow --------------------------------------------------------------
|
|
|
|
|
|
async def _step_until(predicate, *, limit: int = 200):
|
|
"""Yield to the event loop until ``predicate()`` is true (the convention of the TUI tests)."""
|
|
value = predicate()
|
|
for _ in range(limit):
|
|
if value:
|
|
return value
|
|
await asyncio.sleep(0)
|
|
value = predicate()
|
|
return value
|
|
|
|
|
|
async def _run_login(ctx, node, *, answer: object = "ok"): # noqa: ANN001
|
|
"""Run ``ui.repeater_admin._login`` to its end, and read and close its dialog.
|
|
|
|
Returns the result of the flow and the words that it showed on the screen. Both are
|
|
important. What happens to the password is one half of the fix. The other half is that
|
|
the flow does not tell the user that a password was wrong when it was not. ``answer``
|
|
is the value of the button that the test presses.
|
|
"""
|
|
from meshterm.ui.repeater_admin import _login
|
|
from meshterm.ui.surface import TuiUi
|
|
from meshterm.ui.tui.prompt import ButtonDialog
|
|
from meshterm.ui.tui.session import TuiSession
|
|
|
|
ctx.ui = TuiUi(TuiSession())
|
|
device = await ctx.device()
|
|
task = asyncio.ensure_future(_login(ctx, device, node))
|
|
try:
|
|
dialog = None
|
|
for _ in range(200):
|
|
top = ctx.ui.session.top
|
|
if isinstance(top, ButtonDialog):
|
|
dialog = top
|
|
break
|
|
if task.done():
|
|
break
|
|
await asyncio.sleep(0)
|
|
shown = ""
|
|
if dialog is not None:
|
|
prompt = dialog._prompt
|
|
shown = prompt.plain if hasattr(prompt, "plain") else str(prompt)
|
|
dialog.resolve(answer)
|
|
return await task, shown
|
|
finally:
|
|
if not task.done():
|
|
task.cancel()
|
|
|
|
|
|
async def test_the_admin_flow_says_no_reply_and_keeps_the_password(ctx) -> None: # noqa: ANN001
|
|
"""The screen that JP was on. It must not report a refusal, and must not clear the password.
|
|
|
|
The dialog offers a new password, because a stock node does not answer a wrong
|
|
password either. Cancel leaves the stored password as it was.
|
|
"""
|
|
node = await _mock_node(ctx, down=True)
|
|
|
|
ok, shown = await _run_login(ctx, node, answer=False)
|
|
|
|
assert ok is False
|
|
assert "No reply" in shown and "kept" in shown
|
|
assert "rejected" not in shown
|
|
assert ctx.admin_store.get(node) == "admin"
|
|
|
|
|
|
async def test_the_admin_flow_still_clears_a_password_the_node_rejected(ctx) -> None: # noqa: ANN001
|
|
"""This behaviour was always correct. The test makes sure that it stays correct."""
|
|
node = await _mock_node(ctx, down=False, refusing=True)
|
|
ctx.admin_store.remember(node, "not-the-password")
|
|
|
|
ok, shown = await _run_login(ctx, node)
|
|
|
|
assert ok is False
|
|
assert "wrong password" in shown and "cleared" in shown
|
|
assert ctx.admin_store.get(node) is None
|
|
|
|
|
|
class _StockNode:
|
|
"""A device whose node answers only its current password, as stock firmware does.
|
|
|
|
A wrong password gets no reply, never a refusal (GitHub issue 28). ``tried`` lists the
|
|
passwords in the order of the logins.
|
|
"""
|
|
|
|
def __init__(self, password: str) -> None:
|
|
self.password = password
|
|
self.tried: list[str] = []
|
|
|
|
async def admin_login(self, node: Contact, password: str) -> LoginResult: # noqa: ARG002
|
|
self.tried.append(password)
|
|
await asyncio.sleep(0)
|
|
return LoginResult.ACCEPTED if password == self.password else LoginResult.NO_REPLY
|
|
|
|
|
|
async def _top(ctx, kind): # noqa: ANN001, ANN202
|
|
"""The top screen of the session once it is a ``kind``, or ``None``."""
|
|
session = ctx.ui.session
|
|
return await _step_until(lambda: session.top if isinstance(session.top, kind) else None)
|
|
|
|
|
|
async def test_a_changed_password_is_offered_and_replaced(ctx) -> None: # noqa: ANN001
|
|
"""The owner changed the password. The stored one gets silence, and the user types the new one.
|
|
|
|
Before, the flow showed "No reply" and kept the old password, and each later visit
|
|
tried the old password again with no prompt. The user had no way to type the new one.
|
|
"""
|
|
from meshterm.ui.admin_login import log_in
|
|
from meshterm.ui.surface import TuiUi
|
|
from meshterm.ui.tui.prompt import ButtonDialog, TextScreen
|
|
from meshterm.ui.tui.session import TuiSession
|
|
|
|
ctx.ui = TuiUi(TuiSession())
|
|
ctx.admin_store.remember(_NODE, "old")
|
|
device = _StockNode("new")
|
|
task = asyncio.ensure_future(log_in(ctx, device, _NODE, why="Log in.", again="try again"))
|
|
try:
|
|
offer = await _top(ctx, ButtonDialog)
|
|
assert offer is not None, "a silence after a stored password offers a choice"
|
|
assert [label for label, _ in offer._buttons] == ["Cancel", "New password…"]
|
|
assert offer._index == 1, "New password… is the default"
|
|
offer.resolve(True)
|
|
prompt = await _top(ctx, TextScreen)
|
|
assert prompt is not None, "the choice opens the password prompt"
|
|
prompt.resolve("new")
|
|
ok = await task
|
|
finally:
|
|
if not task.done():
|
|
task.cancel()
|
|
|
|
assert ok is True
|
|
assert device.tried == ["old", "new"]
|
|
assert ctx.admin_store.get(_NODE) == "new"
|
|
|
|
|
|
async def test_a_new_password_that_also_gets_no_reply_keeps_the_old_one(ctx) -> None: # noqa: ANN001
|
|
"""The node can be down after all. A typed password replaces the stored one only if it works."""
|
|
from meshterm.ui.admin_login import log_in
|
|
from meshterm.ui.surface import TuiUi
|
|
from meshterm.ui.tui.prompt import ButtonDialog, TextScreen
|
|
from meshterm.ui.tui.session import TuiSession
|
|
|
|
ctx.ui = TuiUi(TuiSession())
|
|
ctx.admin_store.remember(_NODE, "old")
|
|
device = _StockNode("unknown")
|
|
task = asyncio.ensure_future(log_in(ctx, device, _NODE, why="Log in.", again="try again"))
|
|
try:
|
|
(await _top(ctx, ButtonDialog)).resolve(True)
|
|
(await _top(ctx, TextScreen)).resolve("typo")
|
|
notice = await _top(ctx, ButtonDialog)
|
|
assert notice is not None
|
|
shown = notice._prompt.plain
|
|
assert "No reply" in shown and "wrong password" in shown
|
|
assert "Try again to enter it again." in shown
|
|
notice.resolve("ok")
|
|
ok = await task
|
|
finally:
|
|
if not task.done():
|
|
task.cancel()
|
|
|
|
assert ok is False
|
|
assert device.tried == ["old", "typo"]
|
|
assert ctx.admin_store.get(_NODE) == "old"
|
|
|
|
|
|
async def test_a_typed_password_with_no_reply_asks_nothing_more(ctx) -> None: # noqa: ANN001
|
|
"""With no stored password, there is nothing to replace. The flow explains and stops."""
|
|
from meshterm.ui.admin_login import log_in
|
|
from meshterm.ui.surface import TuiUi
|
|
from meshterm.ui.tui.prompt import ButtonDialog, TextScreen
|
|
from meshterm.ui.tui.session import TuiSession
|
|
|
|
ctx.ui = TuiUi(TuiSession())
|
|
device = _StockNode("unknown")
|
|
task = asyncio.ensure_future(log_in(ctx, device, _NODE, why="Log in.", again="sweep again"))
|
|
try:
|
|
(await _top(ctx, TextScreen)).resolve("typo")
|
|
notice = await _top(ctx, ButtonDialog)
|
|
assert [label for label, _ in notice._buttons] == ["OK"]
|
|
assert "Sweep again to enter it again." in notice._prompt.plain
|
|
notice.resolve("ok")
|
|
ok = await task
|
|
finally:
|
|
if not task.done():
|
|
task.cancel()
|
|
|
|
assert ok is False
|
|
assert ctx.admin_store.get(_NODE) is None
|
|
|
|
|
|
class _RoutedNode:
|
|
"""A device whose node is silent while its route is stale, as the companion's is.
|
|
|
|
``reset_route`` forgets the stale route, and then the node answers its password.
|
|
``log`` lists the calls in order, and ``routes`` counts the ``reset_route`` calls.
|
|
"""
|
|
|
|
def __init__(self, password: str, *, stale: bool = True) -> None:
|
|
self.password = password
|
|
self.stale = stale
|
|
self.log: list[str] = []
|
|
|
|
async def admin_login(self, node: Contact, password: str) -> LoginResult: # noqa: ARG002
|
|
self.log.append(f"login:{password}")
|
|
await asyncio.sleep(0)
|
|
if self.stale or password != self.password:
|
|
return LoginResult.NO_REPLY
|
|
return LoginResult.ACCEPTED
|
|
|
|
async def reset_route(self, node: Contact) -> None: # noqa: ARG002
|
|
self.log.append("reset")
|
|
self.stale = False
|
|
|
|
|
|
_ROUTED = Contact(
|
|
name="Yagi-Repeater", public_key="a1b2c3d4" * 8, key_prefix="a1b2c3d4", route_hops=("3d",)
|
|
)
|
|
|
|
|
|
def _watch_cache(ctx) -> list[int]: # noqa: ANN001
|
|
"""Replace the contact cache of the context with one that counts its invalidations."""
|
|
from types import SimpleNamespace
|
|
|
|
flushed: list[int] = []
|
|
ctx._devstate = SimpleNamespace(invalidate_contacts=lambda: flushed.append(1))
|
|
return flushed
|
|
|
|
|
|
async def test_a_silent_stored_password_on_a_route_offers_a_flood_and_it_works(ctx) -> None: # noqa: ANN001
|
|
"""GitHub issue 34. A stale route is silent. Try by flood forgets it, then logs in once."""
|
|
from meshterm.ui.admin_login import log_in
|
|
from meshterm.ui.surface import TuiUi
|
|
from meshterm.ui.tui.prompt import ButtonDialog
|
|
from meshterm.ui.tui.session import TuiSession
|
|
|
|
ctx.ui = TuiUi(TuiSession())
|
|
flushed = _watch_cache(ctx)
|
|
ctx.admin_store.remember(_ROUTED, "secret")
|
|
device = _RoutedNode("secret")
|
|
task = asyncio.ensure_future(log_in(ctx, device, _ROUTED, why="Log in.", again="try again"))
|
|
try:
|
|
offer = await _top(ctx, ButtonDialog)
|
|
assert offer is not None, "a silence on a route offers a choice"
|
|
assert [label for label, _ in offer._buttons] == [
|
|
"Cancel",
|
|
"New password…",
|
|
"Try by flood",
|
|
]
|
|
assert offer._index == 2, "Try by flood is the default on the right"
|
|
assert "route" in offer._prompt.plain and "password changed" in offer._prompt.plain
|
|
assert device.log == ["login:secret"], "nothing floods before the user chooses"
|
|
offer.resolve("flood")
|
|
ok = await task
|
|
finally:
|
|
if not task.done():
|
|
task.cancel()
|
|
|
|
assert ok is True
|
|
assert device.log == ["login:secret", "reset", "login:secret"]
|
|
assert flushed == [1]
|
|
|
|
|
|
async def test_cancel_on_the_flood_offer_sends_nothing_more(ctx) -> None: # noqa: ANN001
|
|
"""Cancel leaves the route as it was and sends no second login."""
|
|
from meshterm.ui.admin_login import log_in
|
|
from meshterm.ui.surface import TuiUi
|
|
from meshterm.ui.tui.prompt import ButtonDialog
|
|
from meshterm.ui.tui.session import TuiSession
|
|
|
|
ctx.ui = TuiUi(TuiSession())
|
|
flushed = _watch_cache(ctx)
|
|
ctx.admin_store.remember(_ROUTED, "secret")
|
|
device = _RoutedNode("secret")
|
|
task = asyncio.ensure_future(log_in(ctx, device, _ROUTED, why="Log in.", again="try again"))
|
|
try:
|
|
(await _top(ctx, ButtonDialog)).resolve(None)
|
|
ok = await task
|
|
finally:
|
|
if not task.done():
|
|
task.cancel()
|
|
|
|
assert ok is False
|
|
assert device.log == ["login:secret"] and flushed == []
|
|
assert ctx.admin_store.get(_ROUTED) == "secret"
|
|
|
|
|
|
async def test_a_typed_password_on_a_route_offers_only_cancel_and_flood(ctx) -> None: # noqa: ANN001
|
|
"""With no stored password, a new password is not a choice. The flood is."""
|
|
from meshterm.ui.admin_login import log_in
|
|
from meshterm.ui.surface import TuiUi
|
|
from meshterm.ui.tui.prompt import ButtonDialog, TextScreen
|
|
from meshterm.ui.tui.session import TuiSession
|
|
|
|
ctx.ui = TuiUi(TuiSession())
|
|
_watch_cache(ctx)
|
|
device = _RoutedNode("typed")
|
|
task = asyncio.ensure_future(log_in(ctx, device, _ROUTED, why="Log in.", again="try again"))
|
|
try:
|
|
(await _top(ctx, TextScreen)).resolve("typed")
|
|
offer = await _top(ctx, ButtonDialog)
|
|
assert [label for label, _ in offer._buttons] == ["Cancel", "Try by flood"]
|
|
assert offer._index == 1
|
|
offer.resolve("flood")
|
|
ok = await task
|
|
finally:
|
|
if not task.done():
|
|
task.cancel()
|
|
|
|
assert ok is True
|
|
assert device.log == ["login:typed", "reset", "login:typed"]
|
|
assert ctx.admin_store.get(_ROUTED) == "typed"
|
|
|
|
|
|
async def test_a_flood_that_also_gets_no_reply_is_not_offered_again(ctx) -> None: # noqa: ANN001
|
|
"""One flood for each flow. The next silence gets the dialog of before (no flood button)."""
|
|
from meshterm.ui.admin_login import log_in
|
|
from meshterm.ui.surface import TuiUi
|
|
from meshterm.ui.tui.prompt import ButtonDialog
|
|
from meshterm.ui.tui.session import TuiSession
|
|
|
|
ctx.ui = TuiUi(TuiSession())
|
|
_watch_cache(ctx)
|
|
ctx.admin_store.remember(_ROUTED, "old")
|
|
# The node is down, or its password changed. A flood changes nothing.
|
|
device = _RoutedNode("other")
|
|
task = asyncio.ensure_future(log_in(ctx, device, _ROUTED, why="Log in.", again="try again"))
|
|
try:
|
|
(await _top(ctx, ButtonDialog)).resolve("flood")
|
|
again = await _step_until(
|
|
lambda: (
|
|
ctx.ui.session.top
|
|
if isinstance(ctx.ui.session.top, ButtonDialog) and len(device.log) == 3
|
|
else None
|
|
)
|
|
)
|
|
assert again is not None
|
|
assert [label for label, _ in again._buttons] == ["Cancel", "New password…"]
|
|
again.resolve(None)
|
|
ok = await task
|
|
finally:
|
|
if not task.done():
|
|
task.cancel()
|
|
|
|
assert ok is False
|
|
assert device.log == ["login:old", "reset", "login:old"], "exactly one flood"
|
|
|
|
|
|
def test_a_refusal_message_starts_its_sentences_with_a_capital() -> None:
|
|
"""A typed password has nothing to clear. The message once read "(wrong password?). try"."""
|
|
from meshterm.ui.admin_login import refused_text
|
|
|
|
typed = refused_text(_NODE, saved=False, again="try again")
|
|
saved = refused_text(_NODE, saved=True, again="try again")
|
|
|
|
assert typed.endswith("(wrong password?). Try again to enter a new one.")
|
|
assert saved.endswith("The saved password was cleared; try again to enter a new one.")
|
|
|
|
|
|
async def test_the_admin_flow_replaces_a_changed_password_on_the_simulator(ctx) -> None: # noqa: ANN001
|
|
"""GitHub issue 28 from end to end: the owner changed the password with a serial console.
|
|
|
|
The stored password gets silence from the simulated repeater, as from a real one. The
|
|
user selects "New password…", types the new password, and the repeater accepts it.
|
|
"""
|
|
from meshterm.ui.repeater_admin import _login
|
|
from meshterm.ui.surface import TuiUi
|
|
from meshterm.ui.tui.prompt import ButtonDialog, TextScreen
|
|
from meshterm.ui.tui.session import TuiSession
|
|
|
|
node = await _mock_node(ctx, down=False)
|
|
ctx.admin_store.remember(node, "before-the-change")
|
|
ctx.ui = TuiUi(TuiSession())
|
|
task = asyncio.ensure_future(_login(ctx, await ctx.device(), node))
|
|
try:
|
|
offer = await _top(ctx, ButtonDialog)
|
|
assert offer is not None and "password changed" in str(offer._prompt)
|
|
offer.resolve(True)
|
|
(await _top(ctx, TextScreen)).resolve("admin")
|
|
ok = await task
|
|
finally:
|
|
if not task.done():
|
|
task.cancel()
|
|
|
|
assert ok is True
|
|
assert ctx.admin_store.get(node) == "admin"
|
|
|
|
|
|
# --- no call site decides this locally again --------------------------------------------
|
|
|
|
|
|
def test_every_login_caller_goes_through_the_one_credential_policy() -> None:
|
|
"""A sixth caller must not make the rule again, as the other five did, with errors.
|
|
|
|
The test reads the source on purpose. The failure is not a wrong branch. The failure is
|
|
a call site that never asks the question. Each code path that logs in must record the
|
|
result through the store, and none can call :meth:`AdminStore.forget` to do it.
|
|
"""
|
|
import ast
|
|
|
|
import meshterm
|
|
|
|
def calls_admin_login(tree: ast.AST) -> bool:
|
|
"""A real call, not the word in a docstring. This is why the test parses the source."""
|
|
return any(
|
|
isinstance(node, ast.Call)
|
|
and isinstance(node.func, ast.Attribute)
|
|
and node.func.attr == "admin_login"
|
|
for node in ast.walk(tree)
|
|
)
|
|
|
|
root = Path(meshterm.__file__).parent
|
|
callers = [
|
|
path
|
|
for path in root.rglob("*.py")
|
|
if calls_admin_login(ast.parse(path.read_text(encoding="utf-8")))
|
|
]
|
|
|
|
assert callers, "the scan found no callers at all — it has stopped testing anything"
|
|
for path in callers:
|
|
source = path.read_text(encoding="utf-8")
|
|
assert "admin_store.record(" in source, f"{path.name} logs in without recording"
|
|
assert "admin_store.forget(" not in source, (
|
|
f"{path.name} decides the credential policy itself; use admin_store.record()"
|
|
)
|