# SPDX-License-Identifier: Apache-2.0 """Room servers: joining one, reading its board under each post's author, and posting. A room server is a bulletin board on a radio. It keeps its members' latest posts and sends each member the ones they missed — as direct messages from *itself*, each signed with the first four bytes of its author's key. So the facts these tests pin are the ones a room adds to a direct exchange: who wrote a post (``author``), what a login let us do (:class:`~meshterm.core.models.RoomAccess`), when a room needs logging in to again, and that a room's posts stay a board — deduplicated, kept apart from its command replies, and raising the unread badge — rather than leaking into anything else. Everything runs against the simulator and scratch stores; no hardware. """ from __future__ import annotations import asyncio import logging from datetime import datetime, timedelta, timezone from pathlib import Path from types import SimpleNamespace import pytest from rich.cells import cell_len from meshterm.core.admin_store import AdminStore from meshterm.core.config import Settings from meshterm.core.connection import MeshCoreDevice, MockDevice, message_from_event from meshterm.core.events import MeshEvent from meshterm.core.models import ( NODE_TYPE_CHAT, NODE_TYPE_REPEATER, NODE_TYPE_ROOM, ChatMessage, Contact, Conversation, LoginResult, Message, RoomAccess, RoomLogin, is_direct_messageable, is_room, ) from meshterm.core.preferences import Preferences from meshterm.core.remote_config import get_setting from meshterm.core.room_store import RoomStore from meshterm.persistence.repository import Repository from meshterm.services.chat_service import ChatService from meshterm.services.event_hub import EventHub from meshterm.services.rooms import RoomService from meshterm.ui.room import LOGGING_IN, NO_REPLY, NOT_JOINED, RoomScreen, author_label from meshterm.ui.tui import fkeys from tests.conftest import plain from tests.test_admin_login import _device, _Event, _FakeMeshCore, quick_budget # noqa: F401 #: The simulator's room server, exactly as MockDevice lists it. ROOM = Contact( name="Lakeside BBS", public_key="f6a7b8c9" + "0" * 56, key_prefix="f6a7b8c9", node_type=NODE_TYPE_ROOM, route_hops=("a1b2c3d4",), ) ALICE_KEY = "d4e5f6a7" #: A node no contact names (the simulator's neighbour that never advertised to us). STRANGER_KEY = "e5f6a7b8" NOW = datetime(2026, 10, 4, 12, 0, tzinfo=timezone.utc) def _post(text: str, author: str = ALICE_KEY, *, minutes: int = 0) -> Message: """One room post as the wire hands it over: from the room, signed by its author.""" return Message( text=text, sender=ROOM.key_prefix, sender_timestamp=NOW + timedelta(minutes=minutes), author=author, ) @pytest.fixture() def repo(tmp_path: Path) -> Repository: """A Repository on a scratch database.""" r = Repository(tmp_path / "rooms.db") yield r r.close() # --- the model ------------------------------------------------------------------------ def test_only_a_room_server_is_a_room() -> None: """A room is its own section — and still not a direct-message recipient.""" assert is_room(NODE_TYPE_ROOM) assert not is_room(NODE_TYPE_CHAT) and not is_room(None) and not is_room(NODE_TYPE_REPEATER) assert not is_direct_messageable(NODE_TYPE_ROOM) assert ROOM.is_room assert Conversation(label=ROOM.name, is_channel=False, contact=ROOM).is_room assert not Conversation(label="#x", is_channel=True, channel_id="c").is_room @pytest.mark.parametrize( "payload,access", [ ({"acl_permissions": 3, "permissions": 1}, RoomAccess.ADMIN), ({"acl_permissions": 2, "permissions": 0}, RoomAccess.MEMBER), # Role 1 is the firmware's "read-only", set by hand; the room still keeps its posts. ({"acl_permissions": 1, "permissions": 0}, RoomAccess.MEMBER), ({"acl_permissions": 0, "permissions": 2}, RoomAccess.READ_ONLY), # Only the high bits differ — the role is the low two. ({"acl_permissions": 0x80 | 2}, RoomAccess.MEMBER), # A reply from before the permissions byte: only the legacy flag. ({"permissions": 1}, RoomAccess.ADMIN), ({"permissions": 2}, RoomAccess.READ_ONLY), ({"permissions": 0}, RoomAccess.MEMBER), ({}, RoomAccess.MEMBER), ], ) def test_the_access_a_login_reply_grants(payload: dict, access: RoomAccess) -> None: """Read from the access-list byte where there is one, the legacy flag where not.""" assert RoomAccess.from_login(payload) is access def test_only_a_read_only_member_cannot_post() -> None: """The one access a room drops posts from.""" assert RoomAccess.ADMIN.can_post and RoomAccess.MEMBER.can_post assert not RoomAccess.READ_ONLY.can_post def test_a_room_login_is_truthy_only_when_accepted() -> None: """The ``if not login`` idiom keeps LoginResult's meaning.""" assert RoomLogin(LoginResult.ACCEPTED, RoomAccess.MEMBER) assert not RoomLogin(LoginResult.NO_REPLY) assert not RoomLogin(LoginResult.REFUSED) def test_a_post_keeps_its_author_and_the_time_it_was_posted() -> None: """The room is the sender; the author rides beside it; the time is the post's own.""" chat = ChatMessage.from_message(_post("swap meet?")) assert chat.peer == ROOM.key_prefix assert chat.author == ALICE_KEY assert chat.is_post assert chat.created_at == NOW assert chat.key == f"dm:{ROOM.key_prefix}" # the room's board, keyed like the room # --- the wire ------------------------------------------------------------------------- def _received(txt_type: int, **extra) -> SimpleNamespace: payload = { "type": "PRIV", "pubkey_prefix": "f6a7b8c90000", "txt_type": txt_type, "sender_timestamp": int(NOW.timestamp()), "text": "hello", **extra, } return SimpleNamespace(payload=payload) def test_a_signed_message_names_its_author() -> None: """The library's ``signature`` is the author's key prefix, not a signature.""" message = message_from_event(_received(2, signature="E5F6A7B8")) assert message.author == STRANGER_KEY assert message.is_post assert message.sender == "f6a7b8c90000" @pytest.mark.parametrize("txt_type", [0, 1]) def test_plain_text_and_command_replies_have_no_author(txt_type: int) -> None: """A room's command reply shares its key with its posts; only a post has an author.""" message = message_from_event(_received(txt_type, signature="e5f6a7b8")) assert message.author is None and not message.is_post def test_a_channel_message_never_has_an_author() -> None: """Authors belong to room posts; a channel names its sender in the text.""" event = SimpleNamespace( payload={"type": "CHAN", "channel_idx": 0, "txt_type": 2, "signature": "ab", "text": "x"} ) assert message_from_event(event).author is None def test_a_room_login_reads_the_access_from_the_reply(quick_budget) -> None: # noqa: ANN001, F811 """One login exchange, read for the role the room filed us under.""" from meshcore import EventType answer = _Event( EventType.LOGIN_SUCCESS, {"pubkey_prefix": "f6a7b8c90000", "permissions": 2, "acl_permissions": 0}, ) mc = _FakeMeshCore(answer=answer) login = asyncio.run(_device(mc).room_login(ROOM, "anything")) assert login.result is LoginResult.ACCEPTED assert login.access is RoomAccess.READ_ONLY assert mc.sent == [(ROOM.public_key, "anything")] def test_a_room_that_stays_silent_is_no_reply_with_no_access(quick_budget) -> None: # noqa: ANN001, F811 """A room says nothing to a wrong password — silence, never a refusal.""" login = asyncio.run(_device(_FakeMeshCore()).room_login(ROOM, "wrong")) assert login == RoomLogin(LoginResult.NO_REPLY) class _CommandMeshCore: """A meshcore client stand-in for an admin command: arms, sends, then hears replies. ``replies`` are delivered after the command goes out, each through the subscription's attribute filter exactly as the library's dispatcher applies it. """ def __init__(self, replies: list[dict]) -> None: self._replies = replies self._subs: list = [] self.commands = self def subscribe(self, event_type, callback, attribute_filters=None): # noqa: ANN001, ANN201 sub = SimpleNamespace(callback=callback, filters=attribute_filters or {}) sub.unsubscribe = lambda: self._subs.remove(sub) if sub in self._subs else None self._subs.append(sub) return sub async def send_cmd(self, pub, cmd): # noqa: ANN001, ANN201 for payload in self._replies: event = SimpleNamespace(payload=payload) for sub in list(self._subs): if all(payload.get(k) == v for k, v in sub.filters.items()): sub.callback(event) return None def test_an_admin_command_reply_is_not_a_post_or_someone_elses_message() -> None: """THE trap a room sets: its members' posts arrive down the command reply's channel. A post pushed by the room, and a companion's message landing mid-command, both used to be taken for the node's answer. """ room_prefix = ROOM.public_key[:12] mc = _CommandMeshCore( [ {"pubkey_prefix": "d4e5f6a70000", "txt_type": 0, "text": "hi from Alice"}, {"pubkey_prefix": room_prefix, "txt_type": 2, "text": "a member's post"}, {"pubkey_prefix": room_prefix, "txt_type": 1, "text": "> hello"}, ] ) device = MeshCoreDevice(port="mock") device._mc = mc assert asyncio.run(device._send_admin_cmd(ROOM, "get guest.password", timeout=1)) == "> hello" # --- the room store ------------------------------------------------------------------- @pytest.fixture() def rooms(tmp_path: Path) -> RoomStore: """A room store on a scratch file.""" return RoomStore(tmp_path / "rooms.json") def test_an_accepted_member_login_remembers_the_room_password(rooms: RoomStore) -> None: """The password that got us in is the one opening the room again uses.""" rooms.record(ROOM, "hello", RoomLogin(LoginResult.ACCEPTED, RoomAccess.MEMBER)) assert rooms.password(ROOM) == "hello" assert rooms.access(ROOM) is RoomAccess.MEMBER def test_an_open_room_remembers_its_empty_password(rooms: RoomStore) -> None: """``""`` is a password that worked, not an absence.""" rooms.record(ROOM, "", RoomLogin(LoginResult.ACCEPTED, RoomAccess.MEMBER)) assert rooms.password(ROOM) == "" def test_an_admin_login_remembers_the_access_but_not_the_password(rooms: RoomStore) -> None: """The admin password lives in one place, where Repeater admin can change it.""" rooms.record(ROOM, "s3cret", RoomLogin(LoginResult.ACCEPTED, RoomAccess.ADMIN)) assert rooms.password(ROOM) is None assert rooms.access(ROOM) is RoomAccess.ADMIN def test_silence_neither_remembers_nor_forgets(rooms: RoomStore) -> None: """A room is silent for a wrong password, so silence proves nothing either way.""" rooms.record(ROOM, "typo", RoomLogin(LoginResult.NO_REPLY)) assert rooms.membership(ROOM) is None rooms.record(ROOM, "hello", RoomLogin(LoginResult.ACCEPTED, RoomAccess.MEMBER)) rooms.record(ROOM, "hello", RoomLogin(LoginResult.NO_REPLY)) assert rooms.password(ROOM) == "hello" def test_a_refusal_forgets_the_room(rooms: RoomStore) -> None: """The node said no: the password it refused is gone.""" rooms.record(ROOM, "hello", RoomLogin(LoginResult.ACCEPTED, RoomAccess.MEMBER)) rooms.record(ROOM, "hello", RoomLogin(LoginResult.REFUSED)) assert rooms.membership(ROOM) is None # --- the room service ----------------------------------------------------------------- class _Ctx: """The slice of AppContext the room service and the chat recorder read.""" def __init__(self, tmp_path: Path, device: MockDevice, repo: Repository | None = None): self._device = device self.repo = repo self.log = logging.getLogger("test.rooms") self.profile_name = None self.settings = Settings() self.preferences = Preferences() self.admin_store = AdminStore(tmp_path / "admin.json") self.room_store = RoomStore(tmp_path / "rooms.json") self.events = EventHub(self) self.rooms = RoomService(self) async def device(self) -> MockDevice: await self._device.connect() return self._device def test_the_admin_password_is_tried_before_the_room_password(tmp_path: Path) -> None: """A login replaces a known member's role, so the room password would demote an owner.""" ctx = _Ctx(tmp_path, MockDevice()) assert ctx.rooms.password(ROOM) is None and not ctx.rooms.joined(ROOM) ctx.room_store.record(ROOM, "hello", RoomLogin(LoginResult.ACCEPTED, RoomAccess.MEMBER)) assert ctx.rooms.password(ROOM) == "hello" ctx.admin_store.remember(ROOM, "admin") assert ctx.rooms.password(ROOM) == "admin" def test_an_admin_password_alone_is_not_a_join(tmp_path: Path) -> None: """Repeater admin's password lets a join go through unasked; joining is still a login.""" ctx = _Ctx(tmp_path, MockDevice()) ctx.admin_store.remember(ROOM, "admin") assert ctx.rooms.password(ROOM) == "admin" assert not ctx.rooms.joined(ROOM) and not ctx.rooms.login_due(ROOM) async def test_forgetting_a_room_leaves_it(tmp_path: Path) -> None: """The membership and its password go; nothing is transmitted.""" ctx = _Ctx(tmp_path, MockDevice()) await ctx.rooms.login(ROOM, "hello") ctx.rooms.forget(ROOM) assert not ctx.rooms.joined(ROOM) and ctx.rooms.password(ROOM) is None assert not ctx.rooms.heard_recently(ROOM) def test_read_only_never_replaces_the_room_password(rooms: RoomStore) -> None: """A room that lets readers in lets any password in: that proves nothing about one.""" rooms.record(ROOM, "hello", RoomLogin(LoginResult.ACCEPTED, RoomAccess.MEMBER)) rooms.record(ROOM, "helo", RoomLogin(LoginResult.ACCEPTED, RoomAccess.READ_ONLY)) assert rooms.password(ROOM) == "hello" assert rooms.access(ROOM) is RoomAccess.READ_ONLY first = RoomStore(rooms._path.with_name("other.json")) first.record(ROOM, "guess", RoomLogin(LoginResult.ACCEPTED, RoomAccess.READ_ONLY)) assert first.password(ROOM) == "guess", "with nothing better, it is what gets back in" def test_a_blank_login_never_replaces_a_password(rooms: RoomStore) -> None: """Blank proves the room knows us — until it restarts and forgets a member.""" rooms.record(ROOM, "hello", RoomLogin(LoginResult.ACCEPTED, RoomAccess.MEMBER)) rooms.record(ROOM, "", RoomLogin(LoginResult.ACCEPTED, RoomAccess.MEMBER)) assert rooms.password(ROOM) == "hello" rooms.record(ROOM, "", RoomLogin(LoginResult.ACCEPTED, RoomAccess.ADMIN)) assert rooms.password(ROOM) == "hello" def test_an_admin_login_keeps_the_room_password_beside_it(rooms: RoomStore) -> None: """The admin password lives in the admin store; the member's stays here as the fallback.""" rooms.record(ROOM, "hello", RoomLogin(LoginResult.ACCEPTED, RoomAccess.MEMBER)) rooms.record(ROOM, "admin", RoomLogin(LoginResult.ACCEPTED, RoomAccess.ADMIN)) assert rooms.password(ROOM) == "hello" and rooms.access(ROOM) is RoomAccess.ADMIN def test_a_refusal_forgets_only_the_password_it_refused(rooms: RoomStore) -> None: """A node turning one password down says nothing about another.""" rooms.record(ROOM, "hello", RoomLogin(LoginResult.ACCEPTED, RoomAccess.MEMBER)) rooms.record(ROOM, "other", RoomLogin(LoginResult.REFUSED)) assert rooms.password(ROOM) == "hello" async def test_a_blank_admin_login_leaves_the_admin_password_alone(tmp_path: Path) -> None: """Repeater admin shares that password; a blank probe must not erase it.""" ctx = _Ctx(tmp_path, MockDevice()) await ctx.rooms.login(ROOM, "admin") login = await ctx.rooms.login(ROOM, "") assert login.access is RoomAccess.ADMIN assert ctx.admin_store.get(ROOM) == "admin" async def test_one_login_to_a_room_at_a_time(tmp_path: Path) -> None: """A view closed and reopened mid-login shares the login rather than sending another.""" device = MockDevice() ctx = _Ctx(tmp_path, device) ctx.room_store.record(ROOM, "hello", RoomLogin(LoginResult.ACCEPTED, RoomAccess.MEMBER)) sent: list[str] = [] original = device.room_login async def slow(room, password): # noqa: ANN001, ANN202 sent.append(password) await asyncio.sleep(0.05) return await original(room, password) device.room_login = slow first = asyncio.ensure_future(ctx.rooms.login(ROOM, "hello")) await asyncio.sleep(0) assert not ctx.rooms.login_due(ROOM), "a login on its way is not due again" second = await ctx.rooms.login(ROOM, "hello") assert (await first) == second assert sent == ["hello"] third = await ctx.rooms.login(ROOM, "hello") # once it is answered, a new one may go assert third and sent == ["hello", "hello"] async def test_joining_with_the_room_password_makes_us_a_member(tmp_path: Path) -> None: """The stock room password, the simulator's room, a member.""" ctx = _Ctx(tmp_path, MockDevice()) login = await ctx.rooms.login(ROOM, "hello") assert login.access is RoomAccess.MEMBER assert ctx.rooms.joined(ROOM) and ctx.rooms.access(ROOM) is RoomAccess.MEMBER assert ctx.admin_store.get(ROOM) is None # a member password is never an admin one async def test_joining_with_the_admin_password_remembers_it_for_repeater_admin( tmp_path: Path, ) -> None: """Typed into a room's join prompt, it works for administering the room too.""" ctx = _Ctx(tmp_path, MockDevice()) login = await ctx.rooms.login(ROOM, "admin") assert login.access is RoomAccess.ADMIN assert ctx.admin_store.get(ROOM) == "admin" assert ctx.room_store.password(ROOM) is None assert ctx.rooms.password(ROOM) == "admin" async def test_a_wrong_password_is_silence_and_is_never_remembered(tmp_path: Path) -> None: """A password that never worked is never written down.""" ctx = _Ctx(tmp_path, MockDevice()) login = await ctx.rooms.login(ROOM, "nope") assert login.result is LoginResult.NO_REPLY assert not ctx.rooms.joined(ROOM) async def test_a_room_heard_lately_needs_no_login(tmp_path: Path) -> None: """A login is a transmission; a room still sending to us needs none.""" ctx = _Ctx(tmp_path, MockDevice()) assert not ctx.rooms.login_due(ROOM), "nothing to log in with yet" ctx.room_store.record(ROOM, "hello", RoomLogin(LoginResult.ACCEPTED, RoomAccess.MEMBER)) assert ctx.rooms.login_due(ROOM), "joined, but not heard this session" ctx.rooms.heard("F6A7B8C90000") # a post, its prefix at the wire's width assert not ctx.rooms.login_due(ROOM) async def test_a_login_counts_as_hearing_the_room(tmp_path: Path) -> None: """A room that just let us in is sending: opening it again sends nothing.""" ctx = _Ctx(tmp_path, MockDevice()) await ctx.rooms.login(ROOM, "hello") assert not ctx.rooms.login_due(ROOM) # --- the simulator's room ------------------------------------------------------------- async def test_the_simulators_room_sends_its_board_after_a_login(tmp_path: Path) -> None: """Oldest first, from the room, each under its author — and never our own posts.""" device = MockDevice() heard: list[Message] = [] unsubscribe = await device.subscribe_events( lambda event: heard.append(event.message) if event.message is not None else None ) try: heard.clear() # the stream's opening burst carries a synthetic DM of its own assert not (await device.send_direct_message(ROOM, "before joining")).acked login = await device.room_login(ROOM, "hello") assert login.access is RoomAccess.MEMBER while len([m for m in heard if m.is_post]) < 5: await asyncio.sleep(0.01) posts = [m for m in heard if m.is_post] assert all(m.sender == ROOM.key_prefix for m in posts) assert [m.sender_timestamp for m in posts] == sorted(m.sender_timestamp for m in posts) assert {m.author for m in posts} == {ALICE_KEY, "c3d4e5f6", STRANGER_KEY, "f6a7b8c9"} assert (await device.send_direct_message(ROOM, "mine")).acked # kept, acked heard.clear() await device.room_login(ROOM, "") # the room knows us; nothing new but our own await asyncio.sleep(0.2) assert not [m for m in heard if m.is_post] finally: unsubscribe() await device.disconnect() async def test_a_read_only_member_is_heard_but_not_kept(tmp_path: Path) -> None: """``allow.read.only`` lets any password in — and drops what it posts.""" device = MockDevice() device._remote_config(ROOM)["allow.read.only"] = "on" login = await device.room_login(ROOM, "anything") assert login.access is RoomAccess.READ_ONLY assert not (await device.send_direct_message(ROOM, "lost")).acked await device.disconnect() async def test_an_admin_posts_in_the_rooms_own_name(tmp_path: Path) -> None: """``room.post`` adds a notice authored by the room itself.""" device = MockDevice() assert await device.admin_login(ROOM, "admin") is LoginResult.ACCEPTED assert await device.send_remote_command(ROOM, "room.post Meeting at 7") == "OK" assert device._room_board[-1][0] == "f6a7b8c9" assert await device.send_remote_command(ROOM, "get guest.password") == "> hello" await device.disconnect() # --- history and the recorder --------------------------------------------------------- def test_a_rooms_board_leaves_out_its_command_replies(repo: Repository) -> None: """Posts and our own posts are the board; a reply under the room's key is not.""" peer = ROOM.key_prefix repo.record_chat_message(ChatMessage.from_message(_post("first", minutes=1))) repo.record_chat_message(ChatMessage(text="OK", peer=peer)) # an admin command's reply repo.record_chat_message(ChatMessage(text="mine", outbound=True, peer=peer, acked=True)) board = repo.recent_chat_messages(is_channel=False, peer=peer, posts_only=True) assert [m.text for m in board] == ["first", "mine"] assert board[0].author == ALICE_KEY everything = repo.recent_chat_messages(is_channel=False, peer=peer) assert [m.text for m in everything] == ["first", "OK", "mine"] repo.record_chat_message(ChatMessage(text="OK again", peer=peer)) assert repo.last_chat_messages()[f"dm:{peer}"].text == "OK again" assert repo.last_chat_messages(rooms=[peer])[f"dm:{peer}"].text == "mine" def test_a_post_already_stored_is_recognised(repo: Repository) -> None: """The same room, author, time and text name one post.""" post = ChatMessage.from_message(_post("swap meet?")) assert not repo.has_room_post(post) repo.record_chat_message(post) assert repo.has_room_post(ChatMessage.from_message(_post("swap meet?"))) assert not repo.has_room_post(ChatMessage.from_message(_post("swap meet?", minutes=1))) assert not repo.has_room_post(ChatMessage.from_message(_post("swap meet?", STRANGER_KEY))) class _GatedCtx(_Ctx): """With the device-state cache, so the badge rule can place a sender.""" def __init__(self, tmp_path: Path, device: MockDevice, repo: Repository) -> None: super().__init__(tmp_path, device, repo) from meshterm.services.device_state import DeviceState self.devstate = DeviceState(self) async def _record(chat: ChatService, ctx, message: Message) -> None: # noqa: ANN001 ctx.events.publish(MeshEvent.message_event(message)) await chat._queue.join() def _join(ctx) -> None: # noqa: ANN001 """Record a membership, as an accepted login does.""" ctx.room_store.record(ROOM, "hello", RoomLogin(LoginResult.ACCEPTED, RoomAccess.MEMBER)) async def test_a_room_not_joined_records_its_posts_but_raises_no_badge( tmp_path: Path, repo: Repository ) -> None: """Chat has no row for a room not joined, so the badge would point at nothing.""" ctx = _GatedCtx(tmp_path, MockDevice(), repo) chat = ChatService(ctx) await chat.start() try: await _record(chat, ctx, _post("still sending after we forgot it")) assert chat.unread(f"dm:{ROOM.key_prefix}") == 0 board = repo.recent_chat_messages(is_channel=False, peer=ROOM.key_prefix, posts_only=True) assert [m.text for m in board] == ["still sending after we forgot it"] finally: await chat.stop() async def test_a_post_is_recorded_once_and_raises_the_badge_once( tmp_path: Path, repo: Repository ) -> None: """A re-sent post lands twice on the wire and once in history.""" ctx = _GatedCtx(tmp_path, MockDevice(), repo) _join(ctx) chat = ChatService(ctx) await chat.start() try: await _record(chat, ctx, _post("swap meet?")) await _record(chat, ctx, _post("swap meet?")) key = f"dm:{ROOM.key_prefix}" assert chat.unread(key) == 1 board = repo.recent_chat_messages(is_channel=False, peer=ROOM.key_prefix, posts_only=True) assert [(m.text, m.author) for m in board] == [("swap meet?", ALICE_KEY)] assert ctx.rooms.heard_recently(ROOM) finally: await chat.stop() async def test_a_rooms_command_reply_is_recorded_but_silent( tmp_path: Path, repo: Repository ) -> None: """The board is listed; what else a room sends has no row to point the badge at.""" ctx = _GatedCtx(tmp_path, MockDevice(), repo) chat = ChatService(ctx) await chat.start() try: await _record(chat, ctx, Message(text="> hello", sender=ROOM.key_prefix)) assert chat.unread(f"dm:{ROOM.key_prefix}") == 0 assert [m.text for m in repo.recent_chat_messages(is_channel=False, peer=ROOM.key_prefix)] finally: await chat.stop() async def test_posting_records_the_post_under_the_room(tmp_path: Path, repo: Repository) -> None: """Acknowledged means the room kept it; a read-only member's post is not.""" device = MockDevice() ctx = _Ctx(tmp_path, device, repo) chat = ChatService(ctx) await device.room_login(ROOM, "hello") kept = await chat.send_post(ROOM, "count me in") assert kept.acked is True and kept.outbound and kept.peer == ROOM.key_prefix device._room_access[device._mock_key(ROOM)] = RoomAccess.READ_ONLY dropped = await chat.send_post(ROOM, "and me") assert dropped.acked is False board = repo.recent_chat_messages(is_channel=False, peer=ROOM.key_prefix, posts_only=True) assert [m.text for m in board] == ["count me in", "and me"] async def test_a_post_is_never_soft_retried(tmp_path: Path, repo: Repository) -> None: """A retry is a new post, which every member would receive twice.""" device = MockDevice() ctx = _Ctx(tmp_path, device, repo) ctx.preferences.direct_message_soft_retries = 2 sends: list[str] = [] original = device.send_direct_message async def counting(contact, text): # noqa: ANN001, ANN202 sends.append(text) return await original(contact, text) device.send_direct_message = counting await ChatService(ctx).send_post(ROOM, "unacked") # not a member: no ack assert sends == ["unacked"] # --- the repeater-admin page in a room server's words -------------------------------- def test_a_room_servers_guest_password_is_its_room_password() -> None: """Same key on both firmwares; a room's page calls it what it is there.""" spec = get_setting("guest.password") assert spec.for_node(NODE_TYPE_ROOM).label == "Room password" assert spec.for_node(NODE_TYPE_REPEATER).label == "Guest password" assert spec.for_node(NODE_TYPE_ROOM).key == "guest.password" plain_spec = get_setting("txdelay") assert plain_spec.for_node(NODE_TYPE_ROOM) is plain_spec # --- the room view -------------------------------------------------------------------- class _Session: def __init__(self) -> None: self.invalidations = 0 def invalidate(self) -> None: self.invalidations += 1 def run_detached(self, work): # noqa: ANN001, ANN201 return asyncio.ensure_future(work) def _resolve(hash_: str | None) -> str | None: """Alice's key names her and the room's names the room; nothing names the stranger.""" return {ALICE_KEY: "Alice", "f6a7b8c9": ROOM.name}.get(hash_ or "", hash_) def _view( messages: list[ChatMessage] | None = None, *, access: RoomAccess | None = RoomAccess.MEMBER, joined: bool = True, login: RoomLogin | None = None, ) -> tuple[RoomScreen, dict]: """A board over stubbed hooks; ``calls`` records what they were asked.""" calls: dict = {"auto": 0, "joins": [], "sent": []} outcome = login if login is not None else RoomLogin(LoginResult.ACCEPTED, RoomAccess.MEMBER) async def auto_login() -> RoomLogin | None: calls["auto"] += 1 await asyncio.sleep(0) # an exchange on the air: the board goes on drawing meanwhile return outcome async def join(ask: bool) -> RoomLogin | None: calls["joins"].append(ask) await asyncio.sleep(0) return outcome async def send(text: str) -> ChatMessage: calls["sent"].append(text) return ChatMessage(text=text, outbound=True, peer=ROOM.key_prefix, acked=True) screen = RoomScreen( Conversation(label=ROOM.name, is_channel=False, contact=ROOM), messages or [], send=send, names={}, session=_Session(), resolve=_resolve, auto_login=auto_login, join=join, joined=joined, access=access, ) return screen, calls async def _settled(screen: RoomScreen) -> None: while screen._login_open: await asyncio.sleep(0) def _board() -> list[ChatMessage]: return [ ChatMessage.from_message(_post("Anyone driving Saturday?", minutes=-30)), ChatMessage.from_message(_post("Is the north repeater down?", STRANGER_KEY, minutes=-20)), ChatMessage.from_message(_post("Board keeps 32 posts.", "f6a7b8c9", minutes=-10)), ChatMessage(text="I'll check it", outbound=True, peer=ROOM.key_prefix, acked=True), ] def _compose(screen: RoomScreen) -> str: return plain("\n".join(screen.render_body(72))).splitlines()[-1] def test_an_author_is_named_by_key_or_stands_as_a_grey_hash() -> None: """A key something names is that name, in its hue; one nothing names stays a hash.""" assert author_label(ALICE_KEY, _resolve) == ("Alice", ALICE_KEY) assert author_label(STRANGER_KEY, _resolve) == (STRANGER_KEY, None) def test_the_board_draws_each_post_under_its_author() -> None: """A contact, a stranger, the room's own notice, and us — each under its own chip.""" screen, _ = _view(_board()) text = plain("\n".join(screen.render_body(72))) for expected in ("Alice", STRANGER_KEY, ROOM.name, "Anyone driving Saturday?", "I'll check it"): assert expected in text assert screen.title == f"{ROOM.name} · member" def test_a_post_that_arrives_twice_is_shown_once_and_a_reply_not_at_all() -> None: """The live view applies the same two rules the recorder does.""" screen, _ = _view(_board()) screen.append(ChatMessage.from_message(_post("Board keeps 32 posts.", "f6a7b8c9", minutes=-10))) screen.append(ChatMessage(text="> hello", peer=ROOM.key_prefix)) # a command reply assert len(screen._messages) == 4 screen.append(ChatMessage.from_message(_post("New one", minutes=1))) assert screen._messages[-1].text == "New one" async def test_a_member_posts_from_the_compose_line() -> None: """Enter posts, through the same path a direct message takes.""" screen, calls = _view() for ch in "hi": screen.handle("text", ch) screen.handle("enter") while screen._sending: await asyncio.sleep(0) assert calls["sent"] == ["hi"] async def test_the_compose_line_waits_for_the_quiet_login() -> None: """Opening a quiet room logs in in the background; posting opens once it lets us in.""" screen, calls = _view(access=RoomAccess.MEMBER) screen.begin_auto_login() assert screen.title == f"{ROOM.name} · {LOGGING_IN}" assert "posting opens once" in _compose(screen) screen.handle("text", "x") assert screen._editor.text == "", "nothing typed while the room may not know us" await _settled(screen) assert calls["auto"] == 1 and screen.title == f"{ROOM.name} · member" assert screen._composing async def test_after_silence_nothing_can_be_posted_and_the_line_says_why() -> None: """THE reported bug: a login met silence, and the compose line went on taking posts.""" screen, calls = _view(login=RoomLogin(LoginResult.NO_REPLY, flood=True)) screen.begin_auto_login() await _settled(screen) assert screen.title.endswith(NO_REPLY) assert "no answer" in _compose(screen) and "^L" in _compose(screen) for ch in "hi": screen.handle("text", ch) screen.handle("enter") await asyncio.sleep(0) assert calls["sent"] == [] assert "Enter send" not in screen.footer_hint async def test_control_l_runs_the_explained_login() -> None: """^L hands the login to the Rooms flow, its dialogs over the board, and shows the end.""" screen, calls = _view(access=None, login=RoomLogin(LoginResult.ACCEPTED, RoomAccess.ADMIN)) screen.handle("login") assert screen._login_open assert "^L log in" not in screen.footer_hint # a second press would do nothing await _settled(screen) assert calls["joins"] == [False] assert screen.title == f"{ROOM.name} · admin" and screen._composing async def test_a_read_only_member_is_asked_for_another_password_and_offered_no_retry() -> None: """^L asks (the room password is what lets a reader post); ^R would only be dropped.""" unacked = ChatMessage(text="lost", outbound=True, peer=ROOM.key_prefix, acked=False) screen, calls = _view([unacked], access=RoomAccess.READ_ONLY) assert "read-only" in _compose(screen) assert screen._retry_target() is None and "^R" not in screen.footer_hint screen.handle("login") await _settled(screen) assert calls["joins"] == [True] def test_a_board_not_joined_takes_no_posts() -> None: """Its stored posts read from the Rooms page; posting starts with joining.""" screen, _ = _view(_board(), access=None, joined=False) assert screen.title.endswith(NOT_JOINED) assert "not joined" in _compose(screen) and not screen._composing async def test_enter_on_a_picked_post_replies_to_its_author() -> None: """A board has many voices, so Enter on a post primes an @mention, as a channel does.""" screen, _ = _view(_board()) for _ in range(3): # ours, the room's notice, then the stranger's post screen.handle("up") screen.handle("enter") assert screen._editor.text == f"@[{STRANGER_KEY}] " async def test_a_read_only_member_picks_a_post_to_see_its_paths_not_to_reply() -> None: """With no compose line, Enter on a post has nothing to prime, and a paste nowhere to go.""" screen, _ = _view(_board(), access=RoomAccess.READ_ONLY) opened: list[ChatMessage] = [] async def paths(message: ChatMessage) -> None: opened.append(message) screen._paths = paths screen.handle("paste", "pasted text") assert not screen._paste_open and screen._editor.text == "" screen.handle("up") assert screen.footer_hint.startswith("Enter paths") screen.handle("enter") await asyncio.sleep(0) assert screen._editor.text == "" assert [m.text for m in opened] == ["I'll check it"] def test_the_hint_names_log_in_and_fits() -> None: """^L is named where it acts, inside 72 cells, picked or not.""" screen, _ = _view(_board()) assert "^L log in" in screen.footer_hint assert cell_len(screen.footer_hint) <= 72 screen.handle("up") assert cell_len(screen.footer_hint) <= 72 def test_the_handheld_lane_puts_log_in_behind_f1() -> None: """Every chord earns a chip where the keyboard has no Ctrl to reach it by.""" screen, _ = _view(_board()) lane = screen.picocalc_lyra_lane assert lane[0].opp_label == "Log in" assert fkeys.PICOCALC_LYRA_DECK.action_for(lane, 6) == "login" # --- joining: the explained flow ------------------------------------------------------ class _ScriptedUi: """A UI surface answering the join flow's prompt and dialogs from a script. ``choices`` are button *labels*, pressed in order; every dialog shown is kept as ``(text, labels, default label)`` for the test to read. """ def __init__(self, *, passwords=(), choices=()) -> None: # noqa: ANN001 self.passwords = list(passwords) self.choices = list(choices) self.asked: list[str] = [] self.defaults: list[str] = [] self.dialogs: list[tuple[str, list[str], str]] = [] async def text(self, title: str, **kwargs): # noqa: ANN003, ANN201 self.asked.append(title) self.defaults.append(kwargs.get("default", "")) assert kwargs["validate"]("x" * 16) is not True, "a password the radio would cut" return self.passwords.pop(0) if self.passwords else None async def dialog(self, prompt, buttons, **kwargs): # noqa: ANN001, ANN003, ANN201 labels = [label for label, _ in buttons] default = labels[kwargs.get("default", 0)] self.dialogs.append((getattr(prompt, "plain", prompt), labels, default)) pressed = self.choices.pop(0) if self.choices else labels[0] return dict(buttons)[pressed] def busy_dialog(self, message: str = "", *, title: str = ""): # noqa: ANN201 from contextlib import asynccontextmanager @asynccontextmanager async def card(): # noqa: ANN202 yield SimpleNamespace(message=message) return card() class _JoinCtx(_Ctx): """A context with a scripted UI and a device-state stub the flow invalidates.""" def __init__(self, tmp_path: Path, device: MockDevice, ui: _ScriptedUi) -> None: super().__init__(tmp_path, device) self.ui = ui self.devstate = SimpleNamespace(invalidate_contacts=lambda: None) async def test_joining_with_the_right_password_says_nothing_more(tmp_path: Path) -> None: """A login that lets us post ends the flow quietly; the page shows the access.""" from meshterm.ui.rooms import join_room ui = _ScriptedUi(passwords=["hello"]) ctx = _JoinCtx(tmp_path, MockDevice(), ui) login = await join_room(ctx, ROOM) assert login.access is RoomAccess.MEMBER and ctx.rooms.joined(ROOM) assert ui.asked == [f"Join — {ROOM.name}"] and ui.dialogs == [] async def test_a_stale_route_is_explained_and_a_flood_gets_through(tmp_path: Path) -> None: """THE case on hardware: a learned route silently dead, the same login by flood fine.""" from meshterm.ui.rooms import join_room device = MockDevice() device._stale_routes.add(ROOM.name) ui = _ScriptedUi(passwords=["hello"], choices=["Try by flood"]) ctx = _JoinCtx(tmp_path, device, ui) login = await join_room(ctx, ROOM) assert login.access is RoomAccess.MEMBER and login.flood is True text, labels, default = ui.dialogs[0] assert text.startswith(f"{ROOM.name} didn't answer.") assert "route your radio learned to the room (1 hop)" in text assert labels == ["Cancel", "Try by flood"] and default == "Try by flood" assert len(ui.asked) == 1, "the flood carries the same password" async def test_silence_by_flood_names_both_causes_and_offers_another_password( tmp_path: Path, ) -> None: """A password that never worked here could be the problem; the dialog says so.""" from meshterm.ui.rooms import join_room device = MockDevice() await device.reset_route(ROOM) # no route: every login floods ui = _ScriptedUi(passwords=["nope", "hello"], choices=["Try again…"]) ctx = _JoinCtx(tmp_path, device, ui) login = await join_room(ctx, ROOM) assert login.access is RoomAccess.MEMBER and len(ui.asked) == 2 text, labels, default = ui.dialogs[0] assert "went out to the whole mesh" in text and "the password is wrong" in text assert labels == ["Cancel", "Try again…"] and default == "Try again…" assert ui.defaults == ["", "nope"], "the second prompt holds the password just tried" async def test_silence_with_a_password_that_worked_points_at_reach(tmp_path: Path) -> None: """A remembered password is still right; the room most likely didn't hear us.""" from meshterm.ui.rooms import join_room device = MockDevice() await device.reset_route(ROOM) ui = _ScriptedUi(choices=["Cancel"]) ctx = _JoinCtx(tmp_path, device, ui) await ctx.rooms.login(ROOM, "hello") await device.reset_route(ROOM) # the answer taught it a route; flood the next one too device._unreachable.add(ROOM.name) login = await join_room(ctx, ROOM) assert login.result is LoginResult.NO_REPLY and ui.asked == [] text, labels, _ = ui.dialogs[0] assert "got you in before" in text and labels == ["Cancel", "Try again"] assert ctx.rooms.password(ROOM) == "hello", "silence keeps the password" async def test_read_only_is_explained_and_another_password_offered(tmp_path: Path) -> None: """In, but not as a member: the dialog says what that means and why it may be.""" from meshterm.ui.rooms import join_room device = MockDevice() device._remote_config(ROOM)["allow.read.only"] = "on" ui = _ScriptedUi(passwords=["guess"], choices=["Keep read-only"]) ctx = _JoinCtx(tmp_path, device, ui) login = await join_room(ctx, ROOM) assert login.access is RoomAccess.READ_ONLY text, labels, default = ui.dialogs[0] assert "read-only" in text and labels == ["Keep read-only", "Try again…"] async def test_a_room_the_radio_forgot_is_put_back_and_tried_again(tmp_path: Path) -> None: """Not sent at all is its own case: the radio said why, and the fix is one write.""" from meshterm.ui.rooms import join_room device = MockDevice() device._contacts = [c for c in device._contacts if not c.is_room] ui = _ScriptedUi(passwords=["hello"], choices=["Add it & try again"]) ctx = _JoinCtx(tmp_path, device, ui) login = await join_room(ctx, ROOM) assert login.access is RoomAccess.MEMBER text, labels, _ = ui.dialogs[0] assert text == "Your radio didn't send the login: this node isn't in the radio's contacts." assert labels == ["Cancel", "Add it & try again"] async def test_backing_out_of_the_prompt_sends_nothing(tmp_path: Path) -> None: """Esc on the password prompt is the end of it; no login goes out.""" from meshterm.ui.rooms import join_room device = MockDevice() ui = _ScriptedUi() ctx = _JoinCtx(tmp_path, device, ui) assert await join_room(ctx, ROOM) is None assert not device._room_access def test_a_password_the_radio_would_cut_is_refused() -> None: """MeshCore sends 15 bytes of a password; a longer one could never work.""" from meshterm.ui.rooms import valid_password assert valid_password("x" * 15) is True assert valid_password("x" * 16) is not True assert valid_password("é" * 8) is not True, "bytes, not characters" def test_how_long_since_the_room_was_heard_is_part_of_the_explanation(tmp_path: Path) -> None: """Never heard, heard just now: the evidence a reader judges reach by.""" from dataclasses import replace from meshterm.ui.rooms import silence_explanation ctx = _Ctx(tmp_path, MockDevice()) silent = RoomLogin(LoginResult.NO_REPLY, flood=True) never = silence_explanation(ctx, replace(ROOM, last_seen=None), silent, "x") assert "The room has never been heard here." in never now = datetime.now(timezone.utc) fresh = silence_explanation(ctx, replace(ROOM, last_seen=now), silent, "x") assert "The room was heard just now." in fresh # --- the radio's confirmation --------------------------------------------------------- class _ConfirmingMeshCore: """A meshcore stand-in whose login sends confirmations and answers as scripted.""" def __init__(self, frames: list[tuple[str, dict]]) -> None: self.frames = frames self.subs: list = [] self.commands = self def subscribe(self, event_type, callback, attribute_filters=None): # noqa: ANN001, ANN201 sub = SimpleNamespace(event_type=event_type, callback=callback) sub.unsubscribe = lambda: self.subs.remove(sub) if sub in self.subs else None self.subs.append(sub) return sub async def send_login_sync(self, pub, password): # noqa: ANN001, ANN201 from meshcore import EventType for name, payload in self.frames: event = SimpleNamespace(type=getattr(EventType, name), payload=payload) for sub in list(self.subs): if sub.event_type is event.type: sub.callback(event) return None def _confirmed_login(frames: list[tuple[str, dict]]) -> RoomLogin: device = MeshCoreDevice(port="mock") device._mc = _ConfirmingMeshCore(frames) return asyncio.run(device.room_login(ROOM, "hello")) def test_the_radios_confirmation_says_how_the_login_went_out(quick_budget) -> None: # noqa: ANN001, F811 """Matched by the login's expected ack — the room's first four key bytes.""" ours = bytes.fromhex(ROOM.public_key[:8]) flood = _confirmed_login( [("MSG_SENT", {"type": 1, "expected_ack": ours}), ("LOGIN_SUCCESS", {"acl_permissions": 2})] ) assert flood.access is RoomAccess.MEMBER and flood.flood is True direct = _confirmed_login([("MSG_SENT", {"type": 0, "expected_ack": ours})]) assert direct.result is LoginResult.NO_REPLY and direct.flood is False def test_another_commands_confirmation_is_not_ours(quick_budget) -> None: # noqa: ANN001, F811 """A MSG_SENT for anything else in flight says nothing about this login.""" other = _confirmed_login([("MSG_SENT", {"type": 1, "expected_ack": b"\x00\x01\x02\x03"})]) assert other.flood is None and other.radio_error is None def test_a_login_the_radio_would_not_send_carries_its_reason(quick_budget) -> None: # noqa: ANN001, F811 """No confirmation, and the radio's own error: the room isn't in its contacts.""" refused = _confirmed_login([("ERROR", {"error_code": 2})]) assert refused.flood is None assert refused.radio_error == "this node isn't in the radio's contacts" async def test_the_simulator_floods_once_its_route_is_forgotten(tmp_path: Path) -> None: """A stale route meets silence; forgetting it floods, and the answer brings a new one.""" device = MockDevice() device._stale_routes.add(ROOM.name) stale = await device.room_login(ROOM, "hello") assert stale.result is LoginResult.NO_REPLY and stale.flood is False await device.reset_route(ROOM) flooded = await device.room_login(ROOM, "hello") assert flooded.access is RoomAccess.MEMBER and flooded.flood is True again = await device.room_login(ROOM, "") assert again.flood is False and again.access is RoomAccess.MEMBER # --- the Rooms page ------------------------------------------------------------------- def test_the_page_lists_joined_rooms_first(tmp_path: Path, repo: Repository) -> None: """Joined, then the rest heard most recently first, each with its lanes.""" from dataclasses import replace from meshterm.ui.rooms import _page_items ctx = _Ctx(tmp_path, MockDevice(), repo) ctx.chat = SimpleNamespace(unread=lambda key: 0) now = datetime.now(timezone.utc) joined = replace(ROOM, last_seen=now) hilltop = Contact( name="Hilltop Swap", public_key="b7" * 32, key_prefix="b7" * 6, node_type=NODE_TYPE_ROOM ) _join(ctx) title, items = _page_items(ctx, [hilltop, joined]) assert title == "Rooms · 1 joined" rows = [i.title().plain for i in items if hasattr(i, "value")] assert rows[0].startswith("■ Lakeside BBS") and "member" in rows[0] and "now" in rows[0] assert rows[1].startswith("■ Hilltop Swap") and "never" in rows[1] # --- end to end, through the real session --------------------------------------------- async def test_joining_from_the_rooms_page_end_to_end(tmp_path: Path) -> None: """Rooms, the room's page, Join…, the password, Open the board: read, post, leave.""" from prompt_toolkit.input.defaults import create_pipe_input from prompt_toolkit.output import DummyOutput from rich.console import Console from meshterm.context import AppContext from meshterm.core.device_store import DeviceStore from meshterm.ui.rooms import manage_rooms from meshterm.ui.surface import TuiUi from meshterm.ui.tui.session import TuiSession settings = Settings(config_dir=tmp_path, db_path=tmp_path / "e2e.db") ctx = AppContext( console=Console(), settings=settings, repo=Repository(settings.db_path), device_store=DeviceStore(tmp_path / "devices.json"), admin_store=AdminStore(tmp_path / "admin.json"), mock=True, ) def board() -> list[ChatMessage]: return ctx.repo.recent_chat_messages( is_channel=False, peer=ROOM.key_prefix, posts_only=True ) def top() -> str: return getattr(session._stack[-1], "title", "") if session._stack else "" async def until(check, what: str) -> None: # noqa: ANN001 for _ in range(500): if check(): return await asyncio.sleep(0.01) raise AssertionError(f"never reached: {what} (top is {top()!r})") try: with create_pipe_input() as inp: session = TuiSession(input=inp, output=DummyOutput()) ctx.ui = TuiUi(session) async def drive() -> None: await until(lambda: top().startswith("Rooms"), "the Rooms page") inp.send_text("\r") # the one room, under Not joined await until(lambda: top() == f"Room — {ROOM.name}", "the room's page") inp.send_text("\r") # Join… await until(lambda: top() == f"Join — {ROOM.name}", "the password prompt") inp.send_text("hello\r") await until(lambda: ctx.rooms.joined(ROOM), "the join") await until(lambda: top() == f"Room — {ROOM.name}", "back on the room's page") inp.send_text("\r") # Open the board await until(lambda: top().startswith(f"{ROOM.name} ·"), "the board") await until(lambda: len([m for m in board() if m.is_post]) >= 5, "the catch-up") inp.send_text("count me in\r") await until(lambda: [m for m in board() if m.outbound], "the post") inp.send_text("\x1b") # board, back to the room's page await until(lambda: top() == f"Room — {ROOM.name}", "the room's page again") inp.send_text("\x1b") # the room's page, back to Rooms await until(lambda: top().startswith("Rooms"), "the Rooms page again") inp.send_text("\x1b") async def main() -> None: driver = asyncio.ensure_future(drive()) try: await manage_rooms(ctx) finally: driver.cancel() await asyncio.wait_for(session.run(main()), timeout=20) mine = [m for m in board() if m.outbound] assert [(m.text, m.acked) for m in mine] == [("count me in", True)] assert ctx.room_store.password(ROOM) == "hello" finally: await ctx.aclose() # --- the command line ----------------------------------------------------------------- @pytest.fixture() def cli(tmp_path: Path, monkeypatch: pytest.MonkeyPatch): # noqa: ANN201 - a closure """The real CLI against the simulator, in a home of its own (see test_cli_contract).""" from typer.testing import CliRunner from meshterm.cli import app monkeypatch.setenv("MESHTERM_HOME", str(tmp_path / "home")) runner = CliRunner() db = tmp_path / "cli.db" def invoke(*args: str): # noqa: ANN202 return runner.invoke(app, ["--mock", "--db", str(db), *args]) invoke.db = db return invoke def test_chat_list_names_a_room_as_one(cli) -> None: # noqa: ANN001 """A room is its own kind of conversation, on both faces.""" import json assert "Lakeside BBS room" in cli("chat", "list").stdout rows = json.loads(cli("--json", "chat", "list").stdout) kinds = {r["node"]["name"]: r["kind"] for r in rows if r["node"]} assert kinds["Lakeside BBS"] == "room" and kinds["Alice"] == "direct" def test_rooms_join_answers_with_the_access_won(cli) -> None: # noqa: ANN001 """The access word alone on the plain face; the room, the access and the route in JSON.""" import json from meshterm.core import exitcodes unknown = cli("rooms", "join", "Lakeside BBS") assert unknown.exit_code == exitcodes.USAGE, "nothing remembered, nothing sent" assert cli("rooms", "join", "Alice", "--password", "x").exit_code == exitcodes.USAGE long = cli("rooms", "join", "Lakeside BBS", "--password", "x" * 16) assert long.exit_code == exitcodes.USAGE, "a password the radio would cut" silent = cli("rooms", "join", "Lakeside BBS", "--password", "nope") assert silent.exit_code == exitcodes.DEVICE assert silent.stdout == "" and "didn't answer" in silent.stderr joined = cli("rooms", "join", "Lakeside BBS", "--password", "hello") assert joined.exit_code == exitcodes.OK and joined.stdout == "member\n" again = json.loads(cli("--json", "rooms", "join", "Lakeside BBS").stdout) # remembered assert again["access"] == "member" and again["route"] == "direct" assert again["room"]["name"] == "Lakeside BBS" and again["room"]["type"] == "room server" flooded = json.loads(cli("--json", "rooms", "join", "Lakeside BBS", "--flood").stdout) assert flooded["route"] == "flood" def test_rooms_list_and_forget(cli) -> None: # noqa: ANN001 """Every room the radio knows, joined or not; forgetting one is local and silent.""" import json from meshterm.core import exitcodes header, *rows = cli("rooms", "list").stdout.splitlines() assert header.split() == ["ROOM", "ACCESS", "HEARD", "LAST_POST", "UNREAD"] assert rows[0].startswith("Lakeside BBS") cli("rooms", "join", "Lakeside BBS", "--password", "hello") docs = json.loads(cli("--json", "rooms", "list").stdout) assert docs[0]["joined"] is True and docs[0]["access"] == "member" forgot = cli("rooms", "forget", "Lakeside BBS") assert forgot.exit_code == exitcodes.OK and forgot.stdout == "" assert cli("rooms", "forget", "Lakeside BBS").exit_code == exitcodes.NO_RESULT assert json.loads(cli("--json", "rooms", "list").stdout)[0]["joined"] is False def test_chat_history_reads_a_room_by_author(cli) -> None: # noqa: ANN001 """AUTHOR stands where PEER would; a command reply is not on the board; one shape.""" import json repo = Repository(cli.db) try: repo.record_chat_message(ChatMessage.from_message(_post("swap meet?"))) repo.record_chat_message(ChatMessage.from_message(_post("north down?", STRANGER_KEY))) repo.record_chat_message(ChatMessage(text="> hello", peer=ROOM.key_prefix)) finally: repo.close() header, *rows = cli("chat", "history", "--to", "Lakeside BBS").stdout.splitlines() assert header.split() == ["TIME", "DIR", "AUTHOR", "SNR_DB", "TEXT"] assert "Alice (d4e5f6a7)" in rows[0] and rows[0].endswith("swap meet?") assert STRANGER_KEY in rows[1] and "(" not in rows[1].split("north")[0] assert len(rows) == 2 docs = json.loads(cli("--json", "chat", "history", "--to", "Lakeside BBS").stdout) assert docs[0]["author"]["name"] == "Alice" and docs[0]["author"]["hash"] == ALICE_KEY assert docs[1]["author"] == { "name": None, "key": None, "hash": STRANGER_KEY, "type": None, "self": False, } def test_chat_send_to_a_room_is_a_post(cli) -> None: # noqa: ANN001 """The receipt says it was a room it went to.""" import json receipt = json.loads(cli("--json", "chat", "send", "--to", "Lakeside BBS", "hi").stdout) assert receipt["kind"] == "room" assert receipt["acked"] is False, "this simulator never joined, so the room drops it"