feat(stuff): more tests

Author: Mte90

src/report/html/renderer.rs

@@ -517,6 +517,12 @@ pub fn generate_html_report(
         findings.len()
     ));
 
+    // Create parent directory if it doesn't exist
+    if let Some(parent) = std::path::Path::new(output_path).parent() {
+        std::fs::create_dir_all(parent)
+            .map_err(|e| format!("Failed to create output directory: {}", e))?;
+    }
+
     fs::write(output_path, html).map_err(|e| format!("Failed to write HTML report: {}", e))?;
     Ok(())
 }

src/rulesynth/mod.rs

@@ -50,7 +50,7 @@ impl<'a> RuleSynthesizer<'a> {
 
         // Parse YAML rules from response
         let yaml_content = response.content;
-        let rules = self.parse_yaml_rules(&yaml_content, language)?;
+        let rules = parse_yaml_rules(&yaml_content, language)?;
 
         // Validate each rule and collect valid ones
         let mut valid_rules = Vec::new();
@@ -75,82 +75,83 @@ impl<'a> RuleSynthesizer<'a> {
 
         // Persist valid rules
         if !valid_rules.is_empty() {
-            self.persist_rules(&valid_rules, cwe, language)?;
+            persist_rules(
+                &valid_rules,
+                cwe,
+                language,
+                self.config.output_dir.to_string_lossy().as_ref(),
+            )?;
         }
 
         Ok(valid_rules)
     }
+}
 
