envman_test 0.4.1

Test utilities for envman.
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

#[cfg(test)]
mod tests {
    use envman::EnvMan;

    #[derive(EnvMan, Debug, PartialEq)]
    struct Normal {
        db_url: String,
        db_max_conn: u8,
    }

    #[test]
    fn normal() {
        unsafe {
            std::env::set_var("DB_URL", "mysql://example");
            std::env::set_var("DB_MAX_CONN", "5");
        }
        assert_eq!(
            Normal::load().unwrap(),
            Normal {
                db_url: String::from("mysql://example"),
                db_max_conn: 5
            }
        );
    }

    #[derive(EnvMan, Debug, PartialEq)]
    struct Rename {
        #[envman(rename = "CORE_DB_URL")]
        db_url_1: String,
        #[envman(rename = "TRANSACTION_DB_URL")]
        db_url_2: String,
    }

    #[test]
    fn rename() {
        unsafe {
            std::env::set_var("CORE_DB_URL", "mysql://example.1");
            std::env::set_var("TRANSACTION_DB_URL", "mysql://example.2");
        }
        assert_eq!(
            Rename::load().unwrap(),
            Rename {
                db_url_1: String::from("mysql://example.1"),
                db_url_2: String::from("mysql://example.2")
            }
        );
    }

    #[derive(EnvMan, Debug, PartialEq)]
    struct TestDefault {
        redis_url: String,
        #[envman(default = "5")]
        redis_max_conn: u8,
    }

    #[test]
    fn default() {
        unsafe {
            std::env::set_var("REDIS_URL", "redis://example");
        }
        assert_eq!(
            TestDefault::load().unwrap(),
            TestDefault {
                redis_url: String::from("redis://example"),
                redis_max_conn: 5
            }
        );
    }

    #[derive(EnvMan, Debug, PartialEq)]
    struct TestOption {
        secret_1: Option<String>,
        #[envman(default = "5")]
        secret_2: Option<String>,
    }

    #[test]
    fn option() {
        assert_eq!(
            TestOption::load().unwrap(),
            TestOption {
                secret_1: None,
                secret_2: Some(String::from("5"))
            }
        );
    }

    #[derive(EnvMan, Debug, PartialEq)]
    struct TestTestValue {
        #[envman(test = "2")]
        secret_1: String,
        #[envman(default = "1", test = "3")]
        secret_2: String,
    }

    #[test]
    fn test_value() {
        assert_eq!(
            TestTestValue::load().unwrap(),
            TestTestValue {
                secret_1: String::from("2"),
                secret_2: String::from("3")
            }
        );
    }
}