signal-bot/tests/test_app.py

# Copyright (c) 2026 Krzysztof Rudnicki. MIT licence.
"""Wiring, the background loops, and ASGI startup."""

from __future__ import annotations

import asyncio
from dataclasses import dataclass
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.transport_fake import FakeTransport
from signal_bot.transport_rest import TransportError
from tests.conftest import SECOND_GROUP, WATCHED_GROUP, envelope

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": "group.watched==",
    "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 membership check."""

    def handler(request: httpx.Request) -> httpx.Response:
        if "/v1/groups" in request.url.path:
            return httpx.Response(
                200,
                json=[
                    {
                        "id": group_id,
                        "internal_id": group_id,
                        "name": f"group {index}",
                        "member": member,
                    }
                    for index, group_id in enumerate(group_ids)
                ],
            )
        return httpx.Response(200, json={"mode": mode})

    return handler


def _bot(config: Config, store: Store, transport: FakeTransport) -> Bot:
    return build_bot(config, _client(lambda r: httpx.Response(200)), store, transport)


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
) -> None:
    bot = _bot(config, store, transport)
    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
) -> 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).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
) -> None:
    store.increment(WATCHED_GROUP, "u1", "")
    await _bot(config, store, transport).publish_report()
    assert transport.texts[0] == "u1  1"


async def test_listen_dispatches_every_frame(
    config: Config, store: Store, transport: FakeTransport
) -> None:
    transport.queue([envelope(text="hello", group_id=WATCHED_GROUP)])
    await _bot(config, store, transport).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(*config.group_ids)))
    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
) -> None:
    client = _client(lambda r: httpx.Response(200))
    runtime = Runtime(bot=_bot(config, store, transport), client=client, store=store)
    runtime.start()
    assert len(runtime.tasks) == 2
    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(BASE_ENV["GROUP_IDS"]))

    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(BASE_ENV["GROUP_IDS"])),
    )
    async with lifespan(app_module.app):
        assert app_module.app.state.runtime is not None


async def test_create_runtime_refuses_a_group_it_only_got_invited_to(
    config: Config,
) -> None:
    """A pending invite looks healthy from outside; startup must not."""
    with pytest.raises(TransportError, match="has not joined"):
        await create_runtime(config, _client(_signal(*config.group_ids, member=False)))


@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
) -> 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).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) == []