debtmap 0.16.3

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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228

/// Integration test to prevent coverage indexing performance regressions
///
/// This test validates that file analysis with coverage lookups completes
/// within the acceptable performance threshold of ≤3x baseline overhead.
///
/// Baseline: ~53ms for analysis without coverage
/// Target: ≤160ms for analysis with indexed coverage lookups
use debtmap::risk::lcov::parse_lcov_file;
use std::io::Write;
use std::path::PathBuf;
use std::time::Instant;
use tempfile::NamedTempFile;

/// Create a realistic LCOV file for performance testing
fn create_test_lcov_file(num_files: usize, funcs_per_file: usize) -> NamedTempFile {
    let mut temp_file = NamedTempFile::new().unwrap();

    for file_idx in 0..num_files {
        let file_path = format!("src/module_{}/file_{}.rs", file_idx / 10, file_idx);
        writeln!(temp_file, "TN:").unwrap();
        writeln!(temp_file, "SF:{}", file_path).unwrap();

        for func_idx in 0..funcs_per_file {
            let line_start = func_idx * 15 + 10;
            let func_name = format!("function_{}_{}", file_idx, func_idx);

            writeln!(temp_file, "FN:{},{}", line_start, func_name).unwrap();
            writeln!(temp_file, "FNDA:5,{}", func_name).unwrap();

            // Add line coverage data
            for line_offset in 0..10 {
                let line_num = line_start + line_offset;
                let count = if line_offset < 7 { 5 } else { 0 };
                writeln!(temp_file, "DA:{},{}", line_num, count).unwrap();
            }
        }

        writeln!(temp_file, "LF:{}", funcs_per_file * 10).unwrap();
        writeln!(temp_file, "LH:{}", funcs_per_file * 7).unwrap();
        writeln!(temp_file, "end_of_record").unwrap();
    }

    temp_file
}

#[test]
fn test_coverage_lookup_performance_overhead() {
    const NUM_FILES: usize = 100;
    const FUNCS_PER_FILE: usize = 20;
    const MAX_COVERAGE_TIME_MS: u128 = 200; // Absolute max time for lookups

    // Create and parse coverage data
    let temp_file = create_test_lcov_file(NUM_FILES, FUNCS_PER_FILE);
    let data = parse_lcov_file(temp_file.path()).expect("Failed to parse LCOV file");

    // Measure performance with indexed coverage lookups
    let coverage_start = Instant::now();
    for file_idx in 0..NUM_FILES {
        for func_idx in 0..FUNCS_PER_FILE {
            // Add indexed coverage lookup
            let file = PathBuf::from(format!("src/module_{}/file_{}.rs", file_idx / 10, file_idx));
            let func_name = format!("function_{}_{}", file_idx, func_idx);
            let _coverage = data.get_function_coverage(&file, &func_name);
        }
    }
    let coverage_duration = coverage_start.elapsed();
    let coverage_ms = coverage_duration.as_millis();

    println!(
        "Coverage lookup duration: {:?} for {} lookups",
        coverage_duration,
        NUM_FILES * FUNCS_PER_FILE
    );
    println!(
        "Average per lookup: {:.2}μs",
        coverage_duration.as_micros() as f64 / (NUM_FILES * FUNCS_PER_FILE) as f64
    );

    // Assert absolute performance target: coverage lookups should be fast
    assert!(
        coverage_ms <= MAX_COVERAGE_TIME_MS,
        "Coverage lookup took {}ms for {} lookups, exceeds maximum {}ms",
        coverage_ms,
        NUM_FILES * FUNCS_PER_FILE,
        MAX_COVERAGE_TIME_MS
    );
}

