Add unit tests + fix integration tests

Author: gleocadie

Cargo.lock

@@ -23,6 +23,7 @@ libc = "0.2"
 nix = { version = "0.29", features = ["signal", "socket"] }
 hex = "0.4"
 os_info = "3.7.0"
+regex = "1.0"
 
 [dev-dependencies]
 serial_test = "3.2"

bin_tests/Cargo.toml

@@ -360,17 +360,18 @@ fn test_crash_tracking_app(crash_type: &str) {
 #[cfg_attr(miri, ignore)]
 #[cfg(not(target_os = "macos"))] // Same restriction as other panic tests
 fn test_crash_tracking_bin_panic_hook_after_fork() {
-    test_panic_hook_mode("panic_hook_after_fork", "child panicked after fork");
+    test_panic_hook_mode(
+        "panic_hook_after_fork",
+        "message",
+        Some("child panicked after fork"),
+    );
 }
 
 #[test]
 #[cfg_attr(miri, ignore)]
 #[cfg(not(target_os = "macos"))] // Same restriction as other panic tests
 fn test_crash_tracking_bin_panic_hook_string() {
-    test_panic_hook_mode(
-        "panic_hook_string",
-        "Process panicked with message: Panic with value: 42",
-    );
+    test_panic_hook_mode("panic_hook_string", "message", Some("Panic with value: 42"));
 }
 
 #[test]
@@ -379,12 +380,14 @@ fn test_crash_tracking_bin_panic_hook_string() {
 fn test_crash_tracking_bin_panic_hook_unknown_type() {
     test_panic_hook_mode(
         "panic_hook_unknown_type",
-        "Process panicked with unknown type",
+        "unknown type",
+        None, // no panic message for unknown type
     );
 }
 
-/// Helper function to run panic hook tests with different payload types
-fn test_panic_hook_mode(mode: &str, expected_message_substring: &str) {
+/// Helper function to run panic hook tests with different payload types.
+/// Note: Since tests are built with Debug profile, location is always expected.
+fn test_panic_hook_mode(mode: &str, expected_category: &str, expected_panic_message: Option<&str>) {
     use bin_tests::test_runner::run_custom_crash_test;
 
     // Set up custom artifacts: receiver + crashtracker_bin_test
@@ -393,15 +396,38 @@ fn test_panic_hook_mode(mode: &str, expected_message_substring: &str) {
 
     let artifacts_map = build_artifacts(&[&crashtracker_receiver, &crashtracker_bin_test]).unwrap();
 
-    let expected_msg = expected_message_substring.to_owned();
+    let expected_category = expected_category.to_owned();
+    let expected_panic_message = expected_panic_message.map(|s| s.to_owned());
     let validator: ValidatorFn = Box::new(move |payload, _fixtures| {
         // Verify the panic message is captured
         let error = &payload["error"];
         let message = error["message"].as_str().unwrap();
+
+        // Check the message starts with "Process panicked with <category>"
+        let expected_prefix = format!("Process panicked with {}", expected_category);
+        assert!(
+            message.starts_with(&expected_prefix),
+            "Expected panic message to start with '{}', got: {}",
+            expected_prefix,
+            message
+        );
+
+        // Check the panic message if expected (the message passed to panic! macro)
+        if let Some(ref panic_msg) = expected_panic_message {
+            assert!(
+                message.contains(panic_msg),
+                "Expected panic message to contain '{}', got: {}",
+                panic_msg,
+                message
+            );
+        }
+
+        // Check for location format (file:line:column) - always present in Debug builds
+        // Location should end with pattern like " (path/file.rs:123:45)"
+        let location_regex = regex::Regex::new(r" \(.+?:\d+:\d+\)$").unwrap();
         assert!(
-            message.contains(&expected_msg),
-            "Expected panic message to contain '{}', got: {}",
-            expected_msg,
+            location_regex.is_match(message),
+            "Expected panic message to end with location ' (file:line:column)', got: {}",
             message
         );
 

bin_tests/tests/crashtracker_bin_test.rs

@@ -79,26 +79,20 @@ pub fn update_metadata(metadata: Metadata) -> anyhow::Result<()> {
 }
 
 /// Format a panic message with optional location information.
-fn format_panic_message(
+fn format_message(
     category: &str,
-    description: &str,
+    panic_message: &str,
     location: Option<&panic::Location>,
 ) -> String {
-    let base = match location {
-        Some(loc) => format!(
-            "Process panicked with {} ({}:{}:{})",
-            category,
-            loc.file(),
-            loc.line(),
-            loc.column()
-        ),
-        None => format!("Process panicked with {}", category),
+    let base = if panic_message.is_empty() {
+        format!("Process panicked with {}", category)
+    } else {
+        format!("Process panicked with {} \"{}\"", category, panic_message)
     };
 
-    if description.is_empty() {
-        base
-    } else {
-        format!("{}: {}", base, description)
+    match location {
+        Some(loc) => format!("{} ({}:{}:{})", base, loc.file(), loc.line(), loc.column()),
+        None => base,
     }
 }
 
@@ -124,12 +118,12 @@ pub fn register_panic_hook() -> anyhow::Result<()> {
     panic::set_hook(Box::new(|panic_info| {
         // Extract panic message from payload (supports &str and String)
         let message = if let Some(&s) = panic_info.payload().downcast_ref::<&str>() {
-            format_panic_message("message", s, panic_info.location())
+            format_message("message", s, panic_info.location())
         } else if let Some(s) = panic_info.payload().downcast_ref::<String>() {
-            format_panic_message("message", s.as_str(), panic_info.location())
+            format_message("message", s.as_str(), panic_info.location())
         } else {
             // For non-string types, use a generic message
-            format_panic_message("unknown type", "", panic_info.location())
+            format_message("unknown type", "", panic_info.location())
         };
 
         // Store the message, cleaning up any old message
@@ -394,4 +388,58 @@ mod tests {
             assert_eq!(stored_metadata.library_name, "test");
         }
     }
+
+    #[test]
+    fn test_format_message_with_message_and_location() {
+        let location = panic::Location::caller();
+        let result = format_message("message", "test panic", Some(location));
+
+        assert!(result.starts_with("Process panicked with message \"test panic\" ("));
+        assert!(result.contains(&format!("{}:", location.file())));
+        assert!(result.contains(&format!(":{}", location.line())));
+        assert!(result.ends_with(&format!("{})", location.column())));
+    }
+
+    #[test]
+    fn test_format_message_with_message_no_location() {
+        let result = format_message("message", "test panic", None);
+        assert_eq!(result, "Process panicked with message \"test panic\"");
+    }
+
+    #[test]
+    fn test_format_message_empty_message_with_location() {
+        let location = panic::Location::caller();
+        let result = format_message("unknown type", "", Some(location));
+
+        assert!(result.starts_with("Process panicked with unknown type ("));
+        assert!(result.contains(&format!("{}:", location.file())));
+        assert!(result.ends_with(&format!("{})", location.column())));
+    }
+
+    #[test]
+    fn test_format_message_empty_message_no_location() {
+        let result = format_message("unknown type", "", None);
+        assert_eq!(result, "Process panicked with unknown type");
+    }
+
+    #[test]
+    fn test_format_message_different_categories() {
+        let result1 = format_message("message", "test", None);
+        assert_eq!(result1, "Process panicked with message \"test\"");
+
+        let result2 = format_message("unknown type", "", None);
+        assert_eq!(result2, "Process panicked with unknown type");
+
+        let result3 = format_message("custom category", "content", None);
+        assert_eq!(result3, "Process panicked with custom category \"content\"");
+    }
+
+    #[test]
+    fn test_format_message_with_special_characters() {
+        let result = format_message("message", "test \"quoted\" 'text'", None);
+        assert_eq!(
+            result,
+            "Process panicked with message \"test \"quoted\" 'text'\""
+        );
+    }
 }