Use catch_unwind for panicking tests

Replace #[should_panic] expectations with explicit std::panic::catch_unwind checks in tests to assert on panic messages more robustly. Updated test_auth.rs and test_tray.rs to capture the panic, extract the message, and assert it contains the expected text. In test_signal_handler.rs, removed the #[should_panic] on the async runtime test, renamed it to async_thread_runtime_creation_success, and removed an artificial panic so the test validates the normal runtime creation path; the extreme failure path remains documented but not forced in tests. These changes make test failures clearer and avoid brittle should_panic usage.

Author: ReenigneArcher

.github/workflows/ci-rust.yml

@@ -165,9 +165,11 @@ jobs:
         if: inputs.run_tests
         run: |
           tarpaulin_args=()
-          if [[ "${{ matrix.target }}" == "aarch64-unknown-linux-gnu" ]]; then
-            tarpaulin_args+=(--jobs 1)
-          fi
+          case "${{ matrix.target }}" in
+            aarch64-unknown-linux-gnu|aarch64-pc-windows-msvc)
+              tarpaulin_args+=(--jobs 1)
+              ;;
+          esac
 
           cargo tarpaulin \
             --locked \

crates/server/tests/test_auth.rs

@@ -184,9 +184,20 @@ fn test_claims_struct_functionality() {
 }
 
 #[test]
-#[should_panic(expected = "Invalid role constant")]
 fn test_auth_guard_invalid_role_constant() {
     // This should panic because role constant 99 is not valid
     // We test the panic by calling the role() method with an invalid const generic
-    let _ = AuthGuard::<99>::role();
+    let result = std::panic::catch_unwind(AuthGuard::<99>::role);
+    let panic = result.expect_err("Invalid role constant should panic");
+    let message = panic
+        .downcast_ref::<&str>()
+        .copied()
+        .or_else(|| panic.downcast_ref::<String>().map(String::as_str))
+        .unwrap_or("<non-string panic>");
+
+    assert!(
+        message.contains("Invalid role constant"),
+        "unexpected panic message: {}",
+        message
+    );
 }

crates/server/tests/test_signal_handler.rs

@@ -604,17 +604,7 @@ mod shutdown_coordinator {
     }
 
     #[test]
-    #[should_panic(expected = "Failed to create tokio runtime")]
-    fn async_thread_runtime_creation_failure() {
-        // This test is tricky to trigger in practice, but we can document it
-        // The panic path occurs when tokio runtime creation fails
-        // In normal circumstances this should never happen, but the panic is there for safety
-
-        // Since we can't easily mock runtime creation failure, we'll create a separate test
-        // that documents this behavior. The actual panic line will be covered when/if
-        // runtime creation actually fails in extreme circumstances.
-
-        // For now, let's verify that normal async thread creation works fine
+    fn async_thread_runtime_creation_success() {
         let mut coordinator = create_test_coordinator();
 
         coordinator.register_async_thread("normal-async", |_| async move {
@@ -623,9 +613,7 @@ mod shutdown_coordinator {
 
         coordinator.wait_for_completion();
 
-        // If we reach here, runtime creation worked fine
-        // The panic path is for extreme error conditions that are hard to reproduce in tests
-        panic!("Failed to create tokio runtime for test_panic_scenario");
+        // If we reach here, runtime creation worked fine.
     }
 
     #[test]

crates/server/tests/test_tray.rs

@@ -31,12 +31,23 @@ fn test_launch_with_shutdown_exits() {
 /// We expect a panic, because the code calls `image::open`
 /// and it should fail on a non-existent file.
 #[test]
-#[should_panic(expected = "Failed to open icon path")]
 fn test_load_icon_non_existent_path_panics() {
     use koko::tray::load_icon;
 
     let non_existent_path = Path::new("non_existent_file.ico");
 
     // This should panic based on the logic within `load_icon`.
-    let _icon = load_icon(non_existent_path);
+    let result = std::panic::catch_unwind(|| load_icon(non_existent_path));
+    let panic = result.expect_err("Missing icon path should panic");
+    let message = panic
+        .downcast_ref::<&str>()
+        .copied()
+        .or_else(|| panic.downcast_ref::<String>().map(String::as_str))
+        .unwrap_or("<non-string panic>");
+
+    assert!(
+        message.contains("Failed to open icon path"),
+        "unexpected panic message: {}",
+        message
+    );
 }