fmt: apply cargo fmt changes

Author: joshuadavidthomas

crates/djls-project/src/finder.rs

@@ -0,0 +1,122 @@
+use std::path::PathBuf;
+use which::Error as WhichError;
+
+pub fn find(name: &str) -> Result<PathBuf, WhichError> {
+    #[cfg(not(test))]
+    {
+        which::which(name)
+    }
+    #[cfg(test)]
+    {
+        mock::find_mocked(name)
+    }
+}
+
+#[cfg(test)]
+pub mod mock {
+    use super::*;
+    use std::cell::RefCell;
+    use std::collections::HashMap;
+    use std::thread_local;
+
+    thread_local! {
+        static MOCK_RESULTS: RefCell<HashMap<String, Result<PathBuf, WhichError>>> = RefCell::new(HashMap::new());
+    }
+
+    pub(super) fn find_mocked(name: &str) -> Result<PathBuf, WhichError> {
+        MOCK_RESULTS.with(|mocks| {
+            let mocks = mocks.borrow();
+            mocks
+                .get(name)
+                .cloned()
+                .unwrap_or({ Err(WhichError::CannotFindBinaryPath) })
+        })
+    }
+
+    pub struct MockGuard;
+
+    impl Drop for MockGuard {
+        fn drop(&mut self) {
+            MOCK_RESULTS.with(|mocks| mocks.borrow_mut().clear());
+        }
+    }
+
+    pub fn set_mock_path(name: &str, path: PathBuf) {
+        MOCK_RESULTS.with(|mocks| {
+            mocks.borrow_mut().insert(name.to_string(), Ok(path));
+        });
+    }
+
+    pub fn set_mock_error(name: &str, error: WhichError) {
+        MOCK_RESULTS.with(|mocks| {
+            mocks.borrow_mut().insert(name.to_string(), Err(error));
+        });
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::mock::{self as finder_mock, MockGuard};
+    use super::*; // Import find function etc.
+    use std::path::PathBuf;
+    use which::Error as WhichError;
+
+    #[test]
+    fn test_mock_path_retrieval() {
+        let _guard = MockGuard;
+        let expected_path = PathBuf::from("/mock/path/to/python");
+        finder_mock::set_mock_path("python", expected_path.clone());
+
+        let result = find("python");
+        assert_eq!(result.unwrap(), expected_path);
+    }
+
+    #[test]
+    fn test_mock_error_retrieval() {
+        let _guard = MockGuard;
+        finder_mock::set_mock_error("cargo", WhichError::CannotFindBinaryPath);
+
+        let result = find("cargo");
+        assert!(matches!(result, Err(WhichError::CannotFindBinaryPath)));
+    }
+
+    #[test]
+    fn test_mock_default_error_if_unmocked() {
+        let _guard = MockGuard;
+        let result = find("git");
+        assert!(matches!(result, Err(WhichError::CannotFindBinaryPath)));
+    }
+
+    #[test]
+    fn test_mock_guard_clears_mocks() {
+        let expected_path = PathBuf::from("/tmp/myprog");
+
+        {
+            let _guard = MockGuard;
+            finder_mock::set_mock_path("myprog", expected_path.clone());
+        }
+
+        let _guard = MockGuard;
+        let result = find("myprog");
+        // Should default back to error because the previous mock was cleared
+        assert!(matches!(result, Err(WhichError::CannotFindBinaryPath)));
+    }
+
+    #[test]
+    fn test_mocks_are_separate_between_tests() {
+        let _guard = MockGuard;
+
+        // Ensure "python" (mocked in another test) is not mocked here
+        let result_python = find("python");
+        assert!(matches!(
+            result_python,
+            Err(WhichError::CannotFindBinaryPath)
+        ));
+
+        // Set a mock specific to this test
+        let expected_path_node = PathBuf::from("/usr/bin/node");
+        finder_mock::set_mock_path("node", expected_path_node.clone());
+        let result_node = find("node");
+        assert_eq!(result_node.unwrap(), expected_path_node);
+    }
+}

crates/djls-project/src/lib.rs

@@ -1,3 +1,4 @@
+mod finder;
 mod templatetags;
 
 pub use templatetags::TemplateTags;
@@ -6,7 +7,6 @@ use pyo3::prelude::*;
 use std::env;
 use std::fmt;
 use std::path::{Path, PathBuf};
-use which::which;
 
 #[derive(Debug)]
 pub struct DjangoProject {
@@ -126,7 +126,6 @@ impl PythonEnvironment {
         #[cfg(windows)]
         let python_path = prefix.join("Scripts").join("python.exe");
 
-        // Check if the *prefix* and the *binary* exist.
         if !prefix.is_dir() || !python_path.exists() {
             return None;
         }
@@ -137,10 +136,9 @@ impl PythonEnvironment {
         let bin_dir = prefix.join("Scripts");
 
         let mut sys_path = Vec::new();
-        sys_path.push(bin_dir); // Add bin/ or Scripts/
+        sys_path.push(bin_dir);
 
         if let Some(site_packages) = Self::find_site_packages(prefix) {
-            // Check existence inside the if let, as find_site_packages might return a path that doesn't exist
             if site_packages.is_dir() {
                 sys_path.push(site_packages);
             }
@@ -167,12 +165,10 @@ impl PythonEnvironment {
     }
 
     fn from_system_python() -> Option<Self> {
-        let python_path = match which("python") {
+        let python_path = match finder::find("python") {
             Ok(p) => p,
             Err(_) => return None,
         };
-        // which() might return a path inside a bin/Scripts dir, or directly the executable
-        // We need the prefix, which is usually two levels up from the executable in standard layouts
         let bin_dir = python_path.parent()?;
         let prefix = bin_dir.parent()?;
 
@@ -232,11 +228,13 @@ mod tests {
     use super::*;
     use std::fs;
     #[cfg(unix)]
-    use std::os::unix::fs::PermissionsExt; // Needed for setting execute permission
+    use std::os::unix::fs::PermissionsExt;
     use tempfile::tempdir;
 
     mod env_discovery {
+        use super::finder::mock::{self as exec_mock, MockGuard};
         use super::*;
+        use which::Error as WhichError;
 
         fn create_mock_venv(dir: &Path, version: Option<&str>) -> PathBuf {
             let prefix = dir.to_path_buf();
@@ -245,7 +243,7 @@ mod tests {
             {
                 let bin_dir = prefix.join("bin");
                 fs::create_dir_all(&bin_dir).unwrap();
-                fs::write(bin_dir.join("python"), "").unwrap(); // Create dummy executable
+                fs::write(bin_dir.join("python"), "").unwrap();
                 let lib_dir = prefix.join("lib");
                 fs::create_dir_all(&lib_dir).unwrap();
                 let py_version_dir = lib_dir.join(version.unwrap_or("python3.9"));
@@ -256,7 +254,7 @@ mod tests {
             {
                 let bin_dir = prefix.join("Scripts");
                 fs::create_dir_all(&bin_dir).unwrap();
-                fs::write(bin_dir.join("python.exe"), "").unwrap(); // Create dummy executable
+                fs::write(bin_dir.join("python.exe"), "").unwrap();
                 let lib_dir = prefix.join("Lib");
                 fs::create_dir_all(&lib_dir).unwrap();
                 fs::create_dir_all(lib_dir.join("site-packages")).unwrap();
@@ -291,29 +289,6 @@ mod tests {
             }
         }
 
-        // Guard struct to temporarily modify the PATH environment variable
-        struct PathGuard {
-            original_path: Option<String>,
-        }
-
-        impl PathGuard {
-            fn set(new_path_val: &str) -> Self {
-                let original_path = env::var("PATH").ok();
-                env::set_var("PATH", new_path_val);
-                Self { original_path }
-            }
-        }
-
-        impl Drop for PathGuard {
-            fn drop(&mut self) {
-                // Restore original PATH, or remove if it wasn't set initially
-                match self.original_path.as_deref() {
-                    Some(val) => env::set_var("PATH", val),
-                    None => env::remove_var("PATH"),
-                }
-            }
-        }
-
         #[test]
         fn test_explicit_venv_path_found() {
             let project_dir = tempdir().unwrap();
@@ -442,17 +417,15 @@ mod tests {
         }
 
         #[test]
-        // #[ignore = "Relies on system python being available and having standard layout"] // No longer ignored!
         fn test_system_python_fallback() {
-            let project_dir = tempdir().unwrap(); // Dummy project dir, not used for discovery here.
+            let project_dir = tempdir().unwrap();
 
-            // Set VIRTUAL_ENV to something known to be invalid to ensure it's ignored.
+            // Set VIRTUAL_ENV to invalid to ensure it's ignored.
             let invalid_virtual_env_path =
                 project_dir.path().join("non_existent_venv_sys_fallback");
             let _guard =
                 VirtualEnvGuard::set("VIRTUAL_ENV", invalid_virtual_env_path.to_str().unwrap());
 
-            // --- Set up mock system python ---
             let mock_sys_python_dir = tempdir().unwrap();
             let mock_sys_python_prefix = mock_sys_python_dir.path();
 
@@ -472,29 +445,23 @@ mod tests {
             let bin_dir = mock_sys_python_prefix.join(bin_subdir);
             fs::create_dir_all(&bin_dir).unwrap();
             let python_path = bin_dir.join(python_exe);
-            fs::write(&python_path, "").unwrap(); // Create dummy executable
+            fs::write(&python_path, "").unwrap();
 
             // Ensure the dummy executable has execute permissions (required by `which` on Unix)
             #[cfg(unix)]
             {
                 let mut perms = fs::metadata(&python_path).unwrap().permissions();
-                perms.set_mode(0o755); // rwxr-xr-x
+                perms.set_mode(0o755);
                 fs::set_permissions(&python_path, perms).unwrap();
             }
 
             let site_packages_path = mock_sys_python_prefix.join(site_packages_rel_path);
             fs::create_dir_all(&site_packages_path).unwrap();
 
-            // --- Manipulate PATH ---
-            // Completely overwrite PATH to only include the mock bin directory
-            let canonical_bin_dir =
-                bin_dir.canonicalize().expect("Failed to canonicalize mock bin dir");
-            let new_path = canonical_bin_dir.to_str().unwrap().to_string();
-            let _path_guard = PathGuard::set(&new_path);
+            let _guard = MockGuard;
+            exec_mock::set_mock_path("python", python_path.clone());
 
             // We don't create any venvs in project_dir
-
-            // This test assumes `which python` works and points to a standard layout
             let system_env = PythonEnvironment::new(project_dir.path(), None);
 
             assert!(
@@ -503,10 +470,12 @@ mod tests {
             );
 
             if let Some(env) = system_env {
-                assert_eq!(env.python_path, python_path, "Python path should match mock");
                 assert_eq!(
-                    env.sys_prefix,
-                    mock_sys_python_prefix,
+                    env.python_path, python_path,
+                    "Python path should match mock"
+                );
+                assert_eq!(
+                    env.sys_prefix, mock_sys_python_prefix,
                     "Sys prefix should match mock prefix"
                 );
                 assert!(
@@ -517,8 +486,7 @@ mod tests {
                     env.sys_path.contains(&site_packages_path),
                     "Sys path should contain mock site-packages"
                 );
-            } else {
-                panic!("Expected to find environment, but got None"); // Should not happen if assert above passed
+                panic!("Expected to find environment, but got None");
             }
         }
 
@@ -528,17 +496,18 @@ mod tests {
 
             // Ensure no explicit path, no project venvs, and set VIRTUAL_ENV to invalid.
             let invalid_virtual_env_path = project_dir.path().join("non_existent_venv_no_python");
-            let _guard =
+            let _guard_venv =
                 VirtualEnvGuard::set("VIRTUAL_ENV", invalid_virtual_env_path.to_str().unwrap());
 
-            // Overwrite PATH with an empty value to ensure `which("python")` fails.
-            let _path_guard = PathGuard::set("");
+            let _guard_mock = MockGuard;
+            exec_mock::set_mock_error("python", WhichError::CannotFindBinaryPath);
 
-            // Call the function under test
             let env = PythonEnvironment::new(project_dir.path(), None);
 
-            // Assert that no environment was found
-            assert!(env.is_none(), "Expected no environment to be found when all discovery methods fail");
+            assert!(
+                env.is_none(),
+                "Expected no environment to be found when all discovery methods fail"
+            );
         }
 
         #[test]