Files
MeshTerm/tests/test_demo.py
T
Jean-Pierre MartineauandClaude Opus 5.5 01f7f7ebca The demo world carries the place of each located node
The places were found once with the real finder (tiles, then Nominatim) and
frozen in world.PLACES. The history stores them, so the demo shows places at
once, its place job sends no request, and each run is the same. The demo home
also clears places.json at each start.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-03 18:08:24 -05:00

191 lines
7.6 KiB
Python

# SPDX-License-Identifier: Apache-2.0
"""The demo world: the same history at each run, and a device that agrees with it."""
from __future__ import annotations
import asyncio
from datetime import timedelta
from pathlib import Path
from meshterm.core.channels import channel_identity
from meshterm.core.models import utcnow
from meshterm.demo import history, world
from meshterm.demo.device import DemoDevice
from meshterm.demo.home import prepare
from meshterm.persistence.repository import Repository
def _seed(path: Path, now) -> Repository: # noqa: ANN001 - a datetime
repo = Repository(path)
history.seed(repo, now)
return repo
def test_each_node_has_its_own_hash() -> None:
"""No two nodes of the world share a path hash, so each hop resolves to one node."""
hashes = [node.hash for node in (world.SELF, *world.NODES)]
assert len(hashes) == len(set(hashes))
def test_the_history_is_the_same_at_each_run(tmp_path: Path) -> None:
"""Two runs give the same rows, with the times moved by the gap between the two starts."""
now = utcnow()
first = _seed(tmp_path / "a.db", now)
second = _seed(tmp_path / "b.db", now + timedelta(hours=5))
assert first.table_counts() == second.table_counts()
assert first.kind_counts() == second.kind_counts()
public = world.CHANNELS[0]
identity = channel_identity(public.name, public.secret)
def lines(repo: Repository, start) -> list[tuple[str, int]]: # noqa: ANN001 - a datetime
rows = repo.recent_chat_messages(is_channel=True, channel_id=identity, limit=500)
return [(m.text, round((start - m.created_at).total_seconds())) for m in rows]
assert lines(first, now) == lines(second, now + timedelta(hours=5))
def test_a_channel_line_has_its_heard_copies(tmp_path: Path) -> None:
"""The packets of a channel line decrypt to the line, so its paths can be found."""
from meshterm.services.message_paths import channel_arrivals
repo = _seed(tmp_path / "h.db", utcnow())
public = world.CHANNELS[0]
identity = channel_identity(public.name, public.secret)
last = repo.recent_chat_messages(is_channel=True, channel_id=identity, limit=1)[-1]
arrivals = channel_arrivals(repo, last, channel_name=public.name, secret=public.secret)
assert arrivals
def test_the_demo_device_traces_a_path() -> None:
"""A forced path through linked repeaters comes back with a reading for each link."""
async def run(): # noqa: ANN202
device = DemoDevice()
await device.connect()
spec = ",".join(world.node(n).hash for n in ("Rosemont", "Mont-Royal", "Rosemont"))
for _ in range(10):
result = await device.run_trace("(path)", path=spec)
if result.success:
return result
return result
result = asyncio.run(run())
assert result.success
assert [h.node for h in result.hops] == ["d8", "2a", "d8", None]
def test_a_tuned_repeater_is_heard_best_at_its_best_power() -> None:
"""TX optimize finds a peak: far from its best power, a relay loses the target."""
from meshterm.demo.device import REMOTE_TX_BEST
async def heard(tx: int) -> list[float]:
device = DemoDevice()
await device.connect()
rosemont = next(c for c in await device.get_contacts() if c.name == "Rosemont")
await device.admin_login(rosemont, world.ADMIN_PASSWORD)
await device.set_remote_tx_power(rosemont, tx)
spec = ",".join(world.node(n).hash for n in ("Rosemont", "Mont-Royal", "Rosemont"))
results = [await device.run_trace("(path)", path=spec) for _ in range(5)]
return [result.hops[1].snr for result in results if result.success]
best = asyncio.run(heard(REMOTE_TX_BEST))
far = asyncio.run(heard(REMOTE_TX_BEST + 8))
assert best
assert not far or max(far) < min(best)
def test_each_located_node_has_a_place_that_the_job_keeps(tmp_path: Path) -> None:
"""Each node that shares its location has its place, and the job asks for nothing.
The video and the screenshots show the places at once, and the demo sends no request.
"""
import logging
from types import SimpleNamespace
from meshterm.core.place_store import PlaceStore
from meshterm.core.preferences import Preferences
from meshterm.services.places import PlaceService
located = {node.name for node in (world.SELF, *world.NODES) if node.shares_location}
assert set(world.PLACES) == located
repo = _seed(tmp_path / "p.db", utcnow())
ctx = SimpleNamespace(
repo=repo,
place_store=PlaceStore(tmp_path / "places.json"),
preferences=Preferences(),
log=logging.getLogger("test"),
)
service = PlaceService(ctx) # type: ignore[arg-type]
for name, place in world.PLACES.items():
node = world.node(name)
assert service.get(node.public_key) == place
service._locations[node.node_id] = (node.lat, node.lon) # noqa: SLF001
assert service._step_for(node.node_id) is None # noqa: SLF001
def test_prepare_writes_a_home(tmp_path: Path) -> None:
"""The demo home gets a database and the stores of the joined room and the alerts."""
home = tmp_path / "demo"
prepare(home, utcnow())
prepare(home, utcnow()) # a second start writes it again over the first
assert (home / "meshterm.db").exists()
assert (home / "rooms.json").exists()
assert (home / "watchtower.json").exists()
def test_each_line_is_sent_while_its_sender_transmits() -> None:
"""No node speaks before our node first heard it, or after it went quiet."""
from meshterm.demo import script
groups = (script.CHANNEL_LINES, script.DIRECT_LINES, script.ROOM_LINES)
for group in groups:
for lines in group.values():
for line in lines:
node = world.BY_NAME.get(line.sender)
if node is None or node is world.SELF:
continue # an author that no contact names
age_h = line.age_min / 60.0
assert node.quiet_hours is not None, line
assert node.quiet_hours <= age_h <= node.first_heard_days * 24.0, line
def test_our_node_uses_the_path_width_of_the_mesh() -> None:
"""Our node uses three bytes for each hop, so a trace uses two (the widest it encodes)."""
from meshterm.ui.trace_screen import collapse_trace_width
mode = asyncio.run(DemoDevice().get_path_hash_mode())
assert mode + 1 == world.path_width(world.SELF) == 3
assert collapse_trace_width(mode) == 2
def test_a_mentioned_node_answers(monkeypatch) -> None: # noqa: ANN001 - the pytest fixture
"""A channel message that mentions Dave gets his answer, which mentions our node."""
from meshterm.demo import script
monkeypatch.setattr(script, "REPLY_DELAY_S", 0.0)
async def run(): # noqa: ANN202
device = DemoDevice()
await device.connect()
messages = []
def on_event(event) -> None: # noqa: ANN001 - a MeshEvent
if event.message is not None:
messages.append(event.message)
unsubscribe = await device.subscribe_events(on_event)
await device.send_channel_message(0, "Hey, is @[Dave-Lachine] coming?")
await device.send_channel_message(0, "Hello, @[Félix]") # no answer in the script
for _ in range(100):
if messages:
break
await asyncio.sleep(0.05)
await asyncio.sleep(0.5)
unsubscribe()
return messages
messages = asyncio.run(run())
assert [m.text for m in messages] == [f"Dave-Lachine: {script.REPLIES['Dave-Lachine']}"]
assert messages[0].is_channel and messages[0].channel == 0
assert f"@[{world.SELF.name}]" in messages[0].text