Files
qwenpaw/tests/unit/app/routers/test_workspace_router.py
agent-radar 1a3a4ccde1
Creator App Tests / PR Spam Gate (push) Skipped
Frontend Tests / PR Spam Gate (push) Skipped
NPM Format (website & console) / PR Spam Gate (push) Skipped
Pre-commit Checks / PR Spam Gate (push) Skipped
QwenPaw Creator Plugin Release / check-version (push) Canceled after 0s
QwenPaw Creator Plugin Release / upload-oss (push) Canceled after 0s
Tests / PR Spam Gate (push) Skipped
CodeQL / CodeQL (python) (push) Canceled after 0s
CodeQL / CodeQL (typescript) (push) Canceled after 0s
Creator App Tests / Creator Backend Tests (push) Canceled after 0s
Creator App Tests / Creator UI Build & Tests (push) Canceled after 0s
E2E Smoke Tests / Playwright UI Smoke (push) Canceled after 0s
Frontend Tests / Detect console changes (push) Canceled after 0s
NPM Format (website & console) / website format check (push) Canceled after 0s
NPM Format (website & console) / console format check (push) Canceled after 0s
Pre-commit Checks / Pre-commit (push) Canceled after 0s
QwenPaw Data Plugin Release / check-version (push) Canceled after 0s
Tests / Detect code changes (push) Canceled after 0s
Frontend Tests / Vitest Unit Tests (push) Canceled after 0s
Frontend Tests / Frontend Summary (push) Canceled after 0s
QwenPaw Data Plugin Release / upload-oss (push) Canceled after 0s
Tests / Maintainer Approval (push) Canceled after 0s
Tests / Unit Tests - py3.11 - macos-latest (push) Canceled after 0s
Tests / Unit Tests - py3.11 - ubuntu-latest (push) Canceled after 0s
Tests / Unit Tests - py3.13 - ubuntu-latest (push) Canceled after 0s
Tests / Unit Tests - py3.11 - windows-latest (push) Canceled after 0s
Tests / Contract Tests - py3.11 - macos-latest (push) Canceled after 0s
Tests / Contract Tests - py3.11 - ubuntu-latest (push) Canceled after 0s
Tests / Contract Tests - py3.13 - ubuntu-latest (push) Canceled after 0s
Tests / Contract Tests - py3.11 - windows-latest (push) Canceled after 0s
Tests / Integrated Tests - py3.11 - macos-latest - p0 (push) Canceled after 0s
Tests / Integrated Tests - py3.11 - macos-latest - p1 (push) Canceled after 0s
Tests / Integrated Tests - py3.11 - macos-latest - p2 (push) Canceled after 0s
Tests / Integrated Tests - py3.11 - ubuntu-latest - fallback (push) Canceled after 0s
Tests / Integrated Tests - py3.11 - ubuntu-latest - p0 (push) Canceled after 0s
Tests / Integrated Tests - py3.11 - ubuntu-latest - p1 (push) Canceled after 0s
Tests / Integrated Tests - py3.11 - ubuntu-latest - p2 (push) Canceled after 0s
Tests / Integrated Tests - py3.13 - ubuntu-latest - p0 (push) Canceled after 0s
Tests / Integrated Tests - py3.13 - ubuntu-latest - p1 (push) Canceled after 0s
Tests / Integrated Tests - py3.13 - ubuntu-latest - p2 (push) Canceled after 0s
Tests / Integrated Tests - py3.11 - windows-latest - p0 (push) Canceled after 0s
Tests / Integrated Tests - py3.11 - windows-latest - p1 (push) Canceled after 0s
Tests / Integrated Tests - py3.11 - windows-latest - p2 (push) Canceled after 0s
Tests / Coverage Report (push) Canceled after 0s
Tests / Test Summary (push) Canceled after 0s
源码快照 @ 2026-09-01 (source-only, 剔除非源码素材)
2026-09-01 20:01:50 +08:00

686 lines
22 KiB
Python

