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

use clockabilly::DateTime;

use super::*;

#[rstest]
fn test_container_state_waiting() {
    let state = corev1::ContainerState {
        waiting: Some(Default::default()),
        ..Default::default()
    };

    assert_eq!(state.start_ts().unwrap(), None);
    assert_eq!(state.end_ts().unwrap(), None);
}

#[rstest]
fn test_container_state_running() {
    let start_ts = 1234;
    let state = corev1::ContainerState {
        running: Some(corev1::ContainerStateRunning {
            started_at: Some(metav1::Time(DateTime::from_timestamp(start_ts, 0).unwrap())),
        }),
        ..Default::default()
    };

    assert_eq!(state.start_ts().unwrap(), Some(start_ts));
    assert_eq!(state.end_ts().unwrap(), None);
}

#[rstest]
fn test_container_state_running_invalid() {
    let state = corev1::ContainerState {
        running: Some(corev1::ContainerStateRunning { started_at: None }),
        ..Default::default()
    };

    assert!(matches!(
        state.start_ts().unwrap_err().downcast::<KubernetesError>().unwrap(),
        KubernetesError::FieldNotFound(_)
    ));
    assert_eq!(state.end_ts().unwrap(), None);
}

#[rstest]
fn test_container_state_terminated() {
    let start_ts = 1234;
    let end_ts = 5678;
    let state = corev1::ContainerState {
        terminated: Some(corev1::ContainerStateTerminated {
            started_at: Some(metav1::Time(DateTime::from_timestamp(start_ts, 0).unwrap())),
            finished_at: Some(metav1::Time(DateTime::from_timestamp(end_ts, 0).unwrap())),
            ..Default::default()
        }),
        ..Default::default()
    };

    assert_eq!(state.start_ts().unwrap(), Some(start_ts));
    assert_eq!(state.end_ts().unwrap(), Some(end_ts));
}

#[rstest]
fn test_container_state_terminated_invalid() {
    let state = corev1::ContainerState {
        terminated: Some(corev1::ContainerStateTerminated {
            started_at: None,
            finished_at: None,
            ..Default::default()
        }),
        ..Default::default()
    };

    assert!(matches!(
        state.start_ts().unwrap_err().downcast::<KubernetesError>().unwrap(),
        KubernetesError::FieldNotFound(_)
    ));
    assert!(matches!(
        state.end_ts().unwrap_err().downcast::<KubernetesError>().unwrap(),
        KubernetesError::FieldNotFound(_)
    ));
}

#[rstest]
fn test_container_state_invalid() {
    let state = corev1::ContainerState {
        running: Some(corev1::ContainerStateRunning { started_at: None }),
        terminated: Some(corev1::ContainerStateTerminated {
            started_at: None,
            finished_at: None,
            ..Default::default()
        }),
        ..Default::default()
    };

    assert!(matches!(
        state.start_ts().unwrap_err().downcast::<KubernetesError>().unwrap(),
        KubernetesError::MalformedContainerState(_)
    ));
    assert!(matches!(
        state.end_ts().unwrap_err().downcast::<KubernetesError>().unwrap(),
        KubernetesError::MalformedContainerState(_)
    ));
}