test(which): enhance which filter tests with fixture helpers and PATH setup

- Added helper functions for cache removal tests and cwd_mode resolution to reduce duplication.
- Set PATH environment variable in which lookup tests for consistent environment.
- Refactored tests to use new helpers improving clarity and maintainability.

Co-authored-by: terragon-labs[bot] <terragon-labs[bot]@users.noreply.github.com>

Author: leynos

src/stdlib/which/lookup/tests.rs

@@ -4,7 +4,7 @@
 use super::*;
 use anyhow::{Context, Result, anyhow, ensure};
 use rstest::{fixture, rstest};
-use std::fs;
+use std::{ffi::OsStr, fs};
 use tempfile::TempDir;
 use test_support::env::VarGuard;
 
@@ -62,6 +62,7 @@ fn search_workspace_returns_executable_and_skips_non_exec(workspace: TempWorkspa
     let non_exec = workspace.root().join("tool2");
     fs::write(non_exec.as_std_path(), b"not exec").context("write non exec")?;
 
+    let _guard = VarGuard::set("PATH", OsStr::new(workspace.root().as_str()));
     let snapshot =
         EnvSnapshot::capture(Some(workspace.root())).expect("capture env for workspace search");
     let results = search_workspace(&snapshot, "tool", false)?;
@@ -79,6 +80,7 @@ fn search_workspace_collects_all_matches(workspace: TempWorkspace) -> Result<()>
     fs::create_dir_all(subdir.as_std_path()).context("mkdir bin")?;
     let second = write_exec(subdir.as_path(), "tool")?;
 
+    let _guard = VarGuard::set("PATH", OsStr::new(workspace.root().as_str()));
     let snapshot =
         EnvSnapshot::capture(Some(workspace.root())).expect("capture env for workspace search");
     let mut results = search_workspace(&snapshot, "tool", true)?;
@@ -98,6 +100,7 @@ fn search_workspace_skips_heavy_directories(workspace: TempWorkspace) -> Result<
     fs::create_dir_all(heavy.as_std_path()).context("mkdir target")?;
     write_exec(heavy.as_path(), "tool")?;
 
+    let _guard = VarGuard::set("PATH", OsStr::new(workspace.root().as_str()));
     let snapshot =
         EnvSnapshot::capture(Some(workspace.root())).expect("capture env for workspace search");
     let results = search_workspace(&snapshot, "tool", false)?;
@@ -118,6 +121,7 @@ fn search_workspace_ignores_unreadable_entries(workspace: TempWorkspace) -> Resu
     fs::set_permissions(blocked.as_std_path(), perms).context("chmod blocked")?;
 
     let exec = write_exec(workspace.root(), "tool")?;
+    let _guard = VarGuard::set("PATH", OsStr::new(workspace.root().as_str()));
     let snapshot =
         EnvSnapshot::capture(Some(workspace.root())).expect("capture env for workspace search");
     let results = search_workspace(&snapshot, "tool", false)?;
@@ -244,6 +248,7 @@ fn direct_path_not_executable_raises_direct_not_found(workspace: TempWorkspace)
     perms.set_mode(0o644);
     fs::set_permissions(script.as_std_path(), perms).context("chmod script")?;
 
+    let _path_guard = VarGuard::set("PATH", OsStr::new(workspace.root().as_str()));
     let snapshot =
         EnvSnapshot::capture(Some(workspace.root())).context("capture env for direct path")?;
 

tests/std_filter_tests/which_filter_tests.rs

@@ -48,6 +48,24 @@ fn test_cache_after_removal(
     Ok(())
 }
 
+/// Helper to set up a fixture for cache removal tests and run the test.
+fn test_cache_behaviour_after_removal(
+    second_template_str: &str,
+    expect_second_err: bool,
+) -> Result<()> {
+    let mut fixture = WhichTestFixture::with_tool_in_dirs(
+        &ToolName::from("helper"),
+        &[DirName::from("bin_first"), DirName::from("bin_second")],
+    )?;
+
+    test_cache_after_removal(
+        &mut fixture,
+        &Template::from("{{ 'helper' | which }}"),
+        &Template::from(second_template_str),
+        expect_second_err,
+    )
+}
+
 fn test_duplicate_paths(
     fixture: &mut WhichTestFixture,
     canonical: bool,
@@ -70,6 +88,18 @@ fn test_duplicate_paths(
     Ok(())
 }
 
+/// Helper to test cwd_mode resolution with a given case variant.
+fn test_cwd_mode_resolution(cwd_mode_value: &str) -> Result<()> {
+    let (_temp, root) = support::filter_workspace()?;
+    let tool = write_tool(&root, &ToolName::from("local"))?;
+    let _path = PathEnv::new(&[])?;
+    let (mut env, _state) = fallible::stdlib_env_with_state()?;
+    let template = Template::from(format!("{{{{ which('local', cwd_mode='{cwd_mode_value}') }}}}"));
+    let output = render(&mut env, &template)?;
+    assert_eq!(output, tool.as_str());
+    Ok(())
+}
+
 #[rstest]
 fn which_filter_returns_first_match() -> Result<()> {
     let mut fixture = WhichTestFixture::with_tool_in_dirs(
@@ -83,30 +113,12 @@ fn which_filter_returns_first_match() -> Result<()> {
 
 #[rstest]
 fn which_filter_uses_cached_result_when_executable_removed() -> Result<()> {
-    let mut fixture = WhichTestFixture::with_tool_in_dirs(
-        &ToolName::from("helper"),
-        &[DirName::from("bin_first"), DirName::from("bin_second")],
-    )?;
-    test_cache_after_removal(
-        &mut fixture,
-        &Template::from("{{ 'helper' | which }}"),
-        &Template::from("{{ 'helper' | which }}"),
-        false,
-    )
+    test_cache_behaviour_after_removal("{{ 'helper' | which }}", false)
 }
 
 #[rstest]
 fn which_filter_fresh_bypasses_cache_after_executable_removed() -> Result<()> {
-    let mut fixture = WhichTestFixture::with_tool_in_dirs(
-        &ToolName::from("helper"),
-        &[DirName::from("bin_first"), DirName::from("bin_second")],
-    )?;
-    test_cache_after_removal(
-        &mut fixture,
-        &Template::from("{{ 'helper' | which }}"),
-        &Template::from("{{ 'helper' | which(fresh=true) }}"),
-        true,
-    )
+    test_cache_behaviour_after_removal("{{ 'helper' | which(fresh=true) }}", true)
 }
 
 #[rstest]
@@ -165,14 +177,7 @@ fn which_filter_all_with_duplicates_deduplicates_canonicalised_paths() -> Result
 
 #[rstest]
 fn which_function_honours_cwd_mode() -> Result<()> {
-    let (_temp, root) = support::filter_workspace()?;
-    let tool = write_tool(&root, &ToolName::from("local"))?;
-    let _path = PathEnv::new(&[])?;
-    let (mut env, _state) = fallible::stdlib_env_with_state()?;
-    let template = Template::from("{{ which('local', cwd_mode='always') }}");
-    let output = render(&mut env, &template)?;
-    assert_eq!(output, tool.as_str());
-    Ok(())
+    test_cwd_mode_resolution("always")
 }
 
 #[rstest]
@@ -200,14 +205,7 @@ fn which_function_rejects_invalid_cwd_mode() -> Result<()> {
 
 #[rstest]
 fn which_function_accepts_case_insensitive_cwd_mode() -> Result<()> {
-    let (_temp, root) = support::filter_workspace()?;
-    let tool = write_tool(&root, &ToolName::from("local"))?;
-    let _path = PathEnv::new(&[])?;
-    let (mut env, _state) = fallible::stdlib_env_with_state()?;
-    let template = Template::from("{{ which('local', cwd_mode='ALWAYS') }}");
-    let output = render(&mut env, &template)?;
-    assert_eq!(output, tool.as_str());
-    Ok(())
+    test_cwd_mode_resolution("ALWAYS")
 }
 
 #[rstest]