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
10.3 KB
Raw Blame
# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
"""reload 刷新企业配置失败时不得清空缓存(否则 MCP 会被整表清掉)。"""

from __future__ import annotations

import sys
import types
from types import SimpleNamespace
from unittest.mock import MagicMock

import pytest

# interface_deep 顶部会拉可选依赖;精简环境先占位,且不要把 google 打成非包模块。
def _ensure_pkg(name: str) -> types.ModuleType:
    existing = sys.modules.get(name)
    if existing is not None:
        return existing
    mod = types.ModuleType(name)
    mod.__path__ = []
    sys.modules[name] = mod
    return mod


def _ensure_attr(mod: types.ModuleType, name: str, value: object) -> None:
    if not hasattr(mod, name):
        setattr(mod, name, value)


gc = _ensure_pkg("gitcode_api")
_ensure_attr(gc, "AsyncGitCode", type("AsyncGitCode", (), {}))
gc_models = _ensure_pkg("gitcode_api._models")
_ensure_attr(
    gc_models, "RepositoryGitCodeTemplate", type("RepositoryGitCodeTemplate", (), {})
)

# 优先真实导入 image_tools;仅当精简环境缺可选依赖(google.genai 链路)时
# 才注入最小 stub。stub 只有 generate_image 属性,会污染同进程后续测试
# (test_tool_env_tip_reads 需要真实的 _get_vision_api_credentials),
# 因此必须真实导入优先、失败兜底。
try:
    from jiuwenswarm.agents.harness.common.tools import image_tools  # noqa: F401
except ImportError:
    image_tools = types.ModuleType(
        "jiuwenswarm.agents.harness.common.tools.image_tools"
    )
    image_tools.generate_image = MagicMock()
    sys.modules["jiuwenswarm.agents.harness.common.tools.image_tools"] = image_tools

from jiuwenswarm.server.runtime.agent_adapter.interface_deep import (  # noqa: E402
    JiuWenSwarmDeepAdapter,
)
from jiuwenswarm.server.runtime.enterprise_config.schemas import (  # noqa: E402
    EffectiveEnterpriseConfig,
    RoutingContext,
)


def _adapter_with_cached_enterprise() -> JiuWenSwarmDeepAdapter:
    adapter = object.__new__(JiuWenSwarmDeepAdapter)
    adapter._enterprise_config = EffectiveEnterpriseConfig(
        routing=RoutingContext(group_id="g1", bot_id="b1", user_id="u1"),
        mcp=[
            {
                "template_id": "t1",
                "enabled": True,
                "mcp_entry": {
                    "name": "keep-me",
                    "transport": "sse",
                    "url": "http://127.0.0.1:9000/sse",
                    "enabled": True,
                },
            }
        ],
    )
    adapter._agent_permissions_body = None
    adapter._skill_manager = None
    return adapter


@pytest.mark.asyncio
async def test_refresh_enterprise_config_restores_cache_when_load_fails(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    monkeypatch.setenv("JIUWENSWARM_EDITION", "enterprise")
    monkeypatch.setenv("JIUWENSWARM_CONFIG_SOURCE", "enterprise")
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.agent_adapter.interface_deep.is_enterprise",
        lambda: True,
    )
    adapter = _adapter_with_cached_enterprise()
    cached = adapter._enterprise_config

    async def _boom(_request):
        # 模拟旧实现「先清后载」:加载失败前已把缓存冲掉。
        adapter._enterprise_config = None
        raise TimeoutError("gateway db unavailable")

    monkeypatch.setattr(adapter, "_load_enterprise_config", _boom)

    await adapter._refresh_enterprise_config_for_reload()

    assert adapter._enterprise_config is cached
    assert adapter._enterprise_config is not None
    assert len(adapter._enterprise_config.mcp) == 1


@pytest.mark.parametrize("with_permission_rail", [False, True])
def test_skill_authorization_rail_uses_agent_template_without_request_context(
    monkeypatch: pytest.MonkeyPatch,
    with_permission_rail: bool,
) -> None:
    from jiuwenswarm.server.runtime.agent_adapter import interface_deep

    monkeypatch.setenv("SKILL_AUTHORIZATION_ENABLED", "false")
    monkeypatch.setattr(
        interface_deep,
        "get_effective_permissions_config",
        lambda **_kwargs: {
            "enabled": True,
            "skill_authorization": {"enabled": False},
            "defaults": {"*": "allow"},
        },
    )
    adapter = object.__new__(JiuWenSwarmDeepAdapter)
    adapter._agent_permissions_body = {
        "enabled": True,
        "skill_authorization": {"enabled": True},
        "defaults": {"*": "ask"},
    }
    adapter._enterprise_config = None
    adapter._permission_rail = None
    adapter._skill_rail = None
    adapter._instance = object()
    if with_permission_rail:
        from jiuwenswarm.agents.harness.common.rails.permissions.skill_authorization_permission_rail import (
            SkillAuthorizationPermissionRail,
        )
        adapter._permission_rail = SkillAuthorizationPermissionRail(
            config=adapter._agent_permissions_body,
        )

    rail = adapter._build_skill_authorization_rail()

    assert rail is not None
    assert rail._feature_enabled() is True
    base = rail._base_effective_config("session-1")
    if with_permission_rail:
        # Permission rail registers the agent template on its Manager key.
        assert base["defaults"] == {"*": "ask"}
        ctx = SimpleNamespace(agent=adapter._instance, session=SimpleNamespace(session_id="session-1"))
        assert adapter._permission_rail._skill_scope_resolver(ctx) == ("session-1", "main")
    else:
        # Without a rail key, Manager default is empty; provider still exposes template.
        assert rail._config_provider()["defaults"] == {"*": "ask"}
        assert "defaults" not in base or base.get("defaults") != {"*": "ask"}