# -*- coding: utf-8 -*-
"""Focused unit tests for workspace running-config update ordering."""
import asyncio
from types import SimpleNamespace
from unittest.mock import AsyncMock, MagicMock, patch
import pytest
from fastapi import HTTPException
from qwenpaw.app.routers.workspace import (
_ConfigRollbackConflict,
_conditionally_restore_config_changes,
put_agents_running_config,
)
from qwenpaw.config import AgentsRunningConfig
from qwenpaw.config.config import AgentProfileConfig
def _embedding_update_configs():
old_running = AgentsRunningConfig()
new_running = old_running.model_copy(deep=True)
old_embedding = old_running.reme_light_memory_config.embedding_model_config
new_embedding = new_running.reme_light_memory_config.embedding_model_config
old_embedding.api_key = "old-key"
old_embedding.model_name = "old-model"
new_embedding.api_key = "new-key"
new_embedding.model_name = "new-model"
return old_running, new_running
def _config_transaction(
agent_config: AgentProfileConfig,
*,
events: list[str] | None = None,
error: Exception | None = None,
) -> AsyncMock:
async def update(_agent_id, updater):
updater(agent_config)
if error is not None:
raise error
if events is not None:
events.append("save")
return agent_config
return AsyncMock(side_effect=update)
@pytest.mark.asyncio
@pytest.mark.parametrize("old_backend", ["none", "adbpg"])
async def test_backend_switch_to_remelight_skips_old_manager_embedding_update(
old_backend: str,
) -> None:
old_running, new_running = _embedding_update_configs()
old_running.memory_manager_backend = old_backend
new_running.memory_manager_backend = "remelight"
old_manager = SimpleNamespace()
workspace = SimpleNamespace(agent_id="bot", memory_manager=old_manager)
agent_config = AgentProfileConfig(
id="bot",
name="Bot",
running=old_running,
)
transaction = _config_transaction(agent_config)
with (
patch(
"qwenpaw.app.routers.workspace.get_agent_for_request",
AsyncMock(return_value=workspace),
),
patch(
"qwenpaw.app.routers.workspace.update_agent_config_async",
transaction,
),
patch(
"qwenpaw.app.routers.workspace.schedule_agent_reload",
) as schedule_reload,
):
response = await put_agents_running_config(new_running, MagicMock())
assert response.memory_manager_backend == "remelight"
assert agent_config.running == new_running
assert transaction.await_count == 1
schedule_reload.assert_called_once()
@pytest.mark.asyncio
@pytest.mark.parametrize(
("old_backend", "new_backend"),
[
("none", "remelight"),
("adbpg", "remelight"),
("remelight", "none"),
],
)
async def test_backend_only_switch_persists_and_schedules_reload(
old_backend: str,
new_backend: str,
) -> None:
old_running = AgentsRunningConfig(memory_manager_backend=old_backend)
new_running = old_running.model_copy(deep=True)
new_running.memory_manager_backend = new_backend
workspace = SimpleNamespace(
agent_id="bot",
memory_manager=SimpleNamespace(),
)
agent_config = AgentProfileConfig(
id="bot",
name="Bot",
running=old_running,
)
with (
patch(
"qwenpaw.app.routers.workspace.get_agent_for_request",
AsyncMock(return_value=workspace),
),
patch(
"qwenpaw.app.routers.workspace.update_agent_config_async",
_config_transaction(agent_config),
),
patch(
"qwenpaw.app.routers.workspace.schedule_agent_reload",
) as schedule_reload,
):
response = await put_agents_running_config(new_running, MagicMock())
assert response.memory_manager_backend == new_backend
assert agent_config.running.memory_manager_backend == new_backend
schedule_reload.assert_called_once()
@pytest.mark.asyncio
async def test_remelight_switch_skips_embedding_hot_update() -> None:
old_running, new_running = _embedding_update_configs()
new_running.memory_manager_backend = "none"
memory_manager = MagicMock()
memory_manager.apply_tested_embedding = AsyncMock(return_value=True)
memory_manager.reload_embedding_config = AsyncMock(return_value=True)
workspace = SimpleNamespace(
agent_id="bot",
memory_manager=memory_manager,
)
agent_config = AgentProfileConfig(
id="bot",
name="Bot",
running=old_running,
)
with (
patch(
"qwenpaw.app.routers.workspace.get_agent_for_request",
AsyncMock(return_value=workspace),
),
patch(
"qwenpaw.app.routers.workspace.update_agent_config_async",
_config_transaction(agent_config),
),
patch(
"qwenpaw.app.routers.workspace.schedule_agent_reload",
) as schedule_reload,
):
response = await put_agents_running_config(new_running, MagicMock())
assert response.memory_manager_backend == "none"
memory_manager.apply_tested_embedding.assert_not_awaited()
memory_manager.reload_embedding_config.assert_not_awaited()
schedule_reload.assert_called_once()
def test_embedding_rollback_preserves_unrelated_concurrent_changes() -> None:
old_running, new_running = _embedding_update_configs()
before = AgentProfileConfig(id="bot", name="Bot", running=old_running)
submitted = before.model_copy(deep=True)
submitted.running = new_running
current = submitted.model_copy(deep=True)
current.language = "zh"
_conditionally_restore_config_changes(current, before, submitted)
assert current.language == "zh"
assert current.running.reme_light_memory_config.embedding_model_config == (
old_running.reme_light_memory_config.embedding_model_config
)
def test_embedding_rollback_detects_a_concurrent_same_field_change() -> None:
old_running, new_running = _embedding_update_configs()
before = AgentProfileConfig(id="bot", name="Bot", running=old_running)
submitted = before.model_copy(deep=True)
submitted.running = new_running
current = submitted.model_copy(deep=True)
embedding_config = (
current.running.reme_light_memory_config.embedding_model_config
)
embedding_config.model_name = "third-model"
with pytest.raises(_ConfigRollbackConflict) as exc_info:
_conditionally_restore_config_changes(current, before, submitted)
assert any("model_name" in path for path in exc_info.value.paths)
@pytest.mark.asyncio
async def test_running_config_persists_before_embedding_hot_update() -> None:
old_running, new_running = _embedding_update_configs()
new_running.max_iters += 1
events: list[str] = []
async def apply_embedding(_config):
events.append("apply")
return True
memory_manager = MagicMock()
memory_manager.apply_tested_embedding = AsyncMock(
side_effect=apply_embedding,
)
workspace = SimpleNamespace(
agent_id="bot",
memory_manager=memory_manager,
)
agent_config = AgentProfileConfig(
id="bot",
name="Bot",
running=old_running,
)
with (
patch(
"qwenpaw.app.routers.workspace.get_agent_for_request",
AsyncMock(return_value=workspace),
),
patch(
"qwenpaw.app.routers.workspace.update_agent_config_async",
_config_transaction(agent_config, events=events),
),
patch(
"qwenpaw.app.routers.workspace.schedule_agent_reload",
) as schedule_reload,
):
response = await put_agents_running_config(
new_running,
MagicMock(),
)
assert events == ["save", "apply"]
assert response is new_running
assert response.reme_light_memory_config.needs_reindex is True
previous = (
response.reme_light_memory_config.pending_reindex_embedding_config
)
assert previous is not None
assert previous.model_name == (
old_running.reme_light_memory_config.embedding_model_config.model_name
)
schedule_reload.assert_called_once()
@pytest.mark.asyncio
async def test_save_cancel_after_persist_completes_runtime() -> None:
# pylint: disable=protected-access
old_running, new_running = _embedding_update_configs()
old_embedding = old_running.reme_light_memory_config.embedding_model_config
new_embedding = new_running.reme_light_memory_config.embedding_model_config
live_gate = AsyncMock()
async def apply_embedding(_config):
await live_gate()
return True
memory_manager = MagicMock()
memory_manager._active_embedding_config = old_embedding.model_copy(
deep=True,
)
memory_manager._reme = SimpleNamespace(is_started=True)
memory_manager.apply_tested_embedding = AsyncMock(
side_effect=apply_embedding,
)
workspace = SimpleNamespace(agent_id="bot", memory_manager=memory_manager)
agent_config = AgentProfileConfig(
id="bot",
name="Bot",
running=old_running,
)
caller = asyncio.current_task()
assert caller is not None
request = MagicMock()
async def update_config(_agent_id, updater):
updater(agent_config)
caller.cancel()
return agent_config
with (
patch(
"qwenpaw.app.routers.workspace.get_agent_for_request",
AsyncMock(return_value=workspace),
),
patch(
"qwenpaw.app.routers.workspace.update_agent_config_async",
side_effect=update_config,
),
patch(
"qwenpaw.app.routers.workspace.schedule_agent_reload",
) as schedule_reload,
pytest.raises(asyncio.CancelledError),
):
await put_agents_running_config(new_running, request)
assert agent_config.running == new_running
memory_config = agent_config.running.reme_light_memory_config
assert memory_config.needs_reindex is True
assert memory_config.pending_reindex_embedding_config == old_embedding
# The active config still describes the indexed vector space until the
# rebuild completes; the live gate prevents reads from that old space.
assert memory_manager._active_embedding_config == old_embedding
assert memory_manager._reme.is_started is True
live_gate.assert_awaited_once_with()
memory_manager.apply_tested_embedding.assert_awaited_once_with(
new_embedding,
)
schedule_reload.assert_called_once_with(request, "bot")
@pytest.mark.asyncio
async def test_api_key_change_does_not_require_reindex() -> None:
old_running = AgentsRunningConfig()
new_running = old_running.model_copy(deep=True)
old_running.reme_light_memory_config.embedding_model_config.api_key = "old"
new_running.reme_light_memory_config.embedding_model_config.api_key = "new"
memory_manager = MagicMock()
memory_manager.apply_tested_embedding = AsyncMock(return_value=True)
workspace = SimpleNamespace(agent_id="bot", memory_manager=memory_manager)
agent_config = AgentProfileConfig(
id="bot",
name="Bot",
running=old_running,
)
with (
patch(
"qwenpaw.app.routers.workspace.get_agent_for_request",
AsyncMock(return_value=workspace),
),
patch(
"qwenpaw.app.routers.workspace.update_agent_config_async",
_config_transaction(agent_config),
),
patch("qwenpaw.app.routers.workspace.schedule_agent_reload"),
):
response = await put_agents_running_config(new_running, MagicMock())
assert response.reme_light_memory_config.needs_reindex is False
@pytest.mark.asyncio
async def test_restoring_indexed_config_clears_reindex_requirement() -> None:
old_running, _ = _embedding_update_configs()
indexed = old_running.reme_light_memory_config.embedding_model_config
pending_running = old_running.model_copy(deep=True)
pending_memory = pending_running.reme_light_memory_config
pending_memory.embedding_model_config.model_name = "pending-model"
pending_memory.needs_reindex = True
pending_memory.pending_reindex_embedding_config = indexed.model_copy(
deep=True,
)
restored_running = pending_running.model_copy(deep=True)
restored_running.reme_light_memory_config.embedding_model_config = (
indexed.model_copy(deep=True)
)
memory_manager = MagicMock()
memory_manager.apply_tested_embedding = AsyncMock(return_value=True)
memory_manager.reload_embedding_config = AsyncMock(return_value=True)
workspace = SimpleNamespace(agent_id="bot", memory_manager=memory_manager)
agent_config = AgentProfileConfig(
id="bot",
name="Bot",
running=pending_running,
)
with (
patch(
"qwenpaw.app.routers.workspace.get_agent_for_request",
AsyncMock(return_value=workspace),
),
patch(
"qwenpaw.app.routers.workspace.update_agent_config_async",
_config_transaction(agent_config),
),
patch("qwenpaw.app.routers.workspace.schedule_agent_reload"),
):
response = await put_agents_running_config(
restored_running,
MagicMock(),
)
memory_config = response.reme_light_memory_config
assert memory_config.needs_reindex is False
assert memory_config.pending_reindex_embedding_config is None
memory_manager.apply_tested_embedding.assert_not_awaited()
memory_manager.reload_embedding_config.assert_awaited_once_with()
@pytest.mark.asyncio
async def test_running_config_save_failure_does_not_touch_runtime() -> None:
old_running, new_running = _embedding_update_configs()
memory_manager = MagicMock()
memory_manager.apply_tested_embedding = AsyncMock(return_value=True)
workspace = SimpleNamespace(
agent_id="bot",
memory_manager=memory_manager,
)
agent_config = AgentProfileConfig(
id="bot",
name="Bot",
running=old_running,
)
with (
patch(
"qwenpaw.app.routers.workspace.get_agent_for_request",
AsyncMock(return_value=workspace),
),
patch(
"qwenpaw.app.routers.workspace.update_agent_config_async",
_config_transaction(
agent_config,
error=OSError("disk full"),
),
),
patch(
"qwenpaw.app.routers.workspace.schedule_agent_reload",
) as schedule_reload,
):
with pytest.raises(OSError, match="disk full"):
await put_agents_running_config(new_running, MagicMock())
memory_manager.apply_tested_embedding.assert_not_awaited()
schedule_reload.assert_not_called()
@pytest.mark.asyncio
async def test_hot_update_exception_rolls_back_before_reload() -> None:
old_running, new_running = _embedding_update_configs()
events: list[str] = []
async def apply_embedding(_config):
events.append("apply")
raise RuntimeError("index rebuild failed")
async def reload_embedding() -> bool:
events.append("reme-reload")
return True
memory_manager = MagicMock()
memory_manager.apply_tested_embedding = AsyncMock(
side_effect=apply_embedding,
)
memory_manager.reload_embedding_config = AsyncMock(
side_effect=reload_embedding,
)
workspace = SimpleNamespace(
agent_id="bot",
memory_manager=memory_manager,
)
agent_config = AgentProfileConfig(
id="bot",
name="Bot",
running=old_running,
)
def schedule_reload(_request, _agent_id):
events.append("reload")
with (
patch(
"qwenpaw.app.routers.workspace.get_agent_for_request",
AsyncMock(return_value=workspace),
),
patch(
"qwenpaw.app.routers.workspace.update_agent_config_async",
_config_transaction(agent_config, events=events),
),
patch(
"qwenpaw.app.routers.workspace.schedule_agent_reload",
side_effect=schedule_reload,
),
pytest.raises(HTTPException) as exc_info,
):
await put_agents_running_config(
new_running,
MagicMock(),
)
assert exc_info.value.status_code == 503
assert events == ["save", "apply", "save", "reme-reload"]
assert agent_config.running == old_running
@pytest.mark.asyncio
async def test_embedding_update_is_rejected_while_reindexing() -> None:
old_running, new_running = _embedding_update_configs()
memory_manager = MagicMock()
memory_manager.is_reindexing = True
memory_manager.apply_tested_embedding = AsyncMock()
workspace = SimpleNamespace(agent_id="bot", memory_manager=memory_manager)
agent_config = AgentProfileConfig(
id="bot",
name="Bot",
running=old_running,
)
transaction = _config_transaction(agent_config)
with (
patch(
"qwenpaw.app.routers.workspace.get_agent_for_request",
AsyncMock(return_value=workspace),
),
patch(
"qwenpaw.app.routers.workspace.update_agent_config_async",
transaction,
),
):
with pytest.raises(HTTPException) as exc_info:
await put_agents_running_config(new_running, MagicMock())
assert exc_info.value.status_code == 409
memory_manager.apply_tested_embedding.assert_not_awaited()
@pytest.mark.asyncio
async def test_failed_runtime_update_rolls_back_and_returns_503() -> None:
old_running, new_running = _embedding_update_configs()
events: list[str] = []
async def apply_embedding(_config):
events.append("apply")
return False
reload_results = iter([False, True])
async def reload_embedding() -> bool:
events.append("reme-reload")
return next(reload_results)
memory_manager = MagicMock()
memory_manager.apply_tested_embedding = AsyncMock(
side_effect=apply_embedding,
)
memory_manager.reload_embedding_config = AsyncMock(
side_effect=reload_embedding,
)
workspace = SimpleNamespace(agent_id="bot", memory_manager=memory_manager)
agent_config = AgentProfileConfig(
id="bot",
name="Bot",
running=old_running,
)
with (
patch(
"qwenpaw.app.routers.workspace.get_agent_for_request",
AsyncMock(return_value=workspace),
),
patch(
"qwenpaw.app.routers.workspace.update_agent_config_async",
_config_transaction(agent_config, events=events),
),
patch(
"qwenpaw.app.routers.workspace.schedule_agent_reload",
) as schedule_reload,
):
with pytest.raises(HTTPException) as exc_info:
await put_agents_running_config(new_running, MagicMock())
assert exc_info.value.status_code == 503
assert exc_info.value.detail["runtime_restored"] is True
assert events == [
"save",
"apply",
"reme-reload",
"save",
"reme-reload",
]
schedule_reload.assert_not_called()
@pytest.mark.asyncio
async def test_failed_runtime_update_preserves_concurrent_change() -> None:
old_running, new_running = _embedding_update_configs()
persisted = AgentProfileConfig(
id="bot",
name="Bot",
running=old_running,
)
update_count = 0
async def update_config(_agent_id, updater):
nonlocal persisted, update_count
current = persisted.model_copy(deep=True)
updater(current)
persisted = current.model_copy(deep=True)
update_count += 1
if update_count == 1:
persisted.language = "zh"
return current
memory_manager = MagicMock()
memory_manager.apply_tested_embedding = AsyncMock(return_value=False)
memory_manager.reload_embedding_config = AsyncMock(
side_effect=[False, True],
)
workspace = SimpleNamespace(agent_id="bot", memory_manager=memory_manager)
with (
patch(
"qwenpaw.app.routers.workspace.get_agent_for_request",
AsyncMock(return_value=workspace),
),
patch(
"qwenpaw.app.routers.workspace.update_agent_config_async",
side_effect=update_config,
),
patch("qwenpaw.app.routers.workspace.schedule_agent_reload"),
):
with pytest.raises(HTTPException) as exc_info:
await put_agents_running_config(new_running, MagicMock())
assert exc_info.value.status_code == 503
assert persisted.language == "zh"
assert persisted.running == old_running
@pytest.mark.asyncio
async def test_failed_runtime_update_reports_rollback_conflict() -> None:
old_running, new_running = _embedding_update_configs()
persisted = AgentProfileConfig(
id="bot",
name="Bot",
running=old_running,
)
update_count = 0
async def update_config(_agent_id, updater):
nonlocal persisted, update_count
current = persisted.model_copy(deep=True)
updater(current)
persisted = current.model_copy(deep=True)
update_count += 1
if update_count == 1:
memory_config = persisted.running.reme_light_memory_config
embedding_config = memory_config.embedding_model_config
embedding_config.model_name = "third-model"
return current
memory_manager = MagicMock()
memory_manager.apply_tested_embedding = AsyncMock(return_value=False)
memory_manager.reload_embedding_config = AsyncMock(
side_effect=[False, True],
)
workspace = SimpleNamespace(agent_id="bot", memory_manager=memory_manager)
with (
patch(
"qwenpaw.app.routers.workspace.get_agent_for_request",
AsyncMock(return_value=workspace),
),
patch(
"qwenpaw.app.routers.workspace.update_agent_config_async",
side_effect=update_config,
),
patch("qwenpaw.app.routers.workspace.schedule_agent_reload"),
):
with pytest.raises(HTTPException) as exc_info:
await put_agents_running_config(new_running, MagicMock())
assert exc_info.value.status_code == 409
assert exc_info.value.detail["persisted"] is True
assert any(
"model_name" in path for path in exc_info.value.detail["conflicts"]
)
embedding_config = (
persisted.running.reme_light_memory_config.embedding_model_config
)
assert embedding_config.model_name == "third-model"