encrypt_config 0.0.1-alpha2

A rust crate to manage, persist and encrypt your configurations.
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

#![doc = include_str!("../README.md")]

mod config;
mod encrypt_utils;
mod error;
mod source;

pub use config::{Config, ConfigPatch, SecretConfigPatch};
pub use error::*;
pub use source::{PersistSource, SecretSource, Source};

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

    use serde::{Deserialize, Serialize};

    use super::*;

    struct NormalSource;
    impl Source for NormalSource {
        type Value = String;
        type Map = Vec<(String, Self::Value)>;

        fn collect(&self) -> Result<Self::Map, Box<dyn std::error::Error>> {
            Ok(vec![("key".to_owned(), "value".to_owned())])
        }
    }

    #[derive(Serialize, Deserialize)]
    #[cfg_attr(test, derive(PartialEq, Debug))]
    struct Foo(String);

    struct PersistSourceImpl;
    impl PersistSource for PersistSourceImpl {
        type Value = Foo;

        #[cfg(not(feature = "default_config_dir"))]
        fn path(&self) -> std::path::PathBuf {
            std::path::PathBuf::from("tests").join("persist.conf")
        }

        #[cfg(feature = "default_config_dir")]
        fn source_name(&self) -> String {
            "persist_test".to_owned()
        }
    }

    struct SecretSourceImpl;
    impl SecretSource for SecretSourceImpl {
        type Value = Foo;

        #[cfg(not(feature = "default_config_dir"))]
        fn path(&self) -> std::path::PathBuf {
            std::path::PathBuf::from("tests").join("secret.conf")
        }

        #[cfg(feature = "default_config_dir")]
        fn source_name(&self) -> String {
            "secret_test".to_owned()
        }
    }

    #[test]
    fn config_tests() {
        let mut config = Config::new("test"); // Now it's empty
        config.add_source(NormalSource).unwrap();
        assert_eq!(config.get::<_, String>("key").unwrap(), "value");
        let patch = NormalSource.upgrade("key", &"new value".to_owned());
        patch.apply(&mut config).unwrap();
        assert_eq!(config.get::<_, String>("key").unwrap(), "new value");

        config.add_persist_source(PersistSourceImpl).unwrap();
        let new_value = Foo("hello".to_owned());
        let patch = PersistSourceImpl.upgrade("persist", &new_value);
        patch.apply(&mut config).unwrap();
        assert_eq!(config.get::<_, Foo>("persist").unwrap(), new_value);

        let mut config_new = Config::new("test");
        config_new.add_persist_source(PersistSourceImpl).unwrap(); // Read config from disk
        assert_eq!(config_new.get::<_, Foo>("persist").unwrap(), new_value);

        config.add_secret_source(SecretSourceImpl).unwrap();
        let new_value = Foo("world".to_owned());
        let patch = SecretSourceImpl.upgrade("secret", &new_value);
        patch.apply(&mut config).unwrap();
        assert_eq!(config.get::<_, Foo>("secret").unwrap(), new_value);

        std::fs::remove_file(PersistSourceImpl.path()).unwrap();
        std::fs::remove_file(SecretSourceImpl.path()).unwrap();
    }

    #[test]
    fn default_test() {
        struct DefaultSource;
        impl PersistSource for DefaultSource {
            type Value = String;

            #[cfg(not(feature = "default_config_dir"))]
            fn path(&self) -> std::path::PathBuf {
                std::path::PathBuf::from("tests").join("default.conf")
            }

            #[cfg(feature = "default_config_dir")]
            fn source_name(&self) -> String {
                "default.conf".to_owned()
            }

            fn default(&self) -> HashMap<String, Self::Value> {
                HashMap::from([("key".to_owned(), "value".to_owned())])
            }
        }

        let mut config = Config::new("test");
        config.add_persist_source(DefaultSource).unwrap();
        assert_eq!(config.get::<_, String>("key").unwrap(), "value");
    }
}