New integration test suite

Cargo.toml

@@ -1,3 +1,4 @@
 [workspace]
+resolver = "2"
 
-members = ["dotenv", "dotenv_codegen"]
+members = ["dotenv", "dotenv_codegen", "test_util"]

dotenv/Cargo.toml

@@ -29,8 +29,8 @@ required-features = ["cli"]
 clap = { version = "4.3.11", optional = true }
 
 [dev-dependencies]
+dotenvy_test_util = { path = "../test_util", version = "0.1.0" }
 tempfile = "3.3.0"
-once_cell = "1.16.0"
 
 [features]
 cli = ["clap"]

dotenv/tests/integration/api/dotenv.rs

@@ -0,0 +1,36 @@
+use crate::util::*;
+use dotenvy::dotenv;
+use dotenvy_test_util::*;
+
+#[test]
+fn default_env_ok() {
+    test_in_default_env(|| {
+        dotenv().ok();
+        assert_default_keys();
+    });
+}
+
+#[test]
+fn default_env_unwrap() {
+    test_in_default_env(|| {
+        dotenv().unwrap();
+        assert_default_keys();
+    });
+}
+
+#[test]
+fn default_env_unwrap_path() {
+    let testenv = TestEnv::default();
+    test_default_envfile_path(&testenv);
+}
+
+#[test]
+fn explicit_no_override() {
+    let mut testenv = TestEnv::init();
+    testenv.add_env_var("FOOO", "bar");
+    testenv.add_envfile(".env", "FOOO=notbar");
+    test_in_env(&testenv, || {
+        dotenv().unwrap();
+        assert_env_var("FOOO", "bar");
+    })
+}

dotenv/tests/integration/api/dotenv_iter.rs

@@ -0,0 +1,103 @@
+use crate::util::*;
+use dotenvy::dotenv_iter;
+use dotenvy_test_util::*;
+
+#[test]
+fn default_env_ok() {
+    test_in_default_env(|| {
+        dotenv_iter().ok();
+        assert_default_existing_var();
+        // the envfile shouldn't be loaded into the environment
+        assert_env_var_unset(DEFAULT_TEST_KEY);
+    });
+}
+
+#[test]
+fn default_env_unwrap() {
+    test_in_default_env(|| {
+        dotenv_iter().unwrap();
+        assert_default_existing_var();
+        assert_env_var_unset(DEFAULT_TEST_KEY);
+    });
+}
+
+#[test]
+fn no_envfile_ok() {
+    let testenv = TestEnv::init();
+    test_in_env(&testenv, || {
+        dotenv_iter().ok();
+        assert_default_keys_unset();
+    });
+}
+
+#[test]
+fn no_envfile_err() {
+    let testenv = TestEnv::init();
+    test_in_env(&testenv, || match dotenv_iter() {
+        Ok(_) => panic!("should have failed"),
+        Err(err) => assert_err_not_found(err),
+    });
+}
+
+#[test]
+fn no_vars() {
+    let testenv = TestEnv::init_with_envfile("");
+    test_in_env(&testenv, || {
+        dotenv_iter().unwrap().for_each(|_| {
+            panic!("should have no keys");
+        });
+    });
+}
+
+#[test]
+fn one_var() {
+    let testenv = TestEnv::init_with_envfile("FOOO=bar");
+    test_in_env(&testenv, || {
+        let (key, value) = dotenv_iter_unwrap_one_item();
+        assert_eq!(key, "FOOO");
+        assert_eq!(value, "bar");
+    });
+}
+
+#[test]
+fn one_var_only() {
+    let testenv = TestEnv::init_with_envfile("FOOO=bar");
+    test_in_env(&testenv, || {
+        let count = dotenv_iter().expect("valid file").count();
+        assert_eq!(1, count);
+    });
+}
+
+#[test]
+fn one_var_empty() {
+    let testenv = TestEnv::init_with_envfile("FOOO=");
+    test_in_env(&testenv, || {
+        let (key, value) = dotenv_iter_unwrap_one_item();
+        assert_eq!(key, "FOOO");
+        assert_eq!(value, "");
+    });
+}
+
+#[test]
+fn two_vars_into_hash_map() {
+    check_iter_default_envfile_into_hash_map(dotenv_iter);
+}
+
+#[test]
+fn explicit_no_override() {
+    let mut testenv = TestEnv::init();
+    testenv.add_env_var("FOOO", "bar");
+    testenv.add_envfile(".env", "FOOO=notbar");
+    test_in_env(&testenv, || {
+        dotenv_iter().unwrap();
+        assert_env_var("FOOO", "bar");
+    })
+}
+
+fn dotenv_iter_unwrap_one_item() -> (String, String) {
+    dotenv_iter()
+        .expect("valid file")
+        .next()
+        .expect("one item")
+        .expect("valid item")
+}

dotenv/tests/integration/api/dotenv_override.rs

