fmt: apply cargo fmt changes

Author: joshuadavidthomas

crates/djls-project/src/finder.rs

@@ -0,0 +1,137 @@
+use std::path::PathBuf;
+use which::Error as WhichError;
+
+// --- Public API ---
+
+pub fn find(name: &str) -> Result<PathBuf, WhichError> {
+    #[cfg(not(test))]
+    {
+        which::which(name)
+    }
+    #[cfg(test)]
+    {
+        mock::find_mocked(name)
+    }
+}
+
+// --- Test-only Mocking Logic ---
+
+#[cfg(test)]
+pub mod mock {
+    use super::*;
+    use std::cell::RefCell;
+    use std::collections::HashMap;
+    use std::thread_local;
+
+    // Store mock results per thread to avoid test interference
+    thread_local! {
+        static MOCK_RESULTS: RefCell<HashMap<String, Result<PathBuf, WhichError>>> = RefCell::new(HashMap::new());
+    }
+
+    // Internal function called by the public `find` when cfg(test) is enabled.
+    // Returns the mocked result for `name` or a default error if not mocked.
+    pub(super) fn find_mocked(name: &str) -> Result<PathBuf, WhichError> {
+        MOCK_RESULTS.with(|mocks| {
+            let mocks = mocks.borrow();
+            mocks.get(name).cloned().unwrap_or_else(|| {
+                Err(WhichError::CannotFindBinaryPath)
+            })
+        })
+    }
+
+    // --- Test Setup ---
+
+    // RAII guard to ensure mock state is cleared after each test.
+    pub struct MockGuard;
+
+    impl Drop for MockGuard {
+        fn drop(&mut self) {
+            MOCK_RESULTS.with(|mocks| mocks.borrow_mut().clear());
+        }
+    }
+
+    // Sets a mock successful result for `find(name)`.
+    pub fn set_mock_path(name: &str, path: PathBuf) {
+        MOCK_RESULTS.with(|mocks| {
+            mocks.borrow_mut().insert(name.to_string(), Ok(path));
+        });
+    }
+
+    // Sets a mock error result for `find(name)`.
+    pub fn set_mock_error(name: &str, error: WhichError) {
+        MOCK_RESULTS.with(|mocks| {
+            mocks.borrow_mut().insert(name.to_string(), Err(error));
+        });
+    }
+} // end mod mock
+
+#[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"); // "git" is not mocked
+        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());
+            // Mock cleared when _guard drops here
+        }
+
+        // Verify mock was cleared
+        let _guard = MockGuard; // Need guard for this scope too
+        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() {
+        // This test relies on cargo running tests sequentially or in separate threads
+        // where the thread_local works correctly. If tests were run concurrently
+        // in the *same* thread, this could fail, but that's not the default cargo behavior.
+
+        let _guard = MockGuard; // Clears any state from previous tests (like test_mock_path_retrieval)
+
+        // Ensure "python" is not mocked here, even if set in another test
+        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

@@ -6,7 +6,8 @@ use pyo3::prelude::*;
 use std::env;
 use std::fmt;
 use std::path::{Path, PathBuf};
-use which::which;
+
+mod finder;
 
 #[derive(Debug)]
 pub struct DjangoProject {
@@ -126,7 +127,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 +137,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 +166,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()?;
 
@@ -237,6 +234,8 @@ mod tests {
 
     mod env_discovery {
         use super::*;
+        use super::finder::mock::{self as exec_mock, MockGuard};
+        use which::Error as WhichError;
 
         fn create_mock_venv(dir: &Path, version: Option<&str>) -> PathBuf {
             let prefix = dir.to_path_buf();
@@ -291,29 +290,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();
@@ -485,16 +461,13 @@ mod tests {
             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);
+            // --- Set up executable finder mock ---
+            let _guard = MockGuard; // Ensure mocks are cleared after test
+            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
+            // This test now assumes the mock is correctly configured
             let system_env = PythonEnvironment::new(project_dir.path(), None);
 
             assert!(
@@ -503,10 +476,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!(
@@ -528,17 +503,24 @@ 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("");
+            // --- Set up executable finder mock to fail ---
+            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]