signal-bot/tests/test_dispatcher.py

# Copyright (c) 2026 Krzysztof Rudnicki. MIT licence.
"""Routing: scoping, counting, dispatch and error containment."""

from __future__ import annotations

import datetime as dt
from typing import TYPE_CHECKING

import pytest

from signal_bot.dispatcher import Dispatcher
from signal_bot.registry import CommandContext, CommandRegistry
from tests.conftest import OTHER_GROUP, SECOND_GROUP, WATCHED_GROUP, envelope

if TYPE_CHECKING:
    from signal_bot.config import Config
    from signal_bot.discovery import GroupDirectory
    from signal_bot.store import Store
    from signal_bot.transport_fake import FakeTransport

NOW = dt.datetime(2026, 8, 29, 12, 0, tzinfo=dt.UTC)


@pytest.fixture
def runs() -> list[str]:
    return []


@pytest.fixture
def registry(runs: list[str]) -> CommandRegistry:
    async def handler(ctx: CommandContext) -> None:
        runs.append(ctx.command_name)

    reg = CommandRegistry()
    reg.register("cat", ["!cat"], handler)
    return reg


@pytest.fixture
def dispatcher(
    config: Config,
    directory: GroupDirectory,
    registry: CommandRegistry,
    store: Store,
    transport: FakeTransport,
) -> Dispatcher:
    return Dispatcher(
        config=config,
        directory=directory,
        registry=registry,
        store=store,
        transport=transport,
        clock=lambda: NOW,
    )


async def test_counts_a_plain_group_message(dispatcher: Dispatcher, store: Store) -> None:
    await dispatcher.handle(envelope(text="hello"))
    assert store.tallies(WATCHED_GROUP)[0].count == 1


async def test_runs_a_command_and_records_the_use(
    dispatcher: Dispatcher, store: Store, runs: list[str]
) -> None:
    await dispatcher.handle(envelope(text="!cat"))
    assert runs == ["cat"]
    assert store.last_used(WATCHED_GROUP, "uuid-alice", "cat") == NOW.timestamp()
    assert store.uses_today(WATCHED_GROUP, "uuid-alice", "cat", "2026-08-29") == 1


async def test_direct_messages_are_never_handled(
    dispatcher: Dispatcher, store: Store, runs: list[str], transport: FakeTransport
) -> None:
    """A linked device sees every DM on the account; none may reach a handler."""
    await dispatcher.handle(envelope(text="!cat", group_id=None))
    assert runs == []
    assert store.tallies(WATCHED_GROUP) == []
    assert transport.sent == []


async def test_other_groups_are_never_handled(
    dispatcher: Dispatcher, store: Store, runs: list[str]
) -> None:
    await dispatcher.handle(envelope(text="!cat", group_id=OTHER_GROUP))
    assert runs == []
    assert store.tallies(WATCHED_GROUP) == []


async def test_unparseable_frames_are_dropped(dispatcher: Dispatcher, store: Store) -> None:
    await dispatcher.handle("not json")
    assert store.tallies(WATCHED_GROUP) == []


async def test_stickers_are_not_counted(dispatcher: Dispatcher, store: Store) -> None:
    await dispatcher.handle(envelope(text="hi", sticker=True, sync=True))
    assert store.tallies(WATCHED_GROUP) == []


async def test_reactions_are_not_counted(dispatcher: Dispatcher, store: Store) -> None:
    await dispatcher.handle(envelope(text="hi", reaction=True))
    assert store.tallies(WATCHED_GROUP) == []


async def test_non_command_text_runs_nothing(dispatcher: Dispatcher, runs: list[str]) -> None:
    await dispatcher.handle(envelope(text="just chatting"))
    assert runs == []


async def test_a_failing_command_does_not_kill_the_loop(
    config: Config, directory: GroupDirectory, store: Store, transport: FakeTransport
) -> None:
    async def boom(ctx: CommandContext) -> None:
        msg = "upstream is down"
        raise RuntimeError(msg)

    registry = CommandRegistry()
    registry.register("cat", ["!cat"], boom)
    dispatcher = Dispatcher(
        config=config,
        directory=directory,
        registry=registry,
        store=store,
        transport=transport,
        clock=lambda: NOW,
    )
    await dispatcher.handle(envelope(text="!cat"))
    # The use is not recorded, so the cooldown does not punish a failed run.
    assert store.last_used(WATCHED_GROUP, "uuid-alice", "cat") is None


async def test_command_message_is_also_counted(dispatcher: Dispatcher, store: Store) -> None:
    await dispatcher.handle(envelope(text="!cat"))
    assert store.tallies(WATCHED_GROUP)[0].count == 1


async def test_a_reply_goes_back_to_the_group_that_asked(
    config: Config, directory: GroupDirectory, store: Store, transport: FakeTransport
) -> None:
    """The multi-group invariant: never answer in the other watched group."""

    async def answer(ctx: CommandContext) -> None:
        await ctx.reply("pong")

    registry = CommandRegistry()
    registry.register("cat", ["!cat"], answer)
    dispatcher = Dispatcher(
        config=config,
        directory=directory,
        registry=registry,
        store=store,
        transport=transport,
        clock=lambda: NOW,
    )
    await dispatcher.handle(envelope(text="!cat", group_id=SECOND_GROUP))
    assert [m.recipient for m in transport.sent] == [SECOND_GROUP]


async def test_counts_are_kept_per_group(dispatcher: Dispatcher, store: Store) -> None:
    await dispatcher.handle(envelope(text="hello", group_id=WATCHED_GROUP))
    await dispatcher.handle(envelope(text="hello", group_id=SECOND_GROUP))
    await dispatcher.handle(envelope(text="hello", group_id=SECOND_GROUP))
    assert store.tallies(WATCHED_GROUP)[0].count == 1
    assert store.tallies(SECOND_GROUP)[0].count == 2