debtmap 0.16.5

Code complexity and technical debt analyzer
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

mod common;

use common::subprocess_converter::analyze_as_text;
use std::fs;
use std::path::Path;

fn create_test_content() -> &'static str {
    r#"
#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_classify_parameter_list_impact_low() {
        // Test low impact for 7 or fewer parameters
        assert_eq!(
            ParameterAnalyzer::classify_parameter_list_impact(0),
            MaintainabilityImpact::Low
        );
        assert_eq!(
            ParameterAnalyzer::classify_parameter_list_impact(5),
            MaintainabilityImpact::Low
        );
    }

    #[test]
    fn test_another() {
        assert_eq!(7, 7);
    }
}

struct ParameterAnalyzer;
enum MaintainabilityImpact { Low }

impl ParameterAnalyzer {
    fn classify_parameter_list_impact(n: usize) -> MaintainabilityImpact {
        MaintainabilityImpact::Low
    }
}
"#
}

fn run_context_aware_analysis(file_path: &Path) -> (String, String) {
    let stdout_without =
        analyze_as_text(file_path, false).expect("Failed to analyze without context-aware");
    let stdout_with =
        analyze_as_text(file_path, true).expect("Failed to analyze with context-aware");
    (stdout_without, stdout_with)
}

fn count_security_issues(output: &str) -> usize {
    output.matches("SECURITY:").count()
}

fn print_debug_output_if_needed(
    stdout_without: &str,
    stdout_with: &str,
    security_count_without: usize,
    security_count_with: usize,
) {
    if security_count_with >= security_count_without && security_count_without > 0 {
        println!("\n=== OUTPUT WITH --NO-CONTEXT-AWARE ===");
        println!("{}", stdout_without);
        println!("\n=== OUTPUT WITH DEFAULT (CONTEXT-AWARE) ===");
        println!("{}", stdout_with);
    }
}

fn assert_context_aware_effectiveness(security_count_without: usize, security_count_with: usize) {
    assert!(
        security_count_with < security_count_without || security_count_without == 0,
        "Context-aware should reduce security issues in test functions: {} -> {}",
        security_count_without,
        security_count_with
    );
}

#[test]
fn test_context_aware_filters_test_functions() {
    let test_content = create_test_content();
    let temp_file = "test_context_aware_temp.rs";

    fs::write(temp_file, test_content).unwrap();

    let (stdout_without, stdout_with) = run_context_aware_analysis(Path::new(temp_file));

    fs::remove_file(temp_file).ok();

    let security_count_without = count_security_issues(&stdout_without);
    let security_count_with = count_security_issues(&stdout_with);

    println!(
        "Security issues with --no-context-aware: {}",
        security_count_without
    );
    println!(
        "Security issues with default (context-aware): {}",
        security_count_with
    );

    print_debug_output_if_needed(
        &stdout_without,
        &stdout_with,
        security_count_without,
        security_count_with,
    );
    assert_context_aware_effectiveness(security_count_without, security_count_with);
}