tests: replace env lock clippy allows with async-aware guards

Author: rexleimo

crates/rexos-tools/src/browser_cdp/tests/discovery.rs

@@ -9,7 +9,7 @@ use axum::{Json, Router};
 use serde_json::json;
 
 use super::super::discovery::{find_or_create_page_ws, read_devtools_url};
-use super::shared::{EnvVarGuard, ENV_LOCK};
+use super::shared::{async_env_lock, EnvVarGuard};
 
 #[tokio::test]
 async fn find_or_create_page_ws_bypasses_proxy_for_loopback() {
@@ -51,7 +51,6 @@ async fn find_or_create_page_ws_bypasses_proxy_for_loopback() {
 }
 
 #[tokio::test]
-#[allow(clippy::await_holding_lock)]
 async fn cdp_tab_mode_reuse_skips_json_new() {
     #[derive(Clone)]
     struct StateData {
@@ -86,7 +85,7 @@ async fn cdp_tab_mode_reuse_skips_json_new() {
         axum::serve(listener, app).await.unwrap();
     });
 
-    let _lock = ENV_LOCK.lock().unwrap_or_else(|err| err.into_inner());
+    let _lock = async_env_lock().lock().await;
     let _mode = EnvVarGuard::set("LOOPFORGE_BROWSER_CDP_TAB_MODE", "reuse");
 
     let http = reqwest::Client::builder()

crates/rexos-tools/src/browser_cdp/tests/shared.rs

@@ -1,4 +1,9 @@
 pub(super) static ENV_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(());
+static ASYNC_ENV_LOCK: std::sync::OnceLock<tokio::sync::Mutex<()>> = std::sync::OnceLock::new();
+
+pub(super) fn async_env_lock() -> &'static tokio::sync::Mutex<()> {
+    ASYNC_ENV_LOCK.get_or_init(|| tokio::sync::Mutex::new(()))
+}
 
 pub(super) struct EnvVarGuard {
     key: &'static str,

crates/rexos-tools/src/tests/browser/bridge.rs

@@ -2,9 +2,8 @@ use super::shared::{stub_bridge_script, EnvVarGuard};
 use super::*;
 
 #[tokio::test]
-#[allow(clippy::await_holding_lock)]
 async fn browser_tools_work_with_stub_bridge() {
-    let _lock = ENV_LOCK.lock().unwrap_or_else(|e| e.into_inner());
+    let _lock = async_env_lock().lock().await;
 
     let tmp = tempfile::tempdir().unwrap();
     let workspace = tmp.path().join("ws");
@@ -96,9 +95,8 @@ async fn browser_tools_work_with_stub_bridge() {
 }
 
 #[tokio::test]
-#[allow(clippy::await_holding_lock)]
 async fn browser_navigate_honors_headless_flag() {
-    let _lock = ENV_LOCK.lock().unwrap_or_else(|e| e.into_inner());
+    let _lock = async_env_lock().lock().await;
 
     let tmp = tempfile::tempdir().unwrap();
     let workspace = tmp.path().join("ws");

crates/rexos-tools/src/tests/mod.rs

@@ -6,9 +6,14 @@ use axum::routing::{get, post};
 use axum::{Json, Router};
 use base64::Engine as _;
 use std::ffi::OsString;
-use std::sync::Mutex;
+use std::sync::{Mutex, OnceLock};
 
 static ENV_LOCK: Mutex<()> = Mutex::new(());
+static ASYNC_ENV_LOCK: OnceLock<tokio::sync::Mutex<()>> = OnceLock::new();
+
+fn async_env_lock() -> &'static tokio::sync::Mutex<()> {
+    ASYNC_ENV_LOCK.get_or_init(|| tokio::sync::Mutex::new(()))
+}
 
 mod browser;
 mod compat;

crates/rexos-tools/src/tests/process/lifecycle.rs

@@ -1,9 +1,8 @@
 use super::*;
 
 #[tokio::test]
-#[allow(clippy::await_holding_lock)]
 async fn docker_exec_is_disabled_by_default() {
-    let _lock = ENV_LOCK.lock().unwrap_or_else(|e| e.into_inner());
+    let _lock = async_env_lock().lock().await;
 
     let previous = std::env::var_os("LOOPFORGE_DOCKER_EXEC_ENABLED");
     std::env::remove_var("LOOPFORGE_DOCKER_EXEC_ENABLED");

crates/rexos/tests/llm_openai_compat.rs

@@ -1,11 +1,15 @@
-use std::sync::{Arc, Mutex};
+use std::sync::{Arc, Mutex, OnceLock};
 
 use axum::extract::State;
 use axum::routing::post;
 use axum::{Json, Router};
 use serde_json::json;
 
-static ENV_LOCK: Mutex<()> = Mutex::new(());
+static ENV_LOCK: OnceLock<tokio::sync::Mutex<()>> = OnceLock::new();
+
+fn env_lock() -> &'static tokio::sync::Mutex<()> {
+    ENV_LOCK.get_or_init(|| tokio::sync::Mutex::new(()))
+}
 
 #[derive(Clone, Default)]
 struct TestState {
@@ -109,9 +113,8 @@ async fn openai_compat_client_posts_and_parses_tool_calls() {
 }
 
 #[tokio::test]
-#[allow(clippy::await_holding_lock)]
 async fn openai_compat_client_retries_transient_http_errors() {
-    let _lock = ENV_LOCK.lock().unwrap_or_else(|e| e.into_inner());
+    let _lock = env_lock().lock().await;
     let _guard = EnvVarGuard::set("LOOPFORGE_LLM_RETRY_MAX", "1");
 
     async fn handler(
@@ -244,9 +247,8 @@ async fn openai_compat_client_parses_legacy_function_call_into_tool_call() {
 }
 
 #[tokio::test]
-#[allow(clippy::await_holding_lock)]
 async fn openai_compat_client_timeout_can_be_overridden_via_env() {
-    let _lock = ENV_LOCK.lock().unwrap_or_else(|e| e.into_inner());
+    let _lock = env_lock().lock().await;
     let _guard = EnvVarGuard::set("LOOPFORGE_OPENAI_COMPAT_TIMEOUT_SECS", "1");
     let _retry_guard = EnvVarGuard::set("LOOPFORGE_LLM_RETRY_MAX", "0");