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 CommandRegistry
from tests.conftest import OTHER_GROUP, SECOND_GROUP, WATCHED_GROUP, envelope

if TYPE_CHECKING:
    from signal_bot.config import Config
    from signal_bot.context import CommandContext
    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)


def counted(store: Store, group_id: str = WATCHED_GROUP) -> int:
    """How many events one group holds."""
    row = store.events.connection.execute(
        "SELECT COUNT(*) AS n FROM message_events WHERE group_id = ?", (group_id,)
    ).fetchone()
    return int(row["n"])


@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, "cat description")
    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 counted(store) == 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 counted(store) == 0
    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 counted(store) == 0


async def test_unparseable_frames_are_dropped(dispatcher: Dispatcher, store: Store) -> None:
    await dispatcher.handle("not json")
    assert counted(store) == 0


async def test_the_bots_own_messages_are_not_counted(dispatcher: Dispatcher, store: Store) -> None:
    """The sync branch is the account's own outgoing traffic."""
    await dispatcher.handle(envelope(text="hi", sync=True))
    assert counted(store) == 0


async def test_stickers_are_counted(dispatcher: Dispatcher, store: Store) -> None:
    await dispatcher.handle(envelope(text=None, extra="sticker"))
    assert counted(store) == 1


async def test_a_caption_less_photo_is_counted(dispatcher: Dispatcher, store: Store) -> None:
    """Worth zero before 0.1.0. The whole point of the media change."""
    await dispatcher.handle(envelope(text=None, attachments=("image/jpeg",)))
    assert counted(store) == 1


async def test_a_replayed_frame_is_counted_once(dispatcher: Dispatcher, store: Store) -> None:
    """A reconnect replays frames; the primary key is what absorbs them."""
    frame = envelope(text="hello")
    await dispatcher.handle(frame)
    await dispatcher.handle(frame)
    assert counted(store) == 1


async def test_a_command_is_recorded_as_one(dispatcher: Dispatcher, store: Store) -> None:
    """is_command is resolved before the write, so it lands on the row."""
    await dispatcher.handle(envelope(text="!cat"))
    row = store.events.connection.execute(
        "SELECT is_command FROM message_events WHERE group_id = ?", (WATCHED_GROUP,)
    ).fetchone()
    assert row["is_command"] == 1


async def test_reactions_are_not_counted(dispatcher: Dispatcher, store: Store) -> None:
    await dispatcher.handle(envelope(text="hi", extra="reaction"))
    assert counted(store) == 0


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, "cat description")
    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 counted(store) == 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, "cat description")
    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:
    """Distinct timestamps: two frames one millisecond apart are two messages.

    Reusing one timestamp here would be absorbed by the dedupe key, which is
    the behaviour test_a_replayed_frame_is_counted_once pins deliberately.
    """
    await dispatcher.handle(envelope(text="hello", group_id=WATCHED_GROUP, timestamp=1))
    await dispatcher.handle(envelope(text="hello", group_id=SECOND_GROUP, timestamp=1))
    await dispatcher.handle(envelope(text="hello", group_id=SECOND_GROUP, timestamp=2))
    assert counted(store) == 1
    assert counted(store, SECOND_GROUP) == 2