signal-bot/tests/test_dispatcher_gates.py

# Copyright (c) 2026 Krzysztof Rudnicki. MIT licence.
"""What the dispatcher records when a gate refuses -- which is nothing."""

from __future__ import annotations

import datetime as dt
from typing import TYPE_CHECKING

from signal_bot.decorators import cooldown
from signal_bot.dispatcher import Dispatcher
from signal_bot.registry import CommandRegistry
from signal_bot.registry_holder import RegistryHolder
from signal_bot.stats.queries_day import day_rows
from tests.conftest import 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)


async def test_a_refused_command_records_nothing(
    config: Config, directory: GroupDirectory, store: Store, transport: FakeTransport
) -> None:
    """A gate's refusal must not slide the cooldown window forward.

    This is what made "BEEP BOOP POCZEKAJ n SEKUND" a lie: the refusal itself
    was recorded as a use, so waiting the stated n only bought another refusal.
    """
    runs: list[str] = []

    async def handler(ctx: CommandContext) -> None:
        runs.append(ctx.command_name)

    registry = CommandRegistry()
    registry.register("cat", ["!cat"], cooldown(10, "wait {seconds}")(handler), "kot")
    dispatcher = Dispatcher(
        config=config,
        directory=directory,
        holder=RegistryHolder(lambda: registry),
        store=store,
        transport=transport,
        clock=lambda: NOW,
    )
    earlier = NOW.timestamp() - 4.0
    store.record_use(WATCHED_GROUP, "uuid-alice", "cat", earlier, NOW.date().isoformat())

    await dispatcher.handle(envelope(text="!cat"))

    assert runs == []
    assert store.last_used(WATCHED_GROUP, "uuid-alice", "cat") == earlier
    # The seeded run is the only one counted; a refusal must not eat an
    # allowance either, which is the same bug in daily_limit.
    assert store.uses_today(WATCHED_GROUP, "uuid-alice", "cat", NOW.date().isoformat()) == 1


async def test_waiting_the_stated_time_lets_the_command_run(
    config: Config, directory: GroupDirectory, store: Store, transport: FakeTransport
) -> None:
    """The user's own loop: obey the reply, retry, and it must work."""
    runs: list[str] = []
    clock = [NOW]

    async def handler(ctx: CommandContext) -> None:
        runs.append(ctx.command_name)

    registry = CommandRegistry()
    registry.register("cat", ["!cat"], cooldown(10, "{seconds}")(handler), "kot")
    dispatcher = Dispatcher(
        config=config,
        directory=directory,
        holder=RegistryHolder(lambda: registry),
        store=store,
        transport=transport,
        clock=lambda: clock[0],
    )

    await dispatcher.handle(envelope(text="!cat"))
    clock[0] = NOW + dt.timedelta(seconds=3)
    await dispatcher.handle(envelope(text="!cat"))
    assert runs == ["cat"]

    waited = int(transport.texts[-1])
    clock[0] += dt.timedelta(seconds=waited)
    await dispatcher.handle(envelope(text="!cat"))
    assert runs == ["cat", "cat"]


async def test_a_scoped_command_in_another_group_is_not_a_command_at_all(
    config: Config, directory: GroupDirectory, store: Store, transport: FakeTransport
) -> None:
    """The whole privacy guarantee, at the only layer that can enforce it.

    Not answered, not counted as a command, and -- because the dispatcher
    never resolves it -- never named in a log line either. A handler that
    simply returned would still leak all three.
    """
    runs: list[str] = []

    async def handler(ctx: CommandContext) -> None:
        runs.append(ctx.command_name)

    registry = CommandRegistry()
    registry.register(
        "pack:p1", ["!alfa"], handler, "album", groups=frozenset({SECOND_GROUP}), takes_args=True
    )
    dispatcher = Dispatcher(
        config=config,
        directory=directory,
        holder=RegistryHolder(lambda: registry),
        store=store,
        transport=transport,
        clock=lambda: NOW,
    )

    await dispatcher.handle(envelope(text="!alfa"))

    assert runs == []
    assert transport.sent == []
    # Counted as an ordinary message, which is the other half of the claim:
    # the text was seen, it simply was not a command here. The day comes from
    # the message's own timestamp, never from the clock.
    day = store.events.first_day(WATCHED_GROUP)
    assert day is not None
    assert [row.commands for row in day_rows(store.events, WATCHED_GROUP, day)] == [0]


async def test_the_words_after_a_trigger_reach_the_handler(
    config: Config, directory: GroupDirectory, store: Store, transport: FakeTransport
) -> None:
    seen: list[tuple[str, ...]] = []

    async def handler(ctx: CommandContext) -> None:
        seen.append(ctx.args)

    registry = CommandRegistry()
    registry.register("pack:p1", ["!alfa"], handler, "album", takes_args=True)
    dispatcher = Dispatcher(
        config=config,
        directory=directory,
        holder=RegistryHolder(lambda: registry),
        store=store,
        transport=transport,
        clock=lambda: NOW,
    )

    await dispatcher.handle(envelope(text="!alfa beta gamma"))

    assert seen == [("beta", "gamma")]