def test_skill_permission_fallback_is_bound_to_owning_agent() -> None:
    from jiuwenswarm.agents.harness.common.rails.permissions.skill_authorization_permission_rail import (
        SkillAuthorizationPermissionRail,
    )

    adapter = object.__new__(JiuWenSwarmDeepAdapter)
    adapter._instance = SimpleNamespace(react_agent=object())
    permission_rail = SkillAuthorizationPermissionRail(config={"enabled": True})
    gate = SimpleNamespace(
        resolve_scope=MagicMock(return_value=("session-1", "main")),
        set_permission_key_resolver=lambda _resolver: None,
    )
    adapter._bind_skill_permission_scope_resolver(permission_rail, gate)

    main_ctx = SimpleNamespace(agent=adapter._instance)
    assert permission_rail._skill_scope_resolver(main_ctx) == ("session-1", "main")
    gate.resolve_scope.assert_called_once_with(main_ctx)
    assert permission_rail._skill_scope_resolver(
        SimpleNamespace(agent=adapter._instance.react_agent)
    ) == ("session-1", "main")
    # The same rail may be inherited by a child that shares the approval session.
    assert permission_rail._skill_scope_resolver(SimpleNamespace(agent=object())) is None
    assert permission_rail._skill_scope_resolver(SimpleNamespace(agent=None)) is None
    assert gate.resolve_scope.call_count == 2


def test_hot_reload_binds_new_permission_rail_to_existing_skill_gate(monkeypatch) -> None:
    from jiuwenswarm.server.runtime.agent_adapter import interface_deep
    from jiuwenswarm.agents.harness.common.rails.permissions.skill_authorization_permission_rail import (
        SkillAuthorizationPermissionRail,
    )

    adapter = object.__new__(JiuWenSwarmDeepAdapter)
    adapter._instance = object()
    adapter._permission_rail = None
    adapter._agent_permissions_body = {"enabled": True}
    adapter._skill_authorization_rail = SimpleNamespace(
        _engine=None,
        resolve_scope=lambda _ctx: ("session-1", "main"),
        set_permission_key_resolver=lambda _resolver: None,
    )
    adapter._resolve_permission_config_for_agent = lambda **_kwargs: {"enabled": True}
    adapter._model = None
    permission_rail = SkillAuthorizationPermissionRail(config={"enabled": True})
    monkeypatch.setattr(interface_deep, "build_permission_rail", lambda **_kwargs: permission_rail)

    adapter._update_permission_rail({})

    assert adapter._permission_rail is permission_rail
    # Skill gate shares the permission_key after rail rebuild (engine removed).
    assert getattr(adapter._skill_authorization_rail, "_permission_key", None) in (
        None,
        "default",
        permission_rail.permission_key,
    )
    assert permission_rail._skill_scope_resolver(SimpleNamespace(agent=adapter._instance)) == (
        "session-1", "main",
    )


@pytest.mark.asyncio
async def test_load_enterprise_config_keeps_cache_when_gateway_raises(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    monkeypatch.setenv("JIUWENSWARM_EDITION", "enterprise")
    monkeypatch.setenv("JIUWENSWARM_CONFIG_SOURCE", "enterprise")
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.agent_adapter.interface_deep.is_enterprise",
        lambda: True,
    )
    adapter = _adapter_with_cached_enterprise()
    cached = adapter._enterprise_config

    async def _raise_load(*_args, **_kwargs):
        raise TimeoutError("gateway db unavailable")

    import jiuwenswarm.server.runtime.enterprise_config as enterprise_config_mod

    monkeypatch.setattr(
        enterprise_config_mod,
        "load_effective_enterprise_config",
        _raise_load,
    )

    request = SimpleNamespace(
        request_id="r1",
        channel_id="web",
        metadata={"routing": {"group_id": "g1", "bot_id": "b1", "user_id": "u1"}},
        params={},
        user_id="u1",
    )

    with pytest.raises(TimeoutError):
        await adapter._load_enterprise_config(request)

    assert adapter._enterprise_config is cached


@pytest.mark.asyncio
async def test_merge_clears_mcp_only_when_enterprise_config_is_none(
    monkeypatch: pytest.MonkeyPatch,
) -> None:
    monkeypatch.setenv("JIUWENSWARM_EDITION", "enterprise")
    monkeypatch.setattr(
        "jiuwenswarm.server.runtime.agent_adapter.interface_deep.is_enterprise",
        lambda: True,
    )
    adapter = _adapter_with_cached_enterprise()
    config_base = {
        "mcp": {
            "servers": [
                {
                    "name": "local-demo",
                    "transport": "stdio",
                    "command": "echo",
                    "enabled": True,
                }
            ]
        }
    }

    kept = adapter._merge_enterprise_mcp_into_config(config_base)
    assert {item["name"] for item in kept["mcp"]["servers"]} == {"keep-me"}

    adapter._enterprise_config = None
    cleared = adapter._merge_enterprise_mcp_into_config(config_base)
    assert cleared["mcp"]["servers"] == []