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

use super::Predicate;
use crate::{Guard, GuardValue};
use test_util::prelude::sim_assert_eq;

#[test]
fn or_truthy_predicate_projects_to_or_guard() {
    let predicate = Predicate::from(Guard::Or {
        paths: vec!["first".to_string(), "second".to_string()],
    });

    sim_assert_eq!(
        have: predicate.contract_guards(),
        want: vec![Guard::Or {
            paths: vec!["first".to_string(), "second".to_string()]
        }]
    );
}

#[test]
fn negated_truthy_predicate_projects_to_not_guard() {
    let predicate = Predicate::from(Guard::Truthy {
        path: "enabled".to_string(),
    })
    .negated();

    sim_assert_eq!(
        have: predicate.contract_guards(),
        want: vec![Guard::Not {
            path: "enabled".to_string()
        }]
    );
}

#[test]
fn double_negated_truthy_predicate_projects_to_truthy_guard() {
    let predicate = Predicate::from(Guard::Truthy {
        path: "enabled".to_string(),
    })
    .negated()
    .negated();

    sim_assert_eq!(
        have: predicate.contract_guards(),
        want: vec![Guard::Truthy {
            path: "enabled".to_string()
        }]
    );
}

#[test]
fn negated_eq_predicate_projects_to_not_eq_guard() {
    let predicate = Predicate::Not(Box::new(Predicate::from(Guard::Eq {
        path: "mode".to_string(),
        value: GuardValue::string("prod"),
    })));

    sim_assert_eq!(
        have: predicate.contract_guards(),
        want: vec![Guard::NotEq {
            path: "mode".to_string(),
            value: GuardValue::string("prod"),
        }]
    );
}

#[test]
fn not_eq_predicate_projects_to_not_eq_guard() {
    let predicate = Predicate::from(Guard::NotEq {
        path: "mode".to_string(),
        value: GuardValue::string("disabled"),
    });

    sim_assert_eq!(
        have: predicate.contract_guards(),
        want: vec![Guard::NotEq {
            path: "mode".to_string(),
            value: GuardValue::string("disabled"),
        }]
    );
}

#[test]
fn mixed_or_predicate_projects_to_structural_any_of_guard() {
    let predicate = Predicate::Or(vec![
        Predicate::from(Guard::Truthy {
            path: "first".to_string(),
        }),
        Predicate::from(Guard::Eq {
            path: "mode".to_string(),
            value: GuardValue::string("prod"),
        }),
    ]);

    sim_assert_eq!(
        have: predicate.contract_guards(),
        want: vec![Guard::AnyOf {
            alternatives: vec![
                vec![Guard::Truthy {
                    path: "first".to_string(),
                }],
                vec![Guard::Eq {
                    path: "mode".to_string(),
                    value: GuardValue::string("prod"),
                }],
            ],
        }]
    );
}

#[test]
fn contract_guard_stack_dedupes_projected_guards() {
    let predicate = Predicate::from(Guard::Truthy {
        path: "enabled".to_string(),
    });

    sim_assert_eq!(
        have: Predicate::contract_guard_stack(&[predicate.clone(), predicate]),
        want: vec![Guard::Truthy {
            path: "enabled".to_string()
        }]
    );
}

#[test]
fn approximate_predicate_keeps_an_opaque_complement_without_becoming_a_guard() {
    let predicate =
        Predicate::approximate("condition-1", ["version".to_string()].into_iter().collect());

    sim_assert_eq!(
        have: predicate.negated(),
        want: Predicate::Not(Box::new(predicate.clone()))
    );
    sim_assert_eq!(have: predicate.contract_guards(), want: Vec::<Guard>::new());
    assert!(predicate.contains_approximation());
}