forjar 1.4.2

Rust-native Infrastructure as Code — bare-metal first, BLAKE3 state, provenance tracing
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

//! Tests: FJ-1423 brownfield state import.

#![allow(unused_imports)]
use super::helpers::*;
use super::state_import_brownfield::*;
use std::path::Path;

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_parse_dpkg_packages() {
        let content =
            "Package: curl\nStatus: install ok installed\n\nPackage: vim\nStatus: install ok installed\n";
        let pkgs = parse_dpkg_packages(content);
        assert_eq!(pkgs, vec!["curl", "vim"]);
    }

    #[test]
    fn test_parse_dpkg_empty() {
        let pkgs = parse_dpkg_packages("");
        assert!(pkgs.is_empty());
    }

    #[test]
    fn test_generate_config_basic() {
        let resources = vec![DiscoveredResource {
            id: "pkg-curl".to_string(),
            resource_type: "package".to_string(),
            properties: {
                let mut m = std::collections::BTreeMap::new();
                m.insert("provider".to_string(), "apt".to_string());
                m
            },
            source: "dpkg".to_string(),
        }];
        let config = generate_config("local", &resources);
        assert!(config.contains("version: \"1.0\""));
        assert!(config.contains("pkg-curl:"));
        assert!(config.contains("type: package"));
        assert!(config.contains("packages: [curl]"));
    }

    #[test]
    fn test_generate_config_empty() {
        let config = generate_config("test-host", &[]);
        assert!(config.contains("name: imported-test-host"));
        assert!(config.contains("resources:"));
    }

    #[test]
    fn test_parse_resource_type() {
        use crate::core::types::ResourceType;
        assert!(matches!(
            parse_resource_type("package"),
            Some(ResourceType::Package)
        ));
        assert!(matches!(
            parse_resource_type("pkg"),
            Some(ResourceType::Package)
        ));
        assert!(matches!(
            parse_resource_type("service"),
            Some(ResourceType::Service)
        ));
        assert!(matches!(
            parse_resource_type("file"),
            Some(ResourceType::File)
        ));
        assert!(matches!(
            parse_resource_type("docker"),
            Some(ResourceType::Docker)
        ));
        assert!(parse_resource_type("unknown").is_none());
    }

    #[test]
    fn test_import_brownfield_basic() {
        let result = cmd_import_brownfield("localhost", &[], None, false);
        assert!(result.is_ok());
    }

    #[test]
    fn test_import_brownfield_json() {
        let result = cmd_import_brownfield("test-host", &["package".to_string()], None, true);
        assert!(result.is_ok());
    }

    #[test]
    fn test_import_brownfield_with_output() {
        let dir = tempfile::tempdir().unwrap();
        let output = dir.path().join("imported.yaml");
        let result = cmd_import_brownfield("local", &[], Some(&output), false);
        assert!(result.is_ok());
        assert!(output.exists());
    }

    #[test]
    fn test_discovered_resource_serde() {
        let r = DiscoveredResource {
            id: "pkg-curl".to_string(),
            resource_type: "package".to_string(),
            properties: std::collections::BTreeMap::new(),
            source: "dpkg".to_string(),
        };
        let json = serde_json::to_string(&r).unwrap();
        assert!(json.contains("\"source\":\"dpkg\""));
    }
}