koprs 0.5.4

A reusable, ergonomic library that streamlines Kubernetes operator development, allowing developers to build controllers with significantly less code.
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
142
143
144
145
146
147
148
149
150
151
152
153

// src/tests/error.rs

#[cfg(test)]
mod error_tests {
    use std::io;

    use crate::error::{KubeGenericError, Result};

    // -----------------------------------------------------------------------
    // Display — #[error("...")] format strings
    // -----------------------------------------------------------------------

    #[test]
    fn missing_metadata_display_contains_field_name() {
        let err = KubeGenericError::MissingMetadata("name".to_string());
        assert_eq!(err.to_string(), "Missing metadata field: name");
    }

    #[test]
    fn internal_display_contains_message() {
        let err = KubeGenericError::Internal("something went wrong".to_string());
        assert_eq!(err.to_string(), "Internal error: something went wrong");
    }

    #[test]
    fn io_display_contains_underlying_message() {
        let io_err = io::Error::new(io::ErrorKind::NotFound, "file not found");
        let err = KubeGenericError::Io(io_err);
        assert!(
            err.to_string().contains("file not found"),
            "display was: {err}"
        );
    }

    #[test]
    fn serialization_display_contains_underlying_message() {
        let json_err = serde_json::from_str::<serde_json::Value>("not json").unwrap_err();
        let err = KubeGenericError::Serialization(json_err);
        assert!(
            err.to_string().starts_with("Serialization error:"),
            "display was: {err}"
        );
    }

    // -----------------------------------------------------------------------
    // From conversions — #[from] derives
    // -----------------------------------------------------------------------

    #[test]
    fn from_io_error_produces_io_variant() {
        let io_err = io::Error::new(io::ErrorKind::PermissionDenied, "access denied");
        let err = KubeGenericError::from(io_err);
        assert!(
            matches!(err, KubeGenericError::Io(_)),
            "expected Io variant, got: {err:?}"
        );
    }

    #[test]
    fn from_serde_json_error_produces_serialization_variant() {
        let json_err = serde_json::from_str::<serde_json::Value>("{bad}").unwrap_err();
        let err = KubeGenericError::from(json_err);
        assert!(
            matches!(err, KubeGenericError::Serialization(_)),
            "expected Serialization variant, got: {err:?}"
        );
    }

    #[test]
    fn question_mark_converts_io_error_automatically() {
        fn fallible() -> Result<()> {
            let _ = std::fs::read("/this/path/does/not/exist/ever")?;
            Ok(())
        }
        let err = fallible().unwrap_err();
        assert!(
            matches!(err, KubeGenericError::Io(_)),
            "expected Io variant from ?, got: {err:?}"
        );
    }

    #[test]
    fn question_mark_converts_serde_json_error_automatically() {
        fn fallible() -> Result<serde_json::Value> {
            Ok(serde_json::from_str("not valid json")?)
        }
        let err = fallible().unwrap_err();
        assert!(
            matches!(err, KubeGenericError::Serialization(_)),
            "expected Serialization variant from ?, got: {err:?}"
        );
    }

    // -----------------------------------------------------------------------
    // Manually constructed variants
    // -----------------------------------------------------------------------

    #[test]
    fn missing_metadata_stores_field_name() {
        let err = KubeGenericError::MissingMetadata("namespace".to_string());
        if let KubeGenericError::MissingMetadata(field) = err {
            assert_eq!(field, "namespace");
        } else {
            panic!("expected MissingMetadata variant");
        }
    }

    #[test]
    fn internal_stores_message() {
        let err = KubeGenericError::Internal("reconcile loop failed".to_string());
        if let KubeGenericError::Internal(msg) = err {
            assert_eq!(msg, "reconcile loop failed");
        } else {
            panic!("expected Internal variant");
        }
    }

    // -----------------------------------------------------------------------
    // Result type alias
    // -----------------------------------------------------------------------

    #[test]
    fn result_ok_variant_works() {
        let r: Result<i32> = Ok(42);
        assert_eq!(r.unwrap(), 42);
    }

    #[test]
    fn result_err_variant_carries_error() {
        let r: Result<()> = Err(KubeGenericError::Internal("oops".to_string()));
        assert!(r.is_err());
    }

    // -----------------------------------------------------------------------
    // Debug — all variants are reachable and format without panicking
    // -----------------------------------------------------------------------

    #[test]
    fn all_variants_implement_debug_without_panicking() {
        let variants: &[KubeGenericError] = &[
            KubeGenericError::MissingMetadata("x".to_string()),
            KubeGenericError::Internal("x".to_string()),
            KubeGenericError::Io(io::Error::new(io::ErrorKind::Other, "x")),
            KubeGenericError::Serialization(
                serde_json::from_str::<serde_json::Value>("!").unwrap_err(),
            ),
        ];
        for v in variants {
            // format! must not panic
            let _ = format!("{v:?}");
        }
    }
}