WIP add tests to report generator

Author: ekump

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

@@ -234,3 +234,360 @@ fn get_all_keys<K: Clone + Ord + std::hash::Hash, V>(
 
     keys_vec
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::analyzer::ClippyAnnotation;
+    use std::collections::{HashMap, HashSet};
+    use std::rc::Rc;
+
+    // Helper function to create a test AnalysisResult
+    fn create_analysis_result() -> crate::analyzer::AnalysisResult {
+        let mut base_counts = HashMap::new();
+        let rule1 = Rc::new("clippy::unwrap_used".to_owned());
+        let rule2 = Rc::new("clippy::match_bool".to_owned());
+        let rule3 = Rc::new("clippy::unused_imports".to_owned());
+
+        base_counts.insert(rule1.clone(), 5);
+        base_counts.insert(rule2.clone(), 3);
+        base_counts.insert(rule3.clone(), 10);
+
+        let mut head_counts = HashMap::new();
+        head_counts.insert(rule1.clone(), 3);
+        head_counts.insert(rule2.clone(), 4);
+        head_counts.insert(rule3.clone(), 5);
+
+        let mut base_crate_counts = HashMap::new();
+        let crate1 = Rc::new("crate1".to_owned());
+        let crate2 = Rc::new("crate2".to_owned());
+
+        base_crate_counts.insert(crate1.clone(), 8);
+        base_crate_counts.insert(crate2.clone(), 10);
+
+        let mut head_crate_counts = HashMap::new();
+        head_crate_counts.insert(crate1.clone(), 5);
+        head_crate_counts.insert(crate2.clone(), 12);
+
+        let mut changed_files = HashSet::new();
+        changed_files.insert("src/file1.rs".to_owned());
+        changed_files.insert("src/file2.rs".to_owned());
+
+        let file1 = Rc::new("src/file1.rs".to_owned());
+        let file2 = Rc::new("src/file2.rs".to_owned());
+
+        let base_annotations = vec![
+            ClippyAnnotation {
+                file: file1.clone(),
+                rule: rule1.clone(),
+            },
+            ClippyAnnotation {
+                file: file1.clone(),
+                rule: rule1.clone(),
+            },
+            ClippyAnnotation {
+                file: file1.clone(),
+                rule: rule2.clone(),
+            },
+            ClippyAnnotation {
+                file: file2.clone(),
+                rule: rule1.clone(),
+            },
+            ClippyAnnotation {
+                file: file2.clone(),
+                rule: rule3.clone(),
+            },
+        ];
+
+        let head_annotations = vec![
+            ClippyAnnotation {
+                file: file1.clone(),
+                rule: rule1.clone(),
+            },
+            ClippyAnnotation {
+                file: file1.clone(),
+                rule: rule2.clone(),
+            },
+            ClippyAnnotation {
+                file: file1.clone(),
+                rule: rule2.clone(),
+            },
+            ClippyAnnotation {
+                file: file2.clone(),
+                rule: rule3.clone(),
+            },
+        ];
+
+        crate::analyzer::AnalysisResult {
+            base_annotations,
+            head_annotations,
+            base_counts,
+            head_counts,
+            changed_files,
+            base_crate_counts,
+            head_crate_counts,
+        }
+    }
+
+    #[test]
+    fn test_generate_report_basic() {
+        let analysis = create_analysis_result();
+        let rules = vec![
+            "clippy::unwrap_used".to_owned(),
+            "clippy::match_bool".to_owned(),
+            "clippy::unused_imports".to_owned(),
+        ];
+
+        let report = generate_report(
+            &analysis,
+            &rules,
+            "test-owner/test-repo",
+            "main",
+            "feature-branch",
+        );
+
+        // Verify the report contains expected sections
+        assert!(report.contains("## Clippy Allow Annotation Report"));
+        assert!(report.contains("### Summary by Rule"));
+        assert!(report.contains("### Annotation Counts by File"));
+        assert!(report.contains("### Annotation Stats by Crate"));
+        assert!(report.contains("### About This Report"));
+
+        // Verify the report contains repository and branch information
+        assert!(report.contains("test-owner/test-repo"));
+        assert!(report.contains("main"));
+        assert!(report.contains("feature-branch"));
+    }
+
+    #[test]
+    fn test_generate_report_rule_summary() {
+        let analysis = create_analysis_result();
+        let rules = vec![
+            "clippy::unwrap_used".to_owned(),
+            "clippy::match_bool".to_owned(),
+            "clippy::unused_imports".to_owned(),
+        ];
+
+        let report = generate_report(
+            &analysis,
+            &rules,
+            "test-owner/test-repo",
+            "main",
+            "feature-branch",
+        );
+
+        // Verify rule summary contains all rules
+        assert!(report.contains("clippy::unwrap_used"));
+        assert!(report.contains("clippy::match_bool"));
+        assert!(report.contains("clippy::unused_imports"));
+
+        // Verify counts and changes
+        assert!(report.contains("5")); // Base count for unwrap_used
+        assert!(report.contains("3")); // Head count for unwrap_used
+        assert!(report.contains("-2")); // Change for unwrap_used
+
+        assert!(report.contains("3")); // Base count for match_bool
+        assert!(report.contains("4")); // Head count for match_bool
+        assert!(report.contains("+1")); // Change for match_bool
+
+        assert!(report.contains("10")); // Base count for unused_imports
+        assert!(report.contains("5")); // Head count for unused_imports
+        assert!(report.contains("-5")); // Change for unused_imports
+    }
+
+    #[test]
+    fn test_generate_report_file_section() {
+        let analysis = create_analysis_result();
+        let rules = vec![
+            "clippy::unwrap_used".to_owned(),
+            "clippy::match_bool".to_owned(),
+            "clippy::unused_imports".to_owned(),
+        ];
+
+        let report = generate_report(
+            &analysis,
+            &rules,
+            "test-owner/test-repo",
+            "main",
+            "feature-branch",
+        );
+
+        // Verify file section contains the changed files
+        assert!(report.contains("src/file1.rs"));
+        assert!(report.contains("src/file2.rs"));
+
+        // Verify file counts for file1.rs
+        // In the base branch, file1.rs has 3 annotations (2 unwrap_used, 1 match_bool)
+        // In the head branch, file1.rs has 3 annotations (1 unwrap_used, 2 match_bool)
+        let file1_pattern = r"`src/file1\.rs`\s*\|\s*3\s*\|\s*3\s*\|\s*No change";
+        assert!(
+            report.contains("| `src/file1.rs` | 3 | 3 |")
+                || regex::Regex::new(file1_pattern).unwrap().is_match(&report),
+            "File1 count information not found in report"
+        );
+
+        // Verify file counts for file2.rs
+        // In the base branch, file2.rs has 2 annotations (1 unwrap_used, 1 unused_imports)
+        // In the head branch, file2.rs has 1 annotation (1 unused_imports)
+        let file2_pattern = r"`src/file2\.rs`\s*\|\s*2\s*\|\s*1\s*\|\s*.*-1";
+        assert!(
+            report.contains("| `src/file2.rs` | 2 | 1 |")
+                || regex::Regex::new(file2_pattern).unwrap().is_match(&report),
+            "File2 count information not found in report"
+        );
+
+        // Make sure the change column has the correct indicators
+        assert!(
+            report.contains("No change") || report.contains("(0%)"),
+            "No change indicator missing for file1"
+        );
+        assert!(
+            report.contains("✅ -1"),
+            "Decrease indicator missing for file2"
+        );
+    }
+
+    #[test]
+    fn test_generate_report_crate_section() {
+        let analysis = create_analysis_result();
+        let rules = vec![
+            "clippy::unwrap_used".to_owned(),
+            "clippy::match_bool".to_owned(),
+            "clippy::unused_imports".to_owned(),
+        ];
+
+        let report = generate_report(
+            &analysis,
+            &rules,
+            "test-owner/test-repo",
+            "main",
+            "feature-branch",
+        );
+
+        // Verify crate section contains the crates
+        assert!(report.contains("`crate1`"));
+        assert!(report.contains("`crate2`"));
+
+        // Verify crate counts
+        // Base count for crate1: 8, Head count: 5
+        assert!(report.contains("8"));
+        assert!(report.contains("5"));
+        assert!(report.contains("-3")); // Change
+
+        // Base count for crate2: 10, Head count: 12
+        assert!(report.contains("10"));
+        assert!(report.contains("12"));
+        assert!(report.contains("+2")); // Change
+    }
+
+    #[test]
+    fn test_generate_report_empty_changed_files() {
+        let mut analysis = create_analysis_result();
+        analysis.changed_files.clear();
+
+        let rules = vec![
+            "clippy::unwrap_used".to_owned(),
+            "clippy::match_bool".to_owned(),
+            "clippy::unused_imports".to_owned(),
+        ];
+
+        let report = generate_report(
+            &analysis,
+            &rules,
+            "test-owner/test-repo",
+            "main",
+            "feature-branch",
+        );
+
+        // Verify that the file-level section is not included when there are no changed files
+        assert!(!report.contains("### Annotation Counts by File"));
+
+        // But other sections should still be present
+        assert!(report.contains("### Summary by Rule"));
+        assert!(report.contains("### Annotation Stats by Crate"));
+    }
+
+    #[test]
+    fn test_generate_report_formatting() {
+        let analysis = create_analysis_result();
+        let rules = vec![
+            "clippy::unwrap_used".to_owned(),
+            "clippy::match_bool".to_owned(),
+            "clippy::unused_imports".to_owned(),
+        ];
+
+        let report = generate_report(
+            &analysis,
+            &rules,
+            "test-owner/test-repo",
+            "main",
+            "feature-branch",
+        );
+
+        // Verify positive changes are formatted with ⚠️
+        assert!(report.contains("⚠️ +1"));
+
+        // Verify negative changes are formatted with ✅
+        assert!(report.contains("✅ -2"));
+
+        // Verify total row exists
+        assert!(report.contains("**Total**"));
+    }
+
+    #[test]
+    fn test_generate_report_with_origin_prefix() {
+        let analysis = create_analysis_result();
+        let rules = vec![
+            "clippy::unwrap_used".to_owned(),
+            "clippy::match_bool".to_owned(),
+            "clippy::unused_imports".to_owned(),
+        ];
+
+        // Test with origin/ prefix in base branch
+        let report = generate_report(
+            &analysis,
+            &rules,
+            "test-owner/test-repo",
+            "origin/main",
+            "feature-branch",
+        );
+
+        // Verify the origin/ prefix is removed in the link URL
+        assert!(report.contains("https://github.com/test-owner/test-repo/tree/main"));
+        assert!(report.contains("origin/main"));
+    }
+
+    #[test]
+    fn test_generate_report_new_annotations() {
+        // Create an analysis where annotations are added in the head branch
+        let mut analysis = create_analysis_result();
+
+        // Add a new rule that only appears in the head counts
+        let new_rule = Rc::new("clippy::new_rule".to_owned());
+        analysis.head_counts.insert(new_rule.clone(), 2);
+
+        let rules = vec![
+            "clippy::unwrap_used".to_owned(),
+            "clippy::match_bool".to_owned(),
+            "clippy::unused_imports".to_owned(),
+            "clippy::new_rule".to_owned(),
+        ];
+
+        let report = generate_report(
+            &analysis,
+            &rules,
+            "test-owner/test-repo",
+            "main",
+            "feature-branch",
+        );
+
+        // Verify that new rule appears with appropriate formatting
+        assert!(report.contains("clippy::new_rule"));
+        assert!(report.contains("0")); // Base count should be 0
+        assert!(report.contains("2")); // Head count should be 2
+        assert!(report.contains("⚠️ +2")); // Change should be +2
+
+        // Also verify N/A for the percentage since base count is 0
+        assert!(report.contains("N/A"));
+    }
+}