add tests

Author: karthiknadig

crates/pet-python-utils/src/executable.rs

@@ -381,4 +381,137 @@ mod tests {
             PathBuf::from("/home/user/project/shims").as_path()
         ));
     }
+
+    #[test]
+    fn test_is_broken_symlink_regular_file() {
+        // A regular file should not be detected as a broken symlink
+        let temp_dir = std::env::temp_dir();
+        let test_file = temp_dir.join("pet_test_regular_file.txt");
+        fs::write(&test_file, "test").unwrap();
+
+        assert!(!is_broken_symlink(&test_file));
+
+        let _ = fs::remove_file(&test_file);
+    }
+
+    #[test]
+    fn test_is_broken_symlink_nonexistent() {
+        // A non-existent path should not be detected as a broken symlink
+        let nonexistent = PathBuf::from("/this/path/does/not/exist/python");
+        assert!(!is_broken_symlink(&nonexistent));
+    }
+
+    #[test]
+    #[cfg(unix)]
+    fn test_is_broken_symlink_unix() {
+        use std::os::unix::fs::symlink;
+
+        let temp_dir = std::env::temp_dir();
+        let target = temp_dir.join("pet_test_symlink_target_nonexistent");
+        let link = temp_dir.join("pet_test_broken_symlink");
+
+        // Clean up any previous test artifacts
+        let _ = fs::remove_file(&link);
+        let _ = fs::remove_file(&target);
+
+        // Create a symlink to a non-existent target
+        symlink(&target, &link).unwrap();
+
+        // The symlink should be detected as broken
+        assert!(is_broken_symlink(&link));
+
+        // Clean up
+        let _ = fs::remove_file(&link);
+    }
+
+    #[test]
+    #[cfg(unix)]
+    fn test_is_broken_symlink_valid_symlink() {
+        use std::os::unix::fs::symlink;
+
+        let temp_dir = std::env::temp_dir();
+        let target = temp_dir.join("pet_test_symlink_target_exists");
+        let link = temp_dir.join("pet_test_valid_symlink");
+
+        // Clean up any previous test artifacts
+        let _ = fs::remove_file(&link);
+        let _ = fs::remove_file(&target);
+
+        // Create the target file
+        fs::write(&target, "test").unwrap();
+
+        // Create a symlink to the existing target
+        symlink(&target, &link).unwrap();
+
+        // The symlink should NOT be detected as broken
+        assert!(!is_broken_symlink(&link));
+
+        // Clean up
+        let _ = fs::remove_file(&link);
+        let _ = fs::remove_file(&target);
+    }
+
+    #[test]
+    fn test_find_executable_or_broken_not_found() {
+        let temp_dir = std::env::temp_dir().join("pet_test_empty_env");
+        let _ = fs::create_dir_all(&temp_dir);
+
+        match find_executable_or_broken(&temp_dir) {
+            ExecutableResult::NotFound => (),
+            other => panic!("Expected NotFound, got {:?}", other),
+        }
+
+        let _ = fs::remove_dir_all(&temp_dir);
+    }
+
+    #[test]
+    fn test_find_executable_or_broken_found() {
+        let temp_dir = std::env::temp_dir().join("pet_test_valid_env");
+        #[cfg(windows)]
+        let bin_dir = temp_dir.join("Scripts");
+        #[cfg(unix)]
+        let bin_dir = temp_dir.join("bin");
+
+        let _ = fs::remove_dir_all(&temp_dir);
+        fs::create_dir_all(&bin_dir).unwrap();
+
+        #[cfg(windows)]
+        let python_exe = bin_dir.join("python.exe");
+        #[cfg(unix)]
+        let python_exe = bin_dir.join("python");
+
+        fs::write(&python_exe, "fake python").unwrap();
+
+        match find_executable_or_broken(&temp_dir) {
+            ExecutableResult::Found(path) => assert_eq!(path, python_exe),
+            other => panic!("Expected Found, got {:?}", other),
+        }
+
+        let _ = fs::remove_dir_all(&temp_dir);
+    }
+
+    #[test]
+    #[cfg(unix)]
+    fn test_find_executable_or_broken_broken_symlink() {
+        use std::os::unix::fs::symlink;
+
+        let temp_dir = std::env::temp_dir().join("pet_test_broken_env");
+        let bin_dir = temp_dir.join("bin");
+
+        let _ = fs::remove_dir_all(&temp_dir);
+        fs::create_dir_all(&bin_dir).unwrap();
+
+        let python_exe = bin_dir.join("python");
+        let nonexistent_target = PathBuf::from("/nonexistent/python3.10");
+
+        // Create a broken symlink
+        symlink(&nonexistent_target, &python_exe).unwrap();
+
+        match find_executable_or_broken(&temp_dir) {
+            ExecutableResult::Broken(path) => assert_eq!(path, python_exe),
+            other => panic!("Expected Broken, got {:?}", other),
+        }
+
+        let _ = fs::remove_dir_all(&temp_dir);
+    }
 }

