fix(tests): fix Windows CI test failures for cwd_guard and styled_output (#482)

- Fix cwd_guard tests on Windows: Add helper functions (normalized_current_dir
  and normalize_path) that use dunce::canonicalize to normalize paths before
  comparison, handling Windows 8.3 paths and UNC path format differences

- Fix styled_output tests: Add serial_test dependency to cortex-cli and
  #[serial] attribute to tests that manipulate NO_COLOR environment variable
  to prevent race conditions when tests run in parallel

Fixes test failures:
- cwd_guard::tests::test_cwd_guard_disabled
- cwd_guard::tests::test_cwd_guard_restores
- cwd_guard::tests::test_in_directory
- styled_output::tests::test_colors_disabled

Co-authored-by: Droid Agent <droid@factory.ai>

Author: echobt

Cargo.lock

@@ -99,3 +99,6 @@ signal-hook = "0.3"
 
 [build-dependencies]
 chrono = "0.4"
+
+[dev-dependencies]
+serial_test = { workspace = true }

cortex-cli/Cargo.toml

@@ -382,6 +382,7 @@ pub fn styled_icon(msg_type: MessageType) -> String {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use serial_test::serial;
 
     #[test]
     fn test_message_type_icons() {
@@ -393,6 +394,7 @@ mod tests {
     }
 
     #[test]
+    #[serial]
     fn test_format_styled_no_color() {
         // When colors are disabled, should just return icon + message
         // SAFETY: These tests run serially and we restore env vars immediately
@@ -404,6 +406,7 @@ mod tests {
     }
 
     #[test]
+    #[serial]
     fn test_colors_disabled() {
         // SAFETY: These tests run serially and we restore env vars immediately
         unsafe { std::env::set_var("NO_COLOR", "1") };

cortex-cli/src/styled_output.rs

@@ -309,27 +309,39 @@ mod tests {
     use serial_test::serial;
     use tempfile::TempDir;
 
+    /// Helper to get normalized current directory for comparison.
+    /// On Windows, uses dunce::canonicalize to handle 8.3 paths and UNC paths.
+    fn normalized_current_dir() -> PathBuf {
+        let cwd = env::current_dir().unwrap();
+        dunce::canonicalize(&cwd).unwrap_or(cwd)
+    }
+
+    /// Helper to normalize a path for comparison.
+    /// On Windows, uses dunce::canonicalize to handle 8.3 paths and UNC paths.
+    fn normalize_path(path: &Path) -> PathBuf {
+        dunce::canonicalize(path).unwrap_or_else(|_| path.to_path_buf())
+    }
+
     #[test]
     #[serial]
     fn test_cwd_guard_restores() {
-        let original = env::current_dir().unwrap();
+        let original = normalized_current_dir();
         let temp_dir = TempDir::new().unwrap();
-        // Use dunce::canonicalize on Windows to avoid UNC paths (\\?\C:\...)
-        let expected_temp_path = dunce::canonicalize(temp_dir.path()).unwrap();
+        let expected_temp_path = normalize_path(temp_dir.path());
 
         {
             let _guard = CwdGuard::new(temp_dir.path()).unwrap();
-            assert_eq!(env::current_dir().unwrap(), expected_temp_path);
+            assert_eq!(normalized_current_dir(), expected_temp_path);
         }
 
         // Should be back to original after guard dropped
-        assert_eq!(env::current_dir().unwrap(), original);
+        assert_eq!(normalized_current_dir(), original);
     }
 
     #[test]
     #[serial]
     fn test_cwd_guard_restores_on_panic() {
-        let original = env::current_dir().unwrap();
+        let original = normalized_current_dir();
         let temp_dir = TempDir::new().unwrap();
 
         let result = std::panic::catch_unwind(|| {
@@ -339,24 +351,23 @@ mod tests {
 
         assert!(result.is_err());
         // Should still be back to original
-        assert_eq!(env::current_dir().unwrap(), original);
+        assert_eq!(normalized_current_dir(), original);
     }
 
     #[test]
     #[serial]
     fn test_cwd_guard_disabled() {
-        let original = env::current_dir().unwrap();
+        let original = normalized_current_dir();
         let temp_dir = TempDir::new().unwrap();
-        // Use dunce::canonicalize on Windows to avoid UNC paths (\\?\C:\...)
-        let temp_path = dunce::canonicalize(temp_dir.path()).unwrap();
+        let temp_path = normalize_path(temp_dir.path());
 
         {
             let mut guard = CwdGuard::new(temp_dir.path()).unwrap();
             guard.disable_restore();
         }
 
         // Should NOT be back to original
-        assert_eq!(env::current_dir().unwrap(), temp_path);
+        assert_eq!(normalized_current_dir(), temp_path);
 
         // Restore manually
         env::set_current_dir(&original).unwrap();
@@ -365,36 +376,35 @@ mod tests {
     #[test]
     #[serial]
     fn test_cwd_guard_restore_now() {
-        let original = env::current_dir().unwrap();
+        let original = normalized_current_dir();
         let temp_dir = TempDir::new().unwrap();
 
         let mut guard = CwdGuard::new(temp_dir.path()).unwrap();
 
         // Manually restore
         guard.restore_now().unwrap();
-        assert_eq!(env::current_dir().unwrap(), original);
+        assert_eq!(normalized_current_dir(), original);
 
         // Guard drop should not panic (it's disabled after restore_now)
     }
 
     #[test]
     #[serial]
     fn test_in_directory() {
-        let original = env::current_dir().unwrap();
+        let original = normalized_current_dir();
         let temp_dir = TempDir::new().unwrap();
-        // Use dunce::canonicalize on Windows to avoid UNC paths (\\?\C:\...)
-        let temp_path = dunce::canonicalize(temp_dir.path()).unwrap();
+        let temp_path = normalize_path(temp_dir.path());
 
-        let result = in_directory(temp_dir.path(), || env::current_dir().unwrap()).unwrap();
+        let result = in_directory(temp_dir.path(), || normalized_current_dir()).unwrap();
 
         assert_eq!(result, temp_path);
-        assert_eq!(env::current_dir().unwrap(), original);
+        assert_eq!(normalized_current_dir(), original);
     }
 
     #[test]
     #[serial]
     fn test_in_directory_result() {
-        let original = env::current_dir().unwrap();
+        let original = normalized_current_dir();
         let temp_dir = TempDir::new().unwrap();
 
         let result: Result<(), io::Error> = in_directory_result(temp_dir.path(), || {
@@ -403,24 +413,24 @@ mod tests {
 
         assert!(result.is_err());
         // Should still be back to original
-        assert_eq!(env::current_dir().unwrap(), original);
+        assert_eq!(normalized_current_dir(), original);
     }
 
     #[test]
     #[serial]
     fn test_save_current() {
-        let original = env::current_dir().unwrap();
+        let original = normalized_current_dir();
         let temp_dir = TempDir::new().unwrap();
 
         {
             let guard = CwdGuard::save_current().unwrap();
-            assert_eq!(guard.original(), original);
+            assert_eq!(normalize_path(guard.original()), original);
 
             // Manually change directory
             env::set_current_dir(temp_dir.path()).unwrap();
         }
 
         // Should be back to original after guard dropped
-        assert_eq!(env::current_dir().unwrap(), original);
+        assert_eq!(normalized_current_dir(), original);
     }
 }