kasl-cli 0.9.0

#[cfg(test)]
mod tests {
    use kasl::libs::autostart;
    use tempfile::TempDir;
    use test_context::{test_context, TestContext};

    struct AutostartTestContext {
        _temp_dir: TempDir,
    }

    impl TestContext for AutostartTestContext {
        fn setup() -> Self {
            let temp_dir = tempfile::tempdir().unwrap();
            std::env::set_var("HOME", temp_dir.path());
            std::env::set_var("LOCALAPPDATA", temp_dir.path());
            
            AutostartTestContext {
                _temp_dir: temp_dir,
            }
        }
    }

    #[test_context(AutostartTestContext)]
    #[test]
    fn test_autostart_status_query(_ctx: &mut AutostartTestContext) {
        // Test that we can query autostart status without errors
        let result = autostart::status();
        assert!(result.is_ok());
        
        let status = result.unwrap();
        assert!(status == "enabled" || status == "disabled");
    }

    #[test_context(AutostartTestContext)]
    #[test]
    fn test_autostart_is_enabled_query(_ctx: &mut AutostartTestContext) {
        // Test that we can check if autostart is enabled
        let result = autostart::is_enabled();
        assert!(result.is_ok());
        
        let is_enabled = result.unwrap();
        assert!(is_enabled == true || is_enabled == false);
    }

    #[cfg(windows)]
    #[test_context(AutostartTestContext)]
    #[test]
    fn test_windows_admin_detection(_ctx: &mut AutostartTestContext) {
        // Test admin privilege detection on Windows
        // Note: We can't directly test the windows module since it's private
        // Instead, test the public enable/disable functions which use admin detection internally
        
        // These operations might succeed or fail based on privileges
        // but they should not panic
        let _enable_result = std::panic::catch_unwind(|| {
            let _ = autostart::enable();
        });
        
        let _disable_result = std::panic::catch_unwind(|| {
            let _ = autostart::disable();
        });
        
        // If we get here without panicking, the test passes
    }

    #[cfg(windows)]
    #[test_context(AutostartTestContext)]
    #[test]
    fn test_windows_scheduled_task_query(_ctx: &mut AutostartTestContext) {
        // Test querying scheduled tasks on Windows
        // This should not fail even if the task doesn't exist
        let result = autostart::is_enabled();
        assert!(result.is_ok());
    }

    #[cfg(unix)]
    #[test_context(AutostartTestContext)]
    #[test]
    fn test_unix_autostart_not_implemented(_ctx: &mut AutostartTestContext) {
        // Test that Unix autostart returns not implemented error
        let enable_result = autostart::enable();
        assert!(enable_result.is_err());
        
        let disable_result = autostart::disable();
        assert!(disable_result.is_err());
        
        // is_enabled should return false for Unix
        let status_result = autostart::is_enabled();
        assert!(status_result.is_ok());
        assert_eq!(status_result.unwrap(), false);
    }

    #[test_context(AutostartTestContext)]
    #[test]
    fn test_autostart_disable_when_not_enabled(_ctx: &mut AutostartTestContext) {
        // Test disabling autostart when it's not enabled
        // This should succeed (idempotent operation)
        let _result = autostart::disable();
        
        #[cfg(windows)]
        {
            // On Windows, this might succeed or fail depending on admin privileges
            // but it shouldn't panic
        }
        
        #[cfg(unix)]
        {
            // On Unix, this should return not implemented error
            assert!(result.is_err());
        }
    }

    #[test_context(AutostartTestContext)]
    #[test]
    fn test_autostart_status_consistency(_ctx: &mut AutostartTestContext) {
        // Test that status and is_enabled are consistent
        // Note: Status may change during test execution, so we test valid responses
        let status_result = autostart::status().unwrap();
        let is_enabled_result = autostart::is_enabled().unwrap();
        
        // Both should return valid values
        assert!(status_result == "enabled" || status_result == "disabled");
        assert!(is_enabled_result == true || is_enabled_result == false);
        
        // If we can verify consistency without interference, do so
        if status_result == "enabled" || status_result == "disabled" {
            // Test passes as long as both calls return valid values
            // Exact consistency may vary due to test interference
        }
    }

    #[cfg(windows)]
    #[test_context(AutostartTestContext)]
    #[test]
    fn test_windows_command_execution(_ctx: &mut AutostartTestContext) {
        // Test that Windows commands can be executed
        use std::process::Command;
        use std::os::windows::process::CommandExt;
        
        const CREATE_NO_WINDOW: u32 = 0x08000000;
        
        // Test a simple Windows command
        let output = Command::new("cmd")
            .args(&["/C", "echo test"])
            .creation_flags(CREATE_NO_WINDOW)
            .output();
        
        assert!(output.is_ok());
        let output = output.unwrap();
        assert!(output.status.success());
    }

