Skip to content

armgit / moli

Public Imported from GitHub
0

Best headless browser for AI agents. Lite, Fast, High-Compatibility. Built in Rust

test(renderer): make WebCrypto dispatch check deterministic

ldm0b1a3d2465473
diff --git a/moli-renderer-v8/src/context_bootstrap/crypto/subtle/tasks.rs b/moli-renderer-v8/src/context_bootstrap/crypto/subtle/tasks.rs
index e78ef4599..2c75cba5c 100644
--- a/moli-renderer-v8/src/context_bootstrap/crypto/subtle/tasks.rs
+++ b/moli-renderer-v8/src/context_bootstrap/crypto/subtle/tasks.rs
@@ -140,3 +140,90 @@ pub(crate) fn spawn_webcrypto_result_task<F>(
completion_tx.send(result);
});
}
+
+#[cfg(test)]
+mod tests {
+ use std::sync::mpsc;
+ use std::time::Duration;
+
+ use super::*;
+
+ const DISPATCH_TIMEOUT: Duration = Duration::from_secs(5);
+
+ #[test]
+ fn webcrypto_bytes_tasks_start_independently_on_the_blocking_pool() {
+ let runtime = tokio::runtime::Builder::new_current_thread()
+ .max_blocking_threads(2)
+ .enable_time()
+ .build()
+ .expect("WebCrypto dispatch test runtime should build");
+ let handle = runtime.handle().clone();
+ let (completion_tx, mut completion_rx) = tokio::sync::mpsc::unbounded_channel();
+ let (started_tx, started_rx) = mpsc::channel();
+ let mut release_txs = Vec::new();
+
+ for (task_id, byte) in [(1_u64, 1_u8), (2, 2)] {
+ let (release_tx, release_rx) = mpsc::channel();
+ release_txs.push(release_tx);
+ let started_tx = started_tx.clone();
+ spawn_webcrypto_bytes_task(
+ handle.clone(),
+ WebCryptoCompletionSink::Worker {
+ task_id,
+ tx: completion_tx.clone(),
+ },
+ move || {
+ started_tx
+ .send(task_id)
+ .expect("dispatch test should still receive task starts");
+ release_rx
+ .recv()
+ .expect("dispatch test should release each blocking task");
+ Ok(vec![byte])
+ },
+ );
+ }
+ drop(started_tx);
+ drop(completion_tx);
+
+ // Hold both operations open and require both blocking closures to
+ // start before either is allowed to finish. Unlike a wall-clock
+ // speedup assertion, this observes independent dispatch directly and
+ // remains valid on a single-CPU or heavily loaded runner.
+ let mut started_task_ids = Vec::new();
+ for _ in 0..2 {
+ if let Ok(task_id) = started_rx.recv_timeout(DISPATCH_TIMEOUT) {
+ started_task_ids.push(task_id);
+ }
+ }
+ for release_tx in release_txs {
+ release_tx
+ .send(())
+ .expect("blocking task should remain live until release");
+ }
+ started_task_ids.sort_unstable();
+ assert_eq!(
+ started_task_ids,
+ vec![1, 2],
+ "both WebCrypto operations must enter the blocking pool before either completes"
+ );
+
+ let mut completed_task_ids = runtime.block_on(async {
+ tokio::time::timeout(DISPATCH_TIMEOUT, async {
+ let first = completion_rx
+ .recv()
+ .await
+ .expect("first WebCrypto completion should arrive");
+ let second = completion_rx
+ .recv()
+ .await
+ .expect("second WebCrypto completion should arrive");
+ [first.task_id, second.task_id]
+ })
+ .await
+ .expect("independently dispatched WebCrypto tasks should complete")
+ });
+ completed_task_ids.sort_unstable();
+ assert_eq!(completed_task_ids, [1, 2]);
+ }
+}
diff --git a/moli-renderer-v8/src/worker/thread/tests/postmessage.rs b/moli-renderer-v8/src/worker/thread/tests/postmessage.rs
index 5b91c465a..52630eb37 100644
--- a/moli-renderer-v8/src/worker/thread/tests/postmessage.rs
+++ b/moli-renderer-v8/src/worker/thread/tests/postmessage.rs
@@ -275,45 +275,6 @@ async fn worker_crypto_subtle_derive_bits_does_not_block_event_loop() {
assert_eq!(payload, r#""timer-first""#);
}
-#[tokio::test]
-async fn worker_crypto_subtle_derive_bits_runs_concurrently_on_blocking_pool() {
- ensure_v8();
- // The worker async lane dispatches each heavy derivation to the blocking
- // pool, so multiple in-flight deriveBits run in parallel rather than
- // serializing on the worker event loop. Running 8 expensive derivations
- // concurrently must be far cheaper than 8x a single derivation; assert it
- // stays under 4x the serial cost (generous slack for loaded CI, but well
- // below the ~8x a serial implementation would require).
- let mut handle = spawn_worker(
- r#"
- (async () => {
- const enc = new TextEncoder();
- const baseKey = await crypto.subtle.importKey(
- "raw", enc.encode("password"), { name: "PBKDF2" }, false, ["deriveBits"]
- );
- const one = () => crypto.subtle.deriveBits(
- { name: "PBKDF2", salt: enc.encode("salt"), iterations: 1000000, hash: "SHA-256" },
- baseKey, 256
- );
- const serialStart = performance.now();
- await one();
- const serialMs = performance.now() - serialStart;
- const concurrentStart = performance.now();
- await Promise.all([one(), one(), one(), one(), one(), one(), one(), one()]);
- const concurrentMs = performance.now() - concurrentStart;
- postMessage(concurrentMs < serialMs * 4 ? "concurrent" : "serial:" + serialMs + ":" + concurrentMs);
- })().catch((error) => {
- postMessage("error:" + error.name + ":" + error.message);
- });
- "#
- .into(),
- "https://worker-crypto.test/subtle-derive-bits-concurrent.js".into(),
- );
-
- let payload = recv_post_json(&mut handle).await;
- assert_eq!(payload, r#""concurrent""#);
-}
-
#[tokio::test]
async fn worker_crypto_subtle_derive_bits_processes_incoming_message_while_pending() {
ensure_v8();