deslop 0.2.0

A static analyzer that spots low-context and AI-assisted code patterns across naming, concurrency, security, performance, and test quality.
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

#[path = "support/mod.rs"]
mod support;

#[path = "cli_support/mod.rs"]
mod cli_support;

use cli_support::{assert_json_fields, parse_json_output, run_cli};
use support::FixtureWorkspace;

// ── Scan subcommand tests ──

#[test]
fn cli_scan_exits_zero_for_clean_code() {
    let workspace = FixtureWorkspace::new();
    workspace.write_file("main.go", &support::load_fixture("go/cli/clean_main.txt"));

    let output = run_cli(&["scan", workspace.root().to_str().unwrap()]);

    assert!(
        output.status.success(),
        "clean scan should exit 0: {}",
        String::from_utf8_lossy(&output.stderr)
    );
}

#[test]
fn cli_scan_exits_nonzero_for_findings() {
    let workspace = FixtureWorkspace::new();
    workspace.write_file("bad.go", &support::load_fixture("go/cli/findings_main.txt"));

    let output = run_cli(&["scan", workspace.root().to_str().unwrap()]);

    assert!(
        !output.status.success(),
        "findings scan should exit non-zero"
    );
}

#[test]
fn cli_scan_no_fail_exits_zero_even_with_findings() {
    let workspace = FixtureWorkspace::new();
    workspace.write_file("bad.go", &support::load_fixture("go/cli/findings_main.txt"));

    let output = run_cli(&["scan", workspace.root().to_str().unwrap(), "--no-fail"]);

    assert!(
        output.status.success(),
        "--no-fail should exit 0 even with findings: {}",
        String::from_utf8_lossy(&output.stderr)
    );
}

#[test]
fn cli_scan_json_produces_valid_json() {
    let workspace = FixtureWorkspace::new();
    workspace.write_file("main.go", &support::load_fixture("go/cli/clean_main.txt"));

    let output = run_cli(&[
        "scan",
        workspace.root().to_str().unwrap(),
        "--json",
        "--no-fail",
    ]);

    let parsed = parse_json_output(&output);
    assert_json_fields(&parsed, &["root", "findings", "timings"]);
}

#[test]
fn cli_scan_ignore_flag_suppresses_specific_rules() {
    let workspace = FixtureWorkspace::new();
    workspace.write_file("bad.go", &support::load_fixture("go/cli/findings_main.txt"));

    let output = run_cli(&[
        "scan",
        workspace.root().to_str().unwrap(),
        "--json",
        "--no-fail",
        "--ignore",
        "overlong_name",
    ]);

    let parsed = parse_json_output(&output);
    let findings = parsed["findings"].as_array().unwrap();
    assert!(
        !findings.iter().any(|f| f["rule_id"] == "overlong_name"),
        "--ignore should suppress the specified rule"
    );
}

// ── Rules subcommand tests ──

#[test]
fn cli_rules_lists_rules() {
    let output = run_cli(&["rules"]);

    assert!(output.status.success(), "rules should exit 0");
    let stdout = String::from_utf8_lossy(&output.stdout);
    assert!(stdout.contains("dropped_error"), "should list known rules");
}

#[test]
fn cli_rules_json_produces_valid_json() {
    let output = run_cli(&["rules", "--json"]);

    assert!(output.status.success(), "rules --json should exit 0");
    let parsed = parse_json_output(&output);
    assert!(parsed.is_array(), "JSON rules output should be an array");
}

#[test]
fn cli_rules_language_filter() {
    let output = run_cli(&["rules", "--json", "--language", "rust"]);

    assert!(output.status.success());
    let parsed = parse_json_output(&output);
    let rules = parsed.as_array().unwrap();
    assert!(
        rules
            .iter()
            .all(|r| r["language"] == "rust" || r["language"] == "common"),
        "language filter should only return rust and common rules"
    );
}