test(iroh-relay, netcheck): move tests to use local relays

iroh-net/Cargo.toml

@@ -163,6 +163,7 @@ iroh-net = { path = "." }
 serde_json = "1.0.107"
 testresult = "0.4.0"
 mainline = "2.0.1"
+iroh-relay = { version = "0.28", path = "../iroh-relay", features = ["test-utils", "server"] }
 
 [[bench]]
 name = "key"

iroh-net/src/netcheck.rs

@@ -769,6 +769,46 @@ pub(crate) fn os_has_ipv6() -> bool {
     UdpSocket::bind_local_v6(0).is_ok()
 }
 
+#[cfg(test)]
+mod test_utils {
+    //! Creates a relay server against which to perform tests
+
+    use std::sync::Arc;
+
+    use iroh_relay::server;
+
+    use crate::RelayNode;
+
+    pub(crate) async fn relay() -> (server::Server, Arc<RelayNode>) {
+        let server = server::Server::spawn(server::testing::server_config())
+            .await
+            .expect("should serve relay");
+        let node_desc = RelayNode {
+            url: server.https_url().expect("should work as relay"),
+            stun_only: false, // the checks above and below guarantee both stun and relay
+            stun_port: server.stun_addr().expect("server should serve stun").port(),
+        };
+
+        (server, Arc::new(node_desc))
+    }
+
+    /// Create a [`crate::RelayMap`] of the given size.
+    ///
+    /// This function uses [`relay`]. Note that the returned map uses internal order that will
+    /// often _not_ match the order of the servers.
+    pub(crate) async fn relay_map(relays: usize) -> (Vec<server::Server>, crate::RelayMap) {
+        let mut servers = Vec::with_capacity(relays);
+        let mut nodes = Vec::with_capacity(relays);
+        for _ in 0..relays {
+            let (relay_server, node) = relay().await;
+            servers.push(relay_server);
+            nodes.push(node);
+        }
+        let map = crate::RelayMap::from_nodes(nodes).expect("unuque urls");
+        (servers, map)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use std::net::Ipv4Addr;
@@ -778,11 +818,7 @@ mod tests {
     use tracing::info;
 
     use super::*;
-    use crate::{
-        defaults::{staging::EU_RELAY_HOSTNAME, DEFAULT_STUN_PORT},
-        ping::Pinger,
-        RelayNode,
-    };
+    use crate::ping::Pinger;
 
     mod stun_utils {
         //! Utils for testing that expose a simple stun server.
@@ -799,8 +835,6 @@ mod tests {
         use super::*;
         use crate::{RelayMap, RelayNode, RelayUrl};
 
-        // TODO: make all this private
-
         /// A drop guard to clean up test infrastructure.
         ///
         /// After dropping the test infrastructure will asynchronously shutdown and release its
@@ -956,57 +990,6 @@ mod tests {
         Ok(())
     }
 
-    #[tokio::test]
-    async fn test_iroh_computer_stun() -> Result<()> {
-        let _guard = iroh_test::logging::setup();
-
-        let resolver = crate::dns::default_resolver().clone();
-        let mut client = Client::new(None, resolver).context("failed to create netcheck client")?;
-        let url: RelayUrl = format!("https://{}", EU_RELAY_HOSTNAME).parse().unwrap();
-
-        let dm = RelayMap::from_nodes([RelayNode {
-            url: url.clone(),
-            stun_only: true,
-            stun_port: DEFAULT_STUN_PORT,
-        }])
-        .expect("hardcoded");
-
-        for i in 0..10 {
-            println!("starting report {}", i + 1);
-            let now = Instant::now();
-
-            let r = client
-                .get_report(dm.clone(), None, None)
-                .await
-                .context("failed to get netcheck report")?;
-
-            if r.udp {
-                assert_eq!(
-                    r.relay_latency.len(),
-                    1,
-                    "expected 1 key in RelayLatency; got {}",
-                    r.relay_latency.len()
-                );
-                assert!(
-                    r.relay_latency.iter().next().is_some(),
-                    "expected key 1 in RelayLatency; got {:?}",
-                    r.relay_latency
-                );
-                assert!(
-                    r.global_v4.is_some() || r.global_v6.is_some(),
-                    "expected at least one of global_v4 or global_v6"
-                );
-                assert!(r.preferred_relay.is_some());
-            } else {
-                eprintln!("missing UDP, probe not returned by network");
-            }
-
-            println!("report {} done in {:?}", i + 1, now.elapsed());
-        }
-
-        Ok(())
-    }
-
     #[tokio::test]
     async fn test_udp_blocked() -> Result<()> {
         let _guard = iroh_test::logging::setup();

iroh-net/src/netcheck/reportgen.rs

@@ -1177,101 +1177,99 @@ mod tests {
 
     use testresult::TestResult;
 
-    use super::*;
-    use crate::{
-        defaults::staging::{default_eu_relay_node, default_na_relay_node},
-        test_utils,
-    };
+    use super::{super::test_utils, *};
 
-    #[test]
-    fn test_update_report_stun_working() {
-        let eu_relayer = Arc::new(default_eu_relay_node());
-        let na_relayer = Arc::new(default_na_relay_node());
+    #[tokio::test]
+    async fn test_update_report_stun_working() {
+        let _logging = iroh_test::logging::setup();
+        let (_server_a, relay_a) = test_utils::relay().await;
+        let (_server_b, relay_b) = test_utils::relay().await;
 
         let mut report = Report::default();
 
-        // A STUN IPv4 probe from the EU relay server.
-        let probe_report_eu = ProbeReport {
+        // A STUN IPv4 probe from the the first relay server.
+        let probe_report_a = ProbeReport {
             ipv4_can_send: true,
             ipv6_can_send: false,
             icmpv4: None,
             icmpv6: None,
             latency: Some(Duration::from_millis(5)),
             probe: Probe::StunIpv4 {
                 delay: Duration::ZERO,
-                node: eu_relayer.clone(),
+                node: relay_a.clone(),
             },
             addr: Some((Ipv4Addr::new(203, 0, 113, 1), 1234).into()),
         };
-        update_report(&mut report, probe_report_eu.clone());
+        update_report(&mut report, probe_report_a.clone());
 
         assert!(report.udp);
         assert_eq!(
-            report.relay_latency.get(&eu_relayer.url).unwrap(),
+            report.relay_latency.get(&relay_a.url).unwrap(),
             Duration::from_millis(5)
         );
         assert_eq!(
-            report.relay_v4_latency.get(&eu_relayer.url).unwrap(),
+            report.relay_v4_latency.get(&relay_a.url).unwrap(),
             Duration::from_millis(5)
         );
         assert!(report.ipv4_can_send);
         assert!(!report.ipv6_can_send);
 
         // A second STUN IPv4 probe, same external IP detected but slower.
-        let probe_report_na = ProbeReport {
+        let probe_report_b = ProbeReport {
             latency: Some(Duration::from_millis(8)),
             probe: Probe::StunIpv4 {
                 delay: Duration::ZERO,
-                node: na_relayer.clone(),
+                node: relay_b.clone(),
             },
-            ..probe_report_eu
+            ..probe_report_a
         };
-        update_report(&mut report, probe_report_na);
+        update_report(&mut report, probe_report_b);
 
         assert!(report.udp);
         assert_eq!(
-            report.relay_latency.get(&eu_relayer.url).unwrap(),
+            report.relay_latency.get(&relay_a.url).unwrap(),
             Duration::from_millis(5)
         );
         assert_eq!(
-            report.relay_v4_latency.get(&eu_relayer.url).unwrap(),
+            report.relay_v4_latency.get(&relay_a.url).unwrap(),
             Duration::from_millis(5)
         );
         assert!(report.ipv4_can_send);
         assert!(!report.ipv6_can_send);
 
         // A STUN IPv6 probe, this one is faster.
-        let probe_report_eu_ipv6 = ProbeReport {
+        let probe_report_a_ipv6 = ProbeReport {
             ipv4_can_send: false,
             ipv6_can_send: true,
             icmpv4: None,
             icmpv6: None,
             latency: Some(Duration::from_millis(4)),
             probe: Probe::StunIpv6 {
                 delay: Duration::ZERO,
-                node: eu_relayer.clone(),
+                node: relay_a.clone(),
             },
             addr: Some((Ipv6Addr::new(2001, 0xdb8, 0, 0, 0, 0, 0, 1), 1234).into()),
         };
-        update_report(&mut report, probe_report_eu_ipv6);
+        update_report(&mut report, probe_report_a_ipv6);
 
         assert!(report.udp);
         assert_eq!(
-            report.relay_latency.get(&eu_relayer.url).unwrap(),
+            report.relay_latency.get(&relay_a.url).unwrap(),
             Duration::from_millis(4)
         );
         assert_eq!(
-            report.relay_v6_latency.get(&eu_relayer.url).unwrap(),
+            report.relay_v6_latency.get(&relay_a.url).unwrap(),
             Duration::from_millis(4)
         );
         assert!(report.ipv4_can_send);
         assert!(report.ipv6_can_send);
     }
 
-    #[test]
-    fn test_update_report_icmp() {
-        let eu_relayer = Arc::new(default_eu_relay_node());
-        let na_relayer = Arc::new(default_na_relay_node());
+    #[tokio::test]
+    async fn test_update_report_icmp() {
+        let _logging = iroh_test::logging::setup();
+        let (_server_a, relay_a) = test_utils::relay().await;
+        let (_server_b, relay_b) = test_utils::relay().await;
 
         let mut report = Report::default();
 
@@ -1284,7 +1282,7 @@ mod tests {
             latency: Some(Duration::from_millis(5)),
             probe: Probe::IcmpV4 {
                 delay: Duration::ZERO,
-                node: eu_relayer.clone(),
+                node: relay_a.clone(),
             },
             addr: Some((Ipv4Addr::new(203, 0, 113, 1), 1234).into()),
         };
@@ -1303,7 +1301,7 @@ mod tests {
             latency: None,
             probe: Probe::IcmpV4 {
                 delay: Duration::ZERO,
-                node: na_relayer.clone(),
+                node: relay_b.clone(),
             },
             addr: None,
         };
@@ -1320,7 +1318,7 @@ mod tests {
             latency: Some(Duration::from_millis(5)),
             probe: Probe::StunIpv4 {
                 delay: Duration::ZERO,
-                node: eu_relayer.clone(),
+                node: relay_a.clone(),
             },
             addr: Some((Ipv4Addr::new(203, 0, 113, 1), 1234).into()),
         };
@@ -1378,18 +1376,14 @@ mod tests {
     //
     // TODO: Not sure what about IPv6 pings using sysctl.
     #[tokio::test]
-    async fn test_icmpk_probe_eu_relayer() {
+    async fn test_icmpk_probe() {
         let _logging_guard = iroh_test::logging::setup();
         let pinger = Pinger::new();
-        let relay = default_eu_relay_node();
-        let resolver = crate::dns::default_resolver();
-        let addr = get_relay_addr(resolver, &relay, ProbeProto::IcmpV4)
-            .await
-            .map_err(|err| format!("{err:#}"))
-            .unwrap();
+        let (server, node) = test_utils::relay().await;
+        let addr = server.stun_addr().expect("test relay serves stun");
         let probe = Probe::IcmpV4 {
             delay: Duration::from_secs(0),
-            node: Arc::new(relay),
+            node,
         };
 
         // A single ICMP packet might get lost.  Try several and take the first.
@@ -1434,20 +1428,16 @@ mod tests {
     #[tokio::test]
     async fn test_measure_https_latency() -> TestResult {
         let _logging_guard = iroh_test::logging::setup();
-        let (_relay_map, relay_url, server) = test_utils::run_relay_server().await?;
+        let (server, relay) = test_utils::relay().await;
         let dns_resolver = crate::dns::resolver();
-        warn!(?relay_url, "RELAY_URL");
-        let node = RelayNode {
-            stun_only: false,
-            stun_port: 0,
-            url: relay_url.clone(),
-        };
+        tracing::info!(relay_url = ?relay.url , "RELAY_URL");
         let (latency, ip) =
-            measure_https_latency(dns_resolver, &node, server.certificates()).await?;
+            measure_https_latency(dns_resolver, &relay, server.certificates()).await?;
 
         assert!(latency > Duration::ZERO);
 
-        let relay_url_ip = relay_url
+        let relay_url_ip = relay
+            .url
             .host_str()
             .context("host")?
             .parse::<std::net::IpAddr>()?;