spikard 0.3.6 → 0.5.0

data/vendor/crates/spikard-core/src/debug.rs

@@ -61,3 +61,67 @@ macro_rules! debug_log_value {
         }
     };
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::sync::Mutex;
+    use std::sync::atomic::Ordering;
+
+    static FLAG_LOCK: Mutex<()> = Mutex::new(());
+
+    struct DebugFlagGuard {
+        previous_flag: bool,
+        previous_env: Option<String>,
+    }
+
+    impl Drop for DebugFlagGuard {
+        fn drop(&mut self) {
+            DEBUG_ENABLED.store(self.previous_flag, Ordering::Relaxed);
+            if let Some(prev) = &self.previous_env {
+                unsafe { std::env::set_var("SPIKARD_DEBUG", prev) };
+            } else {
+                unsafe { std::env::remove_var("SPIKARD_DEBUG") };
+            }
+        }
+    }
+
+    #[test]
+    fn init_sets_debug_enabled_in_tests() {
+        let _lock = FLAG_LOCK.lock().unwrap();
+        let previous = DEBUG_ENABLED.load(Ordering::Relaxed);
+        let previous_env = std::env::var("SPIKARD_DEBUG").ok();
+        let _guard = DebugFlagGuard {
+            previous_flag: previous,
+            previous_env,
+        };
+
+        unsafe { std::env::set_var("SPIKARD_DEBUG", "1") };
+
+        init();
+        assert!(is_enabled(), "init should enable debug when SPIKARD_DEBUG is set");
+    }
+
+    #[test]
+    fn macros_follow_debug_flag() {
+        let _lock = FLAG_LOCK.lock().unwrap();
+        let previous = DEBUG_ENABLED.load(Ordering::Relaxed);
+        let previous_env = std::env::var("SPIKARD_DEBUG").ok();
+        let _guard = DebugFlagGuard {
+            previous_flag: previous,
+            previous_env,
+        };
+
+        DEBUG_ENABLED.store(false, Ordering::Relaxed);
+        debug_log!("disabled branch");
+        debug_log_module!("core", "disabled");
+        debug_log_value!("counter", 0_u8);
+        assert!(!is_enabled());
+
+        DEBUG_ENABLED.store(true, Ordering::Relaxed);
+        debug_log!("enabled branch {}", 1);
+        debug_log_module!("core", "enabled");
+        debug_log_value!("counter", 2_i32);
+        assert!(is_enabled());
+    }
+}

data/vendor/crates/spikard-core/src/di/container.rs

@@ -50,6 +50,7 @@ use tokio::sync::RwLock;
 /// let request_data = RequestData {
 ///     path_params: Arc::new(HashMap::new()),
 ///     query_params: serde_json::Value::Null,
+///     validated_params: None,
 ///     raw_query_params: Arc::new(HashMap::new()),
 ///     body: serde_json::Value::Null,
 ///     raw_body: None,
