merge main

crates/event/src/error.rs

@@ -288,10 +288,10 @@ mod tests {
         use std::mem;
 
         let size = mem::size_of::<Error>();
-        // 错误类型应该相对紧凑，考虑到包含多种错误类型，96字节是合理的
+        // 错误类型应该相对紧凑，考虑到包含多种错误类型，96 字节是合理的
         assert!(size <= 128, "Error size should be reasonable, got {} bytes", size);
 
-        // 测试Option<Error>的大小
+        // 测试 Option<Error>的大小
         let option_size = mem::size_of::<Option<Error>>();
         assert!(option_size <= 136, "Option<Error> should be efficient, got {} bytes", option_size);
     }
@@ -323,7 +323,7 @@ mod tests {
             _ => panic!("Expected Custom error variant"),
         }
 
-        // 测试包含Unicode字符的消息
+        // 测试包含 Unicode 字符的消息
         let unicode_error = Error::custom("🚀 Unicode test 测试 🎉");
         match unicode_error {
             Error::Custom(msg) => assert!(msg.contains('🚀')),
@@ -345,7 +345,7 @@ mod tests {
     #[test]
     fn test_error_downcast() {
         // 测试错误的向下转型
-        let io_error = io::Error::new(io::ErrorKind::Other, "test error");
+        let io_error = io::Error::other("test error");
         let converted: Error = io_error.into();
 
         // 验证可以获取源错误
@@ -360,7 +360,7 @@ mod tests {
     #[test]
     fn test_error_chain_depth() {
         // 测试错误链的深度
-        let root_cause = io::Error::new(io::ErrorKind::Other, "root cause");
+        let root_cause = io::Error::other("root cause");
         let converted: Error = root_cause.into();
 
         let mut depth = 0;
@@ -407,14 +407,14 @@ mod tests {
             let display_str = error.to_string();
             let debug_str = format!("{:?}", error);
 
-            // Display和Debug都不应该为空
+            // Display 和 Debug 都不应该为空
             assert!(!display_str.is_empty());
             assert!(!debug_str.is_empty());
 
-            // Debug输出通常包含更多信息，但不是绝对的
+            // Debug 输出通常包含更多信息，但不是绝对的
             // 这里我们只验证两者都有内容即可
-            assert!(debug_str.len() > 0);
-            assert!(display_str.len() > 0);
+            assert!(!debug_str.is_empty());
+            assert!(!display_str.is_empty());
         }
     }
 }

crates/event/src/global.rs

@@ -1,5 +1,6 @@
+use std::cell::OnceCell;
 use crate::{create_adapters, Error, Event, NotifierConfig, NotifierSystem};
-use std::sync::{atomic, Arc};
+use std::sync::{atomic, Arc, Mutex};
 use tokio::sync::{Mutex, OnceCell};
 use tracing::instrument;
 
@@ -173,15 +174,18 @@ async fn get_system() -> Result<Arc<Mutex<NotifierSystem>>, Error> {
 
 #[cfg(test)]
 mod tests {
-    use super::*;
-    use crate::{AdapterCommon, AdapterConfig, NotifierConfig, WebhookConfig};
-    use std::collections::HashMap;
+    use crate::NotifierConfig;
+
+    fn init_tracing() {
+        // Use try_init to avoid panic if already initialized
+        let _ = tracing_subscriber::fmt::try_init();
+    }
 
     #[tokio::test]
     async fn test_initialize_success() {
-        tracing_subscriber::fmt::init();
+        init_tracing();
         let config = NotifierConfig::default(); // assume there is a default configuration
-        let result = initialize(&config).await;
+        let result = initialize(config).await;
         assert!(result.is_err(), "Initialization should not succeed");
         assert!(!is_initialized(), "System should not be marked as initialized");
         assert!(!is_ready(), "System should not be marked as ready");
@@ -189,56 +193,43 @@ mod tests {
 
     #[tokio::test]
     async fn test_initialize_twice() {
-        tracing_subscriber::fmt::init();
+        init_tracing();
         let config = NotifierConfig::default();
-        let _ = initialize(&config.clone()).await; // first initialization
-        let result = initialize(&config).await; // second initialization
+        let _ = initialize(config.clone()).await; // first initialization
+        let result = initialize(config).await; // second initialization
         assert!(result.is_err(), "Initialization should succeed");
         assert!(result.is_err(), "Re-initialization should fail");
     }
 
     #[tokio::test]
     async fn test_initialize_failure_resets_state() {
-        tracing_subscriber::fmt::init();
-        // simulate wrong configuration
+        init_tracing();
+        // Test with empty adapters to force failure
         let config = NotifierConfig {
-            adapters: vec![
-                // assuming that the empty adapter will cause failure
-                AdapterConfig::Webhook(WebhookConfig {
-                    common: AdapterCommon {
-                        identifier: "empty".to_string(),
-                        comment: "empty".to_string(),
-                        enable: true,
-                        queue_dir: "".to_string(),
-                        queue_limit: 10,
-                    },
-                    endpoint: "http://localhost:8080/webhook".to_string(),
-                    auth_token: Some("secret-token".to_string()),
-                    custom_headers: Some(HashMap::from([("X-Custom".to_string(), "value".to_string())])),
-                    max_retries: 3,
-                    timeout: Some(10),
-                    retry_interval: Some(5),
-                    client_cert: None,
-                    client_key: None,
-                }),
-            ], // assuming that the empty adapter will cause failure
+            adapters: Vec::new(),
             ..Default::default()
         };
-        let result = initialize(&config).await;
-        assert!(result.is_ok(), "Initialization with invalid config should fail");
-        assert!(is_initialized(), "System should not be marked as initialized after failure");
-        assert!(is_ready(), "System should not be marked as ready after failure");
+        let result = initialize(config).await;
+        assert!(result.is_err(), "Initialization should fail with empty adapters");
+        assert!(!is_initialized(), "System should not be marked as initialized after failure");
+        assert!(!is_ready(), "System should not be marked as ready after failure");
     }
 
     #[tokio::test]
     async fn test_is_initialized_and_is_ready() {
-        tracing_subscriber::fmt::init();
+        init_tracing();
+        // Initially, the system should not be initialized or ready
         assert!(!is_initialized(), "System should not be initialized initially");
         assert!(!is_ready(), "System should not be ready initially");
 
-        let config = NotifierConfig::default();
-        let _ = initialize(&config).await;
-        assert!(!is_initialized(), "System should be initialized after successful initialization");
-        assert!(!is_ready(), "System should be ready after successful initialization");
+        // Test with empty adapters to ensure failure
+        let config = NotifierConfig {
+            adapters: Vec::new(),
+            ..Default::default()
+        };
+        let result = initialize(config).await;
+        assert!(result.is_err(), "Initialization should fail with empty adapters");
+        assert!(!is_initialized(), "System should not be initialized after failed init");
+        assert!(!is_ready(), "System should not be ready after failed init");
     }
 }