sk-core 2.3.0

SimKube core libraries
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

use clockabilly::Utc;
use serde_json as json;

use super::*;

#[rstest]
fn test_sanitize_obj() {
    let mut obj = DynamicObject {
        metadata: metav1::ObjectMeta {
            name: Some("test-obj".into()),
            namespace: Some(TEST_NAMESPACE.into()),

            annotations: klabel!(
                "some_random_annotation" => "blah",
                LAST_APPLIED_CONFIG_LABEL_KEY => "foo",
                DEPL_REVISION_LABEL_KEY => "42.5",
            ),

            creation_timestamp: Some(metav1::Time(Utc::now())),
            deletion_timestamp: Some(metav1::Time(Utc::now())),
            deletion_grace_period_seconds: Some(123),
            generation: Some(456),
            managed_fields: Some(vec![Default::default()]),
            owner_references: Some(vec![Default::default()]),
            resource_version: Some("1234".into()),
            uid: Some("abcd".into()),

            ..Default::default()
        },
        types: None,
        data: json::Value::Null,
    };

    sanitize_obj(&mut obj, "bar.blah.sh/v2", "Stuff");

    assert_eq!(obj.metadata.creation_timestamp, None);
    assert_eq!(obj.metadata.deletion_timestamp, None);
    assert_eq!(obj.metadata.deletion_grace_period_seconds, None);
    assert_eq!(obj.metadata.generation, None);
    assert_eq!(obj.metadata.managed_fields, None);
    assert_eq!(obj.metadata.owner_references, None);
    assert_eq!(obj.metadata.resource_version, None);
    assert_eq!(obj.metadata.uid, None);

    assert_eq!(obj.metadata.annotations, klabel!("some_random_annotation" => "blah"));
    assert!(obj
        .types
        .is_some_and(|tm| tm.api_version == "bar.blah.sh/v2" && tm.kind == "Stuff"));
}

fn build_label_sel(key: &str, op: &str, value: Option<&str>) -> metav1::LabelSelector {
    metav1::LabelSelector {
        match_expressions: Some(vec![metav1::LabelSelectorRequirement {
            key: key.into(),
            operator: op.into(),
            values: match value {
                Some(s) => Some(vec![s.into()]),
                _ => None,
            },
        }]),
        ..Default::default()
    }
}

#[rstest]
#[case::op_in(OPERATOR_IN)]
#[case::op_not_in(OPERATOR_NOT_IN)]
fn test_label_expr_match(test_pod: corev1::Pod, #[case] op: &str) {
    let sel = build_label_sel("foo", op, Some("bar"));
    let res = test_pod.matches(&sel).unwrap();
    assert_eq!(res, op == OPERATOR_IN);
}

#[rstest]
#[case::op_in(OPERATOR_IN)]
#[case::op_not_in(OPERATOR_NOT_IN)]
fn test_label_expr_no_values(test_pod: corev1::Pod, #[case] op: &str) {
    let sel = build_label_sel("foo", op, None);
    let res = test_pod.matches(&sel).unwrap_err().downcast().unwrap();
    assert!(matches!(res, KubernetesError::MalformedLabelSelector(_)));
}

#[rstest]
#[case::op_in(OPERATOR_IN)]
#[case::op_not_in(OPERATOR_NOT_IN)]
fn test_label_expr_no_match(test_pod: corev1::Pod, #[case] op: &str) {
    let sel = build_label_sel("baz", op, Some("qux"));
    let res = test_pod.matches(&sel).unwrap();
    assert_eq!(res, op == OPERATOR_NOT_IN);
}

#[rstest]
#[case::op_exists(OPERATOR_EXISTS)]
#[case::op_exists(OPERATOR_DOES_NOT_EXIST)]
fn test_label_expr_exists(test_pod: corev1::Pod, #[case] op: &str) {
    let sel = build_label_sel("foo", op, None);
    let res = test_pod.matches(&sel).unwrap();
    assert_eq!(res, op == OPERATOR_EXISTS);
}

#[rstest]
#[case::op_exists(OPERATOR_EXISTS)]
#[case::op_not_exists(OPERATOR_DOES_NOT_EXIST)]
fn test_label_expr_exists_values(test_pod: corev1::Pod, #[case] op: &str) {
    let sel = build_label_sel("foo", op, Some("bar"));
    let res = test_pod.matches(&sel).unwrap_err().downcast().unwrap();
    assert!(matches!(res, KubernetesError::MalformedLabelSelector(_)));
}

#[rstest]
#[case::op_in(OPERATOR_EXISTS)]
#[case::op_not_in(OPERATOR_DOES_NOT_EXIST)]
fn test_label_expr_not_exists(test_pod: corev1::Pod, #[case] op: &str) {
    let sel = build_label_sel("baz", op, None);
    let res = test_pod.matches(&sel).unwrap();
    assert_eq!(res, op == OPERATOR_DOES_NOT_EXIST);
}

#[rstest]
#[case::label_match("foo".into())]
#[case::label_no_match("baz".into())]
fn test_label_match(test_pod: corev1::Pod, #[case] label_key: String) {
    let sel = metav1::LabelSelector {
        match_labels: klabel!(label_key => "bar"),
        ..Default::default()
    };
    let res = test_pod.matches(&sel).unwrap();
    assert_eq!(res, &label_key == "foo");
}