use async_trait::async_trait;
use serde_json::json;
use yang_base::error::BaseError;
use yang_base::plugin::{Plugin, PluginManager};
struct BasicPlugin;
#[async_trait]
impl Plugin for BasicPlugin {
fn name(&self) -> &str {
"basic_plugin"
}
fn version(&self) -> &str {
"1.0.0"
}
}
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 ConfigurablePlugin;
#[async_trait]
impl Plugin for ConfigurablePlugin {
fn name(&self) -> &str {
"configurable_plugin"
}
fn config_schema(&self) -> Option<serde_json::Value> {
Some(json!({
"type": "object",
"properties": {
"host": {"type": "string"},
"port": {"type": "number"}
},
"required": ["host", "port"]
}))
}
}
struct LifecyclePlugin {
register_called: std::sync::Arc<std::sync::Mutex<bool>>,
init_called: std::sync::Arc<std::sync::Mutex<bool>>,
shutdown_called: std::sync::Arc<std::sync::Mutex<bool>>,
}
impl LifecyclePlugin {
fn new() -> Self {
Self {
register_called: std::sync::Arc::new(std::sync::Mutex::new(false)),
init_called: std::sync::Arc::new(std::sync::Mutex::new(false)),
shutdown_called: std::sync::Arc::new(std::sync::Mutex::new(false)),
}
}
fn is_register_called(&self) -> bool {
*self.register_called.lock().unwrap()
}
fn is_init_called(&self) -> bool {
*self.init_called.lock().unwrap()
}
fn is_shutdown_called(&self) -> bool {
*self.shutdown_called.lock().unwrap()
}
}
#[async_trait]
impl Plugin for LifecyclePlugin {
fn name(&self) -> &str {
"lifecycle_plugin"
}
async fn on_register(&self) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
*self.register_called.lock().unwrap() = true;
Ok(())
}
async fn on_init(&self) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
*self.init_called.lock().unwrap() = true;
Ok(())
}
async fn on_shutdown(&self) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
*self.shutdown_called.lock().unwrap() = true;
Ok(())
}
}
struct FailingPlugin;
#[async_trait]
impl Plugin for FailingPlugin {
fn name(&self) -> &str {
"failing_plugin"
}
async fn on_register(&self) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
Err("注册失败".into())
}
}
#[tokio::test]
async fn test_register_plugin() {
let manager = PluginManager::new();
let result = manager.register(BasicPlugin).await;
assert!(result.is_ok(), "插件注册应该成功");
let plugin = manager.get("basic_plugin").await;
assert!(plugin.is_some(), "应该能找到已注册的插件");
assert_eq!(plugin.unwrap().name(), "basic_plugin");
}
#[tokio::test]
async fn test_register_duplicate_plugin() {
let manager = PluginManager::new();
let result = manager.register(BasicPlugin).await;
assert!(result.is_ok(), "第一次注册应该成功");
let result = manager.register(BasicPlugin).await;
assert!(result.is_err(), "重复注册应该失败");
match result {
Err(BaseError::PluginAlreadyRegistered(name)) => {
assert_eq!(name, "basic_plugin");
}
_ => panic!("应该返回 PluginAlreadyRegistered 错误"),
}
}
#[tokio::test]
async fn test_get_nonexistent_plugin() {
let manager = PluginManager::new();
let plugin = manager.get("nonexistent_plugin").await;
assert!(plugin.is_none(), "不存在的插件应该返回 None");
}
#[tokio::test]
async fn test_get_all_plugins() {
let manager = PluginManager::new();
manager.register(BasicPlugin).await.unwrap();
manager.register(PluginA).await.unwrap();
let plugins = manager.get_all().await;
assert_eq!(plugins.len(), 2, "应该有 2 个插件");
let names: Vec<&str> = plugins.iter().map(|p| p.name()).collect();
assert!(names.contains(&"basic_plugin"));
assert!(names.contains(&"plugin_a"));
}
#[tokio::test]
async fn test_topological_sort() {
let manager = PluginManager::new();
manager.register(PluginC).await.unwrap();
manager.register(PluginB).await.unwrap();
manager.register(PluginA).await.unwrap();
let plugins = manager.get_all().await;
assert_eq!(plugins.len(), 3, "应该有 3 个插件");
assert_eq!(plugins[0].name(), "plugin_a", "plugin_a 应该排在第一位");
assert_eq!(plugins[1].name(), "plugin_b", "plugin_b 应该排在第二位");
assert_eq!(plugins[2].name(), "plugin_c", "plugin_c 应该排在第三位");
}
#[tokio::test]
async fn test_complex_dependencies() {
let manager = PluginManager::new();
struct PluginD;
#[async_trait]
impl Plugin for PluginD {
fn name(&self) -> &str {
"plugin_d"
}
fn dependencies(&self) -> &[&str] {
&["plugin_a", "plugin_b"]
}
}
manager.register(PluginD).await.unwrap();
manager.register(PluginC).await.unwrap();
manager.register(PluginA).await.unwrap();
manager.register(PluginB).await.unwrap();
let plugins = manager.get_all().await;
assert_eq!(plugins.len(), 4, "应该有 4 个插件");
let pos_a = plugins.iter().position(|p| p.name() == "plugin_a").unwrap();
let pos_b = plugins.iter().position(|p| p.name() == "plugin_b").unwrap();
let pos_d = plugins.iter().position(|p| p.name() == "plugin_d").unwrap();
assert!(pos_a < pos_b, "plugin_a 应该在 plugin_b 之前");
assert!(pos_a < pos_d, "plugin_a 应该在 plugin_d 之前");
let pos_c = plugins.iter().position(|p| p.name() == "plugin_c").unwrap();
assert!(pos_b < pos_c, "plugin_b 应该在 plugin_c 之前");
assert!(pos_b < pos_d, "plugin_b 应该在 plugin_d 之前");
}
#[tokio::test]
async fn test_load_config() {
let manager = PluginManager::new();
manager.register(ConfigurablePlugin).await.unwrap();
let config = json!({
"host": "localhost",
"port": 3306
});
let result = manager
.load_config("configurable_plugin", config.clone())
.await;
assert!(result.is_ok(), "配置加载应该成功");
let loaded_config = manager.get_config("configurable_plugin").await;
assert!(loaded_config.is_some(), "应该能获取到配置");
assert_eq!(loaded_config.unwrap(), config);
}
#[tokio::test]
async fn test_load_config_nonexistent_plugin() {
let manager = PluginManager::new();
let config = json!({"key": "value"});
let result = manager.load_config("nonexistent_plugin", config).await;
assert!(result.is_err(), "加载不存在插件的配置应该失败");
match result {
Err(BaseError::PluginNotFound(name)) => {
assert_eq!(name, "nonexistent_plugin");
}
_ => panic!("应该返回 PluginNotFound 错误"),
}
}
#[tokio::test]
async fn test_get_nonexistent_config() {
let manager = PluginManager::new();
manager.register(BasicPlugin).await.unwrap();
let config = manager.get_config("basic_plugin").await;
assert!(config.is_none(), "未加载的配置应该返回 None");
}
#[tokio::test]
async fn test_lifecycle_hooks() {
let manager = PluginManager::new();
let plugin = LifecyclePlugin::new();
assert!(!plugin.is_register_called(), "注册钩子未调用");
assert!(!plugin.is_init_called(), "初始化钩子未调用");
assert!(!plugin.is_shutdown_called(), "关闭钩子未调用");
let register_called = plugin.register_called.clone();
manager.register(plugin).await.unwrap();
assert!(*register_called.lock().unwrap(), "注册钩子应该被调用");
let plugin = manager.get("lifecycle_plugin").await.unwrap();
plugin.on_init().await.unwrap();
manager.shutdown().await.unwrap();
}
#[tokio::test]
async fn test_register_failing_plugin() {
use std::error::Error;
let manager = PluginManager::new();
let result = manager.register(FailingPlugin).await;
assert!(result.is_err(), "注册应该失败");
match result {
Err(error @ BaseError::PluginLifecycleFailed { .. }) => {
assert!(matches!(
&error,
BaseError::PluginLifecycleFailed {
plugin,
stage: yang_base::plugin::PluginLifecycleStage::Register,
..
} if plugin == "failing_plugin"
));
assert!(error.to_string().contains("注册失败"));
assert!(error.source().is_some());
}
_ => panic!("应该返回 PluginLifecycleFailed 错误"),
}
let plugin = manager.get("failing_plugin").await;
assert!(plugin.is_none(), "失败的插件不应该被注册");
}
#[tokio::test]
async fn test_shutdown() {
let manager = PluginManager::new();
manager.register(PluginA).await.unwrap();
manager.register(PluginB).await.unwrap();
manager.register(PluginC).await.unwrap();
let result = manager.shutdown().await;
assert!(result.is_ok(), "关闭应该成功");
}
#[tokio::test]
async fn test_default() {
let manager = PluginManager::default();
manager.register(BasicPlugin).await.unwrap();
let plugin = manager.get("basic_plugin").await;
assert!(plugin.is_some(), "应该能找到插件");
}
#[tokio::test]
async fn test_plugin_version() {
let manager = PluginManager::new();
manager.register(BasicPlugin).await.unwrap();
let plugin = manager.get("basic_plugin").await.unwrap();
assert_eq!(plugin.version(), "1.0.0", "版本应该是 1.0.0");
}
#[tokio::test]
async fn test_plugin_dependencies() {
let manager = PluginManager::new();
manager.register(PluginB).await.unwrap();
let plugin = manager.get("plugin_b").await.unwrap();
let deps = plugin.dependencies();
assert_eq!(deps.len(), 1, "应该有 1 个依赖");
assert_eq!(deps[0], "plugin_a");
}