Skip to main content

kibana_object_manager/transform/
managed_flag.rs

1//! Managed flag transformer
2//!
3//! Adds the "managed: true" flag to objects being imported to Kibana.
4
5use crate::etl::Transformer;
6use eyre::Result;
7use serde_json::{json, Value};
8
9/// Transformer that adds a "managed" flag to objects
10///
11/// This flag indicates that the object is managed by an external system
12/// (version control) and should be handled differently by Kibana.
13///
14/// # Example
15/// ```
16/// use kibana_object_manager::transform::ManagedFlagAdder;
17/// use kibana_object_manager::etl::Transformer;
18/// use serde_json::json;
19///
20/// let adder = ManagedFlagAdder::new(true);
21/// let input = json!({
22///     "id": "test",
23///     "type": "dashboard"
24/// });
25///
26/// let output = adder.transform(input).unwrap();
27/// assert_eq!(output["managed"], true);
28/// ```
29pub struct ManagedFlagAdder {
30    managed: bool,
31}
32
33impl ManagedFlagAdder {
34    /// Create a new managed flag adder
35    pub fn new(managed: bool) -> Self {
36        Self { managed }
37    }
38}
39
40impl Default for ManagedFlagAdder {
41    fn default() -> Self {
42        Self::new(true)
43    }
44}
45
46impl Transformer for ManagedFlagAdder {
47    type Input = Value;
48    type Output = Value;
49
50    fn transform(&self, mut input: Self::Input) -> Result<Self::Output> {
51        if let Some(obj) = input.as_object_mut() {
52            if self.managed {
53                obj.insert("managed".to_string(), json!(true));
54            } else {
55                obj.remove("managed");
56            }
57        }
58        Ok(input)
59    }
60}
61
62#[cfg(test)]
63mod tests {
64    use super::*;
65    use serde_json::json;
66
67    #[test]
68    fn test_add_managed_flag() {
69        let adder = ManagedFlagAdder::new(true);
70        let input = json!({
71            "id": "test",
72            "type": "dashboard",
73            "attributes": {"title": "Test"}
74        });
75
76        let output = adder.transform(input).unwrap();
77
78        assert_eq!(output["managed"], true);
79        assert_eq!(output["id"], "test");
80        assert_eq!(output["type"], "dashboard");
81    }
82
83    #[test]
84    fn test_add_unmanaged_flag() {
85        let adder = ManagedFlagAdder::new(false);
86        let input = json!({
87            "id": "test",
88            "type": "dashboard",
89            "attributes": {"title": "Test"},
90            "managed": true
91        });
92
93        let output = adder.transform(input).unwrap();
94
95        assert_eq!(output.get("managed"), None);
96        assert_eq!(output["id"], "test");
97        assert_eq!(output["type"], "dashboard");
98    }
99
100    #[test]
101    fn test_overwrites_existing_managed_flag() {
102        let adder = ManagedFlagAdder::new(true);
103        let input = json!({
104            "id": "test",
105            "managed": false
106        });
107
108        let output = adder.transform(input).unwrap();
109        assert_eq!(output["managed"], true);
110    }
111
112    #[test]
113    fn test_transform_many() {
114        let adder = ManagedFlagAdder::new(true);
115        let inputs = vec![json!({"id": "1"}), json!({"id": "2"}), json!({"id": "3"})];
116
117        let outputs = adder.transform_many(inputs).unwrap();
118
119        assert_eq!(outputs.len(), 3);
120        for output in outputs {
121            assert_eq!(output["managed"], true);
122        }
123    }
124}