From b6431b7fe4ac46222905c07a0d1f53955ce7c1bd Mon Sep 17 00:00:00 2001 From: OneTooMany Date: Tue, 6 Oct 2026 11:38:29 +0200 Subject: [PATCH 1/2] test(net): a reader leaving after the cache window keeps the relay's latest group Co-Authored-By: Claude Opus 5.5 --- rs/moq-net/tests/rejoin.rs | 75 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 75 insertions(+) diff --git a/rs/moq-net/tests/rejoin.rs b/rs/moq-net/tests/rejoin.rs index afea8c5d6e1..edd60710880 100644 --- a/rs/moq-net/tests/rejoin.rs +++ b/rs/moq-net/tests/rejoin.rs @@ -325,3 +325,78 @@ async fn rejoin_goes_live_without_the_join_head() { .unwrap_or_else(|_| panic!("{version}: timed out")); } } + +/// A reader leaving long after its last read leaves the relay holding the latest group. +/// +/// A catalog's latest group can sit unread past the cache's idle expiry. A downstream +/// session that read it and then leaves must not take the relay's copy of that group with +/// it: a reader that joins afterwards needs it, and no newer group may ever come. +#[tokio::test(start_paused = true)] +async fn leaving_after_the_cache_window_keeps_the_latest_group() { + for version in [ + "moq-lite-05", + "moq-lite-06", + "moq-lite-07-wip", + "moq-transport-19", + "moq-transport-22", + ] { + tokio::time::timeout(TEST_TIMEOUT + moq_net::cache::DEFAULT_EXPIRY * 2, async { + let version: Version = version.parse().unwrap(); + let publisher = produce_origin(1); + let relay = produce_origin(2); + + let broadcast = publisher.create_broadcast("bench").unwrap(); + let track = broadcast.create_track("catalog", None).unwrap(); + broadcast.announce(Default::default()).unwrap(); + let mut group = track.append_group().unwrap(); + group.write_frame(Timestamp::ZERO, b"c0".as_ref()).unwrap(); + group.finish().unwrap(); + + let mut options = MockConnectOptions::new(version); + options.server_publish = Some(publisher.consume()); + options.client_subscribe = Some(relay.clone()); + let _upstream = connect_mock(options).await; + + // Each session gets its own hop, so the relay serves it through its own front. + let session = |hop| { + let relay = relay.clone(); + async move { + let client = produce_origin(hop); + let mut options = MockConnectOptions::new(version); + options.server_publish = Some(relay.consume()); + options.client_subscribe = Some(client.clone()); + let pair = connect_mock(options).await; + let consumer = client.consume(); + consumer.routed("bench").await.unwrap(); + let remote = consumer.request_broadcast("bench").await.unwrap(); + (remote, pair) + } + }; + + // Holds the relay's upstream subscription, and its copy, open throughout. + let (holder, _holder) = session(3).await; + let mut held = holder.track("catalog").unwrap().subscribe(None).await.unwrap(); + assert_eq!(held.recv_group().await.unwrap().unwrap().sequence, 0, "{version}"); + + let (leaver, leaver_session) = session(4).await; + let mut sub = leaver.track("catalog").unwrap().subscribe(None).await.unwrap(); + let mut group = sub.recv_group().await.unwrap().unwrap(); + assert_eq!(read_all(&mut group).await.unwrap(), [b"c0"], "{version}"); + tokio::time::sleep(moq_net::cache::DEFAULT_EXPIRY * 2).await; + drop((group, sub, leaver, leaver_session)); + tokio::time::sleep(Duration::from_millis(100)).await; + + let (later, _later) = session(5).await; + let mut sub = later.track("catalog").unwrap().subscribe(None).await.unwrap(); + let group = tokio::time::timeout(Duration::from_secs(1), sub.recv_group()).await; + let mut group = group + .unwrap_or_else(|_| panic!("{version}: the later reader never got the latest group")) + .unwrap() + .unwrap(); + assert_eq!(group.sequence, 0, "{version}"); + assert_eq!(read_all(&mut group).await.unwrap(), [b"c0"], "{version}"); + }) + .await + .unwrap_or_else(|_| panic!("{version}: timed out")); + } +} From a5f6373c8e70aabcfb064d97c8e4e1730dfa023b Mon Sep 17 00:00:00 2001 From: OneTooMany Date: Tue, 6 Oct 2026 12:50:03 +0200 Subject: [PATCH 2/2] test(net): also read the latest group after the leaver's front lets go Co-Authored-By: Claude Opus 5.5 --- rs/moq-net/tests/rejoin.rs | 29 ++++++++++++++++++----------- 1 file changed, 18 insertions(+), 11 deletions(-) diff --git a/rs/moq-net/tests/rejoin.rs b/rs/moq-net/tests/rejoin.rs index edd60710880..d82c7692be0 100644 --- a/rs/moq-net/tests/rejoin.rs +++ b/rs/moq-net/tests/rejoin.rs @@ -340,7 +340,7 @@ async fn leaving_after_the_cache_window_keeps_the_latest_group() { "moq-transport-19", "moq-transport-22", ] { - tokio::time::timeout(TEST_TIMEOUT + moq_net::cache::DEFAULT_EXPIRY * 2, async { + tokio::time::timeout(TEST_TIMEOUT + moq_net::cache::DEFAULT_EXPIRY * 3, async { let version: Version = version.parse().unwrap(); let publisher = produce_origin(1); let relay = produce_origin(2); @@ -384,17 +384,24 @@ async fn leaving_after_the_cache_window_keeps_the_latest_group() { assert_eq!(read_all(&mut group).await.unwrap(), [b"c0"], "{version}"); tokio::time::sleep(moq_net::cache::DEFAULT_EXPIRY * 2).await; drop((group, sub, leaver, leaver_session)); - tokio::time::sleep(Duration::from_millis(100)).await; - let (later, _later) = session(5).await; - let mut sub = later.track("catalog").unwrap().subscribe(None).await.unwrap(); - let group = tokio::time::timeout(Duration::from_secs(1), sub.recv_group()).await; - let mut group = group - .unwrap_or_else(|_| panic!("{version}: the later reader never got the latest group")) - .unwrap() - .unwrap(); - assert_eq!(group.sequence, 0, "{version}"); - assert_eq!(read_all(&mut group).await.unwrap(), [b"c0"], "{version}"); + // Right after the leave, and again once the leaver's front has lingered and let go + // of the track (`IDLE_LINGER` is as long as the cache window). + for (hop, after) in [ + (5, Duration::from_millis(100)), + (6, moq_net::cache::DEFAULT_EXPIRY + Duration::from_secs(1)), + ] { + tokio::time::sleep(after).await; + let (later, _later) = session(hop).await; + let mut sub = later.track("catalog").unwrap().subscribe(None).await.unwrap(); + let group = tokio::time::timeout(Duration::from_secs(1), sub.recv_group()).await; + let mut group = group + .unwrap_or_else(|_| panic!("{version}: reader {hop} never got the latest group")) + .unwrap() + .unwrap(); + assert_eq!(group.sequence, 0, "{version}"); + assert_eq!(read_all(&mut group).await.unwrap(), [b"c0"], "{version}"); + } }) .await .unwrap_or_else(|_| panic!("{version}: timed out"));