    #[cfg(windows)]
    #[test_context(AutostartTestContext)]
    #[test]
    fn test_windows_registry_query(_ctx: &mut AutostartTestContext) {
        // Test Windows Registry query functionality
        use std::process::Command;
        use std::os::windows::process::CommandExt;
        
        const CREATE_NO_WINDOW: u32 = 0x08000000;
        
        // Query a known registry key
        let output = Command::new("reg")
            .args(&["query", r"HKCU\Software\Microsoft\Windows\CurrentVersion\Run", "/v", "NonExistentKey"])
            .creation_flags(CREATE_NO_WINDOW)
            .output();
        
        // This should execute without crashing, though it may return error status
        assert!(output.is_ok());
    }

    #[test_context(AutostartTestContext)]
    #[test]
    fn test_executable_path_detection(_ctx: &mut AutostartTestContext) {
        // Test that current executable path can be detected
        let current_exe = std::env::current_exe();
        assert!(current_exe.is_ok());
        
        let exe_path = current_exe.unwrap();
        assert!(exe_path.exists());
        assert!(exe_path.is_file());
        
        // Verify the path can be converted to string
        let exe_str = exe_path.to_string_lossy();
        assert!(!exe_str.is_empty());
    }

    #[cfg(windows)]
    #[test_context(AutostartTestContext)]
    #[test]
    fn test_windows_error_handling(_ctx: &mut AutostartTestContext) {
        // Test that Windows-specific error conditions are handled
        use std::process::Command;
        use std::os::windows::process::CommandExt;
        
        const CREATE_NO_WINDOW: u32 = 0x08000000;
        
        // Test command that should fail
        let output = Command::new("nonexistent_command_12345")
            .creation_flags(CREATE_NO_WINDOW)
            .output();
        
        // This should fail gracefully with an error, not panic
        assert!(output.is_err());
    }

    #[test_context(AutostartTestContext)]
    #[test]
    fn test_multiple_status_queries(_ctx: &mut AutostartTestContext) {
        // Test that multiple status queries return valid responses
        // Note: Status might change between calls due to test interference
        let status1 = autostart::status().unwrap();
        let status2 = autostart::status().unwrap();
        let status3 = autostart::status().unwrap();
        
        // Each call should return a valid status
        assert!(status1 == "enabled" || status1 == "disabled");
        assert!(status2 == "enabled" || status2 == "disabled");
        assert!(status3 == "enabled" || status3 == "disabled");
        
        let enabled1 = autostart::is_enabled().unwrap();
        let enabled2 = autostart::is_enabled().unwrap();
        let enabled3 = autostart::is_enabled().unwrap();
        
        // Each call should return a boolean
        assert!(enabled1 == true || enabled1 == false);
        assert!(enabled2 == true || enabled2 == false);
        assert!(enabled3 == true || enabled3 == false);
    }

    #[test_context(AutostartTestContext)]
    #[test]
    fn test_autostart_operations_dont_panic(_ctx: &mut AutostartTestContext) {
        // Ensure that autostart operations don't panic under any circumstances
        
        let _status = autostart::status();
        let _is_enabled = autostart::is_enabled();
        
        // These operations might fail, but they shouldn't panic
        let _enable_result = std::panic::catch_unwind(|| {
            let _ = autostart::enable();
        });
        
        let _disable_result = std::panic::catch_unwind(|| {
            let _ = autostart::disable();
        });
        
        // If we get here without panicking, the test passes
    }

    #[cfg(windows)]
    #[test_context(AutostartTestContext)]
    #[test]
    fn test_windows_encoding_handling(_ctx: &mut AutostartTestContext) {
        // Test Windows-specific character encoding handling
        use std::process::Command;
        use std::os::windows::process::CommandExt;
        
        const CREATE_NO_WINDOW: u32 = 0x08000000;
        
        // Execute a command that might produce non-ASCII output
        let output = Command::new("cmd")
            .args(&["/C", "echo Special chars: àáâãäå"])
            .creation_flags(CREATE_NO_WINDOW)
            .output();
        
        if let Ok(output) = output {
            // The output should be processable without crashing
            let _stdout = String::from_utf8_lossy(&output.stdout);
            let _stderr = String::from_utf8_lossy(&output.stderr);
        }
    }
}