Refactor: UDP integration tests to follow mod structure conventions

tests/common/fixtures.rs

@@ -9,6 +9,7 @@ pub struct PeerBuilder {
 }
 
 impl PeerBuilder {
+    #[allow(dead_code)]
     pub fn default() -> PeerBuilder {
         Self {
             peer: default_peer_for_testing(),
@@ -44,6 +45,7 @@ impl PeerBuilder {
     }
 }
 
+#[allow(dead_code)]
 fn default_peer_for_testing() -> Peer {
     Peer {
         peer_id: peer::Id(*b"-qB00000000000000000"),
@@ -56,6 +58,7 @@ fn default_peer_for_testing() -> Peer {
     }
 }
 
+#[allow(dead_code)]
 pub fn invalid_info_hashes() -> Vec<String> {
     [
         "0".to_string(),

tests/common/mod.rs

@@ -1,2 +1,3 @@
 pub mod fixtures;
 pub mod http;
+pub mod udp;

tests/common/udp.rs

@@ -0,0 +1,41 @@
+use std::net::SocketAddr;
+use std::sync::Arc;
+
+use tokio::net::UdpSocket;
+
+/// A generic UDP client
+pub struct Client {
+    pub socket: Arc<UdpSocket>,
+}
+
+impl Client {
+    #[allow(dead_code)]
+    pub async fn connected(remote_socket_addr: &SocketAddr, local_socket_addr: &SocketAddr) -> Client {
+        let client = Client::bind(local_socket_addr).await;
+        client.connect(remote_socket_addr).await;
+        client
+    }
+
+    pub async fn bind(local_socket_addr: &SocketAddr) -> Self {
+        let socket = UdpSocket::bind(local_socket_addr).await.unwrap();
+        Self {
+            socket: Arc::new(socket),
+        }
+    }
+
+    pub async fn connect(&self, remote_address: &SocketAddr) {
+        self.socket.connect(remote_address).await.unwrap();
+    }
+
+    #[allow(dead_code)]
+    pub async fn send(&self, bytes: &[u8]) -> usize {
+        self.socket.writable().await.unwrap();
+        self.socket.send(bytes).await.unwrap()
+    }
+
+    #[allow(dead_code)]
+    pub async fn receive(&self, bytes: &mut [u8]) -> usize {
+        self.socket.readable().await.unwrap();
+        self.socket.recv(bytes).await.unwrap()
+    }
+}