test(p2p): cover peer, utils, quic_upgrade, force_direct, bootnode

crates/p2p/Cargo.toml

@@ -37,13 +37,14 @@ pluto-testutil.workspace = true
 vise-exporter.workspace = true
 anyhow.workspace = true
 clap.workspace = true
-pluto-cluster.workspace = true
+pluto-cluster = { workspace = true, features = ["test-cluster"] }
 hex.workspace = true
 libp2p.workspace = true
 k256.workspace = true
 tokio = { workspace = true, features = ["test-util"] }
 futures.workspace = true
 wiremock.workspace = true
+test-case.workspace = true
 
 [lints]
 workspace = true

crates/p2p/src/bootnode.rs

@@ -404,8 +404,11 @@ fn addr_info_from_p2p_addr(addr: &Multiaddr) -> std::result::Result<AddrInfo, Pe
 
 #[cfg(test)]
 mod tests {
+    use std::net::Ipv4Addr;
+
     use k256::elliptic_curve::rand_core::OsRng;
     use libp2p::PeerId;
+    use pluto_eth2util::enr::EnrEntry;
     use wiremock::{
         Mock, MockServer, ResponseTemplate,
         matchers::{header, method, path},
@@ -546,4 +549,87 @@ mod tests {
             "unexpected error: {err}"
         );
     }
+
+    /// An ENR for `key` in the `enr:` string form a relay serves.
+    fn enr_str(key: &k256::SecretKey, entries: Vec<EnrEntry>) -> String {
+        Record::new(key, entries).expect("build enr").to_string()
+    }
+
+    #[test]
+    fn multi_addr_from_enr_str_maps_ports_to_transports() {
+        let key = k256::SecretKey::random(&mut OsRng);
+        let peer_id = peer_id_from_key(key.public_key()).expect("peer id from key");
+        let ip = EnrEntry::Ipv4(Ipv4Addr::new(1, 2, 3, 4));
+
+        // The UDP port is advertised as QUIC, and comes first when both ports
+        // are set so a dialer prefers it over TCP.
+        let cases = [
+            (vec![ip, EnrEntry::Tcp(3610)], vec!["/ip4/1.2.3.4/tcp/3610"]),
+            (
+                vec![ip, EnrEntry::Udp(3630)],
+                vec!["/ip4/1.2.3.4/udp/3630/quic-v1"],
+            ),
+            (
+                vec![ip, EnrEntry::Tcp(3610), EnrEntry::Udp(3630)],
+                vec!["/ip4/1.2.3.4/udp/3630/quic-v1", "/ip4/1.2.3.4/tcp/3610"],
+            ),
+        ];
+
+        for (entries, want) in cases {
+            let addrs =
+                multi_addr_from_enr_str(&enr_str(&key, entries)).expect("enr should resolve");
+            let want: Vec<Multiaddr> = want
+                .iter()
+                .map(|addr| format!("{addr}/p2p/{peer_id}").parse().expect("multiaddr"))
+                .collect();
+
+            assert_eq!(addrs, want);
+        }
+    }
+
+    #[test]
+    fn multi_addr_from_enr_str_rejects_an_enr_without_an_ip() {
+        let key = k256::SecretKey::random(&mut OsRng);
+        let enr = enr_str(&key, vec![EnrEntry::Tcp(3610)]);
+
+        let err = multi_addr_from_enr_str(&enr).expect_err("an ip is required");
+
+        assert!(
+            matches!(err, BootnodeError::EnrNoIp),
+            "unexpected error: {err}"
+        );
+    }
+
+    #[test]
+    fn multi_addr_from_enr_str_rejects_an_enr_without_a_port() {
+        let key = k256::SecretKey::random(&mut OsRng);
+        let enr = enr_str(&key, vec![EnrEntry::Ipv4(Ipv4Addr::new(1, 2, 3, 4))]);
+
+        let err = multi_addr_from_enr_str(&enr).expect_err("a port is required");
+
+        assert!(
+            matches!(err, BootnodeError::EnrNoPort),
+            "unexpected error: {err}"
+        );
+    }
+
+    #[test]
+    fn multi_addr_from_enr_str_rejects_garbage() {
+        for garbage in [
+            "",
+            "not-an-enr",
+            // Right prefix, unparsable body.
+            "enr:not-base64-@@@",
+            // Valid base64, but not an RLP-encoded record.
+            "enr:AAAAAAAA",
+        ] {
+            let err = multi_addr_from_enr_str(garbage)
+                .expect_err("garbage must not resolve to an address");
+
+            assert!(
+                matches!(err, BootnodeError::ParseEnr(_)),
+                "unexpected error for {garbage:?}: {err}"
+            );
+        }
+    }
 }