cha-cli 1.10.0

Cha — pluggable code smell detection CLI (察)
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

use super::*;
use cha_core::SourceModel;

fn func(name: &str, calls: Vec<&str>) -> FunctionInfo {
    FunctionInfo {
        name: name.into(),
        start_line: 1,
        end_line: 1,
        called_functions: calls.into_iter().map(String::from).collect(),
        ..Default::default()
    }
}

fn model_with(functions: Vec<FunctionInfo>) -> SourceModel {
    SourceModel {
        language: "rust".into(),
        total_lines: 10,
        functions,
        classes: vec![],
        imports: vec![],
        comments: vec![],
        type_aliases: vec![],
    }
}

#[test]
fn flags_function_that_calls_external_module_heavily() {
    let orchestrator = model_with(vec![func("run", vec!["tick", "render", "commit"])]);
    // These three live in another file.
    let view = model_with(vec![
        func("tick", vec![]),
        func("render", vec![]),
        func("commit", vec![]),
    ]);
    let models = vec![
        (PathBuf::from("src/controller.rs"), orchestrator),
        (PathBuf::from("src/view.rs"), view),
    ];
    let findings = detect(&ProjectIndex::from_models(models));
    assert_eq!(findings.len(), 1);
    assert_eq!(findings[0].smell_name, "module_envy");
    assert!(findings[0].message.contains("run"));
    assert!(findings[0].message.contains("view.rs"));
}

#[test]
fn ignores_when_calls_are_balanced() {
    // run calls 3 into view.rs but also 3 into its own file — balanced
    // coordinator, not envious.
    let controller = model_with(vec![
        func(
            "run",
            vec!["tick", "render", "commit", "validate", "authorise", "log"],
        ),
        func("validate", vec![]),
        func("authorise", vec![]),
        func("log", vec![]),
    ]);
    let view = model_with(vec![
        func("tick", vec![]),
        func("render", vec![]),
        func("commit", vec![]),
    ]);
    let models = vec![
        (PathBuf::from("src/controller.rs"), controller),
        (PathBuf::from("src/view.rs"), view),
    ];
    let findings = detect(&ProjectIndex::from_models(models));
    assert!(findings.is_empty());
}

#[test]
fn ignores_below_threshold() {
    // Only 2 external calls — below MIN_EXTERNAL_CALLS.
    let orchestrator = model_with(vec![func("run", vec!["tick", "render"])]);
    let view = model_with(vec![func("tick", vec![]), func("render", vec![])]);
    let models = vec![
        (PathBuf::from("src/controller.rs"), orchestrator),
        (PathBuf::from("src/view.rs"), view),
    ];
    let findings = detect(&ProjectIndex::from_models(models));
    assert!(findings.is_empty());
}

#[test]
fn unresolvable_callees_are_ignored() {
    // Calls to functions that aren't in any project file (stdlib, third
    // party) don't count toward envy.
    let f = model_with(vec![func(
        "run",
        vec!["println", "format", "clone", "to_string"],
    )]);
    let models = vec![(PathBuf::from("src/main.rs"), f)];
    let findings = detect(&ProjectIndex::from_models(models));
    assert!(findings.is_empty());
}

#[test]
fn ignores_known_helper_patterns() {
    // Two well-known false-positive shapes are suppressed:
    //   1. test file → common.rs (same tests directory)
    //   2. any file   → utils.rs (by convention, a shared helper)
    let cases: [(&str, &str); 2] = [
        ("tests/test_scenario.rs", "tests/common.rs"),
        ("src/service.rs", "src/utils.rs"),
    ];
    for (caller, callee_file) in cases {
        let caller_model = model_with(vec![func("op", vec!["helper_a", "helper_b", "helper_c"])]);
        let callee_model = model_with(vec![
            func("helper_a", vec![]),
            func("helper_b", vec![]),
            func("helper_c", vec![]),
        ]);
        let models = vec![
            (PathBuf::from(caller), caller_model),
            (PathBuf::from(callee_file), callee_model),
        ];
        let findings = detect(&ProjectIndex::from_models(models));
        assert!(
            findings.is_empty(),
            "case `{caller}` → `{callee_file}` should be suppressed"
        );
    }
}

#[test]
fn flags_the_most_envied_module_when_multiple() {
    let orchestrator = model_with(vec![func(
        "run",
        vec!["tick", "render", "commit", "fetch", "parse"],
    )]);
    let view = model_with(vec![
        func("tick", vec![]),
        func("render", vec![]),
        func("commit", vec![]),
    ]);
    let io = model_with(vec![func("fetch", vec![]), func("parse", vec![])]);
    let models = vec![
        (PathBuf::from("src/controller.rs"), orchestrator),
        (PathBuf::from("src/view.rs"), view),
        (PathBuf::from("src/io.rs"), io),
    ];
    let findings = detect(&ProjectIndex::from_models(models));
    assert_eq!(findings.len(), 1);
    // view.rs has 3 calls, io.rs has 2 — view wins.
    assert!(findings[0].message.contains("view.rs"));
}