xchecker 1.2.0

Spec pipeline with receipts and gateable JSON contracts
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

//! Tests for enum introspection with strum `VariantNames`

#[cfg(test)]
mod tests {
    use strum::VariantNames;
    use xchecker::doctor::CheckStatus;
    use xchecker::types::{ConfigSource, ErrorKind};

    #[test]
    fn test_error_kind_has_variant_names() {
        // Verify ErrorKind has VariantNames trait
        let variants = ErrorKind::VARIANTS;

        assert!(variants.contains(&"CliArgs"));
        assert!(variants.contains(&"PacketOverflow"));
        assert!(variants.contains(&"SecretDetected"));
        assert!(variants.contains(&"LockHeld"));
        assert!(variants.contains(&"PhaseTimeout"));
        assert!(variants.contains(&"ClaudeFailure"));
        assert!(variants.contains(&"Unknown"));
        assert_eq!(variants.len(), 7);
    }

    #[test]
    fn test_check_status_has_variant_names() {
        // Verify CheckStatus has VariantNames trait
        let variants = CheckStatus::VARIANTS;

        assert!(variants.contains(&"Pass"));
        assert!(variants.contains(&"Warn"));
        assert!(variants.contains(&"Fail"));
        assert_eq!(variants.len(), 3);
    }

    #[test]
    fn test_config_source_has_variant_names() {
        // Verify ConfigSource has VariantNames trait
        let variants = ConfigSource::VARIANTS;

        assert!(variants.contains(&"Cli"));
        assert!(variants.contains(&"Env"));
        assert!(variants.contains(&"Config"));
        assert!(variants.contains(&"Programmatic"));
        assert!(variants.contains(&"Default"));
        assert_eq!(variants.len(), 5);
    }

    #[test]
    fn test_error_kind_with_rename_all() {
        use crate::doc_validation::common::RenameAll;

        let rename = RenameAll::SnakeCase;
        let variants = ErrorKind::VARIANTS;
        let transformed = rename.apply_to_variants(variants);

        // Verify snake_case transformation matches serde serialization
        assert!(transformed.contains("cli_args"));
        assert!(transformed.contains("packet_overflow"));
        assert!(transformed.contains("secret_detected"));
        assert!(transformed.contains("lock_held"));
        assert!(transformed.contains("phase_timeout"));
        assert!(transformed.contains("claude_failure"));
        assert!(transformed.contains("unknown"));
    }

    #[test]
    fn test_check_status_with_rename_all() {
        use crate::doc_validation::common::RenameAll;

        let rename = RenameAll::SnakeCase;
        let variants = CheckStatus::VARIANTS;
        let transformed = rename.apply_to_variants(variants);

        // Verify snake_case transformation matches serde serialization
        assert!(transformed.contains("pass"));
        assert!(transformed.contains("warn"));
        assert!(transformed.contains("fail"));
    }

    #[test]
    fn test_config_source_with_rename_all() {
        use crate::doc_validation::common::RenameAll;

        let rename = RenameAll::Lowercase;
        let variants = ConfigSource::VARIANTS;
        let transformed = rename.apply_to_variants(variants);

        // Verify lowercase transformation matches serde serialization
        assert!(transformed.contains("cli"));
        assert!(transformed.contains("env"));
        assert!(transformed.contains("config"));
        assert!(transformed.contains("programmatic"));
        assert!(transformed.contains("default"));
    }
}