sprawl-guard 0.1.0

Repository sprawl checker 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

use assert_fs::TempDir;
use indoc::indoc;
use serde_json::json;

use super::common::*;

fn write_rust_and_typescript_sources(root: &TempDir) {
    write_file(root, "src/lib.rs", "fn main() {}\n");
    write_file(root, "src/app.ts", "export const value = 1;\n");
}

fn detected_languages_json(root: &TempDir) -> (std::process::Output, serde_json::Value) {
    run_json(root, &["languages", "--detected", "--format", "json"])
}

mod when_supported_languages_are_listed {
    use super::*;

    #[test]
    fn it_prints_supported_language_metadata_as_json() {
        let root = TempDir::new().unwrap();

        let (output, json) = run_json(&root, &["languages", "--format", "json"]);
        let rust = json_language(&json, "Rust");

        assert_exit_code(&output, exit_codes::SUCCESS);
        assert_eq!(
            json!({
                "mode": json["mode"],
                "rust": {
                    "config_key": rust["config_key"],
                    "include": rust["include"],
                    "test_globs": rust["test_globs"],
                    "rust": rust["rust"],
                },
            }),
            json!({
                "mode": "supported",
                "rust": {
                    "config_key": "rust",
                    "include": ["**/*.rs"],
                    "test_globs": ["benches/**"],
                    "rust": {"exclude_cfg_test": true},
                },
            })
        );
        assert_eq!(stderr(&output), "");
    }

    #[test]
    fn it_ignores_resolved_repo_language_overrides() {
        let root = TempDir::new().unwrap();
        write_config(
            &root,
            indoc! {r#"
                [languages.rust]
                enabled = true
                include = ["custom/**/*.rs"]
            "#},
        );

        let (output, json) = run_json(&root, &["languages", "--format", "json"]);
        let rust = json_language(&json, "Rust");

        assert_exit_code(&output, exit_codes::SUCCESS);
        assert_eq!(
            json!({
                "enabled": rust["enabled"],
                "include": rust["include"],
            }),
            json!({
                "enabled": false,
                "include": ["**/*.rs"],
            })
        );
        assert_eq!(stderr(&output), "");
    }
}

mod when_languages_are_detected_before_config_exists {
    use super::*;

    #[test]
    fn it_lists_only_languages_with_included_source_files() {
        let root = TempDir::new().unwrap();
        write_rust_and_typescript_sources(&root);

        let (output, json) = detected_languages_json(&root);

        assert_exit_code(&output, exit_codes::SUCCESS);
        assert_eq!(
            json!({
                "mode": json["mode"],
            }),
            json!({
                "mode": "detected",
            })
        );
        assert_detected_source_count(&json, "Rust", 1);
        assert_detected_source_count(&json, "TypeScript", 1);
        assert!(
            !json["languages"]
                .as_array()
                .unwrap()
                .iter()
                .any(|language| language["id"] == "JavaScript")
        );
        assert_eq!(stderr(&output), "");
    }
}

mod when_detecting_after_config_exists {
    use super::*;

    #[test]
    fn it_matches_init_style_detection_instead_of_resolved_policy() {
        let root = TempDir::new().unwrap();
        write_config(
            &root,
            indoc! {r#"
                [languages.rust]
                enabled = true
            "#},
        );
        write_rust_and_typescript_sources(&root);

        let (output, json) = detected_languages_json(&root);

        assert_exit_code(&output, exit_codes::SUCCESS);
        assert_detected_source_count(&json, "Rust", 1);
        assert_detected_source_count(&json, "TypeScript", 1);
        assert_eq!(stderr(&output), "");
    }
}