helm-schema-gen 0.0.4

Generate an accurate JSON schema for any helm chart
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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141

use super::*;

#[test]
fn declared_scalar_default_survives_active_conjunctive_branch() {
    let unsafe_plain_scalar = serde_json::json!({
        "allOf": [
            {
                "not": {
                    "pattern": "^(|~|null|Null|NULL)$"
                }
            },
            {
                "not": {
                    "pattern": "^(true|True|TRUE|false|False|FALSE|yes|Yes|YES|no|No|NO|on|On|ON|off|Off|OFF|y|Y|n|N)$"
                }
            }
        ],
        "type": "string"
    });
    let schema = serde_json::json!({
        "type": "object",
        "properties": {
            "mode": { "type": "string" },
            "locations": { "type": "array" }
        },
        "allOf": [{
            "if": {
                "properties": { "mode": { "const": "enabled" } },
                "required": ["mode"]
            },
            "then": {
                "properties": {
                    "locations": {
                        "items": {
                            "properties": {
                                "provider": unsafe_plain_scalar
                            },
                            "type": "object"
                        },
                        "type": "array"
                    }
                }
            }
        }]
    });
    let declared = serde_json::json!({
        "mode": "enabled",
        "locations": [{ "provider": "" }]
    });
    let schema = preserve_declared_default_in_schema(schema, &declared);

    assert!(
        schema_accepts_instance(&schema, &declared),
        "the exact chart-authored empty default should survive: {schema}"
    );
    assert!(
        !schema_accepts_instance(
            &schema,
            &serde_json::json!({
                "mode": "enabled",
                "locations": [{ "provider": "true" }]
            })
        ),
        "preserving the exact default must not widen the lexical domain: {schema}"
    );
}

/// A `range`d map whose members are validated by a shared member schema
/// (`additionalProperties`/`items`) still preserves each member's declared
/// empty scalar default, including through the `anyOf` array | object | null
/// member projection and a nullable-sink `anyOf` wrapper on the leaf.
#[test]
fn declared_empty_default_survives_ranged_map_member_projection() {
    let nullable_unsafe_plain_scalar = serde_json::json!({
        "anyOf": [
            {
                "allOf": [
                    {
                        "not": {
                            "pattern": "^(|~|null|Null|NULL)$"
                        }
                    },
                    {
                        "not": {
                            "pattern": "^(true|True|TRUE|false|False|FALSE|yes|Yes|YES|no|No|NO|on|On|ON|off|Off|OFF|y|Y|n|N)$"
                        }
                    }
                ],
                "type": "string"
            },
            { "type": "null" }
        ]
    });
    let member = serde_json::json!({
        "type": "object",
        "properties": { "secretName": nullable_unsafe_plain_scalar }
    });
    let schema = serde_json::json!({
        "type": "object",
        "properties": {
            "databases": {
                "anyOf": [
                    { "type": "object", "additionalProperties": member },
                    { "type": "array", "items": member },
                    { "type": "null" }
                ]
            }
        }
    });
    let declared = serde_json::json!({
        "databases": { "airtype": { "secretName": "" } }
    });
    let schema = preserve_declared_default_in_schema(schema, &declared);

    assert!(
        schema_accepts_instance(&schema, &declared),
        "the declared empty member default must survive the member projection: {schema}"
    );
    assert!(
        !schema_accepts_instance(
            &schema,
            &serde_json::json!({ "databases": { "airtype": { "secretName": "true" } } })
        ),
        "preserving the exact empty default must not widen the lexical domain: {schema}"
    );
}

#[test]
fn declared_default_does_not_weaken_terminal_false_branch() {
    let schema = serde_json::json!({
        "type": "object",
        "allOf": [false]
    });
    let declared = serde_json::json!({ "enabled": true });
    let schema = preserve_declared_default_in_schema(schema, &declared);

    assert!(
        !schema_accepts_instance(&schema, &declared),
        "a terminal validator must not be bypassed by default preservation: {schema}"
    );
}