[bfops/wasm-test]: wait_for_all funcs

Author: bfops

sdks/rust/tests/test-counter/src/lib.rs

@@ -1,10 +1,9 @@
 #![allow(clippy::disallowed_macros)]
 
 use spacetimedb_data_structures::map::{HashMap, HashSet};
-use std::{
-    sync::{Arc, Condvar, Mutex},
-    time::Duration,
-};
+use std::sync::{Arc, Condvar, Mutex};
+#[cfg(not(target_arch = "wasm32"))]
+use std::time::Duration;
 
 const TEST_TIMEOUT_SECS: u64 = 5 * 60;
 
@@ -55,7 +54,31 @@ impl TestCounter {
         })
     }
 
+    // Keep this legacy sync API for existing native-first callers.
+    // wasm callers should prefer `wait_for_all_async` so we do not
+    // block the JS event loop while waiting for callbacks.
     pub fn wait_for_all(&self) {
+        #[cfg(target_arch = "wasm32")]
+        futures::executor::block_on(self.wait_for_all_wasm_async());
+
+        #[cfg(not(target_arch = "wasm32"))]
+        self.wait_for_all_native();
+    }
+
+    pub async fn wait_for_all_async(&self) {
+        #[cfg(target_arch = "wasm32")]
+        {
+            // wasm/web test clients run callbacks on a single-threaded event loop,
+            // so waiting must be async to allow callback tasks to make progress.
+            self.wait_for_all_wasm_async().await;
+        }
+
+        #[cfg(not(target_arch = "wasm32"))]
+        self.wait_for_all_native();
+    }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    fn wait_for_all_native(&self) {
         let lock = self.inner.lock().expect("TestCounterInner Mutex is poisoned");
         let (lock, timeout_result) = self
             .wait_until_done
@@ -100,4 +123,65 @@ impl TestCounter {
             }
         }
     }
+
+    #[cfg(target_arch = "wasm32")]
+    async fn wait_for_all_wasm_async(&self) {
+        use gloo_timers::future::TimeoutFuture;
+
+        const WAIT_INTERVAL_MS: u32 = 10;
+        const MAX_WAIT_ITERATIONS: u32 = (TEST_TIMEOUT_SECS as u32 * 1000) / WAIT_INTERVAL_MS;
+
+        // On wasm/web the SDK message loop runs on the same single-threaded event loop
+        // as test code. Blocking on a Condvar here can deadlock callbacks forever.
+        // We poll with timer yields so websocket/callback tasks can continue to run.
+        let all_tests_finished = || {
+            let inner = self.inner.lock().expect("TestCounterInner Mutex is poisoned");
+            inner.outcomes.len() == inner.registered.len()
+        };
+
+        for _ in 0..MAX_WAIT_ITERATIONS {
+            if all_tests_finished() {
+                return;
+            }
+            TimeoutFuture::new(WAIT_INTERVAL_MS).await;
+        }
+
+        let lock = self.inner.lock().expect("TestCounterInner Mutex is poisoned");
+        if lock.outcomes.len() != lock.registered.len() {
+            let mut timeout_count = 0;
+            let mut failed_count = 0;
+            for test in lock.registered.iter() {
+                match lock.outcomes.get(test) {
+                    None => {
+                        timeout_count += 1;
+                        println!("TIMEOUT: {test}");
+                    }
+                    Some(Err(e)) => {
+                        failed_count += 1;
+                        println!("FAILED:  {test}:\n\t{e:?}\n");
+                    }
+                    Some(Ok(())) => {
+                        println!("PASSED:  {test}");
+                    }
+                }
+            }
+            panic!("{timeout_count} tests timed out and {failed_count} tests failed");
+        } else {
+            let mut failed_count = 0;
+            for (test, outcome) in lock.outcomes.iter() {
+                match outcome {
+                    Ok(()) => println!("PASSED: {test}"),
+                    Err(e) => {
+                        failed_count += 1;
+                        println!("FAILED: {test}:\n\t{e:?}\n");
+                    }
+                }
+            }
+            if failed_count != 0 {
+                panic!("{failed_count} tests failed");
+            } else {
+                println!("All tests passed");
+            }
+        }
+    }
 }