helm-schema-k8s 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

use serde_json::json;
use test_util::prelude::sim_assert_eq;

use super::*;

#[test]
fn bundles_provider_document_refs_into_local_definitions() {
    let root_leaf = json!({
        "type": "object",
        "additionalProperties": { "$ref": "#/definitions/StringMap" }
    });
    let bundled = bundle_source_schema(
        SourceBundleNode::new(
            "source.json",
            "/definitions/Container/properties/env",
            root_leaf,
        ),
        |current_location, reference| {
            sim_assert_eq!(have: current_location.document.as_str(), want: "source.json");
            (reference == "#/definitions/StringMap").then(|| {
                SourceBundleNode::new(
                    "source.json",
                    "/definitions/StringMap",
                    json!({
                        "type": "object",
                        "additionalProperties": { "type": "string" }
                    }),
                )
            })
        },
    );

    sim_assert_eq!(
        have: bundled,
        want: json!({
            "type": "object",
            "additionalProperties": { "$ref": "#/$defs/StringMap" },
            "$defs": {
                "StringMap": {
                    "type": "object",
                    "additionalProperties": { "type": "string" }
                }
            }
        })
    );
}

#[test]
fn keeps_leaf_local_definitions_intact() {
    let source_schema = json!({
        "type": "object",
        "properties": {
            "labels": { "$ref": "#/$defs/StringMap" }
        },
        "$defs": {
            "StringMap": {
                "type": "object",
                "additionalProperties": { "type": "string" }
            }
        }
    });

    assert!(helm_schema_json_schema_walk::schema_refs_point_inside(
        &source_schema
    ));
}

#[test]
fn bundles_cross_file_refs_into_local_definitions() {
    let root_leaf = json!({
        "type": "object",
        "properties": {
            "selector": { "$ref": "common.json#/definitions/Selector" }
        }
    });
    let bundled = bundle_source_schema(
        SourceBundleNode::new("pod.json", "/definitions/Spec", root_leaf),
        |_, reference| {
            (reference == "common.json#/definitions/Selector")
                .then(|| {
                    SourceBundleNode::new(
                        "common.json",
                        "/definitions/Selector",
                        json!({
                            "type": "object",
                            "properties": {
                                "matchLabels": {
                                    "$ref": "#/definitions/StringMap"
                                }
                            }
                        }),
                    )
                })
                .or_else(|| {
                    (reference == "#/definitions/StringMap").then(|| {
                        SourceBundleNode::new(
                            "common.json",
                            "/definitions/StringMap",
                            json!({
                                "type": "object",
                                "additionalProperties": { "type": "string" }
                            }),
                        )
                    })
                })
        },
    );

    sim_assert_eq!(
        have: bundled,
        want: json!({
            "type": "object",
            "properties": {
                "selector": { "$ref": "#/$defs/Selector" }
            },
            "$defs": {
                "Selector": {
                    "type": "object",
                    "properties": {
                        "matchLabels": { "$ref": "#/$defs/StringMap" }
                    }
                },
                "StringMap": {
                    "type": "object",
                    "additionalProperties": { "type": "string" }
                }
            }
        })
    );
}