WIP: tests for analyzer annotations

Author: ekump

.github/actions/clippy-annotation-reporter/Cargo.toml

@@ -16,12 +16,12 @@ log = "0.4"
 env_logger = "0.10"
 # Octocrab has a defined MSRV < 1.78 and depends on url 2.5.4 which also has a defined MSRV < 1.78 but url has a  dependency on `idna` has a MSRV of 1.81. Not sure what is going on here.
 url = "=2.5.2"
-tempfile = "3.20.0"
 toml = "0.8.22"
 
 [dev-dependencies]
 httpmock = "0.6"
 http = "1.1.0"
+tempfile = "3.20.0"
 
 # TODO: Remove this when move to separate repo
 [workspace]

.github/actions/clippy-annotation-reporter/src/analyzer/annotation.rs

@@ -19,12 +19,12 @@ pub(super) fn find_annotations(
     rule_cache: &mut HashMap<String, Rc<String>>,
 ) {
     // Use Rc for file path
-    let file_rc = Rc::new(file.to_string());
+    let file_rc = Rc::new(file.to_owned());
 
     for line in content.lines() {
         if let Some(captures) = regex.captures(line) {
             if let Some(rule_match) = captures.get(1) {
-                let rule_str = rule_match.as_str().to_string();
+                let rule_str = rule_match.as_str().to_owned();
 
                 // Get or create Rc for this rule
                 let rule_rc = match rule_cache.get(&rule_str) {
@@ -73,7 +73,7 @@ pub(super) fn count_annotations_by_crate(
             Some(name) => name.clone(),
             None => {
                 let name = Rc::new(get_crate_for_file(file_path).to_owned());
-                crate_cache.insert(file_path.to_string(), Rc::clone(&name));
+                crate_cache.insert(file_path.to_owned(), Rc::clone(&name));
 
                 name
             }
@@ -87,6 +87,10 @@ pub(super) fn count_annotations_by_crate(
 
 /// Create a regex for matching clippy allow annotations
 pub(super) fn create_annotation_regex(rules: &[String]) -> Result<Regex> {
+    if rules.is_empty() {
+        return Err(anyhow::anyhow!("Cannot create regex with empty rules list"));
+    }
+
     let rule_pattern = rules.join("|");
     let regex = Regex::new(&format!(
         r"#\s*\[\s*allow\s*\(\s*clippy\s*::\s*({})\s*\)\s*\]",
@@ -96,3 +100,227 @@ pub(super) fn create_annotation_regex(rules: &[String]) -> Result<Regex> {
 
     Ok(regex)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::rc::Rc;
+
+    #[test]
+    fn test_count_annotations_by_rule() {
+        // Create test annotations
+        let rule1 = Rc::new("clippy::unwrap_used".to_owned());
+        let rule2 = Rc::new("clippy::match_bool".to_owned());
+        let file = Rc::new("src/main.rs".to_owned());
+
+        let annotations = vec![
+            ClippyAnnotation {
+                file: file.clone(),
+                rule: rule1.clone(),
+            },
+            ClippyAnnotation {
+                file: file.clone(),
+                rule: rule1.clone(),
+            },
+            ClippyAnnotation {
+                file: file.clone(),
+                rule: rule2.clone(),
+            },
+            ClippyAnnotation {
+                file: file.clone(),
+                rule: rule1.clone(),
+            },
+        ];
+
+        let counts = count_annotations_by_rule(&annotations);
+
+        assert_eq!(counts.len(), 2, "Should have counts for 2 rules");
+        assert_eq!(counts[&rule1], 3, "Rule1 should have 3 annotations");
+        assert_eq!(counts[&rule2], 1, "Rule2 should have 1 annotation");
+    }
+
+    #[test]
+    fn test_count_annotations_by_rule_empty() {
+        // Test with empty annotations
+        let annotations: Vec<ClippyAnnotation> = vec![];
+        let counts = count_annotations_by_rule(&annotations);
+
+        assert_eq!(
+            counts.len(),
+            0,
+            "Empty annotations should produce empty counts"
+        );
+    }
+
+    #[test]
+    fn test_count_annotations_by_crate() {
+        use std::fs::{self, File};
+        use std::io::Write;
+        use tempfile::TempDir;
+
+        // Create a temporary directory structure for testing
+        let temp_dir = TempDir::new().expect("Failed to create temp directory");
+        let temp_path = temp_dir.path();
+
+        // Create a directory structure with two different crates
+        // crate1
+        // ├── Cargo.toml (package.name = "crate1")
+        // └── src
+        //     ├── lib.rs
+        //     └── module.rs
+        // crate2
+        // ├── Cargo.toml (package.name = "crate2")
+        // └── src
+        //     └── main.rs
+
+        // Create directories
+        let crate1_dir = temp_path.join("crate1");
+        let crate1_src_dir = crate1_dir.join("src");
+        let crate2_dir = temp_path.join("crate2");
+        let crate2_src_dir = crate2_dir.join("src");
+
+        fs::create_dir_all(&crate1_src_dir).expect("Failed to create crate1/src directory");
+        fs::create_dir_all(&crate2_src_dir).expect("Failed to create crate2/src directory");
+
+        // Create Cargo.toml files with specific package names
+        let crate1_cargo = crate1_dir.join("Cargo.toml");
+        let mut cargo1_file =
+            File::create(&crate1_cargo).expect("Failed to create crate1 Cargo.toml");
+        writeln!(
+            cargo1_file,
+            r#"[package]
+name = "crate1"
+version = "0.1.0"
+edition = "2021"
+"#
+        )
+        .expect("Failed to write to crate1 Cargo.toml");
+
+        let crate2_cargo = crate2_dir.join("Cargo.toml");
+        let mut cargo2_file =
+            File::create(&crate2_cargo).expect("Failed to create crate2 Cargo.toml");
+        writeln!(
+            cargo2_file,
+            r#"[package]
+name = "crate2"
+version = "0.1.0"
+edition = "2021"
+"#
+        )
+        .expect("Failed to write to crate2 Cargo.toml");
+
+        // Create source files
+        let crate1_lib = crate1_src_dir.join("lib.rs");
+        let mut lib_file = File::create(&crate1_lib).expect("Failed to create lib.rs");
+        writeln!(lib_file, "// Empty lib file").expect("Failed to write to lib.rs");
+
+        let crate1_module = crate1_src_dir.join("module.rs");
+        let mut module_file = File::create(&crate1_module).expect("Failed to create module.rs");
+        writeln!(module_file, "// Empty module file").expect("Failed to write to module.rs");
+
+        let crate2_main = crate2_src_dir.join("main.rs");
+        let mut main_file = File::create(&crate2_main).expect("Failed to create main.rs");
+        writeln!(main_file, "// Empty main file").expect("Failed to write to main.rs");
+
+        // Create test annotations with the real file paths
+        let rule = Rc::new("clippy::unwrap_used".to_owned());
+
+        let crate1_lib_path = Rc::new(crate1_lib.to_string_lossy().to_string());
+        let crate1_module_path = Rc::new(crate1_module.to_string_lossy().to_string());
+        let crate2_main_path = Rc::new(crate2_main.to_string_lossy().to_string());
+
+        let annotations = vec![
+            ClippyAnnotation {
+                file: crate1_lib_path.clone(),
+                rule: rule.clone(),
+            },
+            ClippyAnnotation {
+                file: crate1_module_path.clone(),
+                rule: rule.clone(),
+            },
+            ClippyAnnotation {
+                file: crate1_module_path.clone(), // Another annotation in the same file
+                rule: rule.clone(),
+            },
+            ClippyAnnotation {
+                file: crate2_main_path.clone(),
+                rule: rule.clone(),
+            },
+        ];
+
+        let counts = count_annotations_by_crate(&annotations);
+
+        assert_eq!(counts.len(), 2, "Should have counts for 2 crates");
+
+        let crate1_count = counts
+            .iter()
+            .find(|(k, _)| k.contains("crate1"))
+            .map(|(_, v)| *v)
+            .unwrap_or(0);
+
+        let crate2_count = counts
+            .iter()
+            .find(|(k, _)| k.contains("crate2"))
+            .map(|(_, v)| *v)
+            .unwrap_or(0);
+
+        assert_eq!(crate1_count, 3, "crate1 should have 3 annotations");
+        assert_eq!(crate2_count, 1, "crate2 should have 1 annotation");
+    }
+
+    #[test]
+    fn test_count_annotations_by_crate_empty() {
+        // Test with empty annotations
+        let annotations: Vec<ClippyAnnotation> = vec![];
+        let counts = count_annotations_by_crate(&annotations);
+
+        assert_eq!(
+            counts.len(),
+            0,
+            "Empty annotations should produce empty counts"
+        );
+    }
+
+    #[test]
+    fn test_create_annotation_regex_single_rule() {
+        let rules = vec!["unwrap_used".to_owned()]; // Rule without clippy:: prefix
+        let regex = create_annotation_regex(&rules).expect("Failed to create regex");
+
+        // Test matching
+        assert!(regex.is_match("#[allow(clippy::unwrap_used)]"));
+        assert!(regex.is_match("#[allow(clippy:: unwrap_used )]")); // With spaces
+        assert!(regex.is_match("#  [ allow ( clippy :: unwrap_used ) ]")); // With more spaces
+
+        // Test non-matching
+        assert!(!regex.is_match("#[allow(clippy::unused_imports)]"));
+        assert!(!regex.is_match("#[allow(unwrap_used)]")); // Missing clippy::
+        assert!(!regex.is_match("clippy::unwrap_used")); // Missing #[allow()]
+    }
+    #[test]
+    fn test_create_annotation_regex_multiple_rules() {
+        let rules = vec!["unwrap_used".to_owned(), "match_bool".to_owned()];
+        let regex = create_annotation_regex(&rules).expect("Failed to create regex");
+
+        assert!(regex.is_match("#[allow(clippy::unwrap_used)]"));
+        assert!(regex.is_match("#[allow(clippy::match_bool)]"));
+
+        // Test mixed spacing and formatting
+        assert!(regex.is_match("#[allow(clippy:: unwrap_used )]")); // With spaces
+        assert!(regex.is_match("#  [ allow ( clippy :: match_bool ) ]")); // With more spaces
+
+        // Test non-matching
+        assert!(!regex.is_match("#[allow(clippy::unused_imports)]"));
+        assert!(!regex.is_match("#[allow(unwrap_used)]")); // Missing clippy::
+    }
+
+    #[test]
+    fn test_create_annotation_regex_empty_rules() {
+        let rules: Vec<String> = vec![];
+        let result = create_annotation_regex(&rules);
+
+        assert!(
+            result.is_err(),
+            "Creating regex with empty rules should fail"
+        );
+    }
+}