Skip to content

JiuwenSwarm is an intelligent AI Agent built on openJiuwen. It extends the powerful capabilities of large language models directly to your fingertips through various communication apps you use daily.

Python
4.3 KB
Raw Blame
# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.

"""Cron permission-resume settle releases the runtime slot only when the turn ends."""

from __future__ import annotations

import asyncio
from types import SimpleNamespace

import pytest

from jiuwenswarm.gateway.message_handler.message_handler import MessageHandler


def _clear_message_handler_singleton() -> None:
    setattr(MessageHandler, "_instance", None)


@pytest.fixture(autouse=True)
def _isolate_message_handler_singleton():
    """Avoid leaking MessageHandler singleton into other gateway UTs (xdist worker)."""
    _clear_message_handler_singleton()
    yield
    _clear_message_handler_singleton()


class _ReleaseClient:
    def __init__(self) -> None:
        self.released: list[str] = []

    async def release_session(self, session_id: str) -> str:
        self.released.append(session_id)
        return "evicted"

    async def send_request(self, env: object) -> None:
        raise AssertionError(env)

    async def send_request_stream(self, env: object):
        if False:  # pragma: no cover - keeps this an async generator
            yield env


class _HoldRegistry:
    def __init__(self, *, fail: bool = False) -> None:
        self.fail = fail
        self.released: list[str] = []

    def release_cron_permission_hold(self, session_id: str) -> None:
        if self.fail:
            raise RuntimeError("hold store down")
        self.released.append(session_id)


def _handler(client: _ReleaseClient) -> MessageHandler:
    _clear_message_handler_singleton()
    return MessageHandler(client)


def _resume_env(*, source: str = "permission_interrupt") -> SimpleNamespace:
    return SimpleNamespace(
        request_id="web-resume-1",
        params={
            "source": source,
            "request_id": "ask-1",
            "answers": [{"selected_options": ["本次允许"]}],
        },
    )


async def _settle(
    handler: MessageHandler,
    *,
    env: SimpleNamespace | None = None,
    still_awaiting_hitl: bool = False,
    cancelled: bool = False,
    request_error: BaseException | None = None,
) -> None:
    await handler._settle_cron_permission_hold_after_interrupt_stream(
        env=env or _resume_env(),
        session_id="cron_real_1",
        still_awaiting_hitl=still_awaiting_hitl,
        cancelled=cancelled,
        request_error=request_error,
    )


@pytest.mark.asyncio
async def test_settled_resume_releases_hold_and_runtime_slot() -> None:
    client = _ReleaseClient()
    handler = _handler(client)
    registry = _HoldRegistry()
    handler.set_cron_registry(registry)

    await _settle(handler)

    assert registry.released == ["cron_real_1"]
    assert client.released == ["cron_real_1"]


@pytest.mark.asyncio
@pytest.mark.parametrize(
    ("kwargs", "source"),
    [
        ({"still_awaiting_hitl": True}, "permission_interrupt"),
        ({"cancelled": True}, "permission_interrupt"),
        ({"request_error": RuntimeError("resume failed")}, "permission_interrupt"),
        ({}, "user"),
    ],
)
async def test_unsettled_or_followup_does_not_release(
    kwargs: dict,
    source: str,
) -> None:
    client = _ReleaseClient()
    handler = _handler(client)
    registry = _HoldRegistry()
    handler.set_cron_registry(registry)

    await _settle(handler, env=_resume_env(source=source), **kwargs)

    assert registry.released == []
    assert client.released == []


@pytest.mark.asyncio
async def test_followup_inflight_keeps_runtime_slot() -> None:
    client = _ReleaseClient()
    handler = _handler(client)
    registry = _HoldRegistry()
    handler.set_cron_registry(registry)

    async def _park() -> None:
        await asyncio.Event().wait()

    task = asyncio.create_task(_park())
    handler._stream_tasks["follow-up"] = task
    handler._stream_sessions["follow-up"] = "cron_real_1"
    try:
        await _settle(handler)
    finally:
        task.cancel()
        with pytest.raises(asyncio.CancelledError):
            await task

    assert registry.released == ["cron_real_1"]
    assert client.released == []


@pytest.mark.asyncio
async def test_hold_release_failure_keeps_runtime_slot() -> None:
    client = _ReleaseClient()
    handler = _handler(client)
    handler.set_cron_registry(_HoldRegistry(fail=True))

    await _settle(handler)

    assert client.released == []