mirror of
https://github.com/kuhyx/signal-bot.git
synced 2026-11-10 18:07:29 +01:00
Krzysztof kuhy Rudnicki
6bde3493a4
The bot did not work. `run.sh` started a FastAPI app whose
`@app.on_event("startup")` awaited `asyncio.gather()` on two infinite
tasks, so uvicorn never finished starting up and no HTTP was ever served;
the readme's `python main.py` was a no-op with no `__main__` block and no
`uvicorn.run()` call. All three CI workflows were red, one referencing an
`environment.yml` that does not exist.
Rewritten as a package behind an injectable transport seam, which is what
makes the offline environment possible.
Bugs fixed:
- startup deadlock: lifespan spawns the loops instead of awaiting them
- sticker filter read dataMessage.sticker even on syncMessage envelopes, so
the account's own stickers were never filtered (e038772, 53028cc, 07fa90d,
2416cef all fought this symptom)
- no websocket reconnect: a container restart killed the bot silently
- blocking `requests` inside async functions stalled the event loop
- every counted message DMed the whole tally to the bot itself
- images were written to CWD under a filename taken from the remote URL
- one global 10s cooldown shared across all users and commands
- dead code: RECEIVE_URL, get_attachments (no call site), USER_MESSAGE_COUNT
- .env.sample declared PRIMARY/SECONDARY_PHONE_NUMBER and MODE, none read
Scoping is now an enforced invariant. A linked device receives every DM and
every group on the account; GROUP_ID was the only thing narrowing that and
defaulted to "". Config refuses to start unscoped, direct messages are
dropped explicitly rather than by a falsy check, and a scenario asserts that
DMs and other groups produce zero outbound messages.
Offline environment: fake_signal/ serves the real protocol surface, so the
unmodified bot connects to it by pointing API_BASE_URL at it. scripts/e2e.sh
boots both, replays 7 scenarios and exits non-zero on mismatch. A local
Signal server is not achievable (signal-cli compiles its endpoints and trust
store in; Signal-Server needs FoundationDB), so faking this boundary is the
only way to test every feature without an account.
Transport pinned to bbernhard/signal-cli-rest-api:0.100 with
MODE=json-rpc-native. The readme pinned 0.167-dev; the dev tag series counts
separately, so that was older than 0.100, not newer. /v1/receive is only a
WebSocket in a json-rpc mode, so the mode is verified at startup.
Repo standards: ruff select=ALL, mypy --strict, 189 tests at 100% branch
coverage, 250-line cap, exact pins at newest stable, shared gates delegated
to ~/utils, one CI workflow replacing three red ones. No noqa, no
type: ignore, no coverage omits anywhere.
Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013yaBT45KhHqxTKVCTA87iy
160 lines
5.4 KiB
Python
160 lines
5.4 KiB
Python
# Copyright (c) 2026 Krzysztof Rudnicki. MIT licence.
|
|
"""The reusable gates, tested against a harmless command."""
|
|
|
|
from __future__ import annotations
|
|
|
|
from dataclasses import replace
|
|
from typing import TYPE_CHECKING
|
|
|
|
import pytest
|
|
|
|
from signal_bot.decorators import cooldown, daily_limit, vote_gated
|
|
from signal_bot.models import parse_envelope
|
|
from signal_bot.registry import CommandContext, Handler
|
|
from tests.conftest import REPLY_GROUP, envelope
|
|
|
|
if TYPE_CHECKING:
|
|
from signal_bot.config import Config
|
|
from signal_bot.store import Store
|
|
from signal_bot.transport_fake import FakeTransport
|
|
|
|
DAY = "2026-08-29"
|
|
|
|
|
|
def _context(
|
|
store: Store, transport: FakeTransport, config: Config, *, uuid: str = "u1", now: float = 100.0
|
|
) -> CommandContext:
|
|
message = parse_envelope(envelope(text="!ping", uuid=uuid))
|
|
assert message is not None
|
|
return CommandContext(
|
|
message=message,
|
|
recipient=REPLY_GROUP,
|
|
transport=transport,
|
|
store=store,
|
|
config=config,
|
|
command_name="ping",
|
|
now=now,
|
|
day=DAY,
|
|
)
|
|
|
|
|
|
@pytest.fixture
|
|
def runs() -> list[str]:
|
|
return []
|
|
|
|
|
|
@pytest.fixture
|
|
def handler(runs: list[str]) -> Handler:
|
|
async def _handler(ctx: CommandContext) -> None:
|
|
runs.append(ctx.message.source_uuid)
|
|
|
|
return _handler
|
|
|
|
|
|
async def test_cooldown_allows_first_use(
|
|
store: Store, transport: FakeTransport, config: Config, handler: Handler, runs: list[str]
|
|
) -> None:
|
|
await cooldown(10, "wait {seconds}")(handler)(_context(store, transport, config))
|
|
assert runs == ["u1"]
|
|
|
|
|
|
async def test_cooldown_blocks_and_reports_remaining(
|
|
store: Store, transport: FakeTransport, config: Config, handler: Handler, runs: list[str]
|
|
) -> None:
|
|
store.record_use("u1", "ping", 100.0, DAY)
|
|
ctx = _context(store, transport, config, now=104.0)
|
|
await cooldown(10, "wait {seconds}")(handler)(ctx)
|
|
assert runs == []
|
|
assert transport.texts == ["wait 7"]
|
|
|
|
|
|
async def test_cooldown_expires(
|
|
store: Store, transport: FakeTransport, config: Config, handler: Handler, runs: list[str]
|
|
) -> None:
|
|
store.record_use("u1", "ping", 100.0, DAY)
|
|
await cooldown(10, "wait {seconds}")(handler)(_context(store, transport, config, now=111.0))
|
|
assert runs == ["u1"]
|
|
|
|
|
|
async def test_cooldown_is_per_user(
|
|
store: Store, transport: FakeTransport, config: Config, handler: Handler, runs: list[str]
|
|
) -> None:
|
|
"""One person's cat picture used to silence everybody."""
|
|
store.record_use("u1", "ping", 100.0, DAY)
|
|
await cooldown(10, "wait {seconds}")(handler)(
|
|
_context(store, transport, config, uuid="u2", now=101.0)
|
|
)
|
|
assert runs == ["u2"]
|
|
|
|
|
|
async def test_daily_limit_allows_under_the_cap(
|
|
store: Store, transport: FakeTransport, config: Config, handler: Handler, runs: list[str]
|
|
) -> None:
|
|
await daily_limit(1, "no more")(handler)(_context(store, transport, config))
|
|
assert runs == ["u1"]
|
|
|
|
|
|
async def test_daily_limit_blocks_at_the_cap(
|
|
store: Store, transport: FakeTransport, config: Config, handler: Handler, runs: list[str]
|
|
) -> None:
|
|
store.record_use("u1", "ping", 100.0, DAY)
|
|
await daily_limit(1, "no more, used {used}/{max_uses}")(handler)(
|
|
_context(store, transport, config)
|
|
)
|
|
assert runs == []
|
|
assert transport.texts == ["no more, used 1/1"]
|
|
|
|
|
|
async def test_vote_gate_waits_for_quorum(
|
|
store: Store, transport: FakeTransport, config: Config, handler: Handler, runs: list[str]
|
|
) -> None:
|
|
gated = vote_gated(2, 900, "{votes}/{required}")(handler)
|
|
await gated(_context(store, transport, config, uuid="u1"))
|
|
assert runs == []
|
|
assert transport.texts == ["1/2"]
|
|
|
|
|
|
async def test_vote_gate_fires_on_quorum(
|
|
store: Store, transport: FakeTransport, config: Config, handler: Handler, runs: list[str]
|
|
) -> None:
|
|
gated = vote_gated(2, 900, "{votes}/{required}")(handler)
|
|
await gated(_context(store, transport, config, uuid="u1"))
|
|
await gated(_context(store, transport, config, uuid="u2"))
|
|
assert runs == ["u2"]
|
|
|
|
|
|
async def test_repeat_vote_does_not_reach_quorum(
|
|
store: Store, transport: FakeTransport, config: Config, handler: Handler, runs: list[str]
|
|
) -> None:
|
|
gated = vote_gated(2, 900, "{votes}/{required}")(handler)
|
|
await gated(_context(store, transport, config, uuid="u1"))
|
|
await gated(_context(store, transport, config, uuid="u1", now=101.0))
|
|
assert runs == []
|
|
|
|
|
|
async def test_votes_expire_outside_the_window(
|
|
store: Store, transport: FakeTransport, config: Config, handler: Handler, runs: list[str]
|
|
) -> None:
|
|
gated = vote_gated(2, 60, "{votes}/{required}")(handler)
|
|
await gated(_context(store, transport, config, uuid="u1", now=100.0))
|
|
await gated(_context(store, transport, config, uuid="u2", now=1000.0))
|
|
assert runs == []
|
|
|
|
|
|
async def test_vote_tally_resets_after_firing(
|
|
store: Store, transport: FakeTransport, config: Config, handler: Handler, runs: list[str]
|
|
) -> None:
|
|
gated = vote_gated(2, 900, "{votes}/{required}")(handler)
|
|
await gated(_context(store, transport, config, uuid="u1"))
|
|
await gated(_context(store, transport, config, uuid="u2"))
|
|
assert store.count_votes("ping", 0.0) == 0
|
|
|
|
|
|
async def test_gates_stack(
|
|
store: Store, transport: FakeTransport, config: Config, handler: Handler, runs: list[str]
|
|
) -> None:
|
|
stacked = cooldown(10, "wait {seconds}")(daily_limit(2, "no more")(handler))
|
|
await stacked(_context(store, transport, config))
|
|
assert runs == ["u1"]
|
|
assert replace(config, cooldown_seconds=10).cooldown_seconds == 10
|