#[test]
fn test_indexed_lookup_is_fast() {
    const NUM_FILES: usize = 100;
    const FUNCS_PER_FILE: usize = 20;
    const MAX_LOOKUP_TIME_MS: u128 = 100; // 100ms for 2000 lookups = 50μs per lookup

    let temp_file = create_test_lcov_file(NUM_FILES, FUNCS_PER_FILE);
    let data = parse_lcov_file(temp_file.path()).expect("Failed to parse LCOV file");

    // Measure time for many indexed lookups
    let start = Instant::now();
    let mut lookup_count = 0;

    for file_idx in 0..NUM_FILES {
        for func_idx in 0..FUNCS_PER_FILE {
            let file = PathBuf::from(format!("src/module_{}/file_{}.rs", file_idx / 10, file_idx));
            let func_name = format!("function_{}_{}", file_idx, func_idx);
            let coverage = data.get_function_coverage(&file, &func_name);
            assert!(
                coverage.is_some(),
                "Coverage should be found for existing function"
            );
            lookup_count += 1;
        }
    }

    let duration = start.elapsed();
    let duration_ms = duration.as_millis();

    println!(
        "Performed {} lookups in {:?} ({:.2}μs per lookup)",
        lookup_count,
        duration,
        duration.as_micros() as f64 / lookup_count as f64
    );

    assert!(
        duration_ms <= MAX_LOOKUP_TIME_MS,
        "Indexed lookup took {}ms for {} lookups, exceeds maximum {}ms",
        duration_ms,
        lookup_count,
        MAX_LOOKUP_TIME_MS
    );
}

#[test]
fn test_line_based_lookup_with_tolerance() {
    const NUM_FILES: usize = 100;
    const FUNCS_PER_FILE: usize = 20;
    const MAX_LOOKUP_TIME_MS: u128 = 3500; // Line-based fallback with BTreeMap range query and tolerance strategies (increased for CI environment variability)

    let temp_file = create_test_lcov_file(NUM_FILES, FUNCS_PER_FILE);
    let data = parse_lcov_file(temp_file.path()).expect("Failed to parse LCOV file");

    let start = Instant::now();
    let mut lookup_count = 0;

    // Test line-based lookup with unknown function names (forces line-based search)
    for file_idx in 0..NUM_FILES {
        for func_idx in 0..FUNCS_PER_FILE {
            let file = PathBuf::from(format!("src/module_{}/file_{}.rs", file_idx / 10, file_idx));
            let line = func_idx * 15 + 10;
            let coverage = data.get_function_coverage_with_line(&file, "unknown_function", line);
            assert!(
                coverage.is_some(),
                "Coverage should be found by line number"
            );
            lookup_count += 1;
        }
    }

    let duration = start.elapsed();
    let duration_ms = duration.as_millis();

    println!(
        "Performed {} line-based lookups in {:?} ({:.2}μs per lookup)",
        lookup_count,
        duration,
        duration.as_micros() as f64 / lookup_count as f64
    );

    assert!(
        duration_ms <= MAX_LOOKUP_TIME_MS,
        "Line-based lookup took {}ms for {} lookups, exceeds maximum {}ms",
        duration_ms,
        lookup_count,
        MAX_LOOKUP_TIME_MS
    );
}

#[test]
fn test_batch_parallel_lookup_performance() {
    const NUM_FILES: usize = 100;
    const FUNCS_PER_FILE: usize = 20;
    const MAX_BATCH_TIME_MS: u128 = 150;

    let temp_file = create_test_lcov_file(NUM_FILES, FUNCS_PER_FILE);
    let data = parse_lcov_file(temp_file.path()).expect("Failed to parse LCOV file");

    // Create batch queries
    let queries: Vec<(PathBuf, String, usize)> = (0..NUM_FILES)
        .flat_map(|file_idx| {
            (0..FUNCS_PER_FILE).map(move |func_idx| {
                (
                    PathBuf::from(format!("src/module_{}/file_{}.rs", file_idx / 10, file_idx)),
                    format!("function_{}_{}", file_idx, func_idx),
                    func_idx * 15 + 10,
                )
            })
        })
        .collect();

    let start = Instant::now();
    let results = data.batch_get_function_coverage(&queries);
    let duration = start.elapsed();
    let duration_ms = duration.as_millis();

    println!(
        "Batch processed {} queries in {:?} ({:.2}μs per lookup)",
        queries.len(),
        duration,
        duration.as_micros() as f64 / queries.len() as f64
    );

    // Verify all queries succeeded
    let successful_lookups = results.iter().filter(|r| r.is_some()).count();
    assert_eq!(
        successful_lookups,
        queries.len(),
        "All batch lookups should succeed"
    );

    assert!(
        duration_ms <= MAX_BATCH_TIME_MS,
        "Batch lookup took {}ms for {} queries, exceeds maximum {}ms",
        duration_ms,
        queries.len(),
        MAX_BATCH_TIME_MS
    );
}