moq-native: e2e test for Lite05 TrackConsumer::info() over a session

Resolves a track's immutable properties via a TRACK stream (info(), no
subscription), then subscribes and reads a frame. Guards the on-demand
info path end-to-end ahead of the model refactor.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: kixelated

rs/moq-native/tests/broadcast.rs

@@ -227,6 +227,104 @@ async fn broadcast_moq_lite_05_timestamps_webtransport() {
 	lite05_timestamp_roundtrip("https").await;
 }
 
+/// Lite05 Track Stream: the client resolves a track's immutable properties via
+/// `info()` (a TRACK request answered with TRACK_INFO) without subscribing, then
+/// subscribes and reads a frame. Exercises the on-demand info path end-to-end.
+async fn lite05_info_roundtrip(scheme: &str) {
+	use moq_native::moq_net::Timescale;
+
+	let pub_origin = Origin::random().produce();
+	let mut broadcast = pub_origin.create_broadcast("test").expect("create broadcast");
+	let mut track = broadcast
+		.create_track(Track::new("video").with_timescale(Timescale::MICRO))
+		.expect("create track");
+
+	let mut group = track.append_group().expect("append group");
+	let frame = moq_native::moq_net::Frame {
+		size: 5,
+		timestamp: Some(moq_native::moq_net::Timestamp::new(10_000, Timescale::MICRO).unwrap()),
+	};
+	let mut writer = group.create_frame(frame).expect("create frame");
+	writer.write(bytes::Bytes::from_static(b"hello")).expect("write frame");
+	writer.finish().expect("finish frame");
+	group.finish().expect("finish group");
+
+	let mut server_config = moq_native::ServerConfig::default();
+	server_config.bind = Some("[::]:0".to_string());
+	server_config.tls.generate = vec!["localhost".into()];
+	server_config.version = vec!["moq-lite-05-wip".parse().unwrap()];
+	let mut server = server_config.init().expect("init server");
+	let addr = server.local_addr().expect("local addr");
+
+	let sub_origin = Origin::random().produce();
+	let mut announcements = sub_origin.consume().announced();
+
+	let mut client_config = moq_native::ClientConfig::default();
+	client_config.tls.disable_verify = Some(true);
+	client_config.version = vec!["moq-lite-05-wip".parse().unwrap()];
+	let client = client_config.init().expect("init client");
+	let url: url::Url = format!("{scheme}://localhost:{}", addr.port()).parse().unwrap();
+
+	let server_handle = tokio::spawn(async move {
+		let request = server.accept().await.expect("no incoming connection");
+		let session = request.with_publisher(pub_origin.clone()).ok().await?;
+		let _broadcast = broadcast;
+		let _track = track;
+		let _ = session.closed().await;
+		Ok::<_, anyhow::Error>(())
+	});
+
+	let client = client.with_consumer(sub_origin);
+	let session = tokio::time::timeout(TIMEOUT, client.connect(url))
+		.await
+		.expect("client connect timed out")
+		.expect("client connect failed");
+
+	let (path, bc) = tokio::time::timeout(TIMEOUT, announcements.next())
+		.await
+		.expect("announce timed out")
+		.expect("origin closed");
+	assert_eq!(path.as_str(), "test");
+	let bc = bc.broadcast().expect("expected announce, got unannounce");
+
+	// Resolve the track's immutable info without subscribing.
+	let info = tokio::time::timeout(TIMEOUT, bc.consume_track("video").info())
+		.await
+		.expect("info timed out")
+		.expect("info failed");
+	assert_eq!(info.timescale, Some(Timescale::MICRO));
+
+	// A subscribe still works (and reuses the now-cached info).
+	let mut track_sub = bc
+		.consume_track("video")
+		.subscribe(None)
+		.await
+		.expect("subscribe failed");
+	let mut group_sub = tokio::time::timeout(TIMEOUT, track_sub.recv_group())
+		.await
+		.expect("recv_group timed out")
+		.expect("recv_group failed")
+		.expect("track closed prematurely");
+	let frame = tokio::time::timeout(TIMEOUT, group_sub.read_frame())
+		.await
+		.expect("read_frame timed out")
+		.expect("read_frame failed")
+		.expect("group closed prematurely");
+	assert_eq!(&*frame, b"hello");
+
+	drop(session);
+	server_handle
+		.await
+		.expect("server task panicked")
+		.expect("server task failed");
+}
+
+#[tracing_test::traced_test]
+#[tokio::test]
+async fn broadcast_moq_lite_05_info_webtransport() {
+	lite05_info_roundtrip("https").await;
+}
+
 /// On Lite05 a publisher that doesn't advertise a timescale still works:
 /// SUBSCRIBE_OK carries `timescale = 0` and neither side encodes a
 /// per-frame timestamp byte. Subscribers receive `frame.timestamp = None`.