fix(tests): fix concurrency issues with integration tests

Author: pulsastrix

libcoap/tests/common/mod.rs

@@ -6,6 +6,8 @@ use libcoap_rs::{CoapContext, CoapRequestHandler, CoapResource};
 use std::net::{SocketAddr, UdpSocket};
 use std::rc::Rc;
 use std::sync::atomic::{AtomicBool, Ordering};
+use std::sync::{Arc, Condvar, Mutex};
+use std::thread::JoinHandle;
 use std::time::Duration;
 
 pub(crate) fn get_unused_server_addr() -> SocketAddr {
@@ -25,6 +27,39 @@ pub(crate) fn get_unused_server_addr() -> SocketAddr {
         .expect("Failed to get server socket address")
 }
 
+/// Spawns a test server in a new thread and waits for context_configurator to complete before
+/// returning.
+/// As the context_configurator closure is responsible for binding to sockets, this can be used to
+/// spawn a test server and wait for it to be ready to accept requests before returning (avoiding
+/// test failure due to "Connection Refused" errors).
+pub(crate) fn spawn_test_server<F: FnOnce(&mut CoapContext) + Send + 'static>(
+    context_configurator: F,
+) -> JoinHandle<()> {
+    let ready_condition = Arc::new((Mutex::new(false), Condvar::new()));
+    let ready_condition2 = Arc::clone(&ready_condition);
+
+    let server_handle = std::thread::spawn(move || {
+        let (ready_var, ready_cond) = &*ready_condition2;
+        run_test_server(|context| {
+            context_configurator(context);
+            let mut ready_var = ready_var.lock().expect("ready condition mutex is poisoned");
+            *ready_var = true;
+            ready_cond.notify_all();
+        });
+    });
+
+    let (ready_var, ready_cond) = &*ready_condition;
+    drop(
+        ready_cond
+            .wait_while(ready_var.lock().expect("ready condition mutex is poisoned"), |ready| {
+                !*ready
+            })
+            .expect("ready condition mutex is poisoned"),
+    );
+    server_handle
+}
+
+/// Configures and starts a test server in the current thread.
 pub(crate) fn run_test_server<F: FnOnce(&mut CoapContext)>(context_configurator: F) {
     let mut context = CoapContext::new().unwrap();
     context_configurator(&mut context);

libcoap/tests/dtls_client_server_test.rs

@@ -1,5 +1,6 @@
 #![cfg(feature = "dtls")]
 use std::fmt::Debug;
+use std::sync::{Arc, Condvar, Mutex};
 use std::time::Duration;
 
 use libcoap_rs::crypto::{
@@ -20,6 +21,13 @@ mod common;
 struct DummyCryptoProvider;
 
 impl CoapServerCryptoProvider for DummyCryptoProvider {
+    fn provide_key_for_identity(
+        &mut self,
+        identity: &CoapCryptoPskIdentity,
+    ) -> CoapCryptoProviderResponse<Box<CoapCryptoPskData>> {
+        CoapCryptoProviderResponse::UseCurrent
+    }
+
     fn provide_default_info(&mut self) -> CoapCryptoPskInfo {
         CoapCryptoPskInfo {
             identity: String::from("dtls_test_identity").into_boxed_str().into(),
@@ -48,11 +56,9 @@ impl CoapClientCryptoProvider for DummyCryptoProvider {
 pub fn dtls_client_server_request() {
     let server_address = common::get_unused_server_addr();
 
-    let server_handle = std::thread::spawn(move || {
-        common::run_test_server(|context| {
-            context.set_server_crypto_provider(Some(Box::new(DummyCryptoProvider {})));
-            context.add_endpoint_dtls(server_address).unwrap();
-        });
+    let server_handle = common::spawn_test_server(move |context| {
+        context.set_server_crypto_provider(Some(Box::new(DummyCryptoProvider {})));
+        context.add_endpoint_dtls(server_address).unwrap();
     });
 
     let mut context = CoapContext::new().unwrap();
@@ -65,7 +71,7 @@ pub fn dtls_client_server_request() {
         for response in session.poll_handle(&req_handle) {
             assert_eq!(response.code(), CoapMessageCode::Response(CoapResponseCode::Content));
             assert_eq!(response.data().unwrap().as_ref(), "Hello World!".as_bytes());
-            server_handle.join().unwrap();
+            server_handle.join().expect("Test server crashed with failure.");
             return;
         }
     }

libcoap/tests/udp_client_server_test.rs

@@ -13,9 +13,7 @@ mod common;
 pub fn basic_client_server_request() {
     let server_address = common::get_unused_server_addr();
 
-    let server_handle = std::thread::spawn(move || {
-        common::run_test_server(|context| context.add_endpoint_udp(server_address).unwrap());
-    });
+    let server_handle = common::spawn_test_server(move |context| context.add_endpoint_udp(server_address).unwrap());
 
     let mut context = CoapContext::new().unwrap();
     let session = CoapClientSession::connect_udp(&mut context, server_address).unwrap();