Tests: run local WebRTC peers on a virtual network

The codec-negotiation and ICE/SCTP acceptance tests used real local sockets
and occasionally hit the 30 s connect timeout when the whole suite ran in
parallel. They now use webrtc-rs vnet (shared test_network helper), so they
are deterministic and the acceptance test no longer needs #[ignore].
Test-only change.

Co-Authored-By: Claude Opus 5.5 <[email protected]>
This commit is contained in:
VallierDevandClaude Opus 5.5 committed 2026-10-17 02:37:53 +08:00
1 parent b0beba1a4e
commit ce28d7e230
4 files changed
+40 -15

No files matched your search

+2
View File
@@ -25,6 +25,8 @@ mod terminal;
mod webrtc;
mod video;
mod video_track;
#[cfg(test)]
mod test_network;
mod hevc;
#[cfg(feature = "inproc-av")]
mod damage_capture;
+8 -8
View File
@@ -154,22 +154,21 @@ mod tests {
assert_eq!(rates.sample(now + std::time::Duration::from_secs(3), 0, 0), None);
}
/// Exercises actual ICE nomination and SCTP delivery between local peers, without
/// Exercises actual ICE nomination and SCTP delivery between virtual peers, without
/// login, public STUN, external endpoints or production configuration.
#[tokio::test]
#[ignore = "opens local UDP sockets; run explicitly for network acceptance"]
async fn local_selected_pair_and_payload() {
use std::sync::Arc;
use webrtc::api::{APIBuilder, setting_engine::SettingEngine};
use webrtc::api::APIBuilder;
use webrtc::peer_connection::configuration::RTCConfiguration;
let mut settings = SettingEngine::default();
// This crate excludes loopback addresses during ICE gathering. Both
// peers still run in this process and use only gathered local addresses.
settings.set_ice_multicast_dns_mode(webrtc::ice::mdns::MulticastDnsMode::Disabled);
let (left_setting, right_setting, router) = crate::test_network::virtual_network().await;
let mut media = webrtc::api::media_engine::MediaEngine::default();
media.register_default_codecs().unwrap();
let api = APIBuilder::new().with_media_engine(media).with_setting_engine(settings).build();
let api = APIBuilder::new().with_media_engine(media).with_setting_engine(left_setting).build();
let left = Arc::new(api.new_peer_connection(RTCConfiguration::default()).await.unwrap());
let mut media = webrtc::api::media_engine::MediaEngine::default();
media.register_default_codecs().unwrap();
let api = APIBuilder::new().with_media_engine(media).with_setting_engine(right_setting).build();
let right = Arc::new(api.new_peer_connection(RTCConfiguration::default()).await.unwrap());
for (label, peer) in [("left", &left), ("right", &right)] {
peer.on_peer_connection_state_change(Box::new(move |state| {
@@ -222,6 +221,7 @@ mod tests {
let outcome = tokio::time::timeout(std::time::Duration::from_secs(15), acceptance).await;
left.close().await.unwrap();
right.close().await.unwrap();
router.lock().await.stop().await.unwrap();
outcome.expect("isolated local ICE/SCTP did not connect within 15 seconds");
}
}
+26
View File
@@ -0,0 +1,26 @@
use std::sync::Arc;
use tokio::sync::Mutex;
use webrtc::{api::setting_engine::SettingEngine, ice::{mdns::MulticastDnsMode, network_type::NetworkType},
util::vnet::{net::{Net, NetConfig}, router::{Router, RouterConfig}}};
pub(crate) async fn virtual_network() -> (SettingEngine, SettingEngine, Arc<Mutex<Router>>) {
// Each pair owns its router and address space; no host interfaces or sockets are used.
let router = Arc::new(Mutex::new(Router::new(RouterConfig {
cidr: "192.0.2.0/24".into(), ..Default::default()
}).unwrap()));
let mut settings = Vec::new();
for ip in ["192.0.2.1", "192.0.2.2"] {
let net = Arc::new(Net::new(Some(NetConfig { static_ips: vec![ip.into()], ..Default::default() })));
let nic = net.get_nic().unwrap();
router.lock().await.add_net(nic.clone()).await.unwrap();
nic.lock().await.set_router(router.clone()).await.unwrap();
let mut setting = SettingEngine::default();
setting.set_vnet(Some(net));
setting.set_network_types(vec![NetworkType::Udp4]);
setting.set_ice_multicast_dns_mode(MulticastDnsMode::Disabled);
settings.push(setting);
}
router.lock().await.start().await.unwrap();
let right = settings.pop().unwrap();
(settings.pop().unwrap(), right, router)
}
+4 -7
View File
@@ -105,15 +105,11 @@ mod tests {
sdp_fmtp_line: "level-asymmetry-allowed=1;packetization-mode=1;profile-level-id=42e01f".into(), ..Default::default()
}, payload_type: 102, ..Default::default() }, RTPCodecType::Video).unwrap(); }
if hevc { register_hevc(&mut remote_media).unwrap(); }
let mut setting = webrtc::api::setting_engine::SettingEngine::default();
setting.set_ice_multicast_dns_mode(webrtc::ice::mdns::MulticastDnsMode::Disabled);
// UDP over IPv4 only: pairing every host interface (VPNs, IPv6) made ICE exceed the
// connect timeout when the whole suite runs in parallel.
setting.set_network_types(vec![webrtc::ice::network_type::NetworkType::Udp4]);
let remote = APIBuilder::new().with_setting_engine(setting.clone()).with_media_engine(remote_media).build().new_peer_connection(RTCConfiguration::default()).await.unwrap();
let (remote_setting, host_setting, router) = crate::test_network::virtual_network().await;
let remote = APIBuilder::new().with_setting_engine(remote_setting).with_media_engine(remote_media).build().new_peer_connection(RTCConfiguration::default()).await.unwrap();
remote.add_transceiver_from_kind(RTPCodecType::Video, None).await.unwrap();
let mut media = MediaEngine::default(); media.register_default_codecs().unwrap(); register_hevc(&mut media).unwrap();
let host = APIBuilder::new().with_setting_engine(setting).with_media_engine(media).build().new_peer_connection(RTCConfiguration::default()).await.unwrap();
let host = APIBuilder::new().with_setting_engine(host_setting).with_media_engine(media).build().new_peer_connection(RTCConfiguration::default()).await.unwrap();
let (packets_tx, mut packets_rx) = tokio::sync::mpsc::unbounded_channel();
remote.on_track(Box::new(move |remote_track, _, _| {
let packets_tx = packets_tx.clone();
@@ -171,6 +167,7 @@ mod tests {
previous = Some(packet);
}
host.close().await.unwrap(); remote.close().await.unwrap();
router.lock().await.stop().await.unwrap();
}
#[tokio::test]
async fn negotiated_codecs_only_and_legacy_h264_offer() { negotiate(true, false).await; negotiate(true, true).await; negotiate(false, true).await; }