mirror of
https://github.com/jxxghp/MoviePilot.git
synced 2026-08-29 03:56:43 +08:00
902 lines
32 KiB
Python
902 lines
32 KiB
Python
import asyncio
|
|
import threading
|
|
import time
|
|
from concurrent.futures import ThreadPoolExecutor
|
|
from types import SimpleNamespace
|
|
from unittest.mock import AsyncMock, MagicMock
|
|
|
|
import pytest
|
|
|
|
from app.foundation.singleton import Singleton
|
|
from app.runtime.config import global_vars
|
|
from app.runtime.extensions.plugin.dependency import (
|
|
PluginDependencyClassification,
|
|
PluginDependencyInstallResult,
|
|
)
|
|
from app.runtime.extensions.plugin.monitor import (
|
|
PluginChangeMonitor,
|
|
PluginMonitorController,
|
|
)
|
|
from app.runtime.extensions.plugin.admission import PluginMutationAdmission
|
|
from app.runtime.extensions.plugin.system import reset_plugin_system
|
|
from app.runtime.extensions.plugin_manager import PluginManager
|
|
from app.schemas.plugin import PluginRuntimeStatus
|
|
from app.startup.initializers import plugins as plugins_initializer
|
|
|
|
|
|
def _reset_plugin_manager() -> None:
|
|
"""清除插件管理器单例，保证构造时序测试彼此隔离。"""
|
|
Singleton._instances.pop((PluginManager, (), frozenset()), None)
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
("dev", "auto_reload"),
|
|
((True, False), (False, True)),
|
|
)
|
|
def test_plugin_manager_constructor_does_not_start_monitor_before_runtime(
|
|
monkeypatch,
|
|
dev: bool,
|
|
auto_reload: bool,
|
|
) -> None:
|
|
"""组合根尚未装配时，构造插件管理器不得提前启动开发监控线程。"""
|
|
_reset_plugin_manager()
|
|
reset_plugin_system()
|
|
start = MagicMock()
|
|
monkeypatch.setattr(
|
|
"app.runtime.extensions.plugin_manager.settings",
|
|
SimpleNamespace(
|
|
DEV=dev,
|
|
PLUGIN_AUTO_RELOAD=auto_reload,
|
|
ROOT_PATH=MagicMock(),
|
|
),
|
|
)
|
|
monkeypatch.setattr(PluginMonitorController, "start", start)
|
|
|
|
PluginManager()
|
|
|
|
start.assert_not_called()
|
|
_reset_plugin_manager()
|
|
|
|
|
|
def test_init_plugins_starts_monitor_after_runtime_and_routes(monkeypatch) -> None:
|
|
"""启动阶段只加载依赖已就绪的插件，再开放路由和文件监控。"""
|
|
order: list[str] = []
|
|
manager = MagicMock()
|
|
manager.classify_plugins.return_value = PluginDependencyClassification(
|
|
ready=("ReadyPlugin",),
|
|
missing_dependencies=("DependencyPending",),
|
|
missing_source=("SourcePending",),
|
|
)
|
|
manager.reopen_plugins.side_effect = lambda: order.append("reopen") or True
|
|
manager.start.side_effect = lambda plugin_id: order.append(f"plugin:{plugin_id}")
|
|
manager.start_monitor.side_effect = lambda **_kwargs: order.append("monitor")
|
|
monkeypatch.setattr(
|
|
plugins_initializer,
|
|
"configure_plugin_services",
|
|
lambda: order.append("services"),
|
|
)
|
|
monkeypatch.setattr(plugins_initializer, "PluginManager", lambda: manager)
|
|
monkeypatch.setattr(
|
|
plugins_initializer,
|
|
"register_plugin_api",
|
|
lambda: order.append("routes"),
|
|
)
|
|
|
|
plugins_initializer.init_plugins()
|
|
|
|
assert order == [
|
|
"services",
|
|
"reopen",
|
|
"plugin:ReadyPlugin",
|
|
"routes",
|
|
"monitor",
|
|
]
|
|
manager.reopen_plugins.assert_called_once_with()
|
|
manager.set_plugin_settling.assert_called_once_with(True)
|
|
manager.start_monitor.assert_called_once_with(reopen=True)
|
|
|
|
|
|
def test_plugin_manager_projects_dependency_classification_to_runtime_status() -> None:
|
|
"""真实管理器按分类字段写入三类启动状态，避免测试替身掩盖字段漂移。"""
|
|
_reset_plugin_manager()
|
|
manager = PluginManager()
|
|
|
|
manager.apply_plugin_dependency_classification(
|
|
PluginDependencyClassification(
|
|
ready=("ReadyPlugin",),
|
|
missing_dependencies=("DependencyPending",),
|
|
missing_source=("SourcePending",),
|
|
)
|
|
)
|
|
|
|
assert manager.get_plugin_runtime_statuses() == {
|
|
"ReadyPlugin": PluginRuntimeStatus.READY,
|
|
"DependencyPending": PluginRuntimeStatus.DEPENDENCY_PENDING,
|
|
"SourcePending": PluginRuntimeStatus.SOURCE_MISSING,
|
|
}
|
|
_reset_plugin_manager()
|
|
|
|
|
|
def test_plugin_manager_promotes_running_dependency_after_recovery() -> None:
|
|
"""依赖恢复后，运行中的插件状态必须允许后台流程触发重载。"""
|
|
_reset_plugin_manager()
|
|
manager = PluginManager()
|
|
manager._plugin_registry.running["DependencyRecovered"] = object()
|
|
manager._plugin_registry.set_runtime_status(
|
|
"DependencyRecovered",
|
|
PluginRuntimeStatus.DEPENDENCY_PENDING,
|
|
)
|
|
|
|
manager.apply_plugin_dependency_classification(
|
|
PluginDependencyClassification(
|
|
ready=("DependencyRecovered",),
|
|
missing_dependencies=(),
|
|
missing_source=(),
|
|
)
|
|
)
|
|
|
|
assert manager.get_plugin_runtime_statuses()["DependencyRecovered"] is (
|
|
PluginRuntimeStatus.READY
|
|
)
|
|
_reset_plugin_manager()
|
|
|
|
|
|
def _patch_sync_plugins(monkeypatch, manager: MagicMock) -> MagicMock:
|
|
"""隔离后台执行器并返回动态路由注册替身。"""
|
|
async def execute(_loop, task_func, _task_name):
|
|
return task_func()
|
|
|
|
register = MagicMock()
|
|
monkeypatch.setattr(
|
|
global_vars,
|
|
"CURRENT_EVENT_LOOP",
|
|
asyncio.get_running_loop(),
|
|
)
|
|
monkeypatch.setattr(plugins_initializer, "configure_plugin_services", lambda: None)
|
|
monkeypatch.setattr(plugins_initializer, "PluginManager", lambda: manager)
|
|
monkeypatch.setattr(plugins_initializer, "execute_task", execute)
|
|
monkeypatch.setattr(plugins_initializer, "register_plugin_api", register)
|
|
dependency_result = (
|
|
manager.async_install_plugin_missing_dependencies_with_status.return_value
|
|
)
|
|
manager.async_install_plugin_missing_dependencies_with_status = AsyncMock(
|
|
return_value=dependency_result,
|
|
)
|
|
manager.get_plugin_runtime_statuses.return_value = {}
|
|
return register
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_sync_plugins_rejects_before_configuring_mutable_services(
|
|
monkeypatch,
|
|
) -> None:
|
|
"""启动后同步在 admission 封口后不重装配服务、不写包或运行态。"""
|
|
admission = PluginMutationAdmission()
|
|
admission.seal()
|
|
manager = MagicMock()
|
|
manager.mutation.side_effect = admission.hold
|
|
configure = MagicMock()
|
|
monkeypatch.setattr(plugins_initializer, "PluginManager", lambda: manager)
|
|
monkeypatch.setattr(plugins_initializer, "configure_plugin_services", configure)
|
|
|
|
assert await plugins_initializer.sync_plugins() is False
|
|
|
|
configure.assert_not_called()
|
|
manager.set_plugin_settling.assert_not_called()
|
|
manager.sync.assert_not_called()
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_sync_plugins_activates_ready_plugins_when_dependencies_fail(
|
|
monkeypatch,
|
|
) -> None:
|
|
"""依赖恢复失败时仍激活无关的已就绪插件。"""
|
|
manager = MagicMock()
|
|
manager.sync.return_value = ["demo"]
|
|
manager.async_install_plugin_missing_dependencies_with_status.return_value = (
|
|
PluginDependencyInstallResult(missing=["demo>=1"], success=False)
|
|
)
|
|
manager.classify_plugins.return_value = PluginDependencyClassification(
|
|
ready=("ReadyPlugin",),
|
|
missing_dependencies=("DependencyPending",),
|
|
missing_source=(),
|
|
)
|
|
manager.running_plugins = {}
|
|
register = _patch_sync_plugins(monkeypatch, manager)
|
|
|
|
assert await plugins_initializer.sync_plugins() is True
|
|
|
|
manager.start.assert_called_once_with("ReadyPlugin")
|
|
manager.reload_plugin.assert_not_called()
|
|
register.assert_called_once_with("ReadyPlugin")
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_sync_plugins_loads_only_plugins_that_become_ready(
|
|
monkeypatch,
|
|
) -> None:
|
|
"""后台依赖恢复后只启动尚未运行且当前已就绪的插件。"""
|
|
manager = MagicMock()
|
|
manager.sync.return_value = []
|
|
manager.async_install_plugin_missing_dependencies_with_status.return_value = (
|
|
PluginDependencyInstallResult(missing=["demo>=1"], success=True)
|
|
)
|
|
manager.classify_plugins.return_value = PluginDependencyClassification(
|
|
ready=("ReadyPlugin", "DependencyRecovered"),
|
|
missing_dependencies=(),
|
|
missing_source=("SourcePending",),
|
|
)
|
|
running = {"ReadyPlugin": object()}
|
|
manager.running_plugins = running
|
|
|
|
def start(plugin_id: str) -> None:
|
|
running[plugin_id] = object()
|
|
|
|
manager.start.side_effect = start
|
|
register = _patch_sync_plugins(monkeypatch, manager)
|
|
|
|
assert await plugins_initializer.sync_plugins() is True
|
|
|
|
manager.start.assert_called_once_with("DependencyRecovered")
|
|
manager.reload_plugin.assert_not_called()
|
|
register.assert_called_once_with("DependencyRecovered")
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_sync_plugins_reloads_only_updated_running_plugins(monkeypatch) -> None:
|
|
"""源码同步只重载对应运行实例，不重启其他插件。"""
|
|
manager = MagicMock()
|
|
manager.sync.return_value = ["UpdatedPlugin"]
|
|
manager.async_install_plugin_missing_dependencies_with_status.return_value = (
|
|
PluginDependencyInstallResult(missing=[], success=True)
|
|
)
|
|
manager.classify_plugins.return_value = PluginDependencyClassification(
|
|
ready=("StablePlugin", "UpdatedPlugin"),
|
|
missing_dependencies=(),
|
|
missing_source=(),
|
|
)
|
|
manager.running_plugins = {
|
|
"StablePlugin": object(),
|
|
"UpdatedPlugin": object(),
|
|
}
|
|
register = _patch_sync_plugins(monkeypatch, manager)
|
|
|
|
assert await plugins_initializer.sync_plugins() is True
|
|
|
|
manager.reload_plugin.assert_called_once_with("UpdatedPlugin")
|
|
manager.start.assert_not_called()
|
|
register.assert_called_once_with("UpdatedPlugin")
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_sync_plugins_reloads_running_plugin_after_dependency_recovery(
|
|
monkeypatch,
|
|
) -> None:
|
|
"""依赖恢复后，已运行的旧实例必须切换到新源码。"""
|
|
manager = MagicMock()
|
|
manager.sync.return_value = []
|
|
manager.async_install_plugin_missing_dependencies_with_status.return_value = (
|
|
PluginDependencyInstallResult(missing=["demo>=1"], success=True)
|
|
)
|
|
manager.classify_plugins.return_value = PluginDependencyClassification(
|
|
ready=("DependencyRecovered",),
|
|
missing_dependencies=(),
|
|
missing_source=(),
|
|
)
|
|
manager.running_plugins = {"DependencyRecovered": object()}
|
|
register = _patch_sync_plugins(monkeypatch, manager)
|
|
manager.get_plugin_runtime_statuses.return_value = {
|
|
"DependencyRecovered": PluginRuntimeStatus.DEPENDENCY_PENDING,
|
|
}
|
|
|
|
assert await plugins_initializer.sync_plugins() is True
|
|
|
|
manager.reload_plugin.assert_called_once_with("DependencyRecovered")
|
|
manager.start.assert_not_called()
|
|
register.assert_called_once_with("DependencyRecovered")
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_sync_plugins_keeps_runtime_when_nothing_changed(monkeypatch) -> None:
|
|
"""源码和依赖均无变化时保留首次初始化结果。"""
|
|
manager = MagicMock()
|
|
manager.sync.return_value = []
|
|
manager.async_install_plugin_missing_dependencies_with_status.return_value = (
|
|
PluginDependencyInstallResult(missing=[], success=True)
|
|
)
|
|
manager.classify_plugins.return_value = PluginDependencyClassification(
|
|
ready=("ReadyPlugin",),
|
|
missing_dependencies=(),
|
|
missing_source=(),
|
|
)
|
|
manager.running_plugins = {"ReadyPlugin": object()}
|
|
register = _patch_sync_plugins(monkeypatch, manager)
|
|
|
|
assert await plugins_initializer.sync_plugins() is False
|
|
|
|
manager.start.assert_not_called()
|
|
manager.reload_plugin.assert_not_called()
|
|
register.assert_not_called()
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_sync_plugins_keeps_event_loop_responsive_during_activation(
|
|
monkeypatch,
|
|
) -> None:
|
|
"""插件初始化运行在线程池时，Web 事件循环仍可继续调度。"""
|
|
manager = MagicMock()
|
|
manager.sync.return_value = []
|
|
manager.async_install_plugin_missing_dependencies_with_status.return_value = (
|
|
PluginDependencyInstallResult(missing=[], success=True)
|
|
)
|
|
manager.classify_plugins.return_value = PluginDependencyClassification(
|
|
ready=("SlowPlugin",),
|
|
missing_dependencies=(),
|
|
missing_source=(),
|
|
)
|
|
manager.running_plugins = {}
|
|
activation_started = threading.Event()
|
|
|
|
def slow_start(_plugin_id: str) -> None:
|
|
activation_started.set()
|
|
time.sleep(0.1)
|
|
|
|
manager.start.side_effect = slow_start
|
|
manager.async_install_plugin_missing_dependencies_with_status = AsyncMock(
|
|
return_value=PluginDependencyInstallResult(missing=[], success=True),
|
|
)
|
|
monkeypatch.setattr(plugins_initializer, "configure_plugin_services", lambda: None)
|
|
monkeypatch.setattr(plugins_initializer, "PluginManager", lambda: manager)
|
|
monkeypatch.setattr(plugins_initializer, "register_plugin_api", MagicMock())
|
|
monkeypatch.setattr(
|
|
plugins_initializer.global_vars,
|
|
"CURRENT_EVENT_LOOP",
|
|
asyncio.get_running_loop(),
|
|
)
|
|
|
|
sync_task = asyncio.create_task(plugins_initializer.sync_plugins())
|
|
assert await asyncio.to_thread(activation_started.wait, 1)
|
|
assert sync_task.done() is False
|
|
assert await sync_task is True
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
("dev", "auto_reload", "expected_calls"),
|
|
((True, False, 1), (False, True, 1), (False, False, 0)),
|
|
)
|
|
def test_start_monitor_respects_runtime_configuration(
|
|
monkeypatch,
|
|
dev: bool,
|
|
auto_reload: bool,
|
|
expected_calls: int,
|
|
) -> None:
|
|
"""首次启动只在开发模式或插件自动重载启用时创建监控线程。"""
|
|
_reset_plugin_manager()
|
|
reset_plugin_system()
|
|
monkeypatch.setattr(
|
|
"app.runtime.extensions.plugin_manager.settings",
|
|
SimpleNamespace(
|
|
DEV=dev,
|
|
PLUGIN_AUTO_RELOAD=auto_reload,
|
|
ROOT_PATH=MagicMock(),
|
|
),
|
|
)
|
|
manager = PluginManager()
|
|
start = MagicMock()
|
|
manager._plugin_monitor.start = start
|
|
|
|
manager.start_monitor()
|
|
|
|
assert start.call_count == expected_calls
|
|
_reset_plugin_manager()
|
|
|
|
|
|
def test_plugin_monitor_waits_until_dependency_settlement(monkeypatch) -> None:
|
|
"""后台依赖收敛期间不启动文件监控，避免源码写入触发重复重载。"""
|
|
_reset_plugin_manager()
|
|
reset_plugin_system()
|
|
monkeypatch.setattr(
|
|
"app.runtime.extensions.plugin_manager.settings",
|
|
SimpleNamespace(
|
|
DEV=True,
|
|
PLUGIN_AUTO_RELOAD=False,
|
|
ROOT_PATH=MagicMock(),
|
|
),
|
|
)
|
|
manager = PluginManager()
|
|
start = MagicMock()
|
|
reload_monitor = MagicMock()
|
|
manager._plugin_monitor.start = start
|
|
manager._plugin_monitor.reload = reload_monitor
|
|
|
|
manager.set_plugin_settling(True)
|
|
manager.start_monitor()
|
|
manager.reload_monitor()
|
|
|
|
start.assert_not_called()
|
|
reload_monitor.assert_called_once_with(enabled=False)
|
|
|
|
manager.set_plugin_settling(False)
|
|
manager.start_monitor()
|
|
|
|
start.assert_called_once_with()
|
|
_reset_plugin_manager()
|
|
|
|
|
|
def test_monitor_stop_keeps_thread_owned_until_it_really_exits() -> None:
|
|
"""停止超时后保留活线程引用，使后续停机调用仍能继续等待。"""
|
|
started = threading.Event()
|
|
release = threading.Event()
|
|
|
|
def runner() -> None:
|
|
"""模拟暂时无法响应停止事件的文件监控循环。"""
|
|
started.set()
|
|
release.wait()
|
|
|
|
controller = PluginMonitorController(runner=runner, log=MagicMock())
|
|
controller.start()
|
|
assert started.wait(1)
|
|
owned_thread = controller._thread
|
|
|
|
try:
|
|
assert controller.stop(timeout=0.01) is False
|
|
assert controller._thread is owned_thread
|
|
assert owned_thread is not None and owned_thread.is_alive()
|
|
finally:
|
|
release.set()
|
|
assert controller.stop(timeout=1) is True
|
|
|
|
assert controller._thread is None
|
|
assert controller.stop(timeout=0) is True
|
|
|
|
|
|
def test_monitor_stop_counts_lifecycle_lock_wait_in_timeout() -> None:
|
|
"""并发重建占用生命周期锁时，停止调用不得突破自身预算。"""
|
|
controller = PluginMonitorController(runner=lambda: None, log=MagicMock())
|
|
lock_acquired = threading.Event()
|
|
release = threading.Event()
|
|
|
|
def hold_lifecycle_lock() -> None:
|
|
"""模拟配置重载在停止请求到达时仍持有生命周期锁。"""
|
|
with controller._lifecycle_lock:
|
|
lock_acquired.set()
|
|
release.wait()
|
|
|
|
holder = threading.Thread(target=hold_lifecycle_lock, daemon=True)
|
|
holder.start()
|
|
assert lock_acquired.wait(1)
|
|
started_at = time.monotonic()
|
|
|
|
try:
|
|
assert controller.stop(timeout=0.01) is False
|
|
assert time.monotonic() - started_at < 0.2
|
|
finally:
|
|
release.set()
|
|
holder.join(timeout=1)
|
|
|
|
assert holder.is_alive() is False
|
|
assert controller.stop(timeout=0) is True
|
|
|
|
|
|
def test_shutdown_seal_blocks_reload_between_stop_and_start(monkeypatch) -> None:
|
|
"""停机封口落在热重载停启间隙时，旧重载不得再创建监控线程。"""
|
|
reload_stopped = threading.Event()
|
|
resume_reload = threading.Event()
|
|
runner_started = threading.Event()
|
|
controller = PluginMonitorController(
|
|
runner=lambda: runner_started.set(),
|
|
log=MagicMock(),
|
|
)
|
|
original_stop = controller.stop
|
|
|
|
def pause_after_stop(timeout: float = 5.0) -> bool:
|
|
"""把配置热重载稳定暂停在旧线程已停、新线程未启的窗口。"""
|
|
stopped = original_stop(timeout=timeout)
|
|
reload_stopped.set()
|
|
resume_reload.wait()
|
|
return stopped
|
|
|
|
monkeypatch.setattr(controller, "stop", pause_after_stop)
|
|
reload_thread = threading.Thread(
|
|
target=lambda: controller.reload(enabled=True),
|
|
daemon=True,
|
|
)
|
|
reload_thread.start()
|
|
assert reload_stopped.wait(1)
|
|
|
|
try:
|
|
assert controller.close(timeout=1) is True
|
|
resume_reload.set()
|
|
reload_thread.join(timeout=1)
|
|
assert reload_thread.is_alive() is False
|
|
assert runner_started.is_set() is False
|
|
assert controller._thread is None
|
|
finally:
|
|
resume_reload.set()
|
|
reload_thread.join(timeout=1)
|
|
|
|
assert controller.reopen() is True
|
|
controller.start()
|
|
assert runner_started.wait(1)
|
|
assert controller.close(timeout=1) is True
|
|
|
|
|
|
def test_plugin_manager_stop_monitor_returns_controller_result(monkeypatch) -> None:
|
|
"""管理器停止入口透传线程收口结果和调用预算。"""
|
|
_reset_plugin_manager()
|
|
reset_plugin_system()
|
|
manager = PluginManager()
|
|
stop = MagicMock(return_value=False)
|
|
manager._plugin_monitor.stop = stop
|
|
|
|
try:
|
|
assert manager.stop_monitor(timeout=0.25) is False
|
|
stop.assert_called_once_with(timeout=0.25)
|
|
finally:
|
|
_reset_plugin_manager()
|
|
|
|
|
|
def test_plugin_manager_start_monitor_can_reopen_new_lifespan(monkeypatch) -> None:
|
|
"""新应用生命周期可显式解除封口，再按运行配置启动监控。"""
|
|
_reset_plugin_manager()
|
|
reset_plugin_system()
|
|
monkeypatch.setattr(
|
|
"app.runtime.extensions.plugin_manager.settings",
|
|
SimpleNamespace(
|
|
DEV=True,
|
|
PLUGIN_AUTO_RELOAD=False,
|
|
ROOT_PATH=MagicMock(),
|
|
),
|
|
)
|
|
manager = PluginManager()
|
|
reopen = MagicMock(return_value=True)
|
|
start = MagicMock()
|
|
manager._plugin_monitor.reopen = reopen
|
|
manager._plugin_monitor.start = start
|
|
|
|
try:
|
|
manager.start_monitor(reopen=True)
|
|
reopen.assert_called_once_with()
|
|
start.assert_called_once_with()
|
|
finally:
|
|
_reset_plugin_manager()
|
|
|
|
|
|
def test_stop_plugin_monitor_does_not_materialize_manager() -> None:
|
|
"""插件运行时尚未创建时，独立停机入口直接视为已完成。"""
|
|
_reset_plugin_manager()
|
|
|
|
assert plugins_initializer.stop_plugin_monitor(timeout=0) is True
|
|
assert PluginManager.get_existing_instance() is None
|
|
|
|
|
|
def test_stop_plugin_monitor_returns_existing_manager_result(monkeypatch) -> None:
|
|
"""启动层入口只操作既有管理器，并透传超时失败。"""
|
|
manager = MagicMock()
|
|
manager.close_monitor.return_value = False
|
|
manager_type = SimpleNamespace(get_existing_instance=lambda: manager)
|
|
monkeypatch.setattr(plugins_initializer, "PluginManager", manager_type)
|
|
|
|
assert plugins_initializer.stop_plugin_monitor(timeout=0.25) is False
|
|
manager.close_monitor.assert_called_once_with(timeout=0.25)
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_phased_plugin_shutdown_does_not_materialize_manager() -> None:
|
|
"""三个停机入口在插件管理器尚未创建时都直接视为已收敛。"""
|
|
_reset_plugin_manager()
|
|
|
|
assert await plugins_initializer.quiesce_plugins(timeout=0) is True
|
|
assert await plugins_initializer.quiesce_plugin_services(timeout=0) is True
|
|
assert plugins_initializer.finalize_plugins() is True
|
|
assert PluginManager.get_existing_instance() is None
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_quiesce_timeout_retains_future_owner_until_worker_finishes(
|
|
monkeypatch,
|
|
) -> None:
|
|
"""同步插件 hook 超时后必须保留 Future，且未结束前拒绝卸载实例。"""
|
|
_reset_plugin_manager()
|
|
reset_plugin_system()
|
|
monkeypatch.setattr(
|
|
"app.runtime.extensions.plugin_manager.settings",
|
|
SimpleNamespace(
|
|
DEV=False,
|
|
PLUGIN_AUTO_RELOAD=False,
|
|
ROOT_PATH=MagicMock(),
|
|
),
|
|
)
|
|
manager = PluginManager()
|
|
started = threading.Event()
|
|
release = threading.Event()
|
|
|
|
def blocking_quiesce() -> bool:
|
|
"""模拟无法由 asyncio 取消的同步旧插件 hook。"""
|
|
started.set()
|
|
release.wait(timeout=2)
|
|
return True
|
|
|
|
manager._plugin_lifecycle.quiesce_handlers = MagicMock(return_value=True)
|
|
manager._plugin_lifecycle.quiesce_services = MagicMock(
|
|
side_effect=blocking_quiesce,
|
|
)
|
|
manager._plugin_lifecycle.finalize = MagicMock(return_value=True)
|
|
|
|
try:
|
|
with ThreadPoolExecutor(max_workers=1) as executor:
|
|
thread_helper = SimpleNamespace(submit=executor.submit)
|
|
monkeypatch.setattr(
|
|
"app.runtime.extensions.plugin_manager.ThreadHelper",
|
|
lambda: thread_helper,
|
|
)
|
|
|
|
assert await manager.quiesce_plugins(timeout=1) is True
|
|
assert await manager.quiesce_plugin_services(timeout=0.01) is False
|
|
assert started.is_set()
|
|
owner = manager._plugin_service_quiesce_future
|
|
assert owner is not None
|
|
assert owner.done() is False
|
|
assert manager.finalize_plugins() is False
|
|
manager._plugin_lifecycle.finalize.assert_not_called()
|
|
|
|
release.set()
|
|
assert await asyncio.wrap_future(owner) is True
|
|
assert manager.finalize_plugins() is True
|
|
manager._plugin_lifecycle.finalize.assert_called_once_with()
|
|
finally:
|
|
release.set()
|
|
_reset_plugin_manager()
|
|
|
|
|
|
@pytest.mark.asyncio
|
|
async def test_quiesce_seals_runtime_until_new_lifespan_reopens(monkeypatch) -> None:
|
|
"""屏障前封口后 start/reload/config 不能重开 producer，新 lifespan 可显式恢复。"""
|
|
_reset_plugin_manager()
|
|
reset_plugin_system()
|
|
monkeypatch.setattr(
|
|
"app.runtime.extensions.plugin_manager.settings",
|
|
SimpleNamespace(
|
|
DEBUG=False,
|
|
DEV=False,
|
|
PLUGIN_AUTO_RELOAD=False,
|
|
ROOT_PATH=MagicMock(),
|
|
),
|
|
)
|
|
manager = PluginManager()
|
|
manager._plugin_lifecycle.quiesce_handlers = MagicMock(return_value=True)
|
|
manager._plugin_lifecycle.start = MagicMock(
|
|
return_value={"DemoPlugin": PluginRuntimeStatus.ACTIVE}
|
|
)
|
|
manager._plugin_lifecycle.reload = MagicMock(
|
|
return_value=PluginRuntimeStatus.ACTIVE
|
|
)
|
|
manager._plugin_lifecycle.stop = MagicMock(return_value=True)
|
|
manager._plugin_lifecycle.initialize = MagicMock()
|
|
manager._plugin_lifecycle._disable_events = MagicMock()
|
|
manager._plugin_registry.remove = MagicMock()
|
|
manager._plugin_registry.set_runtime_status = MagicMock()
|
|
manager.classify_plugins = MagicMock()
|
|
|
|
class DemoPlugin:
|
|
"""代表 quiesce 后仍由严格生命周期持有的运行实例。"""
|
|
|
|
plugin_instance = DemoPlugin()
|
|
manager._plugins["DemoPlugin"] = DemoPlugin
|
|
manager._running_plugins["DemoPlugin"] = plugin_instance
|
|
|
|
try:
|
|
assert await manager.quiesce_plugins(timeout=1) is True
|
|
|
|
assert manager.start("DemoPlugin") == {
|
|
"DemoPlugin": PluginRuntimeStatus.LOAD_FAILED
|
|
}
|
|
assert manager.stop("DemoPlugin") is None
|
|
assert manager.remove_plugin("DemoPlugin") is None
|
|
assert (
|
|
manager.reload_plugin("DemoPlugin")
|
|
is PluginRuntimeStatus.LOAD_FAILED
|
|
)
|
|
manager.init_plugin("DemoPlugin", {})
|
|
manager.init_config()
|
|
manager._plugin_lifecycle.start.assert_not_called()
|
|
manager._plugin_lifecycle.stop.assert_not_called()
|
|
manager._plugin_lifecycle.reload.assert_not_called()
|
|
manager._plugin_lifecycle.initialize.assert_not_called()
|
|
manager._plugin_lifecycle._disable_events.assert_not_called()
|
|
manager._plugin_registry.remove.assert_not_called()
|
|
manager._plugin_registry.set_runtime_status.assert_not_called()
|
|
manager.classify_plugins.assert_not_called()
|
|
assert manager._plugins["DemoPlugin"] is DemoPlugin
|
|
assert manager._running_plugins["DemoPlugin"] is plugin_instance
|
|
|
|
assert manager.reopen_plugins() is False
|
|
manager._plugins.clear()
|
|
manager._running_plugins.clear()
|
|
assert manager.reopen_plugins() is True
|
|
assert manager.start("DemoPlugin") == {
|
|
"DemoPlugin": PluginRuntimeStatus.ACTIVE
|
|
}
|
|
assert (
|
|
manager.reload_plugin("DemoPlugin")
|
|
is PluginRuntimeStatus.ACTIVE
|
|
)
|
|
finally:
|
|
_reset_plugin_manager()
|
|
|
|
|
|
def test_plugin_monitor_skips_installing_plugin_until_package_write_finishes(tmp_path) -> None:
|
|
"""安装替换目录期间，文件事件不得抢先导入未完成的插件包。"""
|
|
reload_plugin = MagicMock()
|
|
monitor = PluginChangeMonitor(
|
|
runtime_root=tmp_path,
|
|
local_roots=lambda: [],
|
|
stop_event=threading.Event(),
|
|
recent_sync={},
|
|
federated_change=lambda _path: None,
|
|
runtime_plugin=lambda _path: "DemoPlugin",
|
|
local_candidate=lambda _path: None,
|
|
sync_local=MagicMock(),
|
|
reload_plugin=reload_plugin,
|
|
dependency_manifest_status=lambda _path: None,
|
|
watch=lambda *_args, **_kwargs: (),
|
|
log=MagicMock(),
|
|
monitor_suppressed=lambda plugin_id: plugin_id.lower() == "demoplugin",
|
|
)
|
|
|
|
monitor._process_changes({("modified", str(tmp_path / "demo" / "plugin.py"))})
|
|
|
|
reload_plugin.assert_not_called()
|
|
|
|
|
|
def test_plugin_monitor_suppression_is_reference_counted(monkeypatch) -> None:
|
|
"""同一插件的重叠写入必须等最后一个事务退出后才解除监控抑制。"""
|
|
_reset_plugin_manager()
|
|
reset_plugin_system()
|
|
monkeypatch.setattr(
|
|
"app.runtime.extensions.plugin_manager.settings",
|
|
SimpleNamespace(
|
|
DEV=False,
|
|
PLUGIN_AUTO_RELOAD=False,
|
|
ROOT_PATH=MagicMock(),
|
|
),
|
|
)
|
|
manager = PluginManager()
|
|
|
|
with manager.suppress_plugin_monitor("DemoPlugin"):
|
|
assert manager.is_plugin_monitor_suppressed("demoplugin") is True
|
|
with manager.suppress_plugin_monitor("demoplugin"):
|
|
assert manager.is_plugin_monitor_suppressed("DemoPlugin") is True
|
|
assert manager.is_plugin_monitor_suppressed("DemoPlugin") is True
|
|
|
|
assert manager.is_plugin_monitor_suppressed("DemoPlugin") is False
|
|
_reset_plugin_manager()
|
|
|
|
|
|
def test_config_change_reloads_monitor(monkeypatch) -> None:
|
|
"""配置热更新继续使用重建语义，不复用首次启动入口。"""
|
|
_reset_plugin_manager()
|
|
reset_plugin_system()
|
|
monkeypatch.setattr(
|
|
"app.runtime.extensions.plugin_manager.settings",
|
|
SimpleNamespace(
|
|
DEV=False,
|
|
PLUGIN_AUTO_RELOAD=False,
|
|
ROOT_PATH=MagicMock(),
|
|
),
|
|
)
|
|
manager = PluginManager()
|
|
reload_monitor = MagicMock()
|
|
manager.reload_monitor = reload_monitor
|
|
|
|
manager.on_config_changed()
|
|
|
|
reload_monitor.assert_called_once_with()
|
|
_reset_plugin_manager()
|
|
|
|
|
|
def test_stop_plugins_stops_monitor_before_plugin_runtime(monkeypatch) -> None:
|
|
"""关闭时先隔离文件变化，再停止插件实例。"""
|
|
order: list[str] = []
|
|
manager = MagicMock()
|
|
manager.stop_monitor.side_effect = lambda: order.append("monitor") or True
|
|
manager.stop.side_effect = lambda: order.append("plugins")
|
|
manager_type = SimpleNamespace(get_existing_instance=lambda: manager)
|
|
monkeypatch.setattr(plugins_initializer, "PluginManager", manager_type)
|
|
|
|
assert plugins_initializer.stop_plugins() is True
|
|
|
|
assert order == ["monitor", "plugins"]
|
|
|
|
|
|
def test_stop_plugins_still_stops_runtime_when_monitor_stop_fails(monkeypatch) -> None:
|
|
"""监控线程停止异常不得阻止插件实例释放资源。"""
|
|
manager = MagicMock()
|
|
manager.stop_monitor.side_effect = RuntimeError("monitor stop failed")
|
|
manager_type = SimpleNamespace(get_existing_instance=lambda: manager)
|
|
monkeypatch.setattr(plugins_initializer, "PluginManager", manager_type)
|
|
|
|
assert plugins_initializer.stop_plugins() is False
|
|
|
|
manager.stop.assert_called_once_with()
|
|
|
|
|
|
def test_stop_plugins_does_not_materialize_manager() -> None:
|
|
"""插件初始化尚未创建管理器时，失败清理不得反向构造运行时。"""
|
|
_reset_plugin_manager()
|
|
|
|
assert plugins_initializer.stop_plugins() is True
|
|
|
|
assert PluginManager.get_existing_instance() is None
|
|
|
|
|
|
def test_stop_plugins_remains_idempotent(monkeypatch) -> None:
|
|
"""兼容停机入口可重复调用，并保持每次先停监控再停插件。"""
|
|
order: list[str] = []
|
|
manager = MagicMock()
|
|
manager.stop_monitor.side_effect = lambda: order.append("monitor") or True
|
|
manager.stop.side_effect = lambda: order.append("plugins")
|
|
manager_type = SimpleNamespace(get_existing_instance=lambda: manager)
|
|
monkeypatch.setattr(plugins_initializer, "PluginManager", manager_type)
|
|
|
|
assert plugins_initializer.stop_plugins() is True
|
|
assert plugins_initializer.stop_plugins() is True
|
|
|
|
assert order == ["monitor", "plugins", "monitor", "plugins"]
|
|
|
|
|
|
def test_plugin_manager_legacy_stop_preserves_none_return() -> None:
|
|
"""公共 PluginManager.stop 委托单阶段停机后保持历史 None 返回 ABI。"""
|
|
manager = object.__new__(PluginManager)
|
|
manager._plugin_quiesce_lock = threading.RLock()
|
|
manager._plugin_runtime_closed = False
|
|
manager._plugin_quiesce_future = None
|
|
manager._plugin_mutation_admission = PluginMutationAdmission()
|
|
manager._plugin_lifecycle = SimpleNamespace(stop=MagicMock(return_value=True))
|
|
|
|
assert PluginManager.stop(manager, "DemoPlugin") is None
|
|
|
|
manager._plugin_lifecycle.stop.assert_called_once_with("DemoPlugin")
|
|
|
|
|
|
def test_config_reload_continues_after_legacy_stop() -> None:
|
|
"""配置热重载保持旧行为，stop 的 None 返回不得阻止重新分类和启动。"""
|
|
manager = object.__new__(PluginManager)
|
|
manager._plugin_quiesce_lock = threading.RLock()
|
|
manager._plugin_runtime_closed = False
|
|
manager._plugin_mutation_admission = PluginMutationAdmission()
|
|
manager.stop = MagicMock(return_value=None)
|
|
manager.classify_plugins = MagicMock(
|
|
return_value=PluginDependencyClassification(
|
|
ready=("ReadyPlugin",),
|
|
missing_dependencies=(),
|
|
missing_source=(),
|
|
)
|
|
)
|
|
manager.apply_plugin_dependency_classification = MagicMock()
|
|
manager.start = MagicMock()
|
|
|
|
PluginManager.init_config(manager)
|
|
|
|
manager.stop.assert_called_once_with()
|
|
manager.classify_plugins.assert_called_once_with()
|
|
manager.apply_plugin_dependency_classification.assert_called_once_with(
|
|
manager.classify_plugins.return_value
|
|
)
|
|
manager.start.assert_called_once_with("ReadyPlugin")
|
|
|
|
|
|
def test_remove_plugin_clears_registry_after_legacy_stop() -> None:
|
|
"""卸载路径保持忽略旧 stop 返回值并继续清理注册表。"""
|
|
manager = object.__new__(PluginManager)
|
|
manager._plugin_quiesce_lock = threading.RLock()
|
|
manager._plugin_runtime_closed = False
|
|
manager._plugin_mutation_admission = PluginMutationAdmission()
|
|
manager._plugin_lifecycle = SimpleNamespace(stop=MagicMock(return_value=None))
|
|
manager._plugin_registry = SimpleNamespace(remove=MagicMock())
|
|
|
|
PluginManager.remove_plugin(manager, "DemoPlugin")
|
|
|
|
manager._plugin_lifecycle.stop.assert_called_once_with("DemoPlugin")
|
|
manager._plugin_registry.remove.assert_called_once_with("DemoPlugin")
|