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
7.6 KB
Raw Blame
# Copyright (c) Huawei Technologies Co., Ltd. 2026. All rights reserved.
from __future__ import annotations

import json

import pytest

from jiuwenswarm.common.work_mode import (
    DEFAULT_PROJECT_ID_WORK,
    DEFAULT_WEB_WORK_MODE,
    is_default_project_id,
    normalize_work_mode,
    resolve_default_project_id,
)
from jiuwenswarm.gateway.cron.models import CronJob
from jiuwenswarm.server.runtime.session.project_store import Project
from jiuwenswarm.server.runtime.session.work_mode import (
    DEFAULT_TUI_WORK_MODE,
    default_work_mode_for_channel,
    infer_legacy_project_work_mode,
    resolve_request_work_mode,
    resolve_session_work_mode_params,
)


class TestPureHelpers:
    @pytest.mark.parametrize("fn, arg, expected", [
        (normalize_work_mode, "WORK", "work"),
        (normalize_work_mode, "cod", DEFAULT_WEB_WORK_MODE),
        (is_default_project_id, "default", True),
        (is_default_project_id, "proj_abc", False),
        (resolve_default_project_id, "work", DEFAULT_PROJECT_ID_WORK),
        (default_work_mode_for_channel, "tui", DEFAULT_TUI_WORK_MODE),
    ])
    def test_pure_helpers(self, fn, arg, expected):
        assert fn(arg) == expected


class TestRequestResolution:
    @pytest.mark.parametrize("params, channel, expected_value, expected_error", [
        ({}, "web", "work", None),
        ({"work_mode": "code"}, "web", "code", None),
        ({"work_mode": "cod"}, "web", None, "BAD_REQUEST"),
    ])
    def test_resolve_request_work_mode(self, params, channel, expected_value, expected_error):
        value, error = resolve_request_work_mode(params, channel)
        assert value == expected_value
        assert error == expected_error

    @pytest.mark.parametrize("data, expected", [
        ({"work_mode": "code"}, "code"),
        ({"name": "demo"}, "work"),
    ])
    def test_infer_legacy_project_work_mode(self, data, expected):
        assert infer_legacy_project_work_mode(data) == expected

    @pytest.mark.parametrize("params, channel_id, expected_pid, expected_mode", [
        ({}, "web", "default", "work"),
        ({"project_id": "default_code"}, "tui", "default_code", "code"),
    ])
    def test_default_project_mapping(self, params, channel_id, expected_pid, expected_mode):
        result = resolve_session_work_mode_params(params, channel_id=channel_id)
        assert result.project_id == expected_pid
        assert result.work_mode == expected_mode
        assert result.error is None

    def test_invalid_work_mode_returns_bad_request(self):
        result = resolve_session_work_mode_params({"work_mode": "invalid"}, channel_id="web")
        assert result.code == "BAD_REQUEST"
        assert result.project_id == ""
        assert result.work_mode == ""

    @pytest.mark.parametrize("project_id, expected_pid, expected_mode", [
        (None, "default", "work"),
        ("default", "default", "work"),
        ("default_code", "default_code", "code"),
    ])
    def test_default_project_preserves_project_dir(self, project_id, expected_pid, expected_mode):
        # 纯参数归一化,不直接拒绝;project_dir 透传给 resolve_session_project_binding
        params = {"project_dir": "/tmp/demo"}
        if project_id is not None:
            params["project_id"] = project_id
        result = resolve_session_work_mode_params(params, channel_id="web")
        assert result.project_id == expected_pid
        assert result.project_dir == "/tmp/demo"
        assert result.work_mode == expected_mode
        assert result.error is None


