spikard 0.5.0 → 0.6.1

data/vendor/crates/spikard-bindings-shared/src/lifecycle_base.rs

@@ -1,292 +1,292 @@
-//! Lifecycle hook base implementations
-
-use std::sync::Arc;
-
-/// Lifecycle hook types supported across all bindings
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum LifecycleHookType {
-    /// Called at the start of request processing
-    OnRequest,
-    /// Called before validation
-    PreValidation,
-    /// Called before handler execution
-    PreHandler,
-    /// Called after handler execution
-    OnResponse,
-    /// Called when an error occurs
-    OnError,
-}
-
-/// Result type for lifecycle hooks
-#[derive(Clone)]
-pub enum HookResult {
-    /// Continue with normal processing
-    Continue,
-    /// Short-circuit and return this response
-    ShortCircuit(serde_json::Value),
-}
-
-/// Trait for implementing lifecycle hooks in language bindings
-pub trait LifecycleHook: Send + Sync {
-    /// Execute the lifecycle hook
-    fn execute(&self, context: serde_json::Value) -> Result<HookResult, String>;
-
-    /// Get the hook type
-    fn hook_type(&self) -> LifecycleHookType;
-}
-
-/// Base configuration for lifecycle hooks
-pub struct LifecycleConfig {
-    /// Registered hooks by type
-    hooks: std::collections::HashMap<LifecycleHookType, Vec<Arc<dyn LifecycleHook>>>,
-}
-
-impl LifecycleConfig {
-    /// Create a new lifecycle configuration
-    pub fn new() -> Self {
-        Self {
-            hooks: std::collections::HashMap::new(),
-        }
-    }
-
-    /// Register a lifecycle hook
-    pub fn register(&mut self, hook: Arc<dyn LifecycleHook>) {
-        self.hooks.entry(hook.hook_type()).or_default().push(hook);
-    }
-
-    /// Get hooks for a specific type
-    pub fn get_hooks(&self, hook_type: LifecycleHookType) -> Vec<Arc<dyn LifecycleHook>> {
-        self.hooks.get(&hook_type).cloned().unwrap_or_default()
-    }
-}
-
-impl Default for LifecycleConfig {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use serde_json::json;
-
-    struct TestHook {
-        hook_type: LifecycleHookType,
-        result: HookResult,
-    }
-
-    impl LifecycleHook for TestHook {
-        fn execute(&self, _context: serde_json::Value) -> Result<HookResult, String> {
-            Ok(self.result.clone())
-        }
-
-        fn hook_type(&self) -> LifecycleHookType {
-            self.hook_type
-        }
-    }
-
-    #[test]
-    fn test_lifecycle_hook_type_equality() {
-        assert_eq!(LifecycleHookType::OnRequest, LifecycleHookType::OnRequest);
-        assert_ne!(LifecycleHookType::OnRequest, LifecycleHookType::OnResponse);
-    }
-
-    #[test]
-    fn test_lifecycle_hook_type_hash() {
-        use std::collections::HashSet;
-
-        let mut set = HashSet::new();
-        set.insert(LifecycleHookType::OnRequest);
-        set.insert(LifecycleHookType::PreHandler);
-        set.insert(LifecycleHookType::OnRequest);
-
-        assert_eq!(set.len(), 2);
-    }
-
-    #[test]
-    fn test_hook_result_continue() {
-        let result = HookResult::Continue;
-        match result {
-            HookResult::Continue => {}
-            HookResult::ShortCircuit(_) => panic!("Expected Continue"),
-        }
-    }
-
-    #[test]
-    fn test_hook_result_short_circuit() {
-        let response = json!({ "status": "error" });
-        let result = HookResult::ShortCircuit(response.clone());
-        match result {
-            HookResult::Continue => panic!("Expected ShortCircuit"),
-            HookResult::ShortCircuit(r) => {
-                assert_eq!(r, response);
-            }
-        }
-    }
-
-    #[test]
-    fn test_lifecycle_config_new() {
-        let config = LifecycleConfig::new();
-        assert_eq!(config.get_hooks(LifecycleHookType::OnRequest).len(), 0);
-    }
-
-    #[test]
-    fn test_lifecycle_config_default() {
-        let config = LifecycleConfig::default();
-        assert_eq!(config.get_hooks(LifecycleHookType::OnRequest).len(), 0);
-    }
-
-    #[test]
-    fn test_register_single_hook() {
-        let mut config = LifecycleConfig::new();
-        let hook = Arc::new(TestHook {
-            hook_type: LifecycleHookType::OnRequest,
-            result: HookResult::Continue,
-        });
-
-        config.register(hook);
-
-        let hooks = config.get_hooks(LifecycleHookType::OnRequest);
-        assert_eq!(hooks.len(), 1);
-    }
-
-    #[test]
-    fn test_register_multiple_hooks_same_type() {
-        let mut config = LifecycleConfig::new();
-
-        for i in 0..3 {
-            let hook = Arc::new(TestHook {
-                hook_type: LifecycleHookType::OnRequest,
-                result: if i == 0 {
-                    HookResult::Continue
-                } else {
-                    HookResult::ShortCircuit(json!({ "index": i }))
-                },
-            });
-            config.register(hook);
-        }
-
-        let hooks = config.get_hooks(LifecycleHookType::OnRequest);
-        assert_eq!(hooks.len(), 3);
-    }
-
-    #[test]
-    fn test_register_hooks_different_types() {
-        let mut config = LifecycleConfig::new();
-
-        let hook_on_request = Arc::new(TestHook {
-            hook_type: LifecycleHookType::OnRequest,
-            result: HookResult::Continue,
-        });
-
-        let hook_on_error = Arc::new(TestHook {
-            hook_type: LifecycleHookType::OnError,
-            result: HookResult::Continue,
-        });
-
-        config.register(hook_on_request);
-        config.register(hook_on_error);
-
-        assert_eq!(config.get_hooks(LifecycleHookType::OnRequest).len(), 1);
-        assert_eq!(config.get_hooks(LifecycleHookType::OnError).len(), 1);
-        assert_eq!(config.get_hooks(LifecycleHookType::PreHandler).len(), 0);
-    }
-
-    #[test]
-    fn test_get_hooks_empty() {
-        let config = LifecycleConfig::new();
-        let hooks = config.get_hooks(LifecycleHookType::PreValidation);
-        assert!(hooks.is_empty());
-    }
-
-    #[test]
-    fn test_get_hooks_multiple_calls() {
-        let mut config = LifecycleConfig::new();
-
-        let hook1 = Arc::new(TestHook {
-            hook_type: LifecycleHookType::OnResponse,
-            result: HookResult::Continue,
-        });
-
-        let hook2 = Arc::new(TestHook {
-            hook_type: LifecycleHookType::OnResponse,
-            result: HookResult::Continue,
-        });
-
-        config.register(hook1);
-        config.register(hook2);
-
-        let hooks1 = config.get_hooks(LifecycleHookType::OnResponse);
-        let hooks2 = config.get_hooks(LifecycleHookType::OnResponse);
-
-        assert_eq!(hooks1.len(), 2);
-        assert_eq!(hooks2.len(), 2);
-    }
-
-    #[test]
-    fn test_hook_execute() {
-        let hook = TestHook {
-            hook_type: LifecycleHookType::OnRequest,
-            result: HookResult::Continue,
-        };
-
-        let context = json!({ "test": "data" });
-        let result = hook.execute(context);
-
-        assert!(result.is_ok());
-        match result.unwrap() {
-            HookResult::Continue => {}
-            HookResult::ShortCircuit(_) => panic!("Expected Continue"),
-        }
-    }
-
-    #[test]
-    fn test_hook_type_retrieval() {
-        let hook = TestHook {
-            hook_type: LifecycleHookType::PreValidation,
-            result: HookResult::Continue,
-        };
-
-        assert_eq!(hook.hook_type(), LifecycleHookType::PreValidation);
-    }
-
-    #[test]
-    fn test_all_hook_types() {
-        let hook_types = vec![
-            LifecycleHookType::OnRequest,
-            LifecycleHookType::PreValidation,
-            LifecycleHookType::PreHandler,
-            LifecycleHookType::OnResponse,
-            LifecycleHookType::OnError,
-        ];
-
-        let mut config = LifecycleConfig::new();
-
-        for hook_type in hook_types.iter() {
-            let hook = Arc::new(TestHook {
-                hook_type: *hook_type,
-                result: HookResult::Continue,
-            });
-            config.register(hook);
-        }
-
-        for hook_type in hook_types {
-            let hooks = config.get_hooks(hook_type);
-            assert_eq!(hooks.len(), 1);
-        }
-    }
-
-    #[test]
-    fn test_hook_result_clone() {
-        let original = HookResult::ShortCircuit(json!({ "key": "value" }));
-        let cloned = original.clone();
-
-        match cloned {
-            HookResult::ShortCircuit(response) => {
-                assert_eq!(response["key"], "value");
-            }
-            _ => panic!("Expected ShortCircuit"),
-        }
-    }
-}
+//! Lifecycle hook base implementations
+
+use std::sync::Arc;
+
+/// Lifecycle hook types supported across all bindings
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum LifecycleHookType {
+    /// Called at the start of request processing
+    OnRequest,
+    /// Called before validation
+    PreValidation,
+    /// Called before handler execution
+    PreHandler,
+    /// Called after handler execution
+    OnResponse,
+    /// Called when an error occurs
+    OnError,
+}
+
+/// Result type for lifecycle hooks
+#[derive(Clone)]
+pub enum HookResult {
+    /// Continue with normal processing
+    Continue,
+    /// Short-circuit and return this response
+    ShortCircuit(serde_json::Value),
+}
+
+/// Trait for implementing lifecycle hooks in language bindings
+pub trait LifecycleHook: Send + Sync {
+    /// Execute the lifecycle hook
+    fn execute(&self, context: serde_json::Value) -> Result<HookResult, String>;
+
+    /// Get the hook type
+    fn hook_type(&self) -> LifecycleHookType;
+}
+
+/// Base configuration for lifecycle hooks
+pub struct LifecycleConfig {
+    /// Registered hooks by type
+    hooks: std::collections::HashMap<LifecycleHookType, Vec<Arc<dyn LifecycleHook>>>,
+}
+
+impl LifecycleConfig {
+    /// Create a new lifecycle configuration
+    pub fn new() -> Self {
+        Self {
+            hooks: std::collections::HashMap::new(),
+        }
+    }
+
+    /// Register a lifecycle hook
+    pub fn register(&mut self, hook: Arc<dyn LifecycleHook>) {
+        self.hooks.entry(hook.hook_type()).or_default().push(hook);
+    }
+
+    /// Get hooks for a specific type
+    pub fn get_hooks(&self, hook_type: LifecycleHookType) -> Vec<Arc<dyn LifecycleHook>> {
+        self.hooks.get(&hook_type).cloned().unwrap_or_default()
+    }
+}
+
+impl Default for LifecycleConfig {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    struct TestHook {
+        hook_type: LifecycleHookType,
+        result: HookResult,
+    }
+
+    impl LifecycleHook for TestHook {
+        fn execute(&self, _context: serde_json::Value) -> Result<HookResult, String> {
+            Ok(self.result.clone())
+        }
+
+        fn hook_type(&self) -> LifecycleHookType {
+            self.hook_type
+        }
+    }
+
+    #[test]
+    fn test_lifecycle_hook_type_equality() {
+        assert_eq!(LifecycleHookType::OnRequest, LifecycleHookType::OnRequest);
+        assert_ne!(LifecycleHookType::OnRequest, LifecycleHookType::OnResponse);
+    }
+
+    #[test]
+    fn test_lifecycle_hook_type_hash() {
+        use std::collections::HashSet;
+
+        let mut set = HashSet::new();
+        set.insert(LifecycleHookType::OnRequest);
+        set.insert(LifecycleHookType::PreHandler);
+        set.insert(LifecycleHookType::OnRequest);
+
+        assert_eq!(set.len(), 2);
+    }
+
+    #[test]
+    fn test_hook_result_continue() {
+        let result = HookResult::Continue;
+        match result {
+            HookResult::Continue => {}
+            HookResult::ShortCircuit(_) => panic!("Expected Continue"),
+        }
+    }
+
+    #[test]
+    fn test_hook_result_short_circuit() {
+        let response = json!({ "status": "error" });
+        let result = HookResult::ShortCircuit(response.clone());
+        match result {
+            HookResult::Continue => panic!("Expected ShortCircuit"),
+            HookResult::ShortCircuit(r) => {
+                assert_eq!(r, response);
+            }
+        }
+    }
+
+    #[test]
+    fn test_lifecycle_config_new() {
+        let config = LifecycleConfig::new();
+        assert_eq!(config.get_hooks(LifecycleHookType::OnRequest).len(), 0);
+    }
+
+    #[test]
+    fn test_lifecycle_config_default() {
+        let config = LifecycleConfig::default();
+        assert_eq!(config.get_hooks(LifecycleHookType::OnRequest).len(), 0);
+    }
+
+    #[test]
+    fn test_register_single_hook() {
+        let mut config = LifecycleConfig::new();
+        let hook = Arc::new(TestHook {
+            hook_type: LifecycleHookType::OnRequest,
+            result: HookResult::Continue,
+        });
+
+        config.register(hook);
+
+        let hooks = config.get_hooks(LifecycleHookType::OnRequest);
+        assert_eq!(hooks.len(), 1);
+    }
+
+    #[test]
+    fn test_register_multiple_hooks_same_type() {
+        let mut config = LifecycleConfig::new();
+
+        for i in 0..3 {
+            let hook = Arc::new(TestHook {
+                hook_type: LifecycleHookType::OnRequest,
+                result: if i == 0 {
+                    HookResult::Continue
+                } else {
+                    HookResult::ShortCircuit(json!({ "index": i }))
+                },
+            });
+            config.register(hook);
+        }
+
+        let hooks = config.get_hooks(LifecycleHookType::OnRequest);
+        assert_eq!(hooks.len(), 3);
+    }
+
+    #[test]
+    fn test_register_hooks_different_types() {
+        let mut config = LifecycleConfig::new();
+
+        let hook_on_request = Arc::new(TestHook {
+            hook_type: LifecycleHookType::OnRequest,
+            result: HookResult::Continue,
+        });
+
+        let hook_on_error = Arc::new(TestHook {
+            hook_type: LifecycleHookType::OnError,
+            result: HookResult::Continue,
+        });
+
+        config.register(hook_on_request);
+        config.register(hook_on_error);
+
+        assert_eq!(config.get_hooks(LifecycleHookType::OnRequest).len(), 1);
+        assert_eq!(config.get_hooks(LifecycleHookType::OnError).len(), 1);
+        assert_eq!(config.get_hooks(LifecycleHookType::PreHandler).len(), 0);
+    }
+
+    #[test]
+    fn test_get_hooks_empty() {
+        let config = LifecycleConfig::new();
+        let hooks = config.get_hooks(LifecycleHookType::PreValidation);
+        assert!(hooks.is_empty());
+    }
+
+    #[test]
+    fn test_get_hooks_multiple_calls() {
+        let mut config = LifecycleConfig::new();
+
+        let hook1 = Arc::new(TestHook {
+            hook_type: LifecycleHookType::OnResponse,
+            result: HookResult::Continue,
+        });
+
+        let hook2 = Arc::new(TestHook {
+            hook_type: LifecycleHookType::OnResponse,
+            result: HookResult::Continue,
+        });
+
+        config.register(hook1);
+        config.register(hook2);
+
+        let hooks1 = config.get_hooks(LifecycleHookType::OnResponse);
+        let hooks2 = config.get_hooks(LifecycleHookType::OnResponse);
+
+        assert_eq!(hooks1.len(), 2);
+        assert_eq!(hooks2.len(), 2);
+    }
+
+    #[test]
+    fn test_hook_execute() {
+        let hook = TestHook {
+            hook_type: LifecycleHookType::OnRequest,
+            result: HookResult::Continue,
+        };
+
+        let context = json!({ "test": "data" });
+        let result = hook.execute(context);
+
+        assert!(result.is_ok());
+        match result.unwrap() {
+            HookResult::Continue => {}
+            HookResult::ShortCircuit(_) => panic!("Expected Continue"),
+        }
+    }
+
+    #[test]
+    fn test_hook_type_retrieval() {
+        let hook = TestHook {
+            hook_type: LifecycleHookType::PreValidation,
+            result: HookResult::Continue,
+        };
+
+        assert_eq!(hook.hook_type(), LifecycleHookType::PreValidation);
+    }
+
+    #[test]
+    fn test_all_hook_types() {
+        let hook_types = vec![
+            LifecycleHookType::OnRequest,
+            LifecycleHookType::PreValidation,
+            LifecycleHookType::PreHandler,
+            LifecycleHookType::OnResponse,
+            LifecycleHookType::OnError,
+        ];
+
+        let mut config = LifecycleConfig::new();
+
+        for hook_type in hook_types.iter() {
+            let hook = Arc::new(TestHook {
+                hook_type: *hook_type,
+                result: HookResult::Continue,
+            });
+            config.register(hook);
+        }
+
+        for hook_type in hook_types {
+            let hooks = config.get_hooks(hook_type);
+            assert_eq!(hooks.len(), 1);
+        }
+    }
+
+    #[test]
+    fn test_hook_result_clone() {
+        let original = HookResult::ShortCircuit(json!({ "key": "value" }));
+        let cloned = original.clone();
+
+        match cloned {
+            HookResult::ShortCircuit(response) => {
+                assert_eq!(response["key"], "value");
+            }
+            _ => panic!("Expected ShortCircuit"),
+        }
+    }
+}