The terminal draws some icons in one cell (↻ ⌨ 🗑 ✓ ✗ ⚠) and most emoji in two, so a row written icon-plus-space started its words a column left of its siblings. The fix kept landing one screen at a time. menus.align_icons now pads every icon in a list out to the widest one, and menu_rows applies it itself, so a list built there cannot misalign. Hand-built lists are brought along: the courier outbox and entry actions, the watchtower actions and rule popover, the record card's actions, the main menu's Quit row and the device splash's action rows. The repeater admin's regression test, dropped by a concurrent rewrite of its file, is restored. tests/test_icon_alignment.py sweeps every gallery screen on both platforms and fails, naming the rows and their start cells, when a list's icon-led rows start their words in different cells. Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
704 lines
29 KiB
Python
704 lines
29 KiB
Python
"""Tests for repeater admin.
|
||
|
||
The settings catalog (checked against the firmware's own CLI), the per-node store, the
|
||
simulated remote CLI, the editor's read/apply round trips, and the command-line screen's
|
||
readline behavior.
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import asyncio
|
||
import io
|
||
from datetime import timedelta
|
||
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 MockDevice
|
||
from meshterm.core.device_store import DeviceStore
|
||
from meshterm.core.models import Contact, utcnow
|
||
from meshterm.core.remote_config import (
|
||
REPEATER_SETTINGS,
|
||
composite_reads,
|
||
get_setting,
|
||
known_commands,
|
||
normalize_value,
|
||
parse_reply_value,
|
||
range_hint,
|
||
read_plan,
|
||
reply_is_error,
|
||
validate_value,
|
||
write_plan,
|
||
)
|
||
from meshterm.core.remote_store import HISTORY_CAP, CachedValue, RemoteStore
|
||
from meshterm.persistence.repository import Repository
|
||
from meshterm.ui import repeater_admin
|
||
from meshterm.ui.remote_cli import RemoteCliScreen
|
||
from meshterm.ui.repeater_admin import AdminMenu, ReadOne, open_repeater_admin
|
||
from meshterm.ui.surface import TuiUi
|
||
from meshterm.ui.trace_screen import TracingDialog
|
||
from meshterm.ui.tui.prompt import TextScreen
|
||
from meshterm.ui.tui.screen import CANCEL
|
||
from meshterm.ui.tui.select import SelectScreen
|
||
from meshterm.ui.tui.session import TuiSession
|
||
|
||
NODE = Contact(name="Yagi-Repeater", public_key="a1" * 32, key_prefix="a1b2c3d4")
|
||
|
||
#: Every key MeshCore's ``CommonCLI.cpp`` (``handleSetCmd``) lets an admin write over the
|
||
#: mesh — ``radio`` standing for its four fields. ``prv.key`` and ``freq`` are left out: the
|
||
#: firmware takes those from its serial console only. ``extra.sf`` is LR2021-only.
|
||
FIRMWARE_SET_KEYS = {
|
||
"name",
|
||
"owner.info",
|
||
"lat",
|
||
"lon",
|
||
"radio",
|
||
"tx",
|
||
"radio.rxgain",
|
||
"radio.fem.rxgain",
|
||
"radio.fem.txgain",
|
||
"cad",
|
||
"int.thresh",
|
||
"agc.reset.interval",
|
||
"repeat",
|
||
"txdelay",
|
||
"direct.txdelay",
|
||
"rxdelay",
|
||
"dutycycle",
|
||
"af",
|
||
"loop.detect",
|
||
"path.hash.mode",
|
||
"multi.acks",
|
||
"flood.max",
|
||
"flood.max.unscoped",
|
||
"flood.max.advert",
|
||
"advert.interval",
|
||
"flood.advert.interval",
|
||
"guest.password",
|
||
"allow.read.only",
|
||
"adc.multiplier",
|
||
"bridge.enabled",
|
||
"bridge.source",
|
||
"bridge.delay",
|
||
"bridge.baud",
|
||
"bridge.channel",
|
||
"bridge.secret",
|
||
}
|
||
|
||
#: The settings ``handleCommand`` takes as top-level verbs rather than ``set`` keys.
|
||
FIRMWARE_VERB_SETTINGS = {"powersaving", "gps", "gps advert"}
|
||
|
||
|
||
class _FakeSession:
|
||
def __init__(self) -> None:
|
||
self.repaints = 0
|
||
|
||
def invalidate(self) -> None:
|
||
self.repaints += 1
|
||
|
||
|
||
# --- the catalog ----------------------------------------------------------------------
|
||
|
||
|
||
def test_catalog_covers_every_setting_the_firmware_takes_over_the_mesh() -> None:
|
||
"""Each writable firmware key has a row, and nothing is spelled that the firmware lacks.
|
||
|
||
Regression: the catalog was written from convention and carried ``get bw``/``sf``/``cr``
|
||
(keys no firmware answers — the radio is read as one ``get radio``) while missing
|
||
``path.hash.mode`` and twenty-odd others.
|
||
"""
|
||
spelled = {s.composite or s.key for s in REPEATER_SETTINGS if s.writable and not s.verb}
|
||
assert spelled == FIRMWARE_SET_KEYS
|
||
assert {s.verb for s in REPEATER_SETTINGS if s.verb} == FIRMWARE_VERB_SETTINGS
|
||
assert len({s.key for s in REPEATER_SETTINGS}) == len(REPEATER_SETTINGS)
|
||
|
||
|
||
def test_catalog_carries_the_repeater_only_knobs() -> None:
|
||
"""TX delay and Direct TX delay — the reason this feature exists — are first-class."""
|
||
txdelay = get_setting("txdelay")
|
||
direct = get_setting("direct.txdelay")
|
||
assert txdelay is not None and txdelay.set_command("0.50") == "set txdelay 0.50"
|
||
assert direct is not None and direct.get_command == "get direct.txdelay"
|
||
assert any(s.key == "af" for s in REPEATER_SETTINGS)
|
||
assert any(s.key == "advert.interval" for s in REPEATER_SETTINGS)
|
||
|
||
|
||
def test_delays_are_floats_rounded_to_two_places() -> None:
|
||
"""TX, Direct TX and RX delay read, validate and send as two-decimal floats.
|
||
|
||
Regression: they were typed ``int``, so a firmware ``0.5`` showed as ``0`` and typing
|
||
``0.5`` back was refused as "not a whole number".
|
||
"""
|
||
for key in ("txdelay", "direct.txdelay", "rxdelay"):
|
||
spec = get_setting(key)
|
||
assert spec.kind == "float" and spec.decimals == 2
|
||
assert parse_reply_value(spec, "> 0.5") == "0.50"
|
||
assert parse_reply_value(spec, "> 1.2345678") == "1.23"
|
||
assert validate_value(spec, "0.5") is True
|
||
assert normalize_value(spec, "0.3333") == "0.33"
|
||
assert "≤ 2" in validate_value(get_setting("txdelay"), "2.5")
|
||
assert validate_value(get_setting("rxdelay"), "12.5") is True # RX delay runs to 20
|
||
|
||
|
||
def test_path_hash_mode_is_an_enum_the_firmware_accepts() -> None:
|
||
"""Path-hash mode is on the repeater too, offering exactly the modes ``set`` takes."""
|
||
spec = get_setting("path.hash.mode")
|
||
assert spec is not None and spec.kind == "enum"
|
||
assert [o.value for o in spec.options] == ["0", "1", "2"] # the firmware refuses 3
|
||
assert parse_reply_value(spec, "> 1") == "1"
|
||
assert spec.display("1") == "2-byte"
|
||
assert validate_value(spec, "2") is True
|
||
assert validate_value(spec, "3") != True # noqa: E712 - a message, not False
|
||
assert spec.set_command("2") == "set path.hash.mode 2"
|
||
|
||
|
||
def test_radio_fields_travel_as_one_command() -> None:
|
||
"""Frequency, bandwidth, SF and CR are one ``get radio`` and one ``set radio``."""
|
||
plan = dict(read_plan(REPEATER_SETTINGS))
|
||
assert [s.key for s in plan["get radio"]] == ["freq", "bw", "sf", "cr"]
|
||
assert not any(command in plan for command in ("get freq", "get bw", "get sf", "get cr"))
|
||
assert len(plan) == len(REPEATER_SETTINGS) - 3 # everything else is its own read
|
||
|
||
reply = "> 910.525,62.5,7,5"
|
||
fields = {key: parse_reply_value(get_setting(key), reply) for key in ("freq", "bw", "sf", "cr")}
|
||
assert fields == {"freq": "910.525", "bw": "62.5", "sf": "7", "cr": "5"}
|
||
|
||
(write,) = write_plan({"sf": "9"}, fields)
|
||
assert write.command == "set radio 910.525,62.5,9,5"
|
||
assert write.values == {**fields, "sf": "9"}
|
||
|
||
(blind,) = write_plan({"sf": "9"}, {}) # siblings never read: nothing to restate
|
||
assert blind.command == "" and set(blind.missing) == {"freq", "bw", "cr"}
|
||
assert composite_reads({"sf": "9"}, {}) == ["get radio"]
|
||
assert composite_reads({"sf": "9"}, fields) == []
|
||
|
||
|
||
def test_verb_shaped_and_oddly_spelled_settings() -> None:
|
||
"""Settings the firmware spells its own way read and write the way it spells them."""
|
||
powersaving = get_setting("powersaving")
|
||
assert powersaving.get_command == "powersaving"
|
||
assert powersaving.set_command("on") == "powersaving on"
|
||
assert parse_reply_value(powersaving, "on - Immediate effect") == "on"
|
||
|
||
gps = get_setting("gps")
|
||
assert parse_reply_value(gps, "on, deactivated, no fix, 0 sats") == "off"
|
||
assert parse_reply_value(gps, "on, active, fix, 7 sats") == "on"
|
||
assert get_setting("gps advert").set_command("share") == "gps advert share"
|
||
|
||
assert get_setting("multi.acks").set_command("on") == "set multi.acks 1" # an atoi
|
||
assert parse_reply_value(get_setting("multi.acks"), "> 1") == "on"
|
||
assert parse_reply_value(get_setting("bridge.source"), "> logRx") == "rx"
|
||
assert parse_reply_value(get_setting("dutycycle"), "> 50.0%") == "50.0"
|
||
|
||
|
||
def test_advert_intervals_take_zero_as_off() -> None:
|
||
"""0 turns an advert interval off; anything else must sit in the firmware's range."""
|
||
spec = get_setting("advert.interval")
|
||
assert validate_value(spec, "0") is True
|
||
assert validate_value(spec, "120") is True
|
||
assert validate_value(spec, "30") == "Must be 0, or 60 – 240."
|
||
assert range_hint(spec) == "Allowed: 0 (off), or 60 – 240 (min)"
|
||
|
||
|
||
def test_parse_reply_value_survives_terse_and_verbose_firmware() -> None:
|
||
"""Numbers are extracted from any phrasing; errors parse as unknown, not values."""
|
||
tx = get_setting("tx")
|
||
assert parse_reply_value(tx, "> 20") == "20"
|
||
assert parse_reply_value(tx, "tx: 20") == "20"
|
||
assert parse_reply_value(tx, "TX power = 20 dBm") == "20"
|
||
assert parse_reply_value(tx, "ERR: unknown config: tx") is None
|
||
assert parse_reply_value(tx, "??: tx") is None # handleGetCmd's own spelling
|
||
assert parse_reply_value(tx, None) is None
|
||
|
||
name = get_setting("name")
|
||
assert parse_reply_value(name, "> Yagi") == "Yagi"
|
||
assert parse_reply_value(name, "name: Yagi") == "Yagi"
|
||
# A value echo is a value, even one that reads like a refusal.
|
||
assert parse_reply_value(name, "> Unknown-Hill") == "Unknown-Hill"
|
||
assert not reply_is_error("> Unknown-Hill")
|
||
assert parse_reply_value(get_setting("owner.info"), "> ") == "" # blank is a value
|
||
|
||
repeat = get_setting("repeat")
|
||
assert parse_reply_value(repeat, "> on") == "on"
|
||
assert parse_reply_value(repeat, "repeat is off") == "off"
|
||
|
||
|
||
def test_validate_value_enforces_kind_and_bounds() -> None:
|
||
"""Prompt validation speaks in the setting's own terms."""
|
||
sf = get_setting("sf")
|
||
assert validate_value(sf, "9") is True
|
||
assert "≥ 5" in validate_value(sf, "3")
|
||
assert "number" in validate_value(sf, "fast")
|
||
assert validate_value(get_setting("repeat"), "maybe") == "Enter on or off."
|
||
assert validate_value(get_setting("name"), " ") == "Enter a value."
|
||
|
||
|
||
def test_known_commands_cover_catalog_and_verbs() -> None:
|
||
"""The CLI completions include every catalog spelling plus the fixed verbs."""
|
||
commands = known_commands()
|
||
assert "get txdelay" in commands
|
||
assert "set direct.txdelay " in commands
|
||
assert "get radio" in commands and "set radio " in commands
|
||
assert "powersaving " in commands and "gps advert" in commands
|
||
assert "get path.hash.mode" in commands
|
||
assert "reboot" in commands and "ver" in commands
|
||
assert "get bw" not in commands and "set freq " not in commands
|
||
|
||
|
||
# --- the store ------------------------------------------------------------------------
|
||
|
||
|
||
def test_remote_store_caches_settings_per_node(tmp_path: Path) -> None:
|
||
"""Values round-trip with their read stamps, keyed per node."""
|
||
store = RemoteStore(tmp_path / "remote.json")
|
||
store.remember_setting(NODE, "txdelay", "0.50")
|
||
cached = store.settings(NODE)
|
||
assert cached["txdelay"].value == "0.50"
|
||
assert cached["txdelay"].read_at is not None
|
||
other = Contact(name="Other", public_key="b2" * 32)
|
||
assert store.settings(other) == {}
|
||
|
||
|
||
def test_remote_store_tells_unsupported_from_unread(tmp_path: Path) -> None:
|
||
"""A key the firmware refused is remembered as that; forgetting makes it unread again."""
|
||
store = RemoteStore(tmp_path / "remote.json")
|
||
store.remember_unsupported(NODE, "bridge.delay")
|
||
store.remember_setting(NODE, "af", "1.00")
|
||
cached = store.settings(NODE)
|
||
assert cached["bridge.delay"].supported is False
|
||
assert cached["af"].supported is True
|
||
store.forget_setting(NODE, "af")
|
||
assert "af" not in store.settings(NODE)
|
||
|
||
|
||
def test_remote_store_history_dedupes_and_caps(tmp_path: Path) -> None:
|
||
"""History appends in order, skips adjacent repeats, and stays capped."""
|
||
store = RemoteStore(tmp_path / "remote.json")
|
||
store.append_history(NODE, "get tx")
|
||
store.append_history(NODE, "get tx") # adjacent repeat — no stutter on recall
|
||
store.append_history(NODE, "set tx 20")
|
||
assert store.history(NODE) == ["get tx", "set tx 20"]
|
||
for i in range(HISTORY_CAP + 20):
|
||
store.append_history(NODE, f"cmd {i}")
|
||
history = store.history(NODE)
|
||
assert len(history) == HISTORY_CAP and history[-1] == f"cmd {HISTORY_CAP + 19}"
|
||
|
||
|
||
# --- the simulated remote CLI ----------------------------------------------------------
|
||
|
||
|
||
async def test_mock_remote_cli_requires_login() -> None:
|
||
"""A stranger's command reads as a timeout (None), exactly like hardware."""
|
||
device = MockDevice()
|
||
await device.connect()
|
||
assert await device.send_remote_command(NODE, "get tx") is None
|
||
await device.disconnect()
|
||
|
||
|
||
async def test_mock_remote_cli_answers_like_the_firmware() -> None:
|
||
"""The simulator keeps CommonCLI's spellings and reply shapes, refusals included."""
|
||
device = MockDevice()
|
||
await device.connect()
|
||
assert await device.admin_login(NODE, "admin")
|
||
assert await device.send_remote_command(NODE, "get txdelay") == "> 0.5"
|
||
assert await device.send_remote_command(NODE, "set txdelay 1.25") == "OK"
|
||
assert await device.send_remote_command(NODE, "get txdelay") == "> 1.25"
|
||
assert await device.send_remote_command(NODE, "set tx 22") == "OK"
|
||
assert await device.get_remote_tx_power(NODE) == 22 # one shared TX state
|
||
assert await device.send_remote_command(NODE, "get tx") == "> 22"
|
||
assert await device.send_remote_command(NODE, "get radio") == "> 910.525,62.5,7,5"
|
||
refused = await device.send_remote_command(NODE, "set freq 915")
|
||
assert refused.startswith("unknown config") # serial console only
|
||
reboot = await device.send_remote_command(NODE, "set radio 915,250,10,5")
|
||
assert reboot == "OK - reboot to apply"
|
||
assert await device.send_remote_command(NODE, "get radio") == "> 915,250,10,5"
|
||
assert await device.send_remote_command(NODE, "get nonsense") == "??: nonsense"
|
||
assert "simulator" in (await device.send_remote_command(NODE, "ver"))
|
||
await device.disconnect()
|
||
|
||
|
||
# --- the login flow: the password floats over the node picker, never a blank frame ----
|
||
|
||
|
||
@pytest.fixture()
|
||
def tui_ctx(tmp_path: Path) -> AppContext:
|
||
"""A mock-backed context wired to a headless TUI session (no prompt_toolkit app)."""
|
||
settings = Settings(config_dir=tmp_path, db_path=tmp_path / "admin.db")
|
||
ctx = 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,
|
||
)
|
||
ctx.ui = TuiUi(TuiSession())
|
||
yield ctx
|
||
ctx.repo.close()
|
||
|
||
|
||
async def _step_until(predicate, *, limit: int = 200):
|
||
"""Yield to the event loop until ``predicate()`` is truthy; return it (or its last value)."""
|
||
value = predicate()
|
||
for _ in range(limit):
|
||
if value:
|
||
return value
|
||
await asyncio.sleep(0)
|
||
value = predicate()
|
||
return value
|
||
|
||
|
||
def test_picker_rows_hue_each_name_by_its_own_key(tui_ctx) -> None:
|
||
"""Picker rows lead with the type glyph in *its* colour and hue the name by the key.
|
||
|
||
Regression: the row was built as ``Text(glyph, style=type_style)``, which made the
|
||
node-type colour the whole row's *base* style — so every repeater's name came out the
|
||
repeater violet and a section of them read as one node. The glyph now carries its type
|
||
style as a span and the name takes :func:`~meshterm.ui.theme.name_style`, like every
|
||
other list of nodes in the app.
|
||
"""
|
||
from meshterm.ui.admin_picker import admin_picker_rows
|
||
from meshterm.ui.theme import name_style
|
||
from meshterm.ui.widgets import _NODE_GLYPHS
|
||
|
||
contacts = [
|
||
Contact(name="Hub-North", public_key="a1" * 32, key_prefix="a1b2c3d4", node_type=2),
|
||
Contact(name="Hub-South", public_key="d4" * 32, key_prefix="d4c3b2a1", node_type=2),
|
||
]
|
||
rows, candidates = admin_picker_rows(tui_ctx, contacts)
|
||
assert [c.name for c in candidates] == ["Hub-North", "Hub-South"]
|
||
|
||
glyph, glyph_style = _NODE_GLYPHS[2]
|
||
titles = {str(row.value): row.title for row in rows if getattr(row, "value", None) is not None}
|
||
hues = set()
|
||
for contact in contacts:
|
||
title = titles[contact.name]
|
||
assert str(title.style) == "" # no base style to paint the whole row one colour
|
||
assert title.plain == f"{glyph} {contact.name}"
|
||
assert any(s.style == glyph_style and s.start == 0 for s in title.spans)
|
||
hue = name_style(contact.name, contact.public_key)
|
||
at = title.plain.index(contact.name)
|
||
assert any(s.style == hue and s.start <= at < s.end for s in title.spans)
|
||
hues.add(hue)
|
||
assert len(hues) == 2 # two repeaters, two identities — not one violet block
|
||
|
||
|
||
async def test_login_password_floats_over_the_node_picker(tui_ctx) -> None:
|
||
"""The admin-login password prompt floats over the picker itself, not a lookalike.
|
||
|
||
Regression: ``_login`` ran on an empty stack (the picker was popped when it returned),
|
||
so ``session.text`` pushed a *blank* base and the password box floated over an erased
|
||
frame. That was patched by redrawing a second, identical ``SelectScreen`` as a static
|
||
backdrop; the picker now simply never leaves the stack, so the base under the prompt is
|
||
the list the pick came from — the same object, still highlighted on the row the reader
|
||
chose — and Esc out of the prompt is one pop back onto it rather than out of the flow.
|
||
"""
|
||
ctx = tui_ctx
|
||
session = ctx.ui.session
|
||
pick_title = "Repeater admin — node to manage"
|
||
|
||
task = asyncio.ensure_future(open_repeater_admin(ctx))
|
||
try:
|
||
picker = await _step_until(
|
||
lambda: (
|
||
session.top
|
||
if isinstance(session.top, SelectScreen) and session.top.title == pick_title
|
||
else None
|
||
)
|
||
)
|
||
assert picker is not None, "the node picker never opened"
|
||
|
||
# Walk to the repeater's row and commit it, the way a reader does.
|
||
for _ in range(len(picker._items)):
|
||
current = picker._current_choice()
|
||
if current is not None and current.value == "Yagi-Repeater":
|
||
break
|
||
picker.handle("down")
|
||
picker.handle("enter")
|
||
prompt = await _step_until(
|
||
lambda: session._float_layers()[0] if session._has_float() else None
|
||
)
|
||
assert isinstance(prompt, TextScreen) # the password box floats
|
||
|
||
assert session._base_screen() is picker # the very list, not a redrawn stand-in
|
||
current = picker._current_choice() # still highlighted on the node being logged into
|
||
assert current is not None and current.value == "Yagi-Repeater"
|
||
|
||
prompt.resolve(CANCEL) # Esc — abandon the login…
|
||
again = await _step_until(lambda: session.top if session.top is picker else None)
|
||
assert again is picker, "…and land back on the list, one pop, place kept"
|
||
picker.handle("escape") # Esc again leaves the flow
|
||
result = await task
|
||
finally:
|
||
if not task.done():
|
||
task.cancel()
|
||
|
||
assert result is None # no node was ever administered
|
||
|
||
|
||
# --- reading and applying against the simulator ----------------------------------------
|
||
|
||
|
||
@pytest.fixture()
|
||
async def admin_device(monkeypatch):
|
||
"""A simulator logged in to ``NODE``, recording every command, with pacing waived."""
|
||
real_sleep = asyncio.sleep
|
||
|
||
async def no_wait(_delay, result=None):
|
||
return await real_sleep(0, result)
|
||
|
||
monkeypatch.setattr(asyncio, "sleep", no_wait)
|
||
device = MockDevice()
|
||
await device.connect()
|
||
assert await device.admin_login(NODE, "admin")
|
||
device.sent = []
|
||
original = device.send_remote_command
|
||
|
||
async def recording(node, command, *, timeout=8.0):
|
||
device.sent.append(command)
|
||
return await original(node, command, timeout=timeout)
|
||
|
||
monkeypatch.setattr(device, "send_remote_command", recording)
|
||
yield device
|
||
await device.disconnect()
|
||
|
||
|
||
async def test_read_settings_reads_every_setting_asking_each_question_once(
|
||
tui_ctx, admin_device
|
||
) -> None:
|
||
"""Read settings leaves every row answered — a value, or the node saying it has none.
|
||
|
||
The radio's four fields come from one ``get radio``; nothing is asked twice; a board
|
||
without a front-end module or a bridge reads as unsupported rather than unread.
|
||
"""
|
||
await repeater_admin.read_settings(tui_ctx, admin_device, NODE, REPEATER_SETTINGS)
|
||
|
||
sent = admin_device.sent
|
||
assert len(sent) == len(set(sent)) == len(read_plan(REPEATER_SETTINGS))
|
||
cache = tui_ctx.remote_store.settings(NODE)
|
||
assert set(cache) == {s.key for s in REPEATER_SETTINGS}
|
||
assert cache["txdelay"].value == "0.50" and cache["direct.txdelay"].value == "0.20"
|
||
assert (cache["freq"].value, cache["bw"].value, cache["sf"].value) == ("910.525", "62.5", "7")
|
||
assert cache["path.hash.mode"].value == "0"
|
||
assert cache["dutycycle"].value == "50.0"
|
||
assert cache["gps"].value == "off" and cache["gps advert"].value == "none"
|
||
assert cache["owner.info"].value == "" and cache["owner.info"].supported
|
||
assert not cache["radio.fem.rxgain"].supported
|
||
assert not cache["bridge.delay"].supported
|
||
|
||
|
||
async def test_read_one_setting_sends_one_read(tui_ctx, admin_device) -> None:
|
||
"""``^R``'s read asks for the highlighted setting alone — or its radio line."""
|
||
await repeater_admin.read_settings(tui_ctx, admin_device, NODE, [get_setting("sf")])
|
||
assert admin_device.sent == ["get radio"]
|
||
assert tui_ctx.remote_store.settings(NODE)["cr"].value == "5" # the same answer filled it
|
||
|
||
|
||
async def test_apply_reads_the_radio_first_then_sends_one_line(tui_ctx, admin_device) -> None:
|
||
"""A radio field staged unread restates its siblings from a fresh read, never a guess."""
|
||
ctx = tui_ctx
|
||
session = ctx.ui.session
|
||
ctx.remote_store.remember_setting(NODE, "af", "1.00")
|
||
pending = {"sf": "9", "txdelay": "1.25", "dutycycle": "40.0"}
|
||
|
||
task = asyncio.ensure_future(repeater_admin._apply(ctx, admin_device, NODE, pending))
|
||
summary = await _step_until(
|
||
lambda: (
|
||
session.top
|
||
if session.top is not None and not isinstance(session.top, TracingDialog)
|
||
else None
|
||
),
|
||
limit=5000,
|
||
)
|
||
assert summary is not None, "the apply summary never opened"
|
||
summary.resolve(None)
|
||
applied = await task
|
||
|
||
assert admin_device.sent == [
|
||
"get radio",
|
||
"set radio 910.525,62.5,9,5",
|
||
"set txdelay 1.25",
|
||
"set dutycycle 40.0",
|
||
]
|
||
assert applied == 3 and pending == {}
|
||
cache = ctx.remote_store.settings(NODE)
|
||
assert cache["sf"].value == "9" and cache["txdelay"].value == "1.25"
|
||
assert "af" not in cache # the other spelling of the duty cycle is stale now
|
||
|
||
|
||
# --- the editor menu -----------------------------------------------------------------
|
||
|
||
|
||
def test_value_lane_shows_the_value_without_its_age() -> None:
|
||
"""The value lane is the value: no age stamp, and its own word for each absence."""
|
||
cache = {
|
||
"txdelay": CachedValue("0.50", utcnow() - timedelta(hours=3)),
|
||
"bridge.delay": CachedValue("", utcnow(), supported=False),
|
||
"guest.password": CachedValue("", utcnow()),
|
||
"path.hash.mode": CachedValue("1", utcnow()),
|
||
}
|
||
lane = repeater_admin._value_text
|
||
assert lane(get_setting("txdelay"), cache, {}).plain == "0.50"
|
||
assert lane(get_setting("bridge.delay"), cache, {}).plain == "n/a"
|
||
assert lane(get_setting("guest.password"), cache, {}).plain == "empty"
|
||
assert lane(get_setting("rxdelay"), cache, {}).plain == "?"
|
||
staged = lane(get_setting("path.hash.mode"), cache, {"path.hash.mode": "2"})
|
||
assert staged.plain == "2-byte → 3-byte"
|
||
|
||
|
||
async def test_ctrl_r_reads_only_a_highlighted_setting() -> None:
|
||
"""``^R`` resolves with the highlighted setting, and is named only where it would act."""
|
||
title, items = repeater_admin._menu_items(NODE, {}, {})
|
||
menu = AdminMenu(title, items, footer_hint="↑↓ move · type to filter · Enter select · Esc back")
|
||
loop = asyncio.get_running_loop()
|
||
|
||
menu.future = loop.create_future()
|
||
assert menu._current_choice().value == "name"
|
||
assert menu.footer_hint.endswith("Enter select · ^R read · Esc back")
|
||
assert menu.fkey_lane[2].label == "Read" and menu.fkey_lane[2].enabled
|
||
menu.handle("retry")
|
||
assert menu.future.result() == ReadOne("name")
|
||
|
||
menu.future = loop.create_future()
|
||
menu.handle("end") # the last action row: nothing there to read
|
||
assert "^R" not in menu.footer_hint
|
||
assert not menu.fkey_lane[2].enabled
|
||
menu.handle("retry")
|
||
assert not menu.future.done()
|
||
|
||
|
||
# --- the command-line screen -----------------------------------------------------------
|
||
|
||
|
||
def _cli(history=None, sent=None) -> RemoteCliScreen:
|
||
return RemoteCliScreen(
|
||
node_label="Yagi-Repeater",
|
||
history=list(history or []),
|
||
send=(sent.append if sent is not None else lambda c: None),
|
||
session=_FakeSession(),
|
||
)
|
||
|
||
|
||
def _type(screen: RemoteCliScreen, text: str) -> None:
|
||
for ch in text:
|
||
screen.handle("text", ch)
|
||
|
||
|
||
def test_cli_screen_sends_on_enter_and_parks_while_waiting() -> None:
|
||
"""Enter commits the buffer once; a command in flight blocks the next send."""
|
||
sent: list[str] = []
|
||
screen = _cli(sent=sent)
|
||
_type(screen, "get tx")
|
||
screen.handle("enter")
|
||
assert sent == ["get tx"]
|
||
screen.sent("get tx") # the owner echoes and parks the prompt
|
||
_type(screen, "ver")
|
||
screen.handle("enter")
|
||
assert sent == ["get tx"] # parked: nothing new goes out until the reply lands
|
||
screen.reply("20")
|
||
screen.handle("enter") # the typed-while-parked buffer is still there to send
|
||
assert sent == ["get tx", "ver"]
|
||
|
||
|
||
def test_cli_screen_history_recall_keeps_the_draft() -> None:
|
||
"""↑ walks back through history; ↓ past the newest restores the unsent draft."""
|
||
screen = _cli(history=["get tx", "set tx 20"])
|
||
_type(screen, "dra")
|
||
screen.handle("up")
|
||
assert screen._editor.text == "set tx 20"
|
||
screen.handle("up")
|
||
assert screen._editor.text == "get tx"
|
||
screen.handle("down")
|
||
screen.handle("down")
|
||
assert screen._editor.text == "dra" # the draft came back
|
||
|
||
|
||
def test_cli_screen_tab_completes_known_commands() -> None:
|
||
"""Tab adopts the first known command extending the typed prefix."""
|
||
screen = _cli()
|
||
_type(screen, "get txd")
|
||
screen.handle("tab")
|
||
assert screen._editor.text == "get txdelay"
|
||
|
||
|
||
def test_cli_screen_transcript_shows_exchange() -> None:
|
||
"""The transcript keeps the echoed command and its reply, prompt at the bottom."""
|
||
screen = _cli()
|
||
screen.sent("get txdelay")
|
||
screen.reply("> 5")
|
||
body = "\n".join(screen.render_body(80))
|
||
assert "get txdelay" in body and "> 5" in body
|
||
assert screen.cursor_line() == screen._prompt_line # the view follows the prompt
|
||
|
||
|
||
def test_cli_screen_timeout_note_frees_the_prompt() -> None:
|
||
"""A timeout lands as a muted note and the prompt accepts input again."""
|
||
screen = _cli()
|
||
screen.sent("advert")
|
||
assert screen.busy
|
||
screen.failed("no reply within 10 s")
|
||
assert not screen.busy
|
||
assert "no reply within 10 s" in "\n".join(screen.render_body(80))
|
||
|
||
|
||
# --- the editor menu's column header --------------------------------------------------
|
||
|
||
|
||
def test_admin_menu_pins_the_column_header_over_the_category() -> None:
|
||
"""Scrolled deep, the lane names stay overhead with the category heading under them."""
|
||
import re
|
||
|
||
from meshterm.ui.tui import frame
|
||
|
||
ansi = re.compile(r"\x1b\[[0-9;]*m")
|
||
title, items = repeater_admin._menu_items(NODE, {}, {})
|
||
screen = SelectScreen(title, items)
|
||
for _ in range(18): # down past the first categories
|
||
screen.handle("down")
|
||
visible, above, _below = frame._visible_slice(screen, screen.render_body(72), 10)
|
||
top = [ansi.sub("", row).strip() for row in visible[:2]]
|
||
assert top[0].startswith("SETTING") and top[0].endswith("DESCRIPTION")
|
||
assert top[1].startswith("──") # the category the highlighted row sits in
|
||
assert above is True
|
||
|
||
|
||
def test_admin_menu_header_abbreviates_rather_than_wrapping() -> None:
|
||
"""Too narrow for the whole line, the last label shortens — the header stays one row."""
|
||
from rich.cells import cell_len
|
||
|
||
_title, items = repeater_admin._menu_items(NODE, {}, {})
|
||
header = items[0]
|
||
assert header.pinned
|
||
full = header.text(100)
|
||
assert full.endswith("DESCRIPTION")
|
||
narrow = header.text(cell_len(full) - 2)
|
||
assert narrow.endswith("DESC") and "\n" not in narrow
|
||
|
||
|
||
def test_admin_actions_start_every_label_in_the_same_cell() -> None:
|
||
"""``↻`` and ``⌨`` are one cell among two-cell siblings; the icon column absorbs it.
|
||
|
||
The Actions rows used to write ``icon + " "``, which started *Read settings* and
|
||
*Command line…* a column left of *Send advert…* below them.
|
||
"""
|
||
from rich.cells import cell_len
|
||
|
||
from meshterm.ui.tui import Choice
|
||
|
||
_title, items = repeater_admin._menu_items(NODE, {}, {})
|
||
labels = ("Read settings", "Command line…", "Send advert…", "Sync clock…", "Reboot node…")
|
||
starts = {}
|
||
for item in items:
|
||
if not isinstance(item, Choice) or not hasattr(item.title, "plain"):
|
||
continue
|
||
plain = item.title.plain
|
||
for label in labels:
|
||
if label in plain:
|
||
starts[label] = cell_len(plain[: plain.index(label)])
|
||
assert set(starts) == set(labels)
|
||
assert len(set(starts.values())) == 1, f"a label starts a column early: {starts}"
|