class TestModelRoundtrip:
    @pytest.mark.parametrize("raw, expected_work_mode, expected_git", [
        ({"project_id": "proj_1", "name": "demo", "project_dir": "/tmp/demo"}, "work", {}),
        ({"project_id": "proj_2", "name": "c", "project_dir": "/tmp/c", "work_mode": "code"}, "code", {}),
        ({"project_id": "proj_3", "name": "c", "project_dir": "/tmp/c", "git": {"enabled": True, "branch": "main"}},
         "work", {"enabled": True, "branch": "main"}),
    ])
    def test_project_from_dict(self, raw, expected_work_mode, expected_git):
        p = Project.from_dict(raw)
        assert p.work_mode == expected_work_mode
        assert p.git == expected_git

    def test_project_and_cronjob_roundtrip(self):
        p = Project(project_id="proj_6", name="demo", project_dir="/tmp/demo",
                    work_mode="code", git={"enabled": True, "branch": "dev"})
        d = p.to_dict()
        assert d["work_mode"] == "code"
        assert d["git"] == {"enabled": True, "branch": "dev"}
        assert Project.from_dict(d).git == {"enabled": True, "branch": "dev"}

        base_job = {"id": "j1", "name": "n", "enabled": True, "cron_expr": "0 0 * * *",
                    "timezone": "UTC", "description": "d", "targets": "web"}
        assert CronJob.from_dict(dict(base_job)).to_dict()["work_mode"] == "work"
        raw_code = dict(base_job, work_mode="code")
        assert CronJob.from_dict(raw_code).to_dict()["work_mode"] == "code"

    @pytest.mark.parametrize("raw_overrides, expected_work_mode", [
        ({}, "work"),
        ({"work_mode": "invalid"}, "work"),
        ({"work_mode": "code"}, "code"),
    ])
    def test_cronjob_from_dict(self, raw_overrides, expected_work_mode):
        base = {"id": "j1", "name": "n", "enabled": True, "cron_expr": "0 0 * * *",
                "timezone": "UTC", "description": "d", "targets": "web"}
        cj = CronJob.from_dict({**base, **raw_overrides})
        assert cj.work_mode == expected_work_mode


class TestSessionMetadataWorkMode:
    @pytest.fixture()
    def sessions_dir(self, tmp_path, monkeypatch):
        d = tmp_path / "sessions"
        d.mkdir()
        monkeypatch.setattr(
            "jiuwenswarm.server.runtime.session.session_metadata.get_agent_sessions_dir",
            lambda: d,
        )
        from jiuwenswarm.server.runtime.session.session_metadata import _METADATA_CACHE
        _METADATA_CACHE.clear()
        return d

    def _drain_queue(self):
        from jiuwenswarm.server.runtime.session.session_metadata import _METADATA_QUEUE
        _METADATA_QUEUE.join()

    @pytest.mark.parametrize("channel_id, work_mode, expected", [
        ("web", "code", "code"),
        ("web", None, "work"),
    ])
    def test_init_work_mode(self, sessions_dir, channel_id, work_mode, expected):
        from jiuwenswarm.server.runtime.session.session_metadata import (
            get_session_metadata, init_session_metadata,
        )
        init_session_metadata(session_id=f"sess_{channel_id}", channel_id=channel_id, work_mode=work_mode)
        assert get_session_metadata(f"sess_{channel_id}")["work_mode"] == expected

    def test_update_first_lock_and_repair(self, sessions_dir):
        from jiuwenswarm.server.runtime.session.session_metadata import (
            get_session_metadata, init_session_metadata, update_session_metadata,
        )
        init_session_metadata(session_id="sess_lock", channel_id="web", work_mode="code")
        update_session_metadata(session_id="sess_lock", work_mode="work")
        self._drain_queue()
        # 首次 init 后 update 不可覆盖 work_mode(锁定语义)
        assert get_session_metadata("sess_lock")["work_mode"] == "code"

        # 损坏数据(cod 非法值)由 update 修复
        sid = "sess_repair"
        meta_path = sessions_dir / sid / "metadata.json"
        meta_path.parent.mkdir()
        meta_path.write_text(json.dumps({
            "session_id": sid, "channel_id": "web",
            "project_dir": "", "project_id": "", "work_mode": "cod",
        }), encoding="utf-8")
        update_session_metadata(session_id=sid, channel_id="web", work_mode="code")
        self._drain_queue()
        assert get_session_metadata(sid, cache_bust=True)["work_mode"] == "code"