Share test env lock across modules

Author: pasunboneleve

src/main.rs

@@ -6,6 +6,8 @@ mod external_events;
 mod output;
 mod processes;
 mod state;
+#[cfg(test)]
+mod test_support;
 
 use std::path::PathBuf;
 
@@ -346,59 +348,8 @@ mod tests {
     use crate::output::{
         format_output_prefix, normalize_internal_log_label, normalize_source_label,
     };
+    use crate::test_support::RustLogGuard;
     use clap::Parser;
-    use std::ffi::OsString;
-    use std::sync::{Mutex, MutexGuard, OnceLock};
-
-    fn rust_log_lock() -> &'static Mutex<()> {
-        static LOCK: OnceLock<Mutex<()>> = OnceLock::new();
-        LOCK.get_or_init(|| Mutex::new(()))
-    }
-
-    struct RustLogGuard {
-        _lock: MutexGuard<'static, ()>,
-        original: Option<OsString>,
-    }
-
-    impl RustLogGuard {
-        fn set(value: Option<&str>) -> Self {
-            let lock = rust_log_lock().lock().expect("lock RUST_LOG test mutex");
-            let original = std::env::var_os("RUST_LOG");
-            match value {
-                Some(value) => set_test_env_var("RUST_LOG", value),
-                None => remove_test_env_var("RUST_LOG"),
-            }
-            Self {
-                _lock: lock,
-                original,
-            }
-        }
-    }
-
-    impl Drop for RustLogGuard {
-        fn drop(&mut self) {
-            match &self.original {
-                Some(value) => set_test_env_var("RUST_LOG", value),
-                None => remove_test_env_var("RUST_LOG"),
-            }
-        }
-    }
-
-    fn set_test_env_var(key: &str, value: impl AsRef<std::ffi::OsStr>) {
-        // SAFETY: tests serialize all RUST_LOG mutation through `rust_log_lock`,
-        // so no concurrent test can observe partially updated process-global state.
-        unsafe {
-            std::env::set_var(key, value);
-        }
-    }
-
-    fn remove_test_env_var(key: &str) {
-        // SAFETY: tests serialize all RUST_LOG mutation through `rust_log_lock`,
-        // so removing the variable cannot race with other tests here.
-        unsafe {
-            std::env::remove_var(key);
-        }
-    }
 
     #[test]
     fn default_rust_log_uses_info_when_unset() {

src/processes.rs

@@ -984,64 +984,13 @@ fn timeout_error(name: &str, probe: &ProbeSpec) -> anyhow::Error {
 mod tests {
     use super::*;
     use crate::config::{OutputExtract, ProbeSpec};
+    use crate::test_support::RustLogGuard;
     use serde_json::Value;
-    use std::ffi::OsString;
     use std::sync::Arc;
-    use std::sync::{Mutex as StdMutex, MutexGuard, OnceLock};
     use std::time::{SystemTime, UNIX_EPOCH};
     use tokio::io::AsyncReadExt;
     use tokio::sync::Mutex;
 
-    fn rust_log_lock() -> &'static StdMutex<()> {
-        static LOCK: OnceLock<StdMutex<()>> = OnceLock::new();
-        LOCK.get_or_init(|| StdMutex::new(()))
-    }
-
-    struct RustLogGuard {
-        _lock: MutexGuard<'static, ()>,
-        original: Option<OsString>,
-    }
-
-    impl RustLogGuard {
-        fn set(value: Option<&str>) -> Self {
-            let lock = rust_log_lock().lock().expect("lock RUST_LOG test mutex");
-            let original = std::env::var_os("RUST_LOG");
-            match value {
-                Some(value) => set_test_env_var("RUST_LOG", value),
-                None => remove_test_env_var("RUST_LOG"),
-            }
-            Self {
-                _lock: lock,
-                original,
-            }
-        }
-    }
-
-    impl Drop for RustLogGuard {
-        fn drop(&mut self) {
-            match &self.original {
-                Some(value) => set_test_env_var("RUST_LOG", value),
-                None => remove_test_env_var("RUST_LOG"),
-            }
-        }
-    }
-
-    fn set_test_env_var(key: &str, value: impl AsRef<std::ffi::OsStr>) {
-        // SAFETY: these tests serialize process-global env mutation through
-        // `rust_log_lock`, so no concurrent test observes a torn update.
-        unsafe {
-            std::env::set_var(key, value);
-        }
-    }
-
-    fn remove_test_env_var(key: &str) {
-        // SAFETY: these tests serialize process-global env mutation through
-        // `rust_log_lock`, so removing the variable does not race here.
-        unsafe {
-            std::env::remove_var(key);
-        }
-    }
-
     fn unique_state_path() -> PathBuf {
         let unique = SystemTime::now()
             .duration_since(UNIX_EPOCH)

src/test_support.rs

@@ -0,0 +1,54 @@
+use std::ffi::{OsStr, OsString};
+use std::sync::{Mutex, MutexGuard, OnceLock};
+
+fn rust_log_lock() -> &'static Mutex<()> {
+    static LOCK: OnceLock<Mutex<()>> = OnceLock::new();
+    LOCK.get_or_init(|| Mutex::new(()))
+}
+
+pub(crate) struct RustLogGuard {
+    _lock: MutexGuard<'static, ()>,
+    original: Option<OsString>,
+}
+
+impl RustLogGuard {
+    pub(crate) fn set(value: Option<&str>) -> Self {
+        let lock = rust_log_lock().lock().expect("lock RUST_LOG test mutex");
+        let original = std::env::var_os("RUST_LOG");
+        match value {
+            Some(value) => set_test_env_var("RUST_LOG", value),
+            None => remove_test_env_var("RUST_LOG"),
+        }
+        Self {
+            _lock: lock,
+            original,
+        }
+    }
+}
+
+impl Drop for RustLogGuard {
+    fn drop(&mut self) {
+        match &self.original {
+            Some(value) => set_test_env_var("RUST_LOG", value),
+            None => remove_test_env_var("RUST_LOG"),
+        }
+    }
+}
+
+fn set_test_env_var(key: &str, value: impl AsRef<OsStr>) {
+    // SAFETY: all test-time RUST_LOG mutation goes through the shared
+    // `rust_log_lock`, so no concurrent unit test can race on this
+    // process-global environment state.
+    unsafe {
+        std::env::set_var(key, value);
+    }
+}
+
+fn remove_test_env_var(key: &str) {
+    // SAFETY: all test-time RUST_LOG mutation goes through the shared
+    // `rust_log_lock`, so removing the variable cannot race with another
+    // unit test in this process.
+    unsafe {
+        std::env::remove_var(key);
+    }
+}