Skip to content

Commit 8edaee9

Browse files
test(iroh-relay, netcheck): move tests to use local relays (#2935)
## Description Removes `netcheck`'s dependency on staging relays, using locally served ones instead. This is necessary to move netcheck out without needing to find an appropriate place for the staging values to prevent circular dependecies ## Breaking Changes - `RelayMap` now can be created with an iterator of `Arc`s directly. ## Notes & open questions - a test was removed since it doesn't test properties of netcheck, it just connects to the staging relay - `iroh-relay/src/server/testing.rs` was added by mistake in the split pr, so the deletions are not really picked by rust and all new code should be considered.. well, new. ## Change checklist - [x] Self-review. - [ ] ~~Documentation updates following the [style guide](https://rust-lang.github.io/rfcs/1574-more-api-documentation-conventions.html#appendix-a-full-conventions-text), if relevant.~~ - [ ] ~~Tests if relevant.~~ - [ ] ~~All breaking changes documented.~~
1 parent fbcb056 commit 8edaee9

File tree

7 files changed

+178
-187
lines changed

7 files changed

+178
-187
lines changed

iroh-net/Cargo.toml

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -163,6 +163,7 @@ iroh-net = { path = "." }
163163
serde_json = "1.0.107"
164164
testresult = "0.4.0"
165165
mainline = "2.0.1"
166+
iroh-relay = { version = "0.28", path = "../iroh-relay", features = ["test-utils", "server"] }
166167

167168
[[bench]]
168169
name = "key"

iroh-net/src/netcheck.rs

Lines changed: 41 additions & 58 deletions
Original file line numberDiff line numberDiff line change
@@ -769,6 +769,46 @@ pub(crate) fn os_has_ipv6() -> bool {
769769
UdpSocket::bind_local_v6(0).is_ok()
770770
}
771771

772+
#[cfg(test)]
773+
mod test_utils {
774+
//! Creates a relay server against which to perform tests
775+
776+
use std::sync::Arc;
777+
778+
use iroh_relay::server;
779+
780+
use crate::RelayNode;
781+
782+
pub(crate) async fn relay() -> (server::Server, Arc<RelayNode>) {
783+
let server = server::Server::spawn(server::testing::server_config())
784+
.await
785+
.expect("should serve relay");
786+
let node_desc = RelayNode {
787+
url: server.https_url().expect("should work as relay"),
788+
stun_only: false, // the checks above and below guarantee both stun and relay
789+
stun_port: server.stun_addr().expect("server should serve stun").port(),
790+
};
791+
792+
(server, Arc::new(node_desc))
793+
}
794+
795+
/// Create a [`crate::RelayMap`] of the given size.
796+
///
797+
/// This function uses [`relay`]. Note that the returned map uses internal order that will
798+
/// often _not_ match the order of the servers.
799+
pub(crate) async fn relay_map(relays: usize) -> (Vec<server::Server>, crate::RelayMap) {
800+
let mut servers = Vec::with_capacity(relays);
801+
let mut nodes = Vec::with_capacity(relays);
802+
for _ in 0..relays {
803+
let (relay_server, node) = relay().await;
804+
servers.push(relay_server);
805+
nodes.push(node);
806+
}
807+
let map = crate::RelayMap::from_nodes(nodes).expect("unuque urls");
808+
(servers, map)
809+
}
810+
}
811+
772812
#[cfg(test)]
773813
mod tests {
774814
use std::net::Ipv4Addr;
@@ -778,11 +818,7 @@ mod tests {
778818
use tracing::info;
779819

780820
use super::*;
781-
use crate::{
782-
defaults::{staging::EU_RELAY_HOSTNAME, DEFAULT_STUN_PORT},
783-
ping::Pinger,
784-
RelayNode,
785-
};
821+
use crate::ping::Pinger;
786822

787823
mod stun_utils {
788824
//! Utils for testing that expose a simple stun server.
@@ -799,8 +835,6 @@ mod tests {
799835
use super::*;
800836
use crate::{RelayMap, RelayNode, RelayUrl};
801837

802-
// TODO: make all this private
803-
804838
/// A drop guard to clean up test infrastructure.
805839
///
806840
/// After dropping the test infrastructure will asynchronously shutdown and release its
@@ -956,57 +990,6 @@ mod tests {
956990
Ok(())
957991
}
958992

959-
#[tokio::test]
960-
async fn test_iroh_computer_stun() -> Result<()> {
961-
let _guard = iroh_test::logging::setup();
962-
963-
let resolver = crate::dns::default_resolver().clone();
964-
let mut client = Client::new(None, resolver).context("failed to create netcheck client")?;
965-
let url: RelayUrl = format!("https://{}", EU_RELAY_HOSTNAME).parse().unwrap();
966-
967-
let dm = RelayMap::from_nodes([RelayNode {
968-
url: url.clone(),
969-
stun_only: true,
970-
stun_port: DEFAULT_STUN_PORT,
971-
}])
972-
.expect("hardcoded");
973-
974-
for i in 0..10 {
975-
println!("starting report {}", i + 1);
976-
let now = Instant::now();
977-
978-
let r = client
979-
.get_report(dm.clone(), None, None)
980-
.await
981-
.context("failed to get netcheck report")?;
982-
983-
if r.udp {
984-
assert_eq!(
985-
r.relay_latency.len(),
986-
1,
987-
"expected 1 key in RelayLatency; got {}",
988-
r.relay_latency.len()
989-
);
990-
assert!(
991-
r.relay_latency.iter().next().is_some(),
992-
"expected key 1 in RelayLatency; got {:?}",
993-
r.relay_latency
994-
);
995-
assert!(
996-
r.global_v4.is_some() || r.global_v6.is_some(),
997-
"expected at least one of global_v4 or global_v6"
998-
);
999-
assert!(r.preferred_relay.is_some());
1000-
} else {
1001-
eprintln!("missing UDP, probe not returned by network");
1002-
}
1003-
1004-
println!("report {} done in {:?}", i + 1, now.elapsed());
1005-
}
1006-
1007-
Ok(())
1008-
}
1009-
1010993
#[tokio::test]
1011994
async fn test_udp_blocked() -> Result<()> {
1012995
let _guard = iroh_test::logging::setup();

iroh-net/src/netcheck/reportgen.rs

Lines changed: 40 additions & 50 deletions
Original file line numberDiff line numberDiff line change
@@ -1177,101 +1177,99 @@ mod tests {
11771177

11781178
use testresult::TestResult;
11791179

1180-
use super::*;
1181-
use crate::{
1182-
defaults::staging::{default_eu_relay_node, default_na_relay_node},
1183-
test_utils,
1184-
};
1180+
use super::{super::test_utils, *};
11851181

1186-
#[test]
1187-
fn test_update_report_stun_working() {
1188-
let eu_relayer = Arc::new(default_eu_relay_node());
1189-
let na_relayer = Arc::new(default_na_relay_node());
1182+
#[tokio::test]
1183+
async fn test_update_report_stun_working() {
1184+
let _logging = iroh_test::logging::setup();
1185+
let (_server_a, relay_a) = test_utils::relay().await;
1186+
let (_server_b, relay_b) = test_utils::relay().await;
11901187

11911188
let mut report = Report::default();
11921189

1193-
// A STUN IPv4 probe from the EU relay server.
1194-
let probe_report_eu = ProbeReport {
1190+
// A STUN IPv4 probe from the the first relay server.
1191+
let probe_report_a = ProbeReport {
11951192
ipv4_can_send: true,
11961193
ipv6_can_send: false,
11971194
icmpv4: None,
11981195
icmpv6: None,
11991196
latency: Some(Duration::from_millis(5)),
12001197
probe: Probe::StunIpv4 {
12011198
delay: Duration::ZERO,
1202-
node: eu_relayer.clone(),
1199+
node: relay_a.clone(),
12031200
},
12041201
addr: Some((Ipv4Addr::new(203, 0, 113, 1), 1234).into()),
12051202
};
1206-
update_report(&mut report, probe_report_eu.clone());
1203+
update_report(&mut report, probe_report_a.clone());
12071204

12081205
assert!(report.udp);
12091206
assert_eq!(
1210-
report.relay_latency.get(&eu_relayer.url).unwrap(),
1207+
report.relay_latency.get(&relay_a.url).unwrap(),
12111208
Duration::from_millis(5)
12121209
);
12131210
assert_eq!(
1214-
report.relay_v4_latency.get(&eu_relayer.url).unwrap(),
1211+
report.relay_v4_latency.get(&relay_a.url).unwrap(),
12151212
Duration::from_millis(5)
12161213
);
12171214
assert!(report.ipv4_can_send);
12181215
assert!(!report.ipv6_can_send);
12191216

12201217
// A second STUN IPv4 probe, same external IP detected but slower.
1221-
let probe_report_na = ProbeReport {
1218+
let probe_report_b = ProbeReport {
12221219
latency: Some(Duration::from_millis(8)),
12231220
probe: Probe::StunIpv4 {
12241221
delay: Duration::ZERO,
1225-
node: na_relayer.clone(),
1222+
node: relay_b.clone(),
12261223
},
1227-
..probe_report_eu
1224+
..probe_report_a
12281225
};
1229-
update_report(&mut report, probe_report_na);
1226+
update_report(&mut report, probe_report_b);
12301227

12311228
assert!(report.udp);
12321229
assert_eq!(
1233-
report.relay_latency.get(&eu_relayer.url).unwrap(),
1230+
report.relay_latency.get(&relay_a.url).unwrap(),
12341231
Duration::from_millis(5)
12351232
);
12361233
assert_eq!(
1237-
report.relay_v4_latency.get(&eu_relayer.url).unwrap(),
1234+
report.relay_v4_latency.get(&relay_a.url).unwrap(),
12381235
Duration::from_millis(5)
12391236
);
12401237
assert!(report.ipv4_can_send);
12411238
assert!(!report.ipv6_can_send);
12421239

12431240
// A STUN IPv6 probe, this one is faster.
1244-
let probe_report_eu_ipv6 = ProbeReport {
1241+
let probe_report_a_ipv6 = ProbeReport {
12451242
ipv4_can_send: false,
12461243
ipv6_can_send: true,
12471244
icmpv4: None,
12481245
icmpv6: None,
12491246
latency: Some(Duration::from_millis(4)),
12501247
probe: Probe::StunIpv6 {
12511248
delay: Duration::ZERO,
1252-
node: eu_relayer.clone(),
1249+
node: relay_a.clone(),
12531250
},
12541251
addr: Some((Ipv6Addr::new(2001, 0xdb8, 0, 0, 0, 0, 0, 1), 1234).into()),
12551252
};
1256-
update_report(&mut report, probe_report_eu_ipv6);
1253+
update_report(&mut report, probe_report_a_ipv6);
12571254

12581255
assert!(report.udp);
12591256
assert_eq!(
1260-
report.relay_latency.get(&eu_relayer.url).unwrap(),
1257+
report.relay_latency.get(&relay_a.url).unwrap(),
12611258
Duration::from_millis(4)
12621259
);
12631260
assert_eq!(
1264-
report.relay_v6_latency.get(&eu_relayer.url).unwrap(),
1261+
report.relay_v6_latency.get(&relay_a.url).unwrap(),
12651262
Duration::from_millis(4)
12661263
);
12671264
assert!(report.ipv4_can_send);
12681265
assert!(report.ipv6_can_send);
12691266
}
12701267

1271-
#[test]
1272-
fn test_update_report_icmp() {
1273-
let eu_relayer = Arc::new(default_eu_relay_node());
1274-
let na_relayer = Arc::new(default_na_relay_node());
1268+
#[tokio::test]
1269+
async fn test_update_report_icmp() {
1270+
let _logging = iroh_test::logging::setup();
1271+
let (_server_a, relay_a) = test_utils::relay().await;
1272+
let (_server_b, relay_b) = test_utils::relay().await;
12751273

12761274
let mut report = Report::default();
12771275

@@ -1284,7 +1282,7 @@ mod tests {
12841282
latency: Some(Duration::from_millis(5)),
12851283
probe: Probe::IcmpV4 {
12861284
delay: Duration::ZERO,
1287-
node: eu_relayer.clone(),
1285+
node: relay_a.clone(),
12881286
},
12891287
addr: Some((Ipv4Addr::new(203, 0, 113, 1), 1234).into()),
12901288
};
@@ -1303,7 +1301,7 @@ mod tests {
13031301
latency: None,
13041302
probe: Probe::IcmpV4 {
13051303
delay: Duration::ZERO,
1306-
node: na_relayer.clone(),
1304+
node: relay_b.clone(),
13071305
},
13081306
addr: None,
13091307
};
@@ -1320,7 +1318,7 @@ mod tests {
13201318
latency: Some(Duration::from_millis(5)),
13211319
probe: Probe::StunIpv4 {
13221320
delay: Duration::ZERO,
1323-
node: eu_relayer.clone(),
1321+
node: relay_a.clone(),
13241322
},
13251323
addr: Some((Ipv4Addr::new(203, 0, 113, 1), 1234).into()),
13261324
};
@@ -1378,18 +1376,14 @@ mod tests {
13781376
//
13791377
// TODO: Not sure what about IPv6 pings using sysctl.
13801378
#[tokio::test]
1381-
async fn test_icmpk_probe_eu_relayer() {
1379+
async fn test_icmpk_probe() {
13821380
let _logging_guard = iroh_test::logging::setup();
13831381
let pinger = Pinger::new();
1384-
let relay = default_eu_relay_node();
1385-
let resolver = crate::dns::default_resolver();
1386-
let addr = get_relay_addr(resolver, &relay, ProbeProto::IcmpV4)
1387-
.await
1388-
.map_err(|err| format!("{err:#}"))
1389-
.unwrap();
1382+
let (server, node) = test_utils::relay().await;
1383+
let addr = server.stun_addr().expect("test relay serves stun");
13901384
let probe = Probe::IcmpV4 {
13911385
delay: Duration::from_secs(0),
1392-
node: Arc::new(relay),
1386+
node,
13931387
};
13941388

13951389
// A single ICMP packet might get lost. Try several and take the first.
@@ -1434,20 +1428,16 @@ mod tests {
14341428
#[tokio::test]
14351429
async fn test_measure_https_latency() -> TestResult {
14361430
let _logging_guard = iroh_test::logging::setup();
1437-
let (_relay_map, relay_url, server) = test_utils::run_relay_server().await?;
1431+
let (server, relay) = test_utils::relay().await;
14381432
let dns_resolver = crate::dns::resolver();
1439-
warn!(?relay_url, "RELAY_URL");
1440-
let node = RelayNode {
1441-
stun_only: false,
1442-
stun_port: 0,
1443-
url: relay_url.clone(),
1444-
};
1433+
tracing::info!(relay_url = ?relay.url , "RELAY_URL");
14451434
let (latency, ip) =
1446-
measure_https_latency(dns_resolver, &node, server.certificates()).await?;
1435+
measure_https_latency(dns_resolver, &relay, server.certificates()).await?;
14471436

14481437
assert!(latency > Duration::ZERO);
14491438

1450-
let relay_url_ip = relay_url
1439+
let relay_url_ip = relay
1440+
.url
14511441
.host_str()
14521442
.context("host")?
14531443
.parse::<std::net::IpAddr>()?;

0 commit comments

Comments
 (0)