crates/pet-venv/src/lib.rs

@@ -138,3 +138,125 @@ impl Locator for Venv {
         // We expect the user of this class to call `is_compatible`
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs;
+
+    #[test]
+    fn test_try_environment_from_venv_dir_not_a_venv() {
+        // A directory without pyvenv.cfg should return None
+        let temp_dir = std::env::temp_dir().join("pet_test_not_a_venv");
+        let _ = fs::remove_dir_all(&temp_dir);
+        fs::create_dir_all(&temp_dir).unwrap();
+
+        let result = try_environment_from_venv_dir(&temp_dir);
+        assert!(result.is_none());
+
+        let _ = fs::remove_dir_all(&temp_dir);
+    }
+
+    #[test]
+    fn test_try_environment_from_venv_dir_missing_executable() {
+        // A venv with pyvenv.cfg but no Python executable
+        let temp_dir = std::env::temp_dir().join("pet_test_venv_no_exe");
+        let _ = fs::remove_dir_all(&temp_dir);
+        fs::create_dir_all(&temp_dir).unwrap();
+
+        // Create pyvenv.cfg
+        fs::write(
+            temp_dir.join("pyvenv.cfg"),
+            "version = 3.10.0\nprompt = test-env\n",
+        )
+        .unwrap();
+
+        let result = try_environment_from_venv_dir(&temp_dir);
+        assert!(result.is_some());
+
+        let env = result.unwrap();
+        assert_eq!(env.kind, Some(PythonEnvironmentKind::Venv));
+        assert!(env.error.is_some());
+        assert!(env.error.unwrap().contains("not found"));
+        assert_eq!(env.name, Some("test-env".to_string()));
+
+        let _ = fs::remove_dir_all(&temp_dir);
+    }
+
+    #[test]
+    fn test_try_environment_from_venv_dir_valid() {
+        // A valid venv with pyvenv.cfg and Python executable
+        let temp_dir = std::env::temp_dir().join("pet_test_venv_valid");
+        let _ = fs::remove_dir_all(&temp_dir);
+
+        #[cfg(windows)]
+        let bin_dir = temp_dir.join("Scripts");
+        #[cfg(unix)]
+        let bin_dir = temp_dir.join("bin");
+
+        fs::create_dir_all(&bin_dir).unwrap();
+
+        // Create pyvenv.cfg
+        fs::write(
+            temp_dir.join("pyvenv.cfg"),
+            "version = 3.11.0\nprompt = my-project\n",
+        )
+        .unwrap();
+
+        // Create python executable
+        #[cfg(windows)]
+        let python_exe = bin_dir.join("python.exe");
+        #[cfg(unix)]
+        let python_exe = bin_dir.join("python");
+
+        fs::write(&python_exe, "fake python").unwrap();
+
+        let result = try_environment_from_venv_dir(&temp_dir);
+        assert!(result.is_some());
+
+        let env = result.unwrap();
+        assert_eq!(env.kind, Some(PythonEnvironmentKind::Venv));
+        assert!(env.error.is_none());
+        assert!(env.executable.is_some());
+        assert_eq!(env.name, Some("my-project".to_string()));
+
+        let _ = fs::remove_dir_all(&temp_dir);
+    }
+
+    #[test]
+    #[cfg(unix)]
+    fn test_try_environment_from_venv_dir_broken_symlink() {
+        use std::os::unix::fs::symlink;
+
+        // A venv with pyvenv.cfg but a broken symlink for Python
+        let temp_dir = std::env::temp_dir().join("pet_test_venv_broken_symlink");
+        let _ = fs::remove_dir_all(&temp_dir);
+
+        let bin_dir = temp_dir.join("bin");
+        fs::create_dir_all(&bin_dir).unwrap();
+
+        // Create pyvenv.cfg
+        fs::write(
+            temp_dir.join("pyvenv.cfg"),
+            "version = 3.9.0\nprompt = broken-env\n",
+        )
+        .unwrap();
+
+        // Create a broken symlink
+        let python_exe = bin_dir.join("python");
+        let nonexistent_target = std::path::PathBuf::from("/nonexistent/python3.9");
+        symlink(&nonexistent_target, &python_exe).unwrap();
+
+        let result = try_environment_from_venv_dir(&temp_dir);
+        assert!(result.is_some());
+
+        let env = result.unwrap();
+        assert_eq!(env.kind, Some(PythonEnvironmentKind::Venv));
+        assert!(env.error.is_some());
+        assert!(env.error.as_ref().unwrap().contains("broken symlink"));
+        assert_eq!(env.name, Some("broken-env".to_string()));
+        assert!(env.executable.is_some());
+
+        let _ = fs::remove_dir_all(&temp_dir);
+    }
+}