Use ConfigBuilder in env.rs tests

3 files changed, 417 insertions, 45 deletions

diff --git a/src/config.rs b/src/config.rs
index 7b7da2d..3d80aeb 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -1,7 +1,7 @@
 use std::collections::HashMap;
 use std::fmt::Debug;
 
-use builder::ConfigBuilder;
+use crate::builder::ConfigBuilder;
 use serde::de::Deserialize;
 use serde::ser::Serialize;
 
diff --git a/tests/env.rs b/tests/env.rs
index 6ce82c7..560ec3b 100644
--- a/tests/env.rs
+++ b/tests/env.rs
@@ -105,11 +105,13 @@ fn test_parse_int() {
     env::set_var("INT_VAL", "42");
 
     let environment = Environment::new().try_parsing(true);
-    let mut config = Config::default();
 
-    config.set("tag", "Int").unwrap();
-
-    config.merge(environment).unwrap();
+    let config = Config::builder()
+        .set_default("tag", "Int")
+        .unwrap()
+        .add_source(environment)
+        .build()
+        .unwrap();
 
     let config: TestIntEnum = config.try_into().unwrap();
 
@@ -135,11 +137,13 @@ fn test_parse_float() {
     env::set_var("FLOAT_VAL", "42.3");
 
     let environment = Environment::new().try_parsing(true);
-    let mut config = Config::default();
-
-    config.set("tag", "Float").unwrap();
 
-    config.merge(environment).unwrap();
+    let config = Config::builder()
+        .set_default("tag", "Float")
+        .unwrap()
+        .add_source(environment)
+        .build()
+        .unwrap();
 
     let config: TestFloatEnum = config.try_into().unwrap();
 
@@ -168,11 +172,13 @@ fn test_parse_bool() {
     env::set_var("BOOL_VAL", "true");
 
     let environment = Environment::new().try_parsing(true);
-    let mut config = Config::default();
-
-    config.set("tag", "Bool").unwrap();
 
-    config.merge(environment).unwrap();
+    let config = Config::builder()
+        .set_default("tag", "Bool")
+        .unwrap()
+        .add_source(environment)
+        .build()
+        .unwrap();
 
     let config: TestBoolEnum = config.try_into().unwrap();
 
@@ -202,11 +208,13 @@ fn test_parse_off_int() {
     env::set_var("INT_VAL_1", "42");
 
     let environment = Environment::new().try_parsing(false);
-    let mut config = Config::default();
 
-    config.set("tag", "Int").unwrap();
-
-    config.merge(environment).unwrap();
+    let config = Config::builder()
+        .set_default("tag", "Int")
+        .unwrap()
+        .add_source(environment)
+        .build()
+        .unwrap();
 
     env::remove_var("INT_VAL_1");
 
@@ -231,11 +239,13 @@ fn test_parse_off_float() {
     env::set_var("FLOAT_VAL_1", "42.3");
 
     let environment = Environment::new().try_parsing(false);
-    let mut config = Config::default();
-
-    config.set("tag", "Float").unwrap();
 
-    config.merge(environment).unwrap();
+    let config = Config::builder()
+        .set_default("tag", "Float")
+        .unwrap()
+        .add_source(environment)
+        .build()
+        .unwrap();
 
     env::remove_var("FLOAT_VAL_1");
 
@@ -260,11 +270,13 @@ fn test_parse_off_bool() {
     env::set_var("BOOL_VAL_1", "true");
 
     let environment = Environment::new().try_parsing(false);
-    let mut config = Config::default();
-
-    config.set("tag", "Bool").unwrap();
 
-    config.merge(environment).unwrap();
+    let config = Config::builder()
+        .set_default("tag", "Bool")
+        .unwrap()
+        .add_source(environment)
+        .build()
+        .unwrap();
 
     env::remove_var("BOOL_VAL_1");
 
@@ -289,11 +301,13 @@ fn test_parse_int_fail() {
     env::set_var("INT_VAL_2", "not an int");
 
     let environment = Environment::new().try_parsing(true);
-    let mut config = Config::default();
 
-    config.set("tag", "Int").unwrap();
-
-    config.merge(environment).unwrap();
+    let config = Config::builder()
+        .set_default("tag", "Int")
+        .unwrap()
+        .add_source(environment)
+        .build()
+        .unwrap();
 
     env::remove_var("INT_VAL_2");
 
@@ -318,11 +332,13 @@ fn test_parse_float_fail() {
     env::set_var("FLOAT_VAL_2", "not a float");
 
     let environment = Environment::new().try_parsing(true);
-    let mut config = Config::default();
-
-    config.set("tag", "Float").unwrap();
 
-    config.merge(environment).unwrap();
+    let config = Config::builder()
+        .set_default("tag", "Float")
+        .unwrap()
+        .add_source(environment)
+        .build()
+        .unwrap();
 
     env::remove_var("FLOAT_VAL_2");
 
@@ -347,11 +363,13 @@ fn test_parse_bool_fail() {
     env::set_var("BOOL_VAL_2", "not a bool");
 
     let environment = Environment::new().try_parsing(true);
-    let mut config = Config::default();
-
-    config.set("tag", "Bool").unwrap();
 
-    config.merge(environment).unwrap();
+    let config = Config::builder()
+        .set_default("tag", "Bool")
+        .unwrap()
+        .add_source(environment)
+        .build()
+        .unwrap();
 
     env::remove_var("BOOL_VAL_2");
 
@@ -375,11 +393,13 @@ fn test_parse_string() {
     env::set_var("STRING_VAL", "test string");
 
     let environment = Environment::new().try_parsing(true);
-    let mut config = Config::default();
 
-    config.set("tag", "String").unwrap();
-
-    config.merge(environment).unwrap();
+    let config = Config::builder()
+        .set_default("tag", "String")
+        .unwrap()
+        .add_source(environment)
+        .build()
+        .unwrap();
 
     let config: TestStringEnum = config.try_into().unwrap();
 
@@ -409,11 +429,13 @@ fn test_parse_off_string() {
     env::set_var("STRING_VAL_1", "test string");
 
     let environment = Environment::new().try_parsing(false);
-    let mut config = Config::default();
-
-    config.set("tag", "String").unwrap();
 
-    config.merge(environment).unwrap();
+    let config = Config::builder()
+        .set_default("tag", "String")
+        .unwrap()
+        .add_source(environment)
+        .build()
+        .unwrap();
 
     let config: TestStringEnum = config.try_into().unwrap();
 
diff --git a/tests/legacy/env.rs b/tests/legacy/env.rs
new file mode 100644
index 0000000..adba260
--- /dev/null
+++ b/tests/legacy/env.rs
@@ -0,0 +1,350 @@
+extern crate config;
+extern crate serde_derive;
+
+use config::*;
+use serde_derive::Deserialize;
+use std::env;
+
+/// Reminder that tests using env variables need to use different env variable names, since
+/// tests can be run in parallel
+
+
+#[test]
+fn test_parse_int() {
+    // using a struct in an enum here to make serde use `deserialize_any`
+    #[derive(Deserialize, Debug)]
+    #[serde(tag = "tag")]
+    enum TestIntEnum {
+        Int(TestInt),
+    }
+
+    #[derive(Deserialize, Debug)]
+    struct TestInt {
+        int_val: i32,
+    }
+
+    env::set_var("INT_VAL", "42");
+
+    let environment = Environment::new().try_parsing(true);
+    let mut config = Config::default();
+
+    config.set("tag", "Int").unwrap();
+
+    config.merge(environment).unwrap();
+
+    let config: TestIntEnum = config.try_into().unwrap();
+
+    assert!(matches!(config, TestIntEnum::Int(TestInt { int_val: 42 })));
+
+    env::remove_var("INT_VAL");
+}
+
+#[test]
+fn test_parse_float() {
+    // using a struct in an enum here to make serde use `deserialize_any`
+    #[derive(Deserialize, Debug)]
+    #[serde(tag = "tag")]
+    enum TestFloatEnum {
+        Float(TestFloat),
+    }
+
+    #[derive(Deserialize, Debug)]
+    struct TestFloat {
+        float_val: f64,
+    }
+
+    env::set_var("FLOAT_VAL", "42.3");
+
+    let environment = Environment::new().try_parsing(true);
+    let mut config = Config::default();
+
+    config.set("tag", "Float").unwrap();
+
+    config.merge(environment).unwrap();
+
+    let config: TestFloatEnum = config.try_into().unwrap();
+
+    // can't use `matches!` because of float value
+    match config {
+        TestFloatEnum::Float(TestFloat { float_val }) => assert_eq!(float_val, 42.3),
+    }
+
+    env::remove_var("FLOAT_VAL");
+}
+
+#[test]
+fn test_parse_bool() {
+    // using a struct in an enum here to make serde use `deserialize_any`
+    #[derive(Deserialize, Debug)]
+    #[serde(tag = "tag")]
+    enum TestBoolEnum {
+        Bool(TestBool),
+    }
+
+    #[derive(Deserialize, Debug)]
+    struct TestBool {
+        bool_val: bool,
+    }
+
+    env::set_var("BOOL_VAL", "true");
+
+    let environment = Environment::new().try_parsing(true);
+    let mut config = Config::default();
+
+    config.set("tag", "Bool").unwrap();
+
+    config.merge(environment).unwrap();
+
+    let config: TestBoolEnum = config.try_into().unwrap();
+
+    assert!(matches!(
+        config,
+        TestBoolEnum::Bool(TestBool { bool_val: true }),
+    ));
+
+    env::remove_var("BOOL_VAL");
+}
+
+#[test]
+#[should_panic(expected = "invalid type: string \"42\", expected i32")]
+fn test_parse_off_int() {
+    // using a struct in an enum here to make serde use `deserialize_any`
+    #[derive(Deserialize, Debug)]
+    #[serde(tag = "tag")]
+    enum TestIntEnum {
+        Int(TestInt),
+    }
+
+    #[derive(Deserialize, Debug)]
+    struct TestInt {
+        int_val_1: i32,
+    }
+
+    env::set_var("INT_VAL_1", "42");
+
+    let environment = Environment::new().try_parsing(false);
+    let mut config = Config::default();
+
+    config.set("tag", "Int").unwrap();
+
+    config.merge(environment).unwrap();
+
+    env::remove_var("INT_VAL_1");
+
+    config.try_into::<TestIntEnum>().unwrap();
+}
+
+#[test]
+#[should_panic(expected = "invalid type: string \"42.3\", expected f64")]
+fn test_parse_off_float() {
+    // using a struct in an enum here to make serde use `deserialize_any`
+    #[derive(Deserialize, Debug)]
+    #[serde(tag = "tag")]
+    enum TestFloatEnum {
+        Float(TestFloat),
+    }
+
+    #[derive(Deserialize, Debug)]
+    struct TestFloat {
+        float_val_1: f64,
+    }
+
+    env::set_var("FLOAT_VAL_1", "42.3");
+
+    let environment = Environment::new().try_parsing(false);
+    let mut config = Config::default();
+
+    config.set("tag", "Float").unwrap();
+
+    config.merge(environment).unwrap();
+
+    env::remove_var("FLOAT_VAL_1");
+
+    config.try_into::<TestFloatEnum>().unwrap();
+}
+
+#[test]
+#[should_panic(expected = "invalid type: string \"true\", expected a boolean")]
+fn test_parse_off_bool() {
+    // using a struct in an enum here to make serde use `deserialize_any`
+    #[derive(Deserialize, Debug)]
+    #[serde(tag = "tag")]
+    enum TestBoolEnum {
+        Bool(TestBool),
+    }
+
+    #[derive(Deserialize, Debug)]
+    struct TestBool {
+        bool_val_1: bool,
+    }
+
+    env::set_var("BOOL_VAL_1", "true");
+
+    let environment = Environment::new().try_parsing(false);
+    let mut config = Config::default();
+
+    config.set("tag", "Bool").unwrap();
+
+    config.merge(environment).unwrap();
+
+    env::remove_var("BOOL_VAL_1");
+
+    config.try_into::<TestBoolEnum>().unwrap();
+}
+
+#[test]
+#[should_panic(expected = "invalid type: string \"not an int\", expected i32")]
+fn test_parse_int_fail() {
+    // using a struct in an enum here to make serde use `deserialize_any`
+    #[derive(Deserialize, Debug)]
+    #[serde(tag = "tag")]
+    enum TestIntEnum {
+        Int(TestInt),
+    }
+
+    #[derive(Deserialize, Debug)]
+    struct TestInt {
+        int_val_2: i32,
+    }
+
+    env::set_var("INT_VAL_2", "not an int");
+
+    let environment = Environment::new().try_parsing(true);
+    let mut config = Config::default();
+
+    config.set("tag", "Int").unwrap();
+
+    config.merge(environment).unwrap();
+
+    env::remove_var("INT_VAL_2");
+
+    config.try_into::<TestIntEnum>().unwrap();
+}
+
+#[test]
+#[should_panic(expected = "invalid type: string \"not a float\", expected f64")]
+fn test_parse_float_fail() {
+    // using a struct in an enum here to make serde use `deserialize_any`
+    #[derive(Deserialize, Debug)]
+    #[serde(tag = "tag")]
+    enum TestFloatEnum {
+        Float(TestFloat),
+    }
+
+    #[derive(Deserialize, Debug)]
+    struct TestFloat {
+        float_val_2: f64,
+    }
+
+    env::set_var("FLOAT_VAL_2", "not a float");
+
+    let environment = Environment::new().try_parsing(true);
+    let mut config = Config::default();
+
+    config.set("tag", "Float").unwrap();
+
+    config.merge(environment).unwrap();
+
+    env::remove_var("FLOAT_VAL_2");
+
+    config.try_into::<TestFloatEnum>().unwrap();
+}
+
+#[test]
+#[should_panic(expected = "invalid type: string \"not a bool\", expected a boolean")]
+fn test_parse_bool_fail() {
+    // using a struct in an enum here to make serde use `deserialize_any`
+    #[derive(Deserialize, Debug)]
+    #[serde(tag = "tag")]
+    enum TestBoolEnum {
+        Bool(TestBool),
+    }
+
+    #[derive(Deserialize, Debug)]
+    struct TestBool {
+        bool_val_2: bool,
+    }
+
+    env::set_var("BOOL_VAL_2", "not a bool");
+
+    let environment = Environment::new().try_parsing(true);
+    let mut config = Config::default();
+
+    config.set("tag", "Bool").unwrap();
+
+    config.merge(environment).unwrap();
+
+    env::remove_var("BOOL_VAL_2");
+
+    config.try_into::<TestBoolEnum>().unwrap();
+}
+
+#[test]
+fn test_parse_string() {
+    // using a struct in an enum here to make serde use `deserialize_any`
+    #[derive(Deserialize, Debug)]
+    #[serde(tag = "tag")]
+    enum TestStringEnum {
+        String(TestString),
+    }
+
+    #[derive(Deserialize, Debug)]
+    struct TestString {
+        string_val: String,
+    }
+
+    env::set_var("STRING_VAL", "test string");
+
+    let environment = Environment::new().try_parsing(true);
+    let mut config = Config::default();
+
+    config.set("tag", "String").unwrap();
+
+    config.merge(environment).unwrap();
+
+    let config: TestStringEnum = config.try_into().unwrap();
+
+    let test_string = String::from("test string");
+
+    match config {
+        TestStringEnum::String(TestString { string_val }) => assert_eq!(test_string, string_val),
+    }
+
+    env::remove_var("STRING_VAL");
+}
+
+#[test]
+fn test_parse_off_string() {
+    // using a struct in an enum here to make serde use `deserialize_any`
+    #[derive(Deserialize, Debug)]
+    #[serde(tag = "tag")]
+    enum TestStringEnum {
+        String(TestString),
+    }
+
+    #[derive(Deserialize, Debug)]
+    struct TestString {
+        string_val_1: String,
+    }
+
+    env::set_var("STRING_VAL_1", "test string");
+
+    let environment = Environment::new().try_parsing(false);
+    let mut config = Config::default();
+
+    config.set("tag", "String").unwrap();
+
+    config.merge(environment).unwrap();
+
+    let config: TestStringEnum = config.try_into().unwrap();
+
+    let test_string = String::from("test string");
+
+    match config {
+        TestStringEnum::String(TestString { string_val_1 }) => {
+            assert_eq!(test_string, string_val_1)
+        }
+    }
+
+    env::remove_var("STRING_VAL_1");
+}