@@ -128,10 +129,8 @@ impl DependencyContainer {
     /// container.register("config".to_string(), Arc::new(config)).unwrap();
     /// ```
     pub fn register(&mut self, key: String, dep: Arc<dyn Dependency>) -> Result<&mut Self, DependencyError> {
-        // Add to dependency graph (this checks for cycles and duplicates)
         self.dependency_graph.add_dependency(&key, dep.depends_on())?;
 
-        // Store the dependency
         self.dependencies.insert(key, dep);
 
         Ok(self)
@@ -195,6 +194,7 @@ impl DependencyContainer {
     /// let request_data = RequestData {
     ///     path_params: Arc::new(HashMap::new()),
     ///     query_params: serde_json::Value::Null,
+    ///     validated_params: None,
     ///     raw_query_params: Arc::new(HashMap::new()),
     ///     body: serde_json::Value::Null,
     ///     raw_body: None,
@@ -225,31 +225,23 @@ impl DependencyContainer {
             }
         }
 
-        // Calculate resolution batches
         let batches = self.dependency_graph.calculate_batches(deps)?;
 
         let mut resolved = ResolvedDependencies::new();
         let mut request_cache: HashMap<String, Arc<dyn Any + Send + Sync>> = HashMap::new();
 
-        // Process each batch sequentially
         for batch in batches {
-            // Sort keys within batch by registration order for deterministic resolution
-            // This ensures cleanup happens in a predictable reverse order
             // NOTE: We resolve sequentially within each batch to ensure cleanup tasks
-            // are registered in a deterministic order (LIFO on cleanup)
             let mut sorted_keys: Vec<_> = batch.iter().collect();
 
-            // Sort by insertion order (index in IndexMap) instead of alphabetically
             sorted_keys.sort_by_key(|key| self.dependencies.get_index_of(*key).unwrap_or(usize::MAX));
 
             for key in sorted_keys {
-                // Get the dependency
                 let dep = self
                     .dependencies
                     .get(key)
                     .ok_or_else(|| DependencyError::NotFound { key: key.clone() })?;
 
-                // Check singleton cache first
                 if dep.singleton() {
                     let cache = self.singleton_cache.read().await;
                     if let Some(cached) = cache.get(key) {
@@ -258,7 +250,6 @@ impl DependencyContainer {
                     }
                 }
 
-                // Check request cache
                 if dep.cacheable()
                     && let Some(cached) = request_cache.get(key)
                 {
@@ -266,10 +257,8 @@ impl DependencyContainer {
                     continue;
                 }
 
-                // Need to resolve - do it sequentially to preserve cleanup order
                 let result = dep.resolve(req, data, &resolved).await?;
 
-                // Store in appropriate cache
                 if dep.singleton() {
                     let mut cache = self.singleton_cache.write().await;
                     cache.insert(key.clone(), Arc::clone(&result));
@@ -277,7 +266,6 @@ impl DependencyContainer {
                     request_cache.insert(key.clone(), Arc::clone(&result));
                 }
 
-                // Always store in resolved
                 resolved.insert(key.clone(), result);
             }
         }
@@ -396,6 +384,7 @@ mod tests {
         RequestData {
             path_params: Arc::new(HashMap::new()),
             query_params: serde_json::Value::Null,
+            validated_params: None,
             raw_query_params: Arc::new(HashMap::new()),
             body: serde_json::Value::Null,
             raw_body: None,
@@ -507,11 +496,9 @@ mod tests {
     async fn test_resolve_nested() {
         let mut container = DependencyContainer::new();
 
-        // config (no dependencies)
         let config = ValueDependency::new("config", "production".to_string());
         container.register("config".to_string(), Arc::new(config)).unwrap();
 
-        // database (depends on config)
         let database = FactoryDependency::builder("database")
             .depends_on(vec!["config".to_string()])
             .factory(|_req, _data, resolved| {
@@ -541,10 +528,8 @@ mod tests {
     async fn test_resolve_batched() {
         let mut container = DependencyContainer::new();
 
-        // Track resolution order
         let counter = Arc::new(AtomicU32::new(0));
 
-        // config (no deps)
         let counter1 = Arc::clone(&counter);
         let config = FactoryDependency::builder("config")
             .factory(move |_req, _data, _resolved| {
@@ -557,7 +542,6 @@ mod tests {
             .build();
         container.register("config".to_string(), Arc::new(config)).unwrap();
 
-        // db and cache (both depend on config, can run in parallel)
         let counter2 = Arc::clone(&counter);
         let database = FactoryDependency::builder("database")
             .depends_on(vec!["config".to_string()])
@@ -592,11 +576,9 @@ mod tests {
             .await
             .unwrap();
 
-        // config should be resolved first (order 0)
         let config_order: Arc<u32> = resolved.get("config").unwrap();
         assert_eq!(*config_order, 0);
 
-        // db and cache should be resolved after config (order 1 and 2, in either order)
         let db_order: Arc<u32> = resolved.get("database").unwrap();
         let cache_order: Arc<u32> = resolved.get("cache").unwrap();
         assert!(*db_order >= 1);
@@ -628,7 +610,6 @@ mod tests {
         let request = make_request();
         let request_data = make_request_data();
 
-        // Resolve multiple times
         for _ in 0..3 {
             let resolved = container
                 .resolve_for_handler(&["singleton".to_string()], &request, &request_data)
@@ -636,11 +617,9 @@ mod tests {
                 .unwrap();
 
             let value: Arc<u32> = resolved.get("singleton").unwrap();
-            // Should always be 0 (resolved only once)
             assert_eq!(*value, 0);
         }
 
-        // Counter should only have been incremented once
         assert_eq!(counter.load(Ordering::SeqCst), 1);
     }
 
@@ -669,7 +648,6 @@ mod tests {
         let request = make_request();
         let request_data = make_request_data();
 
-        // First resolve
         let resolved1 = container
             .resolve_for_handler(&["singleton".to_string()], &request, &request_data)
             .await
@@ -677,10 +655,8 @@ mod tests {
         let value1: Arc<u32> = resolved1.get("singleton").unwrap();
         assert_eq!(*value1, 0);
 
-        // Clear cache
         container.clear_singleton_cache().await;
 
-        // Second resolve should re-execute factory
         let resolved2 = container
             .resolve_for_handler(&["singleton".to_string()], &request, &request_data)
             .await

data/vendor/crates/spikard-core/src/di/factory.rs

@@ -107,7 +107,6 @@ impl Dependency for FactoryDependency {
         request_data: &RequestData,
         resolved: &ResolvedDependencies,
     ) -> Pin<Box<dyn Future<Output = Result<Arc<dyn Any + Send + Sync>, DependencyError>> + Send>> {
-        // Call the factory function
         (self.factory)(request, request_data, resolved)
     }
 
@@ -350,6 +349,7 @@ mod tests {
         RequestData {
             path_params: Arc::new(HashMap::new()),
             query_params: serde_json::Value::Null,
+            validated_params: None,
             raw_query_params: Arc::new(HashMap::new()),
             body: serde_json::Value::Null,
             raw_body: None,
@@ -406,7 +406,6 @@ mod tests {
         let factory = FactoryDependency::builder("async_value")
             .factory(|_req, _data, _resolved| {
                 Box::pin(async {
-                    // Simulate async work
                     tokio::time::sleep(tokio::time::Duration::from_millis(10)).await;
                     Ok(Arc::new(100i32) as Arc<dyn Any + Send + Sync>)
                 })
@@ -426,7 +425,6 @@ mod tests {
 
     #[tokio::test]
     async fn test_factory_depends_on() {
-        // Create resolved dependencies with a value
         let mut resolved = ResolvedDependencies::new();
         resolved.insert("config".to_string(), Arc::new("test_config".to_string()));
 
@@ -435,7 +433,6 @@ mod tests {
             .factory(|_req, _data, resolved| {
                 let resolved = resolved.clone();
                 Box::pin(async move {
-                    // Access the config dependency
                     let config: Option<Arc<String>> = resolved.get("config");
                     let config_value = config.map(|c| (*c).clone()).unwrap_or_default();
 
@@ -505,7 +502,6 @@ mod tests {
         let request_data = make_request_data();
         let resolved = ResolvedDependencies::new();
 
-        // Call factory multiple times
         for i in 0..3 {
             let result = factory.resolve(&request, &request_data, &resolved).await;
             let value: Arc<u32> = result.unwrap().downcast().unwrap();

data/vendor/crates/spikard-core/src/di/graph.rs

@@ -96,13 +96,10 @@ impl DependencyGraph {
     /// assert!(result.is_err());
     /// ```
     pub fn add_dependency(&mut self, key: &str, depends_on: Vec<String>) -> Result<(), DependencyError> {
-        // Check for duplicate
         if self.graph.contains_key(key) {
             return Err(DependencyError::DuplicateKey { key: key.to_string() });
         }
 
-        // Don't check for cycles here - allow registration and detect at resolution time
-        // This allows the server to start and return proper HTTP error responses
         self.graph.insert(key.to_string(), depends_on);
         Ok(())
     }
@@ -137,11 +134,9 @@ impl DependencyGraph {
     /// assert!(!graph.has_cycle_with("c", &[]));
     /// ```
     pub fn has_cycle_with(&self, new_key: &str, new_deps: &[String]) -> bool {
-        // Build temporary graph with the new dependency
         let mut temp_graph = self.graph.clone();
         temp_graph.insert(new_key.to_string(), new_deps.to_vec());
 
-        // DFS cycle detection
         let mut visited = HashSet::new();
         let mut rec_stack = HashSet::new();
 
@@ -182,7 +177,6 @@ impl DependencyGraph {
                         return true;
                     }
                 } else if rec_stack.contains(dep) {
-                    // Found a back edge (cycle)
                     return true;
                 }
             }
@@ -238,7 +232,6 @@ impl DependencyGraph {
     /// assert!(batches[1].contains("c"));
     /// ```
     pub fn calculate_batches(&self, keys: &[String]) -> Result<Vec<HashSet<String>>, DependencyError> {
-        // Build subgraph with only the requested keys and their transitive dependencies
         let mut subgraph = HashMap::new();
         let mut to_visit: VecDeque<String> = keys.iter().cloned().collect();
         let mut visited = HashSet::new();
@@ -255,12 +248,10 @@ impl DependencyGraph {
                     to_visit.push_back(dep.clone());
                 }
             } else {
-                // Key not in graph - treat as having no dependencies
                 subgraph.insert(key.clone(), vec![]);
             }
         }
 
-        // Calculate in-degree for each node in the subgraph
         let mut in_degree: HashMap<String, usize> = HashMap::new();
         for key in subgraph.keys() {
             in_degree.entry(key.clone()).or_insert(0);
@@ -271,7 +262,6 @@ impl DependencyGraph {
             }
         }
 
-        // Kahn's algorithm for topological sort with batching
         let mut batches = Vec::new();
         let mut queue: VecDeque<String> = in_degree
             .iter()
@@ -283,17 +273,14 @@ impl DependencyGraph {
         let total = subgraph.len();
 
         while !queue.is_empty() {
-            // All items in the queue can be processed in parallel (same batch)
             let mut batch = HashSet::new();
 
-            // Process all nodes with in-degree 0
             let batch_size = queue.len();
             for _ in 0..batch_size {
                 if let Some(node) = queue.pop_front() {
                     batch.insert(node.clone());
                     processed += 1;
 
-                    // Reduce in-degree for dependents
                     if let Some(deps) = subgraph.get(&node) {
                         for dep in deps {
                             if let Some(degree) = in_degree.get_mut(dep) {
@@ -312,9 +299,7 @@ impl DependencyGraph {
             }
         }
 
-        // Check if we processed all nodes (if not, there's a cycle)
         if processed < total {
-            // Find a cycle by tracing from any unprocessed node
             let unprocessed: Vec<String> = subgraph
                 .keys()
                 .filter(|k| in_degree.get(*k).is_some_and(|&d| d > 0))
@@ -322,17 +307,14 @@ impl DependencyGraph {
                 .collect();
 
             if let Some(start) = unprocessed.first() {
-                // Trace the cycle path
                 let mut cycle = vec![start.clone()];
                 let mut current = start;
                 let mut visited_in_path = HashSet::new();
                 visited_in_path.insert(start.clone());
 
-                // Follow dependencies until we find the cycle
                 while let Some(deps) = subgraph.get(current) {
                     if let Some(next) = deps.iter().find(|d| unprocessed.contains(d)) {
                         if visited_in_path.contains(next) {
-                            // Found the cycle - add the closing node
                             cycle.push(next.clone());
                             break;
                         }
@@ -344,32 +326,23 @@ impl DependencyGraph {
                     }
                 }
 
-                // Normalize the cycle to start with the lexicographically smallest element
-                // This makes cycle detection deterministic
-                // The cycle includes the closing element (first element repeated at end)
-                // e.g., [A, B, A] or [B, A, B]
-                if cycle.len() > 1 {
-                    // Find the index of the smallest element (ignoring the last closing element)
-                    if let Some((min_idx, _)) = cycle[..cycle.len() - 1].iter().enumerate().min_by_key(|(_, s)| *s) {
-                        cycle.rotate_left(min_idx);
-                        // After rotation, update the closing element to match the new first element
-                        if let Some(first) = cycle.first().cloned()
-                            && let Some(last) = cycle.last_mut()
-                        {
-                            *last = first;
-                        }
+                if cycle.len() > 1
+                    && let Some((min_idx, _)) = cycle[..cycle.len() - 1].iter().enumerate().min_by_key(|(_, s)| *s)
+                {
+                    cycle.rotate_left(min_idx);
+                    if let Some(first) = cycle.first().cloned()
+                        && let Some(last) = cycle.last_mut()
+                    {
+                        *last = first;
                     }
                 }
 
                 return Err(DependencyError::CircularDependency { cycle });
             }
 
-            // Fallback if we can't trace the cycle
             return Err(DependencyError::CircularDependency { cycle: unprocessed });
         }
 
-        // Reverse the batches because we built them in reverse order
-        // (dependencies come before dependents in our graph structure)
         batches.reverse();
 
         Ok(batches)
@@ -406,7 +379,6 @@ mod tests {
         let mut graph = DependencyGraph::new();
         graph.add_dependency("a", vec!["b".to_string()]).unwrap();
 
-        // a -> b -> a would be a cycle
         assert!(graph.has_cycle_with("b", &["a".to_string()]));
     }
 
@@ -416,7 +388,6 @@ mod tests {
         graph.add_dependency("a", vec!["b".to_string()]).unwrap();
         graph.add_dependency("b", vec!["c".to_string()]).unwrap();
 
-        // c -> a would create cycle: a -> b -> c -> a
         assert!(graph.has_cycle_with("c", &["a".to_string()]));
     }
 
@@ -424,7 +395,6 @@ mod tests {
     fn test_has_cycle_self_loop() {
         let graph = DependencyGraph::new();
 
-        // Self-loop: a -> a
         assert!(graph.has_cycle_with("a", &["a".to_string()]));
     }
 
@@ -434,7 +404,6 @@ mod tests {
         graph.add_dependency("a", vec![]).unwrap();
         graph.add_dependency("b", vec!["a".to_string()]).unwrap();
 
-        // c -> a is fine (no cycle)
         assert!(!graph.has_cycle_with("c", &["a".to_string()]));
     }
 
@@ -459,7 +428,6 @@ mod tests {
             .calculate_batches(&["a".to_string(), "b".to_string(), "c".to_string()])
             .unwrap();
 
-        // Should be 3 batches in order: a, b, c
         assert_eq!(batches.len(), 3);
         assert!(batches[0].contains("a"));
         assert!(batches[1].contains("b"));
@@ -479,8 +447,6 @@ mod tests {
             .calculate_batches(&["a".to_string(), "b".to_string(), "c".to_string()])
             .unwrap();
 
-        // Batch 1: a and b (parallel)
-        // Batch 2: c
         assert_eq!(batches.len(), 2);
         assert_eq!(batches[0].len(), 2);
         assert!(batches[0].contains("a"));
@@ -507,9 +473,6 @@ mod tests {
             ])
             .unwrap();
 
-        // Batch 1: config
-        // Batch 2: database, cache (parallel)
-        // Batch 3: service
         assert_eq!(batches.len(), 3);
         assert!(batches[0].contains("config"));
         assert_eq!(batches[1].len(), 2);
@@ -525,7 +488,6 @@ mod tests {
         graph.add_dependency("b", vec!["a".to_string()]).unwrap();
         graph.add_dependency("c", vec!["a".to_string()]).unwrap();
 
-        // Only request b (should also include its dependency a)
         let batches = graph.calculate_batches(&["b".to_string()]).unwrap();
 
         assert_eq!(batches.len(), 2);
@@ -538,7 +500,6 @@ mod tests {
         let mut graph = DependencyGraph::new();
         graph.add_dependency("a", vec!["missing".to_string()]).unwrap();
 
-        // Should handle missing dependencies gracefully
         let batches = graph.calculate_batches(&["a".to_string()]).unwrap();
         assert!(!batches.is_empty());
     }

data/vendor/crates/spikard-core/src/di/mod.rs

@@ -63,6 +63,7 @@
 //! let request_data = RequestData {
 //!     path_params: Arc::new(HashMap::new()),
 //!     query_params: serde_json::Value::Null,
+//!     validated_params: None,
 //!     raw_query_params: Arc::new(HashMap::new()),
 //!     body: serde_json::Value::Null,
 //!     raw_body: None,
@@ -182,7 +183,6 @@ mod graph;
 mod resolved;
 mod value;
 
-// Public exports
 pub use container::DependencyContainer;
 pub use dependency::Dependency;
 pub use error::DependencyError;

data/vendor/crates/spikard-core/src/di/resolved.rs

@@ -276,13 +276,11 @@ impl ResolvedDependencies {
     /// # });
     /// ```
     pub async fn cleanup(self) {
-        // Take ownership of cleanup tasks
         let tasks = {
             let mut cleanup_tasks = self.cleanup_tasks.lock().unwrap();
             std::mem::take(&mut *cleanup_tasks)
         };
 
-        // Run cleanup tasks in reverse order (LIFO)
         for task in tasks.into_iter().rev() {
             task().await;
         }
@@ -325,7 +323,6 @@ mod tests {
         let mut resolved = ResolvedDependencies::new();
         resolved.insert("number".to_string(), Arc::new(42i32));
 
-        // Wrong type returns None
         let wrong: Option<Arc<String>> = resolved.get("number");
         assert!(wrong.is_none());
     }
@@ -345,7 +342,6 @@ mod tests {
         let any_ref = resolved.get_arc("data");
         assert!(any_ref.is_some());
 
-        // Can downcast manually
         let vec_ref = any_ref.unwrap().downcast::<Vec<i32>>().ok();
         assert!(vec_ref.is_some());
     }
@@ -388,14 +384,13 @@ mod tests {
 
         resolved.cleanup().await;
 
-        // Tasks run in reverse order (LIFO)
         assert_eq!(*order.lock().unwrap(), vec![3, 2, 1]);
     }
 
     #[tokio::test]
     async fn test_cleanup_empty() {
         let resolved = ResolvedDependencies::new();
-        resolved.cleanup().await; // Should not panic
+        resolved.cleanup().await;
     }
 
     #[test]
@@ -403,7 +398,6 @@ mod tests {
         let mut resolved1 = ResolvedDependencies::new();
         resolved1.insert("key".to_string(), Arc::new(42i32));
 
-        // Clone shares the same underlying data
         let resolved2 = resolved1.clone();
         let value: Option<Arc<i32>> = resolved2.get("key");
         assert_eq!(value.map(|v| *v), Some(42));

data/vendor/crates/spikard-core/src/di/value.rs

@@ -42,6 +42,7 @@ use std::sync::Arc;
 /// let request_data = RequestData {
 ///     path_params: Arc::new(HashMap::new()),
 ///     query_params: serde_json::Value::Null,
+///     validated_params: None,
 ///     raw_query_params: Arc::new(HashMap::new()),
 ///     body: serde_json::Value::Null,
 ///     raw_body: None,
@@ -116,17 +117,14 @@ impl<T: Clone + Send + Sync + 'static> Dependency for ValueDependency<T> {
     }
 
     fn depends_on(&self) -> Vec<String> {
-        // Value dependencies have no dependencies
         vec![]
     }
 
     fn cacheable(&self) -> bool {
-        // Values are inherently cacheable (they never change)
         true
     }
 
     fn singleton(&self) -> bool {
-        // Values can be singletons (they never change)
         true
     }
 }
@@ -149,6 +147,7 @@ mod tests {
         RequestData {
             path_params: Arc::new(HashMap::new()),
             query_params: serde_json::Value::Null,
+            validated_params: None,
             raw_query_params: Arc::new(HashMap::new()),
             body: serde_json::Value::Null,
             raw_body: None,
@@ -225,7 +224,6 @@ mod tests {
         let request = Request::builder().body(()).unwrap();
         let request_data = make_request_data();
 
-        // Resolve concurrently from multiple tasks
         let handles: Vec<_> = (0..10)
             .map(|_| {
                 let dep = Arc::clone(&dep);

data/vendor/crates/spikard-core/src/errors.rs

@@ -37,3 +37,33 @@ where
 {
     catch_unwind(f).map_err(|_| StructuredError::simple("panic", "Unexpected panic in Rust code"))
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    #[test]
+    fn structured_error_constructors_populate_fields() {
+        let details = json!({"field": "name"});
+        let err = StructuredError::new("invalid", "bad input", details.clone());
+        assert_eq!(err.code, "invalid");
+        assert_eq!(err.error, "bad input");
+        assert_eq!(err.details, details);
+
+        let simple = StructuredError::simple("missing", "not found");
+        assert_eq!(simple.code, "missing");
+        assert_eq!(simple.error, "not found");
+        assert!(simple.details.is_object());
+    }
+
+    #[test]
+    fn shield_panic_returns_ok_or_structured_error() {
+        let ok = shield_panic(|| 42);
+        assert_eq!(ok.unwrap(), 42);
+
+        let err = shield_panic(|| panic!("boom")).unwrap_err();
+        assert_eq!(err.code, "panic");
+        assert!(err.error.contains("Unexpected panic"));
+    }
+}