@@ -0,0 +1,83 @@
+use crate::util::*;
+use dotenvy::dotenv_override;
+use dotenvy_test_util::*;
+
+#[test]
+fn no_file_ok() {
+    let testenv = TestEnv::init();
+    test_in_env(&testenv, || {
+        dotenv_override().ok();
+    });
+}
+
+#[test]
+fn no_file_err() {
+    let testenv = TestEnv::init();
+    test_in_env(&testenv, || {
+        let err = dotenv_override().unwrap_err();
+        assert_err_not_found(err);
+    });
+}
+
+#[test]
+fn empty_file_is_ok() {
+    let testenv = TestEnv::init_with_envfile("");
+    test_in_env(&testenv, || {
+        assert!(dotenv_override().is_ok());
+    });
+}
+
+#[test]
+fn one_new_var() {
+    let testenv = TestEnv::init_with_envfile("FOOO=bar");
+    test_in_env(&testenv, || {
+        dotenv_override().unwrap();
+        assert_env_var("FOOO", "bar");
+    });
+}
+
+#[test]
+fn one_old_var() {
+    let mut testenv = TestEnv::init_with_envfile("FOOO=from_file");
+    testenv.add_env_var("FOOO", "from_env");
+    test_in_env(&testenv, || {
+        assert_env_var("FOOO", "from_env");
+        dotenv_override().unwrap();
+        assert_env_var("FOOO", "from_file");
+    });
+}
+
+#[test]
+fn one_old_var_one_new_var() {
+    let vars = [("FOOO", "from_file"), ("BARR", "new")];
+    let envfile = create_custom_envfile(&vars);
+    let mut testenv = TestEnv::init_with_envfile(envfile);
+    testenv.add_env_var("FOOO", "from_env");
+    test_in_env(&testenv, || {
+        assert_env_var_unset("BARR");
+        dotenv_override().unwrap();
+        assert_env_vars(&vars);
+    });
+}
+
+#[test]
+fn substitute_self() {
+    let mut testenv = TestEnv::init_with_envfile("FOOO=$FOOO+1");
+    testenv.add_env_var("FOOO", "test");
+    test_in_env(&testenv, || {
+        assert_env_var("FOOO", "test");
+        dotenv_override().unwrap();
+        assert_env_var("FOOO", "test+1");
+    });
+}
+
+#[test]
+fn substitute_self_twice() {
+    let mut testenv = TestEnv::init_with_envfile("FOOO=$FOOO+1\nFOOO=$FOOO+1");
+    testenv.add_env_var("FOOO", "test");
+    test_in_env(&testenv, || {
+        assert_env_var("FOOO", "test");
+        dotenv_override().unwrap();
+        assert_env_var("FOOO", "test+1+1");
+    });
+}

dotenv/tests/integration/api/from_filename.rs

@@ -0,0 +1,117 @@
+use crate::util::*;
+use dotenvy::from_filename;
+use dotenvy_test_util::*;
+
+#[test]
+fn no_file() {
+    let testenv = TestEnv::init();
+    test_in_env(&testenv, || {
+        let err = from_filename("nonexistent.env").unwrap_err();
+        assert_err_not_found(err);
+    });
+}
+
+#[test]
+fn empty_default_file() {
+    let testenv = TestEnv::init_with_envfile("");
+    test_in_env(&testenv, || {
+        assert!(from_filename(".env").is_ok());
+    });
+}
+
+#[test]
+fn empty_custom_file() {
+    let mut testenv = TestEnv::init();
+    testenv.add_envfile(".custom.env", "");
+    test_in_env(&testenv, || {
+        assert!(from_filename(".custom.env").is_ok());
+    });
+}
+
+#[test]
+fn return_path_valid() {
+    let testenv = TestEnv::default();
+    test_in_env(&testenv, || {
+        let actual = from_filename(".env").unwrap();
+        assert_default_envfile_path(&testenv, &actual);
+    });
+}
+
+#[test]
+fn default_file_not_read_on_missing_file() {
+    test_in_default_env(|| {
+        let err = from_filename("nonexistent.env").unwrap_err();
+        assert_err_not_found(err);
+        assert_env_var_unset(DEFAULT_TEST_KEY);
+    })
+}
+
+#[test]
+fn dotenv_then_custom() {
+    let mut testenv = TestEnv::default();
+    testenv.add_envfile("custom", KEYVAL_1);
+    test_in_env(&testenv, || {
+        dotenvy::dotenv().unwrap();
+        from_filename("custom").unwrap();
+        assert_env_var(KEY_1, VAL_1);
+        assert_default_keys();
+    });
+}
+
+#[test]
+fn dotenv_then_custom_no_override() {
+    let mut testenv = TestEnv::default();
+    testenv.add_envfile("custom", format!("{DEFAULT_TEST_KEY}=from_custom"));
+    test_in_env(&testenv, || {
+        dotenvy::dotenv().unwrap();
+        from_filename("custom").unwrap();
+        assert_default_keys();
+    });
+}
+
+#[test]
+fn explicit_no_override() {
+    let mut testenv = TestEnv::init();
+    testenv.add_env_var(KEY_1, VAL_1);
+    testenv.add_envfile("custom", format!("{KEY_1}=from_custom"));
+    test_in_env(&testenv, || {
+        from_filename("custom").unwrap();
+        assert_env_var(KEY_1, VAL_1);
+    });
+}
+
+#[test]
+fn child_dir() {
+    let mut testenv = TestEnv::init();
+    testenv.add_child_dir("child");
+    testenv.add_envfile("child/custom", KEYVAL_1);
+    test_in_env(&testenv, || {
+        from_filename("child/custom").unwrap();
+        assert_env_var(KEY_1, VAL_1);
+    });
+}
+
+#[test]
+fn parent_dir_relative_path() {
+    let mut testenv = TestEnv::init();
+    testenv.add_child_dir("child");
+    testenv.add_envfile("custom.env", KEYVAL_1);
+    testenv.set_work_dir("child");
+    test_in_env(&testenv, || {
+        from_filename("../custom.env").unwrap();
+        assert_env_var(KEY_1, VAL_1);
+    });
+}
+
+#[test]
+fn parent_dir_absolute_path() {
+    let mut testenv = TestEnv::init();
+    testenv.add_child_dir("child");
+    testenv.add_envfile("custom.env", KEYVAL_1);
+    testenv.set_work_dir("child");
+    test_in_env(&testenv, || {
+        let path = canonicalize_envfile_path(&testenv, "custom.env");
+        from_filename(path).unwrap();
+        assert_env_var(KEY_1, VAL_1);
+    });
+}