main-spex 0.21.0

AI-first development framework that turns specifications into deterministic, verifiable code
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

#[cfg(test)]
mod tests {
    use super::super::*;
    use crate::config::PreexistingError;
    use indoc::indoc;
    use std::collections::HashMap;

    #[test]
    fn set_cli_version_replaces_existing_line() {
        let raw = indoc! {"
            project_name: demo
            cli_version: 0.0.1
            packages: []
        "};
        assert_eq!(
            set_cli_version(raw, "0.2.0"),
            indoc! {"
                project_name: demo
                cli_version: 0.2.0
                packages: []
            "}
        );
    }

    #[test]
    fn set_cli_version_inserts_after_project_name() {
        let raw = indoc! {"
            project_name: demo
            packages: []
        "};
        assert_eq!(
            set_cli_version(raw, "0.2.0"),
            indoc! {"
                project_name: demo
                cli_version: 0.2.0
                packages: []
            "}
        );
    }

    #[test]
    fn set_cli_version_preserves_comments() {
        let raw = indoc! {"
            project_name: demo
            cli_version: 0.0.1
            # keep me
            packages: []
        "};
        assert_eq!(
            set_cli_version(raw, "0.2.0"),
            indoc! {"
                project_name: demo
                cli_version: 0.2.0
                # keep me
                packages: []
            "}
        );
    }

    fn entry(rule_id: &str, check: &str, files: &[&str]) -> PreexistingError {
        PreexistingError {
            rule_id: rule_id.to_string(),
            check: check.to_string(),
            files: files.iter().map(|file| file.to_string()).collect(),
        }
    }

    const TWO_REPOS: &str = indoc! {"
        project_name: demo
        packages:
          - package_name: api
            path: ../api
            rules:
              - X
          - package_name: web
            path: ../web
            rules:
              - X
    "};

    #[test]
    fn set_preexisting_errors_appends_block_with_files() {
        let by_package = HashMap::from([(
            "api".to_string(),
            vec![entry("X", "no-cyrillic", &["README.md", "docs/intro.md"])],
        )]);
        let out = set_preexisting_errors(TWO_REPOS, &by_package);
        assert_eq!(
            out,
            indoc! {"
                project_name: demo
                packages:
                  - package_name: api
                    path: ../api
                    rules:
                      - X
                    ignored_errors:
                      - rule_id: X
                        check: no-cyrillic
                        files:
                          - README.md
                          - docs/intro.md
                  - package_name: web
                    path: ../web
                    rules:
                      - X
            "}
        );
    }

    #[test]
    fn set_preexisting_errors_renders_whole_check_without_files() {
        let by_package =
            HashMap::from([("web".to_string(), vec![entry("Y", "commit-format", &[])])]);
        let out = set_preexisting_errors(TWO_REPOS, &by_package);
        assert!(out.ends_with(
            "  - package_name: web
    path: ../web
    rules:
      - X
    ignored_errors:
      - rule_id: Y
        check: commit-format
"
        ));
        assert!(!out.contains("check: commit-format\n  - package_name: web"));
        assert_eq!(out.matches("ignored_errors:").count(), 1);
    }

    #[test]
    fn set_preexisting_errors_replaces_existing_block() {
        let raw = indoc! {"
            project_name: demo
            packages:
              - package_name: api
                path: ../api
                ignored_errors:
                  - rule_id: X
                    check: stale
                    files:
                      - old.md
                rules:
                  - X
        "};
        let by_package = HashMap::from([(
            "api".to_string(),
            vec![entry("X", "no-cyrillic", &["README.md"])],
        )]);
        let out = set_preexisting_errors(raw, &by_package);
        assert!(!out.contains("stale"), "old block survived:\n{out}");
        assert!(
            out.contains("check: no-cyrillic"),
            "new block missing:\n{out}"
        );
        assert_eq!(out.matches("ignored_errors:").count(), 1);
    }

    #[test]
    fn set_preexisting_errors_removes_stale_block_when_empty() {
        let raw = indoc! {"
            project_name: demo
            packages:
              - package_name: api
                path: ../api
                ignored_errors:
                  - rule_id: X
                    check: gone
        "};
        let by_package = HashMap::from([("api".to_string(), Vec::new())]);
        let out = set_preexisting_errors(raw, &by_package);
        assert_eq!(
            out,
            indoc! {"
                project_name: demo
                packages:
                  - package_name: api
                    path: ../api
            "}
        );
    }
}