use crate::error::BaseError;
use crate::plugin::{Plugin, PluginLifecycleStage, PluginManager, PluginManagerBuilder};
use async_trait::async_trait;
#[cfg(feature = "plugin-schema")]
use serde_json::Value as JsonValue;
use std::sync::Arc;
struct PluginA;
#[async_trait]
impl Plugin for PluginA {
fn name(&self) -> &str {
"plugin_a"
}
}
struct PluginB;
#[async_trait]
impl Plugin for PluginB {
fn name(&self) -> &str {
"plugin_b"
}
fn dependencies(&self) -> &[&str] {
&["plugin_a"]
}
}
struct PluginC;
#[async_trait]
impl Plugin for PluginC {
fn name(&self) -> &str {
"plugin_c"
}
fn dependencies(&self) -> &[&str] {
&["plugin_b"]
}
}
struct PluginFailing;
#[async_trait]
impl Plugin for PluginFailing {
fn name(&self) -> &str {
"plugin_failing"
}
async fn on_register(&self) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
Err("注册失败".into())
}
}
struct PluginASpaced;
#[async_trait]
impl Plugin for PluginASpaced {
fn name(&self) -> &str {
" plugin_a "
}
}
struct PluginBlankName;
#[async_trait]
impl Plugin for PluginBlankName {
fn name(&self) -> &str {
" "
}
}
#[tokio::test]
async fn test_registry_get_matches_registered_plugins() {
let mut builder = PluginManagerBuilder::new();
builder.register(PluginA).await.unwrap();
builder.register(PluginB).await.unwrap();
builder.register(PluginC).await.unwrap();
let registry = builder.build().expect("构建注册表应成功");
let plugin_a = registry.get("plugin_a");
assert!(plugin_a.is_some(), "应能找到 plugin_a");
assert_eq!(plugin_a.unwrap().name(), "plugin_a");
let plugin_b = registry.get("plugin_b");
assert!(plugin_b.is_some(), "应能找到 plugin_b");
assert_eq!(plugin_b.unwrap().name(), "plugin_b");
let plugin_c = registry.get("plugin_c");
assert!(plugin_c.is_some(), "应能找到 plugin_c");
assert_eq!(plugin_c.unwrap().name(), "plugin_c");
assert!(
registry.get("nonexistent").is_none(),
"不存在的插件应返回 None"
);
}
#[tokio::test]
async fn test_registry_get_all_returns_cached_result() {
let mut builder = PluginManagerBuilder::new();
builder.register(PluginA).await.unwrap();
builder.register(PluginB).await.unwrap();
builder.register(PluginC).await.unwrap();
let registry = builder.build().expect("构建注册表应成功");
let all_first = registry.get_all();
let all_second = registry.get_all();
assert_eq!(
all_first.len(),
all_second.len(),
"多次调用 get_all() 应返回相同数量的插件"
);
assert_eq!(all_first.len(), 3, "应有 3 个插件");
let names_first: Vec<&str> = all_first.iter().map(|p| p.name()).collect();
let names_second: Vec<&str> = all_second.iter().map(|p| p.name()).collect();
assert_eq!(
names_first, names_second,
"多次调用 get_all() 应返回相同顺序的插件"
);
}
#[tokio::test]
async fn test_registry_get_all_topological_order() {
let mut builder = PluginManagerBuilder::new();
builder.register(PluginC).await.unwrap();
builder.register(PluginA).await.unwrap();
builder.register(PluginB).await.unwrap();
let registry = builder.build().expect("构建注册表应成功");
let all_plugins = registry.get_all();
let pos_a = all_plugins.iter().position(|p| p.name() == "plugin_a");
let pos_b = all_plugins.iter().position(|p| p.name() == "plugin_b");
let pos_c = all_plugins.iter().position(|p| p.name() == "plugin_c");
assert!(
pos_a.is_some() && pos_b.is_some() && pos_c.is_some(),
"所有插件应在排序结果中"
);
assert!(
pos_a.unwrap() < pos_b.unwrap(),
"plugin_a(被依赖)应在 plugin_b 之前"
);
assert!(
pos_b.unwrap() < pos_c.unwrap(),
"plugin_b(被依赖)应在 plugin_c 之前"
);
}
#[tokio::test]
async fn test_builder_register_duplicate_returns_error() {
let mut builder = PluginManagerBuilder::new();
builder.register(PluginA).await.unwrap();
struct PluginADuplicate;
#[async_trait]
impl Plugin for PluginADuplicate {
fn name(&self) -> &str {
"plugin_a"
}
}
let result = builder.register(PluginADuplicate).await;
assert!(
matches!(result, Err(BaseError::PluginAlreadyRegistered(_))),
"注册重名插件应返回 PluginAlreadyRegistered 错误"
);
}
#[tokio::test]
async fn test_builder_register_trims_plugin_names() {
let mut builder = PluginManagerBuilder::new();
builder
.register(PluginASpaced)
.await
.expect("插件名应在构建期注册时 trim");
let result = builder.register(PluginA).await;
assert!(
matches!(result, Err(BaseError::PluginAlreadyRegistered(name)) if name == "plugin_a"),
"trim 后的重复插件名应返回 PluginAlreadyRegistered"
);
let registry = builder.build().expect("构建注册表应成功");
assert!(registry.get("plugin_a").is_some());
assert!(registry.get(" plugin_a ").is_some());
}
#[tokio::test]
async fn test_plugin_manager_register_trims_plugin_names_and_config_keys() {
let manager = PluginManager::new();
manager
.register(PluginASpaced)
.await
.expect("插件名应在运行期注册时 trim");
assert!(manager.get("plugin_a").await.is_some());
assert!(manager.get(" plugin_a ").await.is_some());
let result = manager.register(PluginA).await;
assert!(
matches!(result, Err(BaseError::PluginAlreadyRegistered(name)) if name == "plugin_a"),
"trim 后的重复插件名应返回 PluginAlreadyRegistered"
);
let config = serde_json::json!({"enabled": true});
manager
.load_config(" plugin_a ", config.clone())
.await
.expect("配置加载应使用 trim 后插件名");
assert_eq!(manager.get_config("plugin_a").await, Some(config.clone()));
assert_eq!(manager.get_config(" plugin_a ").await, Some(config));
}
#[tokio::test]
async fn test_register_rejects_blank_plugin_names() {
let mut builder = PluginManagerBuilder::new();
let builder_result = builder.register(PluginBlankName).await;
assert!(
matches!(builder_result, Err(BaseError::PluginRegisterFailed(name, message)) if name == "<empty>" && message.contains("插件名称不能为空")),
"构建期注册空白插件名应返回 PluginRegisterFailed"
);
let manager = PluginManager::new();
let manager_result = manager.register(PluginBlankName).await;
assert!(
matches!(manager_result, Err(BaseError::PluginRegisterFailed(name, message)) if name == "<empty>" && message.contains("插件名称不能为空")),
"运行期注册空白插件名应返回 PluginRegisterFailed"
);
}
#[tokio::test]
async fn test_builder_register_callback_failure_returns_error() {
use std::error::Error;
let mut builder = PluginManagerBuilder::new();
let result = builder.register(PluginFailing).await;
let error = match result {
Err(error) => error,
Ok(()) => panic!("注册回调失败时不应成功"),
};
assert!(matches!(
&error,
BaseError::PluginLifecycleFailed {
plugin,
stage: PluginLifecycleStage::Register,
..
} if plugin == "plugin_failing"
));
assert_eq!(error.code(), 100003);
assert!(error.source().is_some(), "注册回调底层错误链不得丢失");
}
#[tokio::test]
async fn test_builder_build_produces_registry() {
let mut builder = PluginManagerBuilder::new();
builder.register(PluginA).await.unwrap();
let registry = builder.build().expect("构建注册表应成功");
assert!(
registry.get("plugin_a").is_some(),
"registry 应包含已注册的插件"
);
assert_eq!(registry.get_all().len(), 1, "registry 应有 1 个插件");
}
#[tokio::test]
async fn test_registry_get_returns_correct_plugin() {
let mut builder = PluginManagerBuilder::new();
builder.register(PluginA).await.unwrap();
builder.register(PluginB).await.unwrap();
let registry = builder.build().expect("构建注册表应成功");
let plugin = registry.get("plugin_a").unwrap();
assert_eq!(plugin.name(), "plugin_a", "get() 应返回正确名称的插件");
assert_eq!(plugin.version(), "0.1.0", "get() 应返回正确版本的插件");
}
#[tokio::test]
async fn test_registry_shutdown_succeeds() {
let mut builder = PluginManagerBuilder::new();
builder.register(PluginA).await.unwrap();
builder.register(PluginB).await.unwrap();
let registry = builder.build().expect("构建注册表应成功");
let result = registry.shutdown().await;
assert!(result.is_ok(), "shutdown() 应成功执行");
}
#[tokio::test]
async fn test_shutdown_calls_in_reverse_topological_order() {
use std::sync::Mutex;
static SHUTDOWN_ORDER: Mutex<Vec<String>> = Mutex::new(Vec::new());
SHUTDOWN_ORDER.lock().unwrap().clear();
struct PluginA;
#[async_trait]
impl Plugin for PluginA {
fn name(&self) -> &str {
"plugin_a"
}
async fn on_shutdown(&self) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
SHUTDOWN_ORDER.lock().unwrap().push("plugin_a".to_string());
Ok(())
}
}
struct PluginB;
#[async_trait]
impl Plugin for PluginB {
fn name(&self) -> &str {
"plugin_b"
}
fn dependencies(&self) -> &[&str] {
&["plugin_a"]
}
async fn on_shutdown(&self) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
SHUTDOWN_ORDER.lock().unwrap().push("plugin_b".to_string());
Ok(())
}
}
struct PluginC;
#[async_trait]
impl Plugin for PluginC {
fn name(&self) -> &str {
"plugin_c"
}
fn dependencies(&self) -> &[&str] {
&["plugin_b"]
}
async fn on_shutdown(&self) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
SHUTDOWN_ORDER.lock().unwrap().push("plugin_c".to_string());
Ok(())
}
}
let mut builder = PluginManagerBuilder::new();
builder.register(PluginA).await.unwrap();
builder.register(PluginB).await.unwrap();
builder.register(PluginC).await.unwrap();
let registry = builder.build().expect("构建注册表应成功");
let result = registry.shutdown().await;
assert!(result.is_ok(), "shutdown() 应成功执行");
let order = SHUTDOWN_ORDER.lock().unwrap().clone();
assert_eq!(
order,
vec!["plugin_c", "plugin_b", "plugin_a"],
"shutdown 应按逆拓扑顺序关闭:C (依赖B) → B (依赖A) → A"
);
}
#[tokio::test]
async fn test_manager_shutdown_reverse_order_with_spaced_name() {
use std::sync::Mutex;
static SHUTDOWN_ORDER: Mutex<Vec<String>> = Mutex::new(Vec::new());
SHUTDOWN_ORDER.lock().unwrap().clear();
struct SpacedShutdownA;
#[async_trait]
impl Plugin for SpacedShutdownA {
fn name(&self) -> &str {
" plugin_a "
}
async fn on_shutdown(&self) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
SHUTDOWN_ORDER.lock().unwrap().push("plugin_a".to_string());
Ok(())
}
}
struct ShutdownB;
#[async_trait]
impl Plugin for ShutdownB {
fn name(&self) -> &str {
"plugin_b"
}
fn dependencies(&self) -> &[&str] {
&["plugin_a"]
}
async fn on_shutdown(&self) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
SHUTDOWN_ORDER.lock().unwrap().push("plugin_b".to_string());
Ok(())
}
}
struct ShutdownC;
#[async_trait]
impl Plugin for ShutdownC {
fn name(&self) -> &str {
"plugin_c"
}
fn dependencies(&self) -> &[&str] {
&["plugin_b"]
}
async fn on_shutdown(&self) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
SHUTDOWN_ORDER.lock().unwrap().push("plugin_c".to_string());
Ok(())
}
}
let manager = PluginManager::new();
manager.register(SpacedShutdownA).await.unwrap();
manager.register(ShutdownB).await.unwrap();
manager.register(ShutdownC).await.unwrap();
manager.shutdown().await.expect("shutdown 应成功执行");
let order = SHUTDOWN_ORDER.lock().unwrap().clone();
assert_eq!(
order,
vec!["plugin_c", "plugin_b", "plugin_a"],
"shutdown 应按逆拓扑顺序关闭:C (依赖B) → B (依赖A) → A"
);
}
#[tokio::test]
async fn test_builder_new_creates_empty_builder() {
let builder = PluginManagerBuilder::new();
let registry = builder.build().expect("空构建器构建应成功");
assert_eq!(registry.get_all().len(), 0, "空构建器应生成空 registry");
assert!(
registry.get("any").is_none(),
"空 registry 不应包含任何插件"
);
}
#[tokio::test]
async fn test_build_detects_missing_dependency() {
let mut builder = PluginManagerBuilder::new();
builder
.register(PluginB)
.await
.expect("注册 plugin_b 应成功");
let result = builder.build();
assert!(
matches!(result, Err(BaseError::PluginDependencyMissing(_, _))),
"依赖未注册时应返回 PluginDependencyMissing 错误"
);
if let Err(BaseError::PluginDependencyMissing(plugin, dep)) = result {
assert_eq!(plugin, "plugin_b", "错误应指向 plugin_b");
assert_eq!(dep, "plugin_a", "缺失的依赖应是 plugin_a");
}
}
#[tokio::test]
async fn test_build_detects_circular_dependency() {
struct PluginX;
#[async_trait]
impl Plugin for PluginX {
fn name(&self) -> &str {
"plugin_x"
}
fn dependencies(&self) -> &[&str] {
&["plugin_y"]
}
}
struct PluginY;
#[async_trait]
impl Plugin for PluginY {
fn name(&self) -> &str {
"plugin_y"
}
fn dependencies(&self) -> &[&str] {
&["plugin_x"]
}
}
let mut builder = PluginManagerBuilder::new();
builder
.register(PluginX)
.await
.expect("注册 plugin_x 应成功");
builder
.register(PluginY)
.await
.expect("注册 plugin_y 应成功");
let result = builder.build();
assert!(
matches!(result, Err(BaseError::PluginCircularDependency(_))),
"循环依赖时应返回 PluginCircularDependency 错误"
);
if let Err(BaseError::PluginCircularDependency(msg)) = result {
assert!(
msg.contains("plugin_x") || msg.contains("plugin_y"),
"错误信息应包含循环中的插件名称"
);
}
}
#[cfg(feature = "plugin-schema")]
#[tokio::test]
async fn test_validate_config_with_schema() {
use serde_json::json;
struct SchemaPlugin;
#[async_trait]
impl Plugin for SchemaPlugin {
fn name(&self) -> &str {
"schema_plugin"
}
fn config_schema(&self) -> Option<JsonValue> {
Some(json!({
"type": "object",
"properties": {
"host": {"type": "string"},
"port": {"type": "integer"}
},
"required": ["host", "port"]
}))
}
}
let manager = PluginManager::new();
manager.register(SchemaPlugin).await.expect("注册应成功");
let valid_config = json!({"host": "localhost", "port": 3306});
let result = manager.load_config("schema_plugin", valid_config).await;
assert!(result.is_ok(), "合法配置应通过验证");
}
#[cfg(feature = "plugin-schema")]
#[tokio::test]
async fn test_validate_config_invalid_returns_error() {
use serde_json::json;
struct StrictPlugin;
#[async_trait]
impl Plugin for StrictPlugin {
fn name(&self) -> &str {
"strict_plugin"
}
fn config_schema(&self) -> Option<JsonValue> {
Some(json!({
"type": "object",
"properties": {
"port": {"type": "integer"}
},
"required": ["port"]
}))
}
}
let manager = PluginManager::new();
manager.register(StrictPlugin).await.expect("注册应成功");
let invalid_config = json!({"host": "localhost"});
let result = manager.load_config("strict_plugin", invalid_config).await;
assert!(
matches!(result, Err(BaseError::PluginConfigInvalid(_, _))),
"配置不符合 Schema 应返回 PluginConfigInvalid 错误"
);
}
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn concurrent_same_name_register_keeps_map_consistent() {
struct DupPlugin;
#[async_trait]
impl Plugin for DupPlugin {
fn name(&self) -> &str {
"dup_plugin"
}
}
let manager = Arc::new(PluginManager::new());
let mut handles = Vec::new();
for _ in 0..16 {
let m = Arc::clone(&manager);
handles.push(tokio::spawn(async move { m.register(DupPlugin).await }));
}
let mut ok_count = 0usize;
for h in handles {
let res = h.await.expect("注册任务不应 panic");
if res.is_ok() {
ok_count += 1;
}
}
assert!(ok_count >= 1, "并发同名注册应至少有一个成功");
let got = manager.get("dup_plugin").await;
assert!(got.is_some(), "并发注册后应能查到 dup_plugin");
assert_eq!(got.unwrap().name(), "dup_plugin");
}
#[tokio::test(flavor = "multi_thread", worker_threads = 4)]
async fn concurrent_distinct_register_no_loss() {
macro_rules! make_plugin {
($ty:ident, $name:literal) => {
struct $ty;
#[async_trait]
impl Plugin for $ty {
fn name(&self) -> &str {
$name
}
}
};
}
make_plugin!(P0, "cn_p0");
make_plugin!(P1, "cn_p1");
make_plugin!(P2, "cn_p2");
make_plugin!(P3, "cn_p3");
make_plugin!(P4, "cn_p4");
make_plugin!(P5, "cn_p5");
make_plugin!(P6, "cn_p6");
make_plugin!(P7, "cn_p7");
let manager = Arc::new(PluginManager::new());
let m = Arc::clone(&manager);
let (r0, r1, r2, r3, r4, r5, r6, r7) = tokio::join!(
{
let m = Arc::clone(&m);
async move { m.register(P0).await }
},
{
let m = Arc::clone(&m);
async move { m.register(P1).await }
},
{
let m = Arc::clone(&m);
async move { m.register(P2).await }
},
{
let m = Arc::clone(&m);
async move { m.register(P3).await }
},
{
let m = Arc::clone(&m);
async move { m.register(P4).await }
},
{
let m = Arc::clone(&m);
async move { m.register(P5).await }
},
{
let m = Arc::clone(&m);
async move { m.register(P6).await }
},
{
let m = Arc::clone(&m);
async move { m.register(P7).await }
},
);
for r in [r0, r1, r2, r3, r4, r5, r6, r7] {
r.expect("不同名插件注册应全部成功");
}
for i in 0..8 {
let name = format!("cn_p{}", i);
assert!(
manager.get(&name).await.is_some(),
"{} 应已注册且可查到",
name
);
}
}