Move sources of core folder to root

.github/workflows/ci.yml

@@ -19,7 +19,6 @@ jobs:
         run: cargo test --verbose
       - name: Run core tests
         run: |
-          cd temp_env_vars_core
           cargo test --verbose
       - name: Run macro tests
         run: |

Cargo.toml

@@ -15,13 +15,11 @@ exclude = [".github/", ".vscode/", ".editorconfig", ".gitignore"]
 
 [dependencies]
 temp_env_vars_macro = { version = "0.1.0", path = "./temp_env_vars_macro" }
-temp_env_vars_core = { version = "0.1.0", path = "./temp_env_vars_core" }
 
 [dev-dependencies]
 assertor = "0.0.2"
 serial_test = "3.1.1"
 anyhow = "1.0.86"
 
-
 [workspace]
-members = ["temp_env_vars_core", "temp_env_vars_macro"]
+members = ["temp_env_vars_macro"]

README.adoc

@@ -27,7 +27,6 @@ This crate is not yet available via crates.io (comming soon)
 
 ```toml
 temp_env_vars = { git = "https://github.com/guenhter/temp_env_vars.git", branch = "main" }
-temp_env_vars_core = { git = "https://github.com/guenhter/temp_env_vars.git", branch = "main" }
 ```
 
 

src/lib.rs

@@ -63,37 +63,150 @@
 //!     // "FOO" is not longer set here.
 //! }
 //! ```
-pub use temp_env_vars_core::TestEnvScope;
-pub use temp_env_vars_macro::temp_env_vars;
+use std::{
+    collections::HashMap,
+    sync::{Arc, LazyLock, Mutex},
+};
+
+// Makes the mutex available for the `temp_env_vars` macro. Unfortunately, Macro traits cannot
+// export other types than macros, so this is the least bad place to export this.
+#[doc(hidden)]
+pub static TEMP_ENV_VAR_MACRO_MUTEX: LazyLock<Arc<Mutex<()>>> = LazyLock::new(Arc::default);
+
+#[derive(Debug)]
+pub struct TestEnvScope {
+    original_vars: HashMap<String, String>,
+}
+
+impl TestEnvScope {
+    pub fn new() -> TestEnvScope {
+        TestEnvScope {
+            original_vars: std::env::vars().collect(),
+        }
+    }
+}
+
+impl Drop for TestEnvScope {
+    fn drop(&mut self) {
+        let mut after: HashMap<String, String> = std::env::vars().collect();
+
+        self.original_vars.keys().for_each(|key| {
+            after.remove(key);
+        });
+        after.keys().for_each(|key| {
+            std::env::remove_var(key);
+        });
+        self.original_vars.iter().for_each(|(k, v)| {
+            std::env::set_var(k, v);
+        });
+    }
+}
 
 #[cfg(test)]
-mod test {
-    use super::temp_env_vars;
+mod tests {
+    use std::collections::HashMap;
 
-    use assertor::{assert_that, ResultAssertion};
+    use assertor::{assert_that, EqualityAssertion, ResultAssertion};
     use serial_test::serial;
-    use temp_env_vars_core::TestEnvScope;
+
+    use super::TestEnvScope;
 
     #[test]
-    #[temp_env_vars]
-    #[serial] // Advised to use serial_test if other env-tests are not used with annotated with "temp_env_vars"
-    fn test_with_macro() {
+    #[serial]
+    fn test_nothing_is_changed() {
+        let original: HashMap<String, String> = std::env::vars().collect();
+
+        {
+            let _env_scope = TestEnvScope::new();
+        }
+
+        let after: HashMap<String, String> = std::env::vars().collect();
+        assert_that!(after).is_equal_to(original);
+    }
+
+    #[test]
+    #[serial]
+    fn test_new_vars_are_removed() {
+        std::env::remove_var("FOO");
+        let original: HashMap<String, String> = std::env::vars().collect();
+
+        {
+            let _env_scope = TestEnvScope::new();
+            std::env::set_var("FOO", "BAR1");
+        }
+
+        let after: HashMap<String, String> = std::env::vars().collect();
         assert_that!(std::env::var("FOO")).is_err();
-        std::env::set_var("FOO", "MACRO_TEST");
+        assert_that!(after).is_equal_to(original);
     }
 
     #[test]
-    #[serial] // Advised to use the serial_test create to avoid env mixup
-    fn test_with_env_scope() {
+    #[serial]
+    fn test_changed_vars_are_reset() {
+        std::env::set_var("FOO", "BAR2");
+        let original: HashMap<String, String> = std::env::vars().collect();
+
+        {
+            let _env_scope = TestEnvScope::new();
+            std::env::set_var("FOO", "123");
+        }
+
+        let after: HashMap<String, String> = std::env::vars().collect();
+        assert_that!(std::env::var("FOO")).has_ok("BAR2".to_string());
+        assert_that!(after).is_equal_to(original);
+    }
+
+    #[test]
+    #[serial]
+    fn test_env_vars_are_restored() {
+        std::env::set_var("FOO", "BAR3");
+        let original: HashMap<String, String> = std::env::vars().collect();
+
+        {
+            let _env_scope = TestEnvScope::new();
+            std::env::remove_var("FOO");
+        }
+
+        let after: HashMap<String, String> = std::env::vars().collect();
+        assert_that!(std::env::var("FOO")).has_ok("BAR3".to_string());
+        assert_that!(after).is_equal_to(original);
+    }
+
+    #[test]
+    #[serial]
+    fn test_two_scopes_active_at_same_time() {
+        std::env::remove_var("FOO");
+
+        {
+            let _env_scope_1 = TestEnvScope::new();
+            let _env_scope_2 = TestEnvScope::new();
+
+            std::env::set_var("FOO", "BAR4");
+            assert_that!(std::env::var("FOO")).is_ok();
+        }
+
         assert_that!(std::env::var("FOO")).is_err();
+    }
+
+    #[test]
+    #[serial]
+    fn test_sequential_test_scopes() {
+        std::env::remove_var("FOO");
 
-        let env_scope = TestEnvScope::new();
+        {
+            let _env_scope = TestEnvScope::new();
 
-        std::env::set_var("FOO", "ENV_SCOPE");
-        assert_that!(std::env::var("FOO")).is_ok();
+            std::env::set_var("FOO", "BAR5");
+            assert_that!(std::env::var("FOO")).is_ok();
+        }
+        assert_that!(std::env::var("FOO")).is_err();
 
-        drop(env_scope); // Env vars should be cleaned here
+        {
+            let _env_scope = TestEnvScope::new();
 
+            std::env::set_var("FOO", "BAR6");
+            assert_that!(std::env::var("FOO")).is_ok();
+        }
         assert_that!(std::env::var("FOO")).is_err();
     }
 }