Add comprehensive tests for hooks functionality and update plan.md

- Introduced extensive test suite covering edge cases for all built-in hooks, ensuring thorough validation.
- Updated `plan.md` to streamline tasks by removing unnecessary hook expansion item for https://pre-commit.com/hooks.html.

Author: jensenbox

src/lib.rs

@@ -50,6 +50,10 @@ pub struct Cli {
     #[arg(long, default_value = "info")]
     pub log_level: String,
 
+    /// Comma-separated list of hook IDs to skip
+    #[arg(long)]
+    pub skip: Option<String>,
+
     #[command(subcommand)]
     pub command: Commands,
 }
@@ -218,7 +222,7 @@ fn run_hooks_with_native_config() {
     // Find the native config
     match config::find_config() {
         Ok(mut config) => {
-            // Get the parallelism limit from the CLI
+            // Get the CLI options
             let cli = Cli::parse();
             if cli.parallelism > 0 {
                 // Override the parallelism limit from the config with the one from the CLI
@@ -238,6 +242,33 @@ fn run_hooks_with_native_config() {
             let mut resolver = runner::HookResolver::new(config, cache_dir);
             debug!("Hook resolver created");
 
+            // Set hooks to skip if specified
+            if let Some(skip) = &cli.skip {
+                let hooks_to_skip: Vec<String> = skip.split(',')
+                    .map(|s| s.trim().to_string())
+                    .collect();
+                if !hooks_to_skip.is_empty() {
+                    debug!("Skipping hooks: {}", hooks_to_skip.join(", "));
+                    resolver.set_hooks_to_skip(hooks_to_skip);
+                }
+            }
+
+            // Check for environment variable to skip hooks
+            if let Ok(skip_env) = std::env::var("RUSTYHOOK_SKIP") {
+                if !skip_env.is_empty() {
+                    let env_hooks_to_skip: Vec<String> = skip_env.split(',')
+                        .map(|s| s.trim().to_string())
+                        .collect();
+                    if !env_hooks_to_skip.is_empty() {
+                        debug!("Skipping hooks from environment: {}", env_hooks_to_skip.join(", "));
+                        // Merge with any hooks already set to skip
+                        let mut all_hooks_to_skip = resolver.hooks_to_skip().clone();
+                        all_hooks_to_skip.extend(env_hooks_to_skip);
+                        resolver.set_hooks_to_skip(all_hooks_to_skip);
+                    }
+                }
+            }
+
             // Get the list of files to check
             // For now, we'll just use all files in the current directory
             let files = get_files_to_check();
@@ -290,6 +321,33 @@ fn run_hooks_with_compat_config() {
             let mut resolver = runner::HookResolver::new(config, cache_dir);
             debug!("Hook resolver created");
 
+            // Set hooks to skip if specified
+            if let Some(skip) = &cli.skip {
+                let hooks_to_skip: Vec<String> = skip.split(',')
+                    .map(|s| s.trim().to_string())
+                    .collect();
+                if !hooks_to_skip.is_empty() {
+                    debug!("Skipping hooks: {}", hooks_to_skip.join(", "));
+                    resolver.set_hooks_to_skip(hooks_to_skip);
+                }
+            }
+
+            // Check for environment variable to skip hooks
+            if let Ok(skip_env) = std::env::var("RUSTYHOOK_SKIP") {
+                if !skip_env.is_empty() {
+                    let env_hooks_to_skip: Vec<String> = skip_env.split(',')
+                        .map(|s| s.trim().to_string())
+                        .collect();
+                    if !env_hooks_to_skip.is_empty() {
+                        debug!("Skipping hooks from environment: {}", env_hooks_to_skip.join(", "));
+                        // Merge with any hooks already set to skip
+                        let mut all_hooks_to_skip = resolver.hooks_to_skip().clone();
+                        all_hooks_to_skip.extend(env_hooks_to_skip);
+                        resolver.set_hooks_to_skip(all_hooks_to_skip);
+                    }
+                }
+            }
+
             // Get the list of files to check
             // For now, we'll just use all files in the current directory
             let files = get_files_to_check();

src/runner/hook_resolver.rs

@@ -63,6 +63,8 @@ pub struct HookResolver {
     cache_dir: PathBuf,
     /// Tool cache
     tool_cache: HashMap<String, Box<dyn Tool>>,
+    /// Hooks to skip
+    hooks_to_skip: Vec<String>,
 }
 
 impl HookResolver {
@@ -72,9 +74,20 @@ impl HookResolver {
             config,
             cache_dir,
             tool_cache: HashMap::new(),
+            hooks_to_skip: Vec::new(),
         }
     }
 
+    /// Set hooks to skip
+    pub fn set_hooks_to_skip(&mut self, hooks: Vec<String>) {
+        self.hooks_to_skip = hooks;
+    }
+
+    /// Get hooks to skip
+    pub fn hooks_to_skip(&self) -> &Vec<String> {
+        &self.hooks_to_skip
+    }
+
     /// Get the configuration
     pub fn config(&self) -> &Config {
         &self.config
@@ -254,10 +267,17 @@ impl HookResolver {
         // Collect all hooks first to avoid borrowing issues
         let hooks_to_run: Vec<(String, String)> = self.config.repos.iter()
             .flat_map(|repo| {
-                repo.hooks.iter().map(move |hook| (repo.repo.clone(), hook.id.clone()))
+                repo.hooks.iter()
+                    .filter(|hook| !self.hooks_to_skip.contains(&hook.id))
+                    .map(move |hook| (repo.repo.clone(), hook.id.clone()))
             })
             .collect();
 
+        // Log which hooks are being skipped
+        if !self.hooks_to_skip.is_empty() {
+            log::info!("Skipping hooks: {}", self.hooks_to_skip.join(", "));
+        }
+
         // Run each hook
         for (repo_id, hook_id) in hooks_to_run {
             self.run_hook(&repo_id, &hook_id, files)?;

tests/hook_execution_tests.rs

@@ -160,6 +160,92 @@ fn test_run_hook_in_separate_process() {
     assert!(result.is_ok());
 }
 
+#[test]
+fn test_skip_hooks() {
+    // Create a temporary directory for the test
+    let temp_dir = tempfile::tempdir().unwrap();
+    let cache_dir = temp_dir.path().to_path_buf();
+
+    // Create a test configuration with multiple hooks
+    let config = Config {
+        default_stages: vec!["commit".to_string()],
+        fail_fast: false,
+        parallelism: 0, // 0 means unlimited
+        repos: vec![
+            Repo {
+                repo: "local".to_string(),
+                hooks: vec![
+                    Hook {
+                        id: "hook1".to_string(),
+                        name: "Hook 1".to_string(),
+                        entry: "echo".to_string(),
+                        language: "system".to_string(),
+                        files: ".*\\.rs$".to_string(),
+                        stages: vec!["commit".to_string()],
+                        args: vec!["Hook 1".to_string()],
+                        env: std::collections::HashMap::new(),
+                        version: None,
+                        hook_type: HookType::External,
+                        separate_process: true,
+                    },
+                    Hook {
+                        id: "hook2".to_string(),
+                        name: "Hook 2".to_string(),
+                        entry: "echo".to_string(),
+                        language: "system".to_string(),
+                        files: ".*\\.rs$".to_string(),
+                        stages: vec!["commit".to_string()],
+                        args: vec!["Hook 2".to_string()],
+                        env: std::collections::HashMap::new(),
+                        version: None,
+                        hook_type: HookType::External,
+                        separate_process: true,
+                    },
+                    Hook {
+                        id: "hook3".to_string(),
+                        name: "Hook 3".to_string(),
+                        entry: "echo".to_string(),
+                        language: "system".to_string(),
+                        files: ".*\\.rs$".to_string(),
+                        stages: vec!["commit".to_string()],
+                        args: vec!["Hook 3".to_string()],
+                        env: std::collections::HashMap::new(),
+                        version: None,
+                        hook_type: HookType::External,
+                        separate_process: true,
+                    },
+                ],
+            },
+        ],
+    };
+
+    // Create a hook resolver
+    let mut resolver = HookResolver::new(config, cache_dir);
+
+    // Set hooks to skip
+    let hooks_to_skip = vec!["hook2".to_string()];
+    resolver.set_hooks_to_skip(hooks_to_skip);
+
+    // Check that the hooks_to_skip list is set correctly
+    assert_eq!(resolver.hooks_to_skip().len(), 1);
+    assert_eq!(resolver.hooks_to_skip()[0], "hook2");
+
+    // Create some test files
+    let files = vec![
+        PathBuf::from("src/main.rs"),
+        PathBuf::from("src/lib.rs"),
+    ];
+
+    // Run all hooks
+    let result = resolver.run_all_hooks(&files);
+
+    // Check that the hooks ran successfully
+    assert!(result.is_ok());
+
+    // We can't easily verify that hook2 was skipped in this test framework,
+    // but the implementation in run_all_hooks should filter it out
+}
+
 #[test]
 fn test_hook_context_execution() {
     // Create a hook that should run in a separate process (external hook)