Skip to content

Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy

Rust

harden codex auth socket handling

Raine Virta019e913215a4
diff --git a/src/providers/codex/auth/browser_login.rs b/src/providers/codex/auth/browser_login.rs
index 7b0cff2..5cf7fe0 100644
--- a/src/providers/codex/auth/browser_login.rs
+++ b/src/providers/codex/auth/browser_login.rs
@@ -138,6 +138,9 @@ fn handle_callback(
pkce: &PkceCodes,
state: &str,
) -> Result<TokenResponse, anyhow::Error> {
+ let _ = stream.set_nonblocking(false);
+ let _ = stream.set_read_timeout(Some(Duration::from_secs(5)));
+
let (path, query) = match extract_request_path_and_query(stream) {
Some(pair) => pair,
None => {
@@ -210,28 +213,23 @@ mod tests {
fn new() -> Self {
let shutdown = Arc::new(AtomicBool::new(false));
let sd = shutdown.clone();
- let url: Arc<std::sync::Mutex<Option<String>>> = Arc::new(std::sync::Mutex::new(None));
- let url_clone = url.clone();
+ let listener = std::net::TcpListener::bind("127.0.0.1:0").expect("bind");
+ let addr = listener.local_addr().unwrap();
+ let url = format!("http://{addr}");
+ listener.set_nonblocking(true).expect("nonblocking");
+ let (ready_tx, ready_rx) = std::sync::mpsc::channel();
std::thread::spawn(move || {
- let listener = std::net::TcpListener::bind("127.0.0.1:0").expect("bind");
- let addr = listener.local_addr().unwrap();
- *url_clone.lock().unwrap() = Some(format!("http://{addr}"));
-
- listener.set_nonblocking(true).expect("nonblocking");
-
+ let _ = ready_tx.send(());
loop {
if sd.load(Ordering::Relaxed) {
return;
}
match listener.accept() {
Ok((mut stream, _)) => {
- let mut buf = [0; 4096];
- let n = match stream.read(&mut buf) {
- Ok(n) if n > 0 => n,
- _ => continue,
+ let Some(request) = read_http_request(&mut stream) else {
+ continue;
};
- let request = String::from_utf8_lossy(&buf[..n]);
let response = if request.contains("/oauth/token") {
// Token exchange - return success
@@ -259,13 +257,20 @@ mod tests {
}
}
});
+ ready_rx
+ .recv_timeout(Duration::from_secs(1))
+ .expect("mock browser login auth server should become ready");
- std::thread::sleep(Duration::from_millis(100));
- let url = url.lock().unwrap().clone().unwrap();
Self { url, shutdown }
}
}
+ impl Drop for MockBrowserLoginAuthServer {
+ fn drop(&mut self) {
+ self.shutdown.store(true, Ordering::Relaxed);
+ }
+ }
+
/// Simulate a browser callback request by connecting to our browser login
/// server and sending a crafted HTTP GET request.
fn send_callback_request(addr: std::net::SocketAddr, path: &str) -> String {
@@ -280,29 +285,57 @@ mod tests {
String::from_utf8_lossy(&buf[..n]).to_string()
}
- #[test]
- fn browser_login_rejects_wrong_path() {
- // Start a browser login server on a random port
- // Get a free port for the test
- let test_listener = TcpListener::bind("127.0.0.1:0").unwrap();
- let test_port = test_listener.local_addr().unwrap().port();
- drop(test_listener);
+ fn read_http_request(stream: &mut std::net::TcpStream) -> Option<String> {
+ let _ = stream.set_nonblocking(false);
+ let _ = stream.set_read_timeout(Some(Duration::from_secs(2)));
+ let mut request = Vec::new();
+ let mut chunk = [0; 4096];
- let config = BrowserLoginConfig {
- issuer: "http://fake-issuer".into(),
- port: test_port,
- timeout: Duration::from_millis(100),
- };
+ loop {
+ let n = stream.read(&mut chunk).ok()?;
+ if n == 0 {
+ break;
+ }
+ request.extend_from_slice(&chunk[..n]);
+
+ if let Some(header_end) = find_header_end(&request) {
+ let content_length = content_length(&request[..header_end]).unwrap_or(0);
+ if request.len() >= header_end + 4 + content_length {
+ break;
+ }
+ }
+ }
+
+ if request.is_empty() {
+ None
+ } else {
+ Some(String::from_utf8_lossy(&request).to_string())
+ }
+ }
- // The server will be listening on the port but since we're sending
- // wrong path, it should fail with "Not found" and keep listening.
- // We'll connect and send a wrong path request first.
- let listener = TcpListener::bind(format!("127.0.0.1:{}", config.port)).unwrap();
- let _ = config; // suppress unused warning
+ fn find_header_end(bytes: &[u8]) -> Option<usize> {
+ bytes.windows(4).position(|window| window == b"\r\n\r\n")
+ }
+
+ fn content_length(headers: &[u8]) -> Option<usize> {
+ let text = String::from_utf8_lossy(headers);
+ text.lines().find_map(|line| {
+ let (name, value) = line.split_once(':')?;
+ if name.eq_ignore_ascii_case("content-length") {
+ value.trim().parse().ok()
+ } else {
+ None
+ }
+ })
+ }
+
+ #[test]
+ fn browser_login_rejects_wrong_path() {
+ let listener = TcpListener::bind("127.0.0.1:0").unwrap();
+ let port = listener.local_addr().unwrap().port();
+ listener.set_nonblocking(true).unwrap();
- let _handle = std::thread::spawn(move || {
- listener.set_nonblocking(true).unwrap();
- // Accept one connection and handle it
+ let handle = std::thread::spawn(move || {
loop {
if let Ok((mut stream, _)) = listener.accept() {
let _ = handle_callback(
@@ -321,11 +354,14 @@ mod tests {
}
});
- // Now connect and send a wrong-path request
- let addr: std::net::SocketAddr = format!("127.0.0.1:{}", test_port).parse().unwrap();
+ let addr: std::net::SocketAddr = format!("127.0.0.1:{port}").parse().unwrap();
let response = send_callback_request(addr, "/wrong/path");
- assert!(response.contains("404"));
- assert!(response.contains("Not found"));
+ handle.join().unwrap();
+ assert!(response.contains("404"), "unexpected response: {response}");
+ assert!(
+ response.contains("Not found"),
+ "unexpected response: {response}"
+ );
}
#[test]
@@ -334,7 +370,7 @@ mod tests {
let port = listener.local_addr().unwrap().port();
listener.set_nonblocking(true).unwrap();
- let _handle = std::thread::spawn(move || {
+ let handle = std::thread::spawn(move || {
let pkce = PkceCodes {
verifier: "v".into(),
challenge: "c".into(),
@@ -349,7 +385,6 @@ mod tests {
"expected_state",
);
assert!(result.is_err());
- assert!(result.unwrap_err().to_string().contains("Invalid callback"));
break;
}
std::thread::sleep(Duration::from_millis(10));
@@ -359,6 +394,7 @@ mod tests {
let addr: std::net::SocketAddr = format!("127.0.0.1:{}", port).parse().unwrap();
let response =
send_callback_request(addr, "/auth/callback?code=test_code&state=wrong_state");
+ handle.join().unwrap();
assert!(response.contains("400"));
assert!(response.contains("Invalid callback"));
}
@@ -369,7 +405,7 @@ mod tests {
let port = listener.local_addr().unwrap().port();
listener.set_nonblocking(true).unwrap();
- let _handle = std::thread::spawn(move || {
+ let handle = std::thread::spawn(move || {
let pkce = PkceCodes {
verifier: "v".into(),
challenge: "c".into(),
@@ -384,7 +420,6 @@ mod tests {
"state",
);
assert!(result.is_err());
- assert!(result.unwrap_err().to_string().contains("Invalid callback"));
break;
}
std::thread::sleep(Duration::from_millis(10));
@@ -393,6 +428,7 @@ mod tests {
let addr: std::net::SocketAddr = format!("127.0.0.1:{}", port).parse().unwrap();
let response = send_callback_request(addr, "/auth/callback?state=state");
+ handle.join().unwrap();
assert!(response.contains("400"));
}
@@ -402,7 +438,7 @@ mod tests {
let port = listener.local_addr().unwrap().port();
listener.set_nonblocking(true).unwrap();
- let _handle = std::thread::spawn(move || {
+ let handle = std::thread::spawn(move || {
let pkce = PkceCodes {
verifier: "v".into(),
challenge: "c".into(),
@@ -417,7 +453,6 @@ mod tests {
"state",
);
assert!(result.is_err());
- assert!(result.unwrap_err().to_string().contains("access_denied"));
break;
}
std::thread::sleep(Duration::from_millis(10));
@@ -427,6 +462,7 @@ mod tests {
let addr: std::net::SocketAddr = format!("127.0.0.1:{}", port).parse().unwrap();
let response =
send_callback_request(addr, "/auth/callback?error=access_denied&state=state");
+ handle.join().unwrap();
assert!(response.contains("400"));
assert!(response.contains("access_denied"));
}
@@ -435,12 +471,14 @@ mod tests {
fn callback_success_exchanges_tokens() {
let auth_server = MockBrowserLoginAuthServer::new();
let auth_url = auth_server.url.clone();
+ let callback_result = Arc::new(std::sync::Mutex::new(None));
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let port = listener.local_addr().unwrap().port();
listener.set_nonblocking(true).unwrap();
- let _handle = std::thread::spawn(move || {
+ let callback_result_thread = callback_result.clone();
+ let handle = std::thread::spawn(move || {
let pkce = PkceCodes {
verifier: "test_verifier".into(),
challenge: "test_challenge".into(),
@@ -454,10 +492,10 @@ mod tests {
&pkce,
"expected_state",
);
- assert!(result.is_ok());
- let tokens = result.unwrap();
- assert_eq!(tokens.access_token, "bt_at");
- assert_eq!(tokens.refresh_token, "bt_rt");
+ let stored = result
+ .map(|tokens| (tokens.access_token, tokens.refresh_token))
+ .map_err(|err| err.to_string());
+ *callback_result_thread.lock().unwrap() = Some(stored);
break;
}
std::thread::sleep(Duration::from_millis(10));
@@ -465,9 +503,18 @@ mod tests {
});
let addr: std::net::SocketAddr = format!("127.0.0.1:{}", port).parse().unwrap();
- send_callback_request(addr, "/auth/callback?code=test_code&state=expected_state");
- // Give the handler thread time to complete
- std::thread::sleep(Duration::from_millis(200));
+ let response =
+ send_callback_request(addr, "/auth/callback?code=test_code&state=expected_state");
+ handle.join().unwrap();
+ assert!(response.contains("200"), "unexpected response: {response}");
+ let tokens = callback_result
+ .lock()
+ .unwrap()
+ .take()
+ .expect("callback handler should store a result")
+ .unwrap();
+ assert_eq!(tokens.0, "bt_at");
+ assert_eq!(tokens.1, "bt_rt");
// auth_server dropped here, closing the mock server
drop(auth_server);
@@ -478,28 +525,23 @@ mod tests {
// Server that returns a 500 on token exchange
let shutdown = Arc::new(AtomicBool::new(false));
let sd = shutdown.clone();
- let url: Arc<std::sync::Mutex<Option<String>>> = Arc::new(std::sync::Mutex::new(None));
- let url_clone = url.clone();
+ let listener = std::net::TcpListener::bind("127.0.0.1:0").expect("bind");
+ let addr = listener.local_addr().unwrap();
+ let fail_issuer = format!("http://{addr}");
+ listener.set_nonblocking(true).expect("nonblocking");
+ let (ready_tx, ready_rx) = std::sync::mpsc::channel();
std::thread::spawn(move || {
- let listener = std::net::TcpListener::bind("127.0.0.1:0").expect("bind");
- let addr = listener.local_addr().unwrap();
- *url_clone.lock().unwrap() = Some(format!("http://{addr}"));
-
- listener.set_nonblocking(true).expect("nonblocking");
-
+ let _ = ready_tx.send(());
loop {
if sd.load(Ordering::Relaxed) {
return;
}
match listener.accept() {
Ok((mut stream, _)) => {
- let mut buf = [0; 4096];
- let n = match stream.read(&mut buf) {
- Ok(n) if n > 0 => n,
- _ => continue,
+ let Some(request) = read_http_request(&mut stream) else {
+ continue;
};
- let request = String::from_utf8_lossy(&buf[..n]);
let body = if request.contains("/oauth/token") {
r#"{"error":"bad exchange"}"#
@@ -520,16 +562,16 @@ mod tests {
}
}
});
-
- std::thread::sleep(Duration::from_millis(100));
- let fail_issuer = url.lock().unwrap().clone().unwrap();
+ ready_rx
+ .recv_timeout(Duration::from_secs(1))
+ .expect("mock browser login failure server should become ready");
let listener = TcpListener::bind("127.0.0.1:0").unwrap();
let port = listener.local_addr().unwrap().port();
listener.set_nonblocking(true).unwrap();
let fail_issuer_clone = fail_issuer.clone();
- let _handle = std::thread::spawn(move || {
+ let handle = std::thread::spawn(move || {
let pkce = PkceCodes {
verifier: "v".into(),
challenge: "c".into(),
@@ -544,12 +586,6 @@ mod tests {
"expected_state",
);
assert!(result.is_err());
- assert!(
- result
- .unwrap_err()
- .to_string()
- .contains("Token exchange failed")
- );
break;
}
std::thread::sleep(Duration::from_millis(10));
@@ -557,9 +593,15 @@ mod tests {
});
let addr: std::net::SocketAddr = format!("127.0.0.1:{}", port).parse().unwrap();
- send_callback_request(addr, "/auth/callback?code=test_code&state=expected_state");
-
- std::thread::sleep(Duration::from_millis(200));
+ let response =
+ send_callback_request(addr, "/auth/callback?code=test_code&state=expected_state");
+ handle.join().unwrap();
+ assert!(response.contains("500"), "unexpected response: {response}");
+ assert!(
+ response.contains("Token exchange failed"),
+ "unexpected response: {response}"
+ );
+ shutdown.store(true, Ordering::Relaxed);
}
#[test]
diff --git a/src/providers/codex/auth/device.rs b/src/providers/codex/auth/device.rs
index aa90892..8de77a4 100644
--- a/src/providers/codex/auth/device.rs
+++ b/src/providers/codex/auth/device.rs
@@ -221,7 +221,16 @@ impl Default for DeviceAuthClient {
mod tests {
use super::*;
use std::sync::atomic::{AtomicBool, Ordering};
- use std::sync::{Arc, Mutex};
+ use std::sync::{Arc, Mutex, OnceLock};
+
+ static DEVICE_FLOW_TEST_LOCK: OnceLock<Mutex<()>> = OnceLock::new();
+
+ fn device_flow_test_lock() -> std::sync::MutexGuard<'static, ()> {
+ DEVICE_FLOW_TEST_LOCK
+ .get_or_init(|| Mutex::new(()))
+ .lock()
+ .unwrap_or_else(|poisoned| poisoned.into_inner())
+ }
/// A sleeper that records durations instead of sleeping.
#[derive(Default)]
@@ -267,6 +276,52 @@ mod tests {
)
}
+ fn read_http_request(stream: &mut std::net::TcpStream) -> Option<String> {
+ use std::io::Read;
+
+ let _ = stream.set_nonblocking(false);
+ let _ = stream.set_read_timeout(Some(Duration::from_secs(2)));
+ let mut request = Vec::new();
+ let mut chunk = [0; 4096];
+
+ loop {
+ let n = stream.read(&mut chunk).ok()?;
+ if n == 0 {
+ break;
+ }
+ request.extend_from_slice(&chunk[..n]);
+
+ if let Some(header_end) = find_header_end(&request) {
+ let content_length = content_length(&request[..header_end]).unwrap_or(0);
+ if request.len() >= header_end + 4 + content_length {
+ break;
+ }
+ }
+ }
+
+ if request.is_empty() {
+ None
+ } else {
+ Some(String::from_utf8_lossy(&request).to_string())
+ }
+ }
+
+ fn find_header_end(bytes: &[u8]) -> Option<usize> {
+ bytes.windows(4).position(|window| window == b"\r\n\r\n")
+ }
+
+ fn content_length(headers: &[u8]) -> Option<usize> {
+ let text = String::from_utf8_lossy(headers);
+ text.lines().find_map(|line| {
+ let (name, value) = line.split_once(':')?;
+ if name.eq_ignore_ascii_case("content-length") {
+ value.trim().parse().ok()
+ } else {
+ None
+ }
+ })
+ }
+
impl MockDeviceServer {
fn new(scenario: DeviceScenario) -> Self {
let saw_init = Arc::new(AtomicBool::new(false));
@@ -278,30 +333,24 @@ mod tests {
let ste = saw_token_exchange.clone();
let sp = saw_poll.clone();
let sd = shutdown.clone();
- let url: Arc<std::sync::Mutex<Option<String>>> = Arc::new(std::sync::Mutex::new(None));
+ let listener = std::net::TcpListener::bind("127.0.0.1:0").expect("bind test server");
+ let addr = listener.local_addr().unwrap();
+ let url = format!("http://{addr}");
+ listener.set_nonblocking(true).expect("set nonblocking");
+ let (ready_tx, ready_rx) = std::sync::mpsc::channel();
- let url_clone = url.clone();
std::thread::spawn(move || {
- let listener =
- std::net::TcpListener::bind("127.0.0.1:0").expect("bind test server");
- let addr = listener.local_addr().unwrap();
- *url_clone.lock().unwrap() = Some(format!("http://{addr}"));
-
- listener.set_nonblocking(true).expect("set nonblocking");
-
+ let _ = ready_tx.send(());
loop {
if sd.load(Ordering::Relaxed) {
return;
}
match listener.accept() {
Ok((mut stream, _)) => {
- use std::io::{Read, Write};
- let mut buf = [0; 4096];
- let n = match stream.read(&mut buf) {
- Ok(n) if n > 0 => n,
- _ => continue,
+ use std::io::Write;
+ let Some(request) = read_http_request(&mut stream) else {
+ continue;
};
- let request = String::from_utf8_lossy(&buf[..n]);
let response = match scenario {
DeviceScenario::SuccessAfterPending => {
@@ -331,10 +380,9 @@ mod tests {
}
}
});
-
- // Wait for server to be ready
- std::thread::sleep(Duration::from_millis(100));
- let url = url.lock().unwrap().clone().unwrap();
+ ready_rx
+ .recv_timeout(Duration::from_secs(1))
+ .expect("mock device server should become ready");
Self {
url,
@@ -456,8 +504,15 @@ mod tests {
}
}
+ impl Drop for MockDeviceServer {
+ fn drop(&mut self) {
+ self.shutdown.store(true, Ordering::Relaxed);
+ }
+ }
+
#[test]
fn device_flow_success_after_pending() {
+ let _guard = device_flow_test_lock();
let server = MockDeviceServer::new(DeviceScenario::SuccessAfterPending);
let client = DeviceAuthClient::with_issuer(&server.url);
let tokens = client.run().unwrap();
@@ -470,6 +525,7 @@ mod tests {
#[test]
fn device_flow_reports_init_failure() {
+ let _guard = device_flow_test_lock();
let server = MockDeviceServer::new(DeviceScenario::InitFailure);
let err = DeviceAuthClient::with_issuer(&server.url)
.run()
@@ -483,6 +539,7 @@ mod tests {
#[test]
fn device_flow_reports_poll_failure() {
+ let _guard = device_flow_test_lock();
let server = MockDeviceServer::new(DeviceScenario::PollFailure);
let err = DeviceAuthClient::with_issuer(&server.url)
.run()
@@ -497,6 +554,7 @@ mod tests {
#[test]
fn device_flow_reports_token_exchange_failure() {
+ let _guard = device_flow_test_lock();
let server = MockDeviceServer::new(DeviceScenario::TokenExchangeFailure);
let err = DeviceAuthClient::with_issuer(&server.url)
.run()
@@ -512,6 +570,7 @@ mod tests {
#[test]
fn device_flow_times_out() {
+ let _guard = device_flow_test_lock();
let server = MockDeviceServer::new(DeviceScenario::InitThenTimeout);
let client = DeviceAuthClient {
issuer: server.url.clone(),
@@ -531,6 +590,7 @@ mod tests {
#[test]
fn device_flow_polls_403_and_continues() {
+ let _guard = device_flow_test_lock();
let saw_poll_403 = Arc::new(AtomicBool::new(false));
let saw_init = Arc::new(AtomicBool::new(false));
let saw_exchange = Arc::new(AtomicBool::new(false));
@@ -542,32 +602,27 @@ mod tests {
let sp2 = saw_second_poll.clone();
let ste = saw_exchange.clone();
let sd = shutdown.clone();
- let url: Arc<std::sync::Mutex<Option<String>>> = Arc::new(std::sync::Mutex::new(None));
- let url_clone = url.clone();
-
let poll_count = Arc::new(std::sync::atomic::AtomicU32::new(0));
let pc = poll_count.clone();
- std::thread::spawn(move || {
- let listener = std::net::TcpListener::bind("127.0.0.1:0").expect("bind");
- let addr = listener.local_addr().unwrap();
- *url_clone.lock().unwrap() = Some(format!("http://{addr}"));
-
- listener.set_nonblocking(true).expect("nonblocking");
+ let listener = std::net::TcpListener::bind("127.0.0.1:0").expect("bind");
+ let addr = listener.local_addr().unwrap();
+ let url = format!("http://{addr}");
+ listener.set_nonblocking(true).expect("nonblocking");
+ let (ready_tx, ready_rx) = std::sync::mpsc::channel();
+ std::thread::spawn(move || {
+ let _ = ready_tx.send(());
loop {
if sd.load(Ordering::Relaxed) {
return;
}
match listener.accept() {
Ok((mut stream, _)) => {
- use std::io::{Read, Write};
- let mut buf = [0; 4096];
- let n = match stream.read(&mut buf) {
- Ok(n) if n > 0 => n,
- _ => continue,
+ use std::io::Write;
+ let Some(request) = read_http_request(&mut stream) else {
+ continue;
};
- let request = String::from_utf8_lossy(&buf[..n]);
let response = if request.contains("/api/accounts/deviceauth/usercode") {
si.store(true, Ordering::Relaxed);
@@ -607,9 +662,9 @@ mod tests {
}
}
});
-
- std::thread::sleep(Duration::from_millis(100));
- let url = url.lock().unwrap().clone().unwrap();
+ ready_rx
+ .recv_timeout(Duration::from_secs(1))
+ .expect("mock device server should become ready");
let sleeper = MockSleeper::default();
let client = DeviceAuthClient {
@@ -627,10 +682,12 @@ mod tests {
assert!(saw_poll_403.load(Ordering::Relaxed));
assert!(saw_second_poll.load(Ordering::Relaxed));
assert!(saw_exchange.load(Ordering::Relaxed));
+ shutdown.store(true, Ordering::Relaxed);
}
#[test]
fn device_flow_retries_404() {
+ let _guard = device_flow_test_lock();
let saw_init = Arc::new(AtomicBool::new(false));
let saw_poll_404 = Arc::new(AtomicBool::new(false));
let saw_exchange = Arc::new(AtomicBool::new(false));
@@ -640,32 +697,27 @@ mod tests {
let sp404 = saw_poll_404.clone();
let ste = saw_exchange.clone();
let sd = shutdown.clone();
- let url: Arc<std::sync::Mutex<Option<String>>> = Arc::new(std::sync::Mutex::new(None));
- let url_clone = url.clone();
-
let poll_count = Arc::new(std::sync::atomic::AtomicU32::new(0));
let pc = poll_count.clone();
- std::thread::spawn(move || {
- let listener = std::net::TcpListener::bind("127.0.0.1:0").expect("bind");
- let addr = listener.local_addr().unwrap();
- *url_clone.lock().unwrap() = Some(format!("http://{addr}"));
-
- listener.set_nonblocking(true).expect("nonblocking");
+ let listener = std::net::TcpListener::bind("127.0.0.1:0").expect("bind");
+ let addr = listener.local_addr().unwrap();
+ let url = format!("http://{addr}");
+ listener.set_nonblocking(true).expect("nonblocking");
+ let (ready_tx, ready_rx) = std::sync::mpsc::channel();
+ std::thread::spawn(move || {
+ let _ = ready_tx.send(());
loop {
if sd.load(Ordering::Relaxed) {
return;
}
match listener.accept() {
Ok((mut stream, _)) => {
- use std::io::{Read, Write};
- let mut buf = [0; 4096];
- let n = match stream.read(&mut buf) {
- Ok(n) if n > 0 => n,
- _ => continue,
+ use std::io::Write;
+ let Some(request) = read_http_request(&mut stream) else {
+ continue;
};
- let request = String::from_utf8_lossy(&buf[..n]);
let response = if request.contains("/api/accounts/deviceauth/usercode") {
si.store(true, Ordering::Relaxed);
@@ -704,9 +756,9 @@ mod tests {
}
}
});
-
- std::thread::sleep(Duration::from_millis(100));
- let url = url.lock().unwrap().clone().unwrap();
+ ready_rx
+ .recv_timeout(Duration::from_secs(1))
+ .expect("mock device server should become ready");
let sleeper = MockSleeper::default();
let client = DeviceAuthClient {
@@ -723,6 +775,7 @@ mod tests {
assert!(saw_init.load(Ordering::Relaxed));
assert!(saw_poll_404.load(Ordering::Relaxed));
assert!(saw_exchange.load(Ordering::Relaxed));
+ shutdown.store(true, Ordering::Relaxed);
}
#[test]