-    /// Parse YAML rules from LLM response
-    fn parse_yaml_rules(
-        &self,
-        yaml_content: &str,
-        _language: &str,
-    ) -> Result<Vec<String>, RuleError> {
-        let mut rules = Vec::new();
-        let mut current_rule = String::new();
-        let mut in_rule = false;
-
-        for line in yaml_content.lines() {
-            if line.trim() == "---" {
-                if !current_rule.is_empty() {
-                    rules.push(current_rule.trim().to_string());
-                    current_rule = String::new();
-                }
-                in_rule = true;
-                continue;
+/// Parse YAML rules from LLM response
+pub fn parse_yaml_rules(yaml_content: &str, _language: &str) -> Result<Vec<String>, RuleError> {
+    let mut rules = Vec::new();
+    let mut current_rule = String::new();
+    let mut in_rule = false;
+
+    for line in yaml_content.lines() {
+        if line.trim() == "---" {
+            if !current_rule.is_empty() {
+                rules.push(current_rule.trim().to_string());
+                current_rule = String::new();
             }
+            in_rule = true;
+            continue;
+        }
 
-            if in_rule || line.trim().starts_with("rules:") {
-                let should_add = !current_rule.is_empty() || !line.trim().is_empty();
-                if should_add {
-                    current_rule.push_str(line);
-                    current_rule.push('\n');
-                }
+        if in_rule || line.trim().starts_with("rules:") {
+            let should_add = !current_rule.is_empty() || !line.trim().is_empty();
+            if should_add {
+                current_rule.push_str(line);
+                current_rule.push('\n');
             }
         }
+    }
 
-        // Push last rule
-        if !current_rule.is_empty() {
-            rules.push(current_rule.trim().to_string());
-        }
+    // Push last rule
+    if !current_rule.is_empty() {
+        rules.push(current_rule.trim().to_string());
+    }
 
-        // If no rules found, try to parse as single rule
-        if rules.is_empty() && !yaml_content.trim().is_empty() {
-            rules.push(yaml_content.trim().to_string());
-        }
+    // If no rules found, try to parse as single rule
+    if rules.is_empty() && !yaml_content.trim().is_empty() {
+        rules.push(yaml_content.trim().to_string());
+    }
 
-        Ok(rules)
-    }
-
-    /// Persist valid rules to output directory
-    fn persist_rules(
-        &self,
-        rules: &[SemgrepRule],
-        cwe: &str,
-        language: &str,
-    ) -> Result<(), RuleError> {
-        let output_dir = PathBuf::from(&self.config.output_dir);
-        std::fs::create_dir_all(&output_dir)
-            .map_err(|e| RuleError::IoError(format!("Failed to create output directory: {}", e)))?;
-
-        for (i, rule) in rules.iter().enumerate() {
-            let filename = format!("{}_{}_{}.yml", cwe, language, i);
-            let filepath = output_dir.join(&filename);
-
-            std::fs::write(&filepath, &rule.yaml).map_err(|e| {
-                RuleError::IoError(format!(
-                    "Failed to write rule to {}: {}",
-                    filepath.display(),
-                    e
-                ))
-            })?;
-
-            tracing::info!("Persisted rule: {}", filepath.display());
-        }
+    Ok(rules)
+}
 
-        Ok(())
-    }
+/// Persist valid rules to output directory
+pub fn persist_rules(
+    rules: &[SemgrepRule],
+    cwe: &str,
+    language: &str,
+    output_dir: &str,
+) -> Result<(), RuleError> {
+    let output_dir = PathBuf::from(output_dir);
+    std::fs::create_dir_all(&output_dir)
+        .map_err(|e| RuleError::IoError(format!("Failed to create output directory: {}", e)))?;
+
+    for (i, rule) in rules.iter().enumerate() {
+        let filename = format!("{}_{}_{}.yml", cwe, language, i);
+        let filepath = output_dir.join(&filename);
+
+        std::fs::write(&filepath, &rule.yaml).map_err(|e| {
+            RuleError::IoError(format!(
+                "Failed to write rule to {}: {}",
+                filepath.display(),
+                e
+            ))
+        })?;
+
+        tracing::info!("Persisted rule: {}", filepath.display());
+    }
+
+    Ok(())
 }
 
 /// Extract rule ID from YAML content

src/scanner/mod.rs

@@ -4,7 +4,7 @@ pub mod checkpoint;
 mod core;
 mod env;
 mod orchestrator;
-mod parallel;
+pub(crate) mod parallel;
 #[cfg(test)]
 pub(crate) mod phases;
 #[cfg(not(test))]
@@ -29,6 +29,12 @@ pub use env::{
     get_git_remote_url,
 };
 
+// Re-export parallel module types for testing
+pub use parallel::{
+    combine_parallel_results, has_valid_checkpoint_findings, run_indexing_phase,
+    run_llm_static_phase, run_semgrep_phase, ParallelPhaseConfig, ParallelPhaseResult,
+};
+
 // Use the checkpoint module for save/load
 use crate::checkpoint::ScanPhase;
 use crate::findings::VulnerabilityFinding;

src/tools/diff_analysis.rs

@@ -73,7 +73,7 @@ fn run_diff(
     })
 }
 
-fn parse_diff(diff_output: &str) -> (u32, u32, u32) {
+pub fn parse_diff(diff_output: &str) -> (u32, u32, u32) {
     let lines: Vec<&str> = diff_output.lines().collect();
 
     let mut files_changed = 1u32;

src/variant_search.rs

@@ -163,7 +163,7 @@ impl VariantSearcher {
         Ok(())
     }
 
-    fn should_skip_file(path: &Path) -> bool {
+    pub fn should_skip_file(path: &Path) -> bool {
         let ext = path
             .extension()
             .map(|e| e.to_string_lossy().to_lowercase())
@@ -193,15 +193,22 @@ impl VariantSearcher {
         )
     }
 
-    fn extract_snippet(content: &str, line_num: usize) -> String {
+    pub fn extract_snippet(content: &str, line_num: usize) -> String {
         let lines: Vec<&str> = content.lines().collect();
-        let start = line_num.saturating_sub(1);
+        if lines.is_empty() {
+            return String::new();
+        }
+        let start = line_num
+            .saturating_sub(1)
+            .min(lines.len().saturating_sub(1));
         let end = (line_num + 2).min(lines.len());
-
+        if start >= end {
+            return String::new();
+        }
         lines[start..end].join("\n")
     }
 
-    fn calculate_similarity(&self, line: &str, pattern: &SearchPattern) -> f32 {
+    pub fn calculate_similarity(&self, line: &str, pattern: &SearchPattern) -> f32 {
         let mut score: f32 = 0.0;
 
         if line.contains(&pattern.vulnerability_type) {