Skip to content

The agent that grows with you

3.5 KB
Raw Blame
"""Distinct IRC lines must remain distinct inputs in the gateway's durable FIFO."""

import asyncio
from types import SimpleNamespace

import pytest

from gateway import platform_registry
from gateway.config import GatewayConfig, PlatformConfig
from gateway.platform_registry import PlatformEntry, PlatformRegistry
from gateway.run import GatewayRunner
from gateway.session_authority import SessionAuthority, initialize_session_authority
from gateway.session_ingress_context import native_callback
from hermes_constants import get_hermes_home
from hermes_state_runtime import list_session_admissions
from tests.gateway._plugin_adapter_loader import load_plugin_adapter


@pytest.mark.asyncio
@pytest.mark.parametrize("texts", [("first", "second"), ("same", "same")])
async def test_same_millisecond_irc_lines_get_separate_admissions(monkeypatch, texts):
    home = get_hermes_home()
    monkeypatch.setenv("IRC_ALLOWED_USERS", "sender")
    module = load_plugin_adapter("irc")
    registry = PlatformRegistry()
    monkeypatch.setattr(platform_registry, "platform_registry", registry)
    module.register(
        SimpleNamespace(
            register_platform=lambda **kwargs: registry.register(
                PlatformEntry(**kwargs)
            )
        )
    )
    # Freeze only this adapter's clock, not asyncio's scheduling clock.
    monkeypatch.setattr(module, "time", SimpleNamespace(time=lambda: 1_700_000_000.0))
    monkeypatch.setattr(SessionAuthority, "_schedule", lambda self, ref: None)
    runner = GatewayRunner(GatewayConfig(sessions_dir=home / "sessions"))
    adapter = module.IRCAdapter(
        PlatformConfig(
            enabled=True,
            typing_indicator=False,
            extra={
                "server": "irc.example.invalid",
                "nickname": "testbot",
                "allowed_users": ["sender"],
            },
        )
    )
    adapter.gateway_runner = runner
    runner.adapters = {adapter.platform: adapter}
    authority = await initialize_session_authority(
        runner, profile_id="default", instance_id="irc-test"
    )
    runner._wire_adapter_handlers(adapter)
    received, receipts = [], []

    async def admit(event):
        # Use the real admission/SQLite path without starting a model turn.
        adapter._canonicalize(event.source)
        received.append(event)
        with native_callback(runner, event, home):
            receipts.append(await authority.admit_native(event))

    monkeypatch.setattr(adapter, "handle_message", admit)
    reader = asyncio.StreamReader()
    reader.feed_data(
        "".join(
            f":sender!user@host PRIVMSG testbot :{text}\r\n" for text in texts
        ).encode()
    )
    reader.feed_eof()
    adapter._reader = reader

    try:
        await adapter._receive_loop()
        rows = [
            row
            for session_id in authority.sessions
            for row in list_session_admissions(
                authority.db,
                session_id=session_id,
                pending_only=False,
            )
        ]
        assert [row["payload"]["text"] for row in rows] == list(texts)
        assert len({row["request_id"] for row in rows}) == len(texts)
        assert len({receipt.admission_id for receipt in receipts}) == len(texts)
        # Retrying the already captured event still resolves to its original admission.
        with native_callback(runner, received[0], home):
            retried = await authority.admit_native(received[0])
        assert retried.admission_id == receipts[0].admission_id
    finally:
        authority.db.close()