mirror of
https://github.com/kuhyx/signal-bot.git
synced 2026-11-10 19:17:02 +01:00
Krzysztof kuhy Rudnicki
0c4b259c17
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
223 lines
8.4 KiB
Python
223 lines
8.4 KiB
Python
# Copyright (c) 2026 Krzysztof Rudnicki. MIT licence.
|
|
"""Wiring, the background loops, and ASGI startup."""
|
|
|
|
from __future__ import annotations
|
|
|
|
import asyncio
|
|
from dataclasses import dataclass, replace
|
|
from typing import TYPE_CHECKING
|
|
|
|
import httpx
|
|
import pytest
|
|
from fastapi.testclient import TestClient
|
|
|
|
from signal_bot import app as app_module
|
|
from signal_bot.app import Bot, Runtime, build_bot, create_runtime, lifespan, now_local
|
|
from signal_bot.discovery import GroupDirectory
|
|
from signal_bot.membership import MembershipError
|
|
from signal_bot.transport_fake import FakeTransport
|
|
from signal_bot.transport_rest import TransportError
|
|
from tests.conftest import SECOND_GROUP, WATCHED_GROUP, envelope, group_entry, listing_client
|
|
|
|
if TYPE_CHECKING:
|
|
from signal_bot.config import Config
|
|
from signal_bot.registry import Handler
|
|
from signal_bot.store import Store
|
|
|
|
BASE_ENV = {
|
|
"PHONE_NUMBER": "+15550000000",
|
|
"GROUP_IDS": "",
|
|
"DATABASE_PATH": ":memory:",
|
|
}
|
|
|
|
|
|
# Captured before any monkeypatching, so a patched httpx.AsyncClient cannot
|
|
# recurse into this helper.
|
|
_REAL_ASYNC_CLIENT = httpx.AsyncClient
|
|
|
|
|
|
def _client(handler: Handler) -> httpx.AsyncClient:
|
|
return _REAL_ASYNC_CLIENT(transport=httpx.MockTransport(handler))
|
|
|
|
|
|
def _signal(*group_ids: str, mode: str = "json-rpc", member: bool = True) -> Handler:
|
|
"""Answer both startup probes: the mode check and the group listing."""
|
|
|
|
def handler(request: httpx.Request) -> httpx.Response:
|
|
if "/v1/groups" in request.url.path:
|
|
return httpx.Response(200, json=[group_entry(gid, member=member) for gid in group_ids])
|
|
return httpx.Response(200, json={"mode": mode})
|
|
|
|
return handler
|
|
|
|
|
|
def _bot(config: Config, store: Store, transport: FakeTransport, directory: GroupDirectory) -> Bot:
|
|
return build_bot(config, _client(lambda r: httpx.Response(200)), store, transport, directory)
|
|
|
|
|
|
def test_now_local_is_timezone_aware() -> None:
|
|
assert now_local().tzinfo is not None
|
|
|
|
|
|
def test_build_bot_registers_the_animal_commands(
|
|
config: Config, store: Store, transport: FakeTransport, directory: GroupDirectory
|
|
) -> None:
|
|
bot = _bot(config, store, transport, directory)
|
|
assert bot.dispatcher.registry.resolve("!cat") is not None
|
|
assert bot.dispatcher.registry.resolve("!pies") is not None
|
|
|
|
|
|
async def test_publish_report_posts_each_group_its_own_tally(
|
|
config: Config, store: Store, transport: FakeTransport, directory: GroupDirectory
|
|
) -> None:
|
|
"""Every group gets its own counts, in its own chat, and only its own."""
|
|
store.increment(WATCHED_GROUP, "u1", "Alice")
|
|
store.increment(SECOND_GROUP, "u2", "Bob")
|
|
store.increment(SECOND_GROUP, "u2", "Bob")
|
|
await _bot(config, store, transport, directory).publish_report()
|
|
assert [(m.recipient, m.text) for m in transport.sent] == [
|
|
(WATCHED_GROUP, "Alice 1"),
|
|
(SECOND_GROUP, "Bob 2"),
|
|
]
|
|
assert store.tallies(WATCHED_GROUP) == []
|
|
assert store.tallies(SECOND_GROUP) == []
|
|
|
|
|
|
async def test_publish_report_falls_back_to_uuid_when_unnamed(
|
|
config: Config, store: Store, transport: FakeTransport, directory: GroupDirectory
|
|
) -> None:
|
|
store.increment(WATCHED_GROUP, "u1", "")
|
|
await _bot(config, store, transport, directory).publish_report()
|
|
assert transport.texts[0] == "u1 1"
|
|
|
|
|
|
async def test_listen_dispatches_every_frame(
|
|
config: Config, store: Store, transport: FakeTransport, directory: GroupDirectory
|
|
) -> None:
|
|
transport.queue([envelope(text="hello", group_id=WATCHED_GROUP)])
|
|
await _bot(config, store, transport, directory).listen()
|
|
assert store.tallies(WATCHED_GROUP)[0].count == 1
|
|
|
|
|
|
async def test_create_runtime_verifies_the_container_mode(config: Config) -> None:
|
|
runtime = await create_runtime(config, _client(_signal(WATCHED_GROUP, SECOND_GROUP)))
|
|
assert isinstance(runtime, Runtime)
|
|
await runtime.stop()
|
|
|
|
|
|
async def test_create_runtime_refuses_a_polling_container(config: Config) -> None:
|
|
with pytest.raises(TransportError):
|
|
await create_runtime(
|
|
config, _client(lambda r: httpx.Response(200, json={"mode": "normal"}))
|
|
)
|
|
|
|
|
|
async def test_runtime_start_and_stop_cancels_tasks(
|
|
config: Config, store: Store, transport: FakeTransport, directory: GroupDirectory
|
|
) -> None:
|
|
client = _client(lambda r: httpx.Response(200))
|
|
runtime = Runtime(bot=_bot(config, store, transport, directory), client=client, store=store)
|
|
runtime.start()
|
|
# listen, the daily report, and the group refresh loop.
|
|
assert len(runtime.tasks) == 3
|
|
await asyncio.sleep(0)
|
|
await runtime.stop()
|
|
assert all(task.done() for task in runtime.tasks)
|
|
|
|
|
|
def test_healthz_serves_and_startup_completes(monkeypatch: pytest.MonkeyPatch) -> None:
|
|
"""The old app never finished startup, so no route was ever reachable."""
|
|
for key, value in BASE_ENV.items():
|
|
monkeypatch.setenv(key, value)
|
|
|
|
def fake_client(**kwargs: object) -> httpx.AsyncClient:
|
|
return _client(_signal(WATCHED_GROUP))
|
|
|
|
monkeypatch.setattr(app_module.httpx, "AsyncClient", fake_client)
|
|
with TestClient(app_module.app) as client:
|
|
assert client.get("/healthz").json() == {"status": "ok"}
|
|
|
|
|
|
async def test_lifespan_is_an_async_context_manager(
|
|
monkeypatch: pytest.MonkeyPatch,
|
|
) -> None:
|
|
for key, value in BASE_ENV.items():
|
|
monkeypatch.setenv(key, value)
|
|
monkeypatch.setattr(
|
|
app_module.httpx,
|
|
"AsyncClient",
|
|
lambda **kwargs: _client(_signal(WATCHED_GROUP)),
|
|
)
|
|
async with lifespan(app_module.app):
|
|
assert app_module.app.state.runtime is not None
|
|
|
|
|
|
async def test_create_runtime_refuses_a_pinned_group_it_cannot_join(
|
|
config: Config,
|
|
) -> None:
|
|
"""A pending invite looks healthy from outside; a pinned startup must not."""
|
|
pinned = replace(config, group_ids=(WATCHED_GROUP,))
|
|
with pytest.raises(MembershipError, match="not a joined member"):
|
|
await create_runtime(pinned, _client(_signal(WATCHED_GROUP, member=False)))
|
|
|
|
|
|
async def test_create_runtime_accepts_an_account_in_no_groups_at_all(
|
|
config: Config,
|
|
) -> None:
|
|
"""An unpinned bot with no groups is not broken; it is waiting to be added."""
|
|
runtime = await create_runtime(config, _client(_signal()))
|
|
assert runtime.bot.directory.groups == ()
|
|
await runtime.stop()
|
|
|
|
|
|
@dataclass
|
|
class RefusingTransport(FakeTransport):
|
|
"""A transport that rejects one group, the way a removal from it would."""
|
|
|
|
refuses: str = ""
|
|
|
|
async def send_text(self, text: str, recipient: str) -> None:
|
|
"""Record the send, unless this is the group that refuses them."""
|
|
if recipient == self.refuses:
|
|
msg = "removed from the group"
|
|
raise RuntimeError(msg)
|
|
await super().send_text(text, recipient)
|
|
|
|
|
|
async def test_one_group_failing_its_report_does_not_cost_the_others(
|
|
config: Config, store: Store, directory: GroupDirectory
|
|
) -> None:
|
|
"""A failed send must not clear that group's day, nor skip the next group."""
|
|
store.increment(WATCHED_GROUP, "u1", "Alice")
|
|
store.increment(SECOND_GROUP, "u2", "Bob")
|
|
transport = RefusingTransport(refuses=WATCHED_GROUP)
|
|
|
|
await _bot(config, store, transport, directory).publish_report()
|
|
|
|
assert [(m.recipient, m.text) for m in transport.sent] == [(SECOND_GROUP, "Bob 1")]
|
|
# The group that failed keeps its counts; the one that succeeded is reset.
|
|
assert store.tallies(WATCHED_GROUP)[0].count == 1
|
|
assert store.tallies(SECOND_GROUP) == []
|
|
|
|
|
|
async def test_a_quiet_group_is_logged_rather_than_posted_into(
|
|
config: Config, store: Store, transport: FakeTransport, directory: GroupDirectory
|
|
) -> None:
|
|
"""The bot sits in every group it was added to; a nightly ping is noise."""
|
|
store.increment(SECOND_GROUP, "u2", "Bob")
|
|
await _bot(config, store, transport, directory).publish_report()
|
|
assert [(m.recipient, m.text) for m in transport.sent] == [(SECOND_GROUP, "Bob 1")]
|
|
|
|
|
|
async def test_the_report_follows_the_live_group_set(
|
|
config: Config, store: Store, transport: FakeTransport
|
|
) -> None:
|
|
"""Groups come from the directory, not from .env, so a new one is included."""
|
|
client = listing_client([group_entry(WATCHED_GROUP), group_entry(SECOND_GROUP)])
|
|
directory = GroupDirectory(config, client, store)
|
|
await directory.refresh()
|
|
store.increment(WATCHED_GROUP, "u1", "Alice")
|
|
store.increment(SECOND_GROUP, "u2", "Bob")
|
|
await _bot(config, store, transport, directory).publish_report()
|
|
assert [m.recipient for m in transport.sent] == [WATCHED_GROUP, SECOND_GROUP]
|