signal-bot/tests/test_dispatcher_outcomes.py

# Copyright (c) 2026 Krzysztof Rudnicki. MIT licence.
"""The outcomes that had no data at all before command_events.

Split out of ``test_dispatcher_recording`` so both stay under the 250-line
cap. This half is the one that matters most: a refusal and a crash are rows
now, and the *use* -- the write that feeds the cooldown -- must still not
move for either of them.
"""

from __future__ import annotations

import datetime as dt
from typing import TYPE_CHECKING

import pytest

from signal_bot.analytics import probe
from signal_bot.decorators import cooldown, daily_limit
from signal_bot.registry import CommandRegistry
from tests.conftest import WATCHED_GROUP, envelope
from tests.test_dispatcher_recording import SENDER, build, calls, history

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)


@pytest.fixture
def ok_registry() -> CommandRegistry:
    """One command that succeeds and reports what it did on the way."""

    async def handler(_ctx: CommandContext) -> None:
        probe.note_upstream("api.example.test", 200, 40)
        probe.note_send(120)
        probe.note_item("Q42")

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


async def test_a_refusal_does_not_move_the_cooldown(
    config: Config,
    directory: GroupDirectory,
    store: Store,
    transport: FakeTransport,
) -> None:
    """The invariant. A refused attempt is history, never a use.

    If these two writes are ever merged, this fails and the bug it names
    comes back: every "wait N seconds" reply would push the wait N seconds
    further away, and waiting would never end.
    """

    async def handler(_ctx: CommandContext) -> None:
        pass

    reg = CommandRegistry()
    reg.register(
        "cat",
        ["!cat"],
        cooldown(3600.0, "poczekaj {seconds} {unit}")(handler),
        "kot",
    )
    dispatcher = build(config, directory, reg, store, transport)

    await dispatcher.handle(envelope(text="!cat", timestamp=1000))
    first_use = store.last_used(WATCHED_GROUP, SENDER, "cat")
    await dispatcher.handle(envelope(text="!cat", timestamp=2000))

    outcomes = [row["outcome"] for row in history(store)]
    assert outcomes == ["ok", "refused_cooldown"]
    # The whole point: the second attempt is a row, and it moved nothing.
    assert store.last_used(WATCHED_GROUP, SENDER, "cat") == first_use
    assert store.uses_today(WATCHED_GROUP, SENDER, "cat", "2026-08-29") == 1


async def test_a_daily_refusal_names_its_own_gate(
    config: Config,
    directory: GroupDirectory,
    store: Store,
    transport: FakeTransport,
) -> None:
    """Which gate bit is the difference between "popular" and "mis-tuned"."""

    async def handler(_ctx: CommandContext) -> None:
        pass

    reg = CommandRegistry()
    reg.register(
        "cat",
        ["!cat"],
        daily_limit(1, "dosc na dzis")(handler),
        "kot",
    )
    dispatcher = build(config, directory, reg, store, transport)

    await dispatcher.handle(envelope(text="!cat", timestamp=1000))
    await dispatcher.handle(envelope(text="!cat", timestamp=2000))

    assert [row["outcome"] for row in history(store)] == ["ok", "refused_daily"]


async def test_a_crash_is_recorded_and_the_bot_survives_it(
    config: Config,
    directory: GroupDirectory,
    store: Store,
    transport: FakeTransport,
) -> None:
    """A command that fails every time used to look like one nobody ran."""

    async def handler(_ctx: CommandContext) -> None:
        raise ValueError

    reg = CommandRegistry()
    reg.register("cat", ["!cat"], handler, "kot")
    dispatcher = build(config, directory, reg, store, transport)

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

    (row,) = history(store)
    assert row["outcome"] == "error"
    # The class name, never the message: an exception's str() carries
    # whatever it was processing, and here that is somebody's message.
    assert row["error_class"] == "ValueError"
    assert store.last_used(WATCHED_GROUP, SENDER, "cat") is None


async def test_recording_can_fail_without_taking_the_bot_down(
    config: Config,
    directory: GroupDirectory,
    ok_registry: CommandRegistry,
    store: Store,
    transport: FakeTransport,
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    """A raise here would end the receive loop and the bot would go deaf.

    Analytics are worth a great deal less than answering at all, so the
    storage failure is logged and the use is still recorded.
    """

    def explode(_event: object) -> None:
        raise RuntimeError

    monkeypatch.setattr(store.commands, "record", explode)
    dispatcher = build(config, directory, ok_registry, store, transport)

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

    assert store.last_used(WATCHED_GROUP, SENDER, "cat") == NOW.timestamp()


async def test_a_replayed_frame_is_recorded_once(
    config: Config,
    directory: GroupDirectory,
    ok_registry: CommandRegistry,
    store: Store,
    transport: FakeTransport,
) -> None:
    """signal-cli replays undelivered frames when the bot reconnects."""
    dispatcher = build(config, directory, ok_registry, store, transport)
    for _ in range(3):
        await dispatcher.handle(envelope(text="!cat", timestamp=5000))
    assert len(history(store)) == 1
    assert len(calls(store)) == 1