awsm-env 0.2.5

A lightweight utility for syncing AWS Secrets Manager secrets to environment variables.
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

use std::{fs::File, io};

use indexmap::IndexMap;

use crate::{output::Output, variable::Variables};

use anyhow::Result;

/// Formats environment variables into JSON using [`JsonOutput::format`]
pub struct JsonOutput;

impl Output for JsonOutput {
    /// Formats environment variables into JSON of the form `{"KEY": "value"}`
    fn format(&self, variables: Variables) -> Result<String> {
        let map: IndexMap<_, _> = variables.into();
        Ok(serde_json::to_string(&map)? + "\n")
    }

    /// Loads existing environment variables from a JSON file
    fn load_existing(&self, file: File) -> Result<Variables> {
        let input = io::read_to_string(file)?;
        let obj: IndexMap<_, _> = serde_json::from_str(&input)?;

        Ok(obj.into())
    }
}

#[cfg(test)]
mod tests {
    use std::fs;

    use crate::variable::Variable;

    use super::*;

    fn write_temp(name: &str, contents: &str) -> std::path::PathBuf {
        let path = std::env::temp_dir().join(format!("awsm_env_test_{}", name));
        fs::write(&path, contents).unwrap();
        path
    }

    #[test]
    fn test_json_output() {
        let input: Variables = vec![
            Variable {
                key: "KEY1".to_string(),
                required: true,
                value: Some("value1".to_string()),
                ..Default::default()
            },
            Variable {
                key: "KEY2".to_string(),
                required: true,
                value: Some("val\"ue2".to_string()),
                ..Default::default()
            },
        ]
        .into();

        let output = JsonOutput;
        let result = output.format(input).unwrap();

        let expected = serde_json::json!({
            "KEY1": "value1",
            "KEY2": "val\"ue2",
        });
        assert_eq!(
            serde_json::from_str::<serde_json::Value>(&result).unwrap(),
            expected
        )
    }

    #[test]
    fn test_json_output_default_fallback() {
        // The default is used when `value` is missing, and `value` wins when
        // both the default and value are present.
        let input: Variables = vec![
            Variable {
                key: "ONLY_DEFAULT".to_string(),
                default: Some("def".to_string()),
                ..Default::default()
            },
            Variable {
                key: "BOTH".to_string(),
                default: Some("def".to_string()),
                value: Some("val".to_string()),
                ..Default::default()
            },
        ]
        .into();

        let result = JsonOutput.format(input).unwrap();

        let expected = serde_json::json!({
            "ONLY_DEFAULT": "def",
            "BOTH": "val",
        });
        assert_eq!(
            serde_json::from_str::<serde_json::Value>(&result).unwrap(),
            expected
        )
    }

    #[test]
    fn test_json_load_existing() {
        let path = write_temp(
            "json_load.json",
            "{\"KEY1\":\"value1\",\"KEY2\":\"val\\\"ue2\"}\n",
        );

        let result = JsonOutput
            .load_existing(File::open(&path).unwrap())
            .unwrap();

        // JSON values are loaded straight into `value` (no directives/required).
        let expected: Variables = vec![
            Variable {
                key: "KEY1".to_string(),
                value: Some("value1".to_string()),
                ..Default::default()
            },
            Variable {
                key: "KEY2".to_string(),
                value: Some("val\"ue2".to_string()),
                ..Default::default()
            },
        ]
        .into();
        assert_eq!(result, expected);

        let _ = fs::remove_file(&path);
    }
}