From 5d9dc16341ce1c6d22745fa9612897e0a1fef7ae Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Mon, 12 Oct 2026 21:51:48 -0700 Subject: [PATCH] test(net): make session poll counting opt-in Run ordinary mock drivers without instrumentation and let the idle regression supply its own counter. Assert that an opted-in counter actually observes driver polls. Co-Authored-By: GPT-6 --- rs/moq-net/tests/idle_session.rs | 23 ++++++++++++++++++----- rs/moq-net/tests/support/harness.rs | 27 ++++++++++----------------- 2 files changed, 28 insertions(+), 22 deletions(-) diff --git a/rs/moq-net/tests/idle_session.rs b/rs/moq-net/tests/idle_session.rs index 15c6084c3e2..61ce06e0d1c 100644 --- a/rs/moq-net/tests/idle_session.rs +++ b/rs/moq-net/tests/idle_session.rs @@ -4,7 +4,13 @@ mod support; -use std::{sync::atomic::Ordering, time::Duration}; +use std::{ + sync::{ + Arc, + atomic::{AtomicUsize, Ordering}, + }, + time::Duration, +}; use moq_net::{Hop, Version, bandwidth::Rate, origin}; use support::harness::{MockConnectOptions, MockPair, connect_mock}; @@ -24,11 +30,16 @@ const STATS: MockStats = MockStats { /// A viewer session whose server publishes `origin`, with the viewer's PROBE /// stream open (as a browser viewer keeps one) and its first report received. -async fn viewer(version: &str, origin: &origin::Producer) -> (MockPair, moq_net::bandwidth::Consumer) { +async fn viewer( + version: &str, + origin: &origin::Producer, + polls: Option>, +) -> (MockPair, moq_net::bandwidth::Consumer) { let mut options = MockConnectOptions::new(version.parse::().unwrap()); options.server_publish = Some(origin.consume()); options.client_subscribe = Some(origin::Producer::new(origin::Config::new(Hop::new(2).unwrap())).0); options.stats = STATS; + options.server_polls = polls; let pair = connect_mock(options).await; let mut probe = pair.client.recv_bandwidth().expect("lite carries PROBE"); @@ -47,10 +58,12 @@ fn origin() -> origin::Producer { async fn idle_viewer_does_not_wake_the_server() { for version in VERSIONS { let origin = origin(); - let (pair, _probe) = viewer(version, &origin).await; + let polls = Arc::new(AtomicUsize::new(0)); + let (pair, _probe) = viewer(version, &origin, Some(polls.clone())).await; - let (polls, reads) = (&pair.server_polls, &pair.server_transport); + let reads = &pair.server_transport; let (start_polls, start_reads) = (polls.load(Ordering::Relaxed), reads.stats_reads()); + assert!(start_polls > 0, "the requested poll counter must observe the handshake"); moq_net_sim::sleep(IDLE).await; let polls = polls.load(Ordering::Relaxed) - start_polls; let reads = reads.stats_reads() - start_reads; @@ -69,7 +82,7 @@ async fn idle_viewer_does_not_wake_the_server() { async fn busy_viewer_sees_the_estimate_move() { for version in VERSIONS { let origin = origin(); - let (pair, mut probe) = viewer(version, &origin).await; + let (pair, mut probe) = viewer(version, &origin, None).await; pair.server_transport.set_stats(MockStats { estimated_send_rate: Some(2_000_000), diff --git a/rs/moq-net/tests/support/harness.rs b/rs/moq-net/tests/support/harness.rs index b30e2e0814c..3d9ad90e36a 100644 --- a/rs/moq-net/tests/support/harness.rs +++ b/rs/moq-net/tests/support/harness.rs @@ -26,24 +26,13 @@ pub fn now() -> moq_net::time::Instant { /// Run a protocol driver in the background: on `moq_net_sim` in tests, on tokio in /// the benches. -pub fn spawn(driver: D) { - spawn_counted(driver); -} - -/// [`spawn`], returning how many times the driver has been polled. -pub fn spawn_counted(driver: D) -> Arc { - let polls = Arc::new(AtomicUsize::new(0)); - let mut driver = Counted { - driver, - polls: polls.clone(), - }; +pub fn spawn(mut driver: D) { match moq_net_sim::is_running() { true => drop(moq_net_sim::spawn(moq_net_sim::drive(move |now, waiter| { moq_net::time::Driver::poll(&mut driver, now, waiter) }))), false => drop(tokio::spawn(moq_net::time::run(driver))), } - polls } struct Counted { @@ -93,6 +82,8 @@ pub struct MockConnectOptions { pub cost: Option, /// What both transports report as their connection statistics. pub stats: MockStats, + /// Count server driver polls into this counter when supplied. + pub server_polls: Option>, } impl MockConnectOptions { @@ -110,6 +101,7 @@ impl MockConnectOptions { server_extensions: Default::default(), cost: None, stats: MockStats::default(), + server_polls: None, } } } @@ -123,8 +115,6 @@ pub struct MockPair { pub client_transport: MockSession, /// The server's end of the mock transport, for steering delivery. pub server_transport: MockSession, - /// How many times the server's driver has been polled. - pub server_polls: Arc, } /// Run the MoQ handshake over the mock transport, returning connected sessions. @@ -187,16 +177,19 @@ pub async fn connect_mock(opts: MockConnectOptions) -> MockPair { .accept(now(), server_transport) .await .expect("server handshake failed"); - (session, spawn_counted(driver)) + match opts.server_polls { + Some(polls) => spawn(Counted { driver, polls }), + None => spawn(driver), + } + session }; - let (client_session, (server_session, server_polls)) = futures::join!(client_fut, server_fut); + let (client_session, server_session) = futures::join!(client_fut, server_fut); MockPair { client: client_session, server: server_session, client_transport: transports.0, server_transport: transports.1, - server_polls, } }