From cc2586492968720bb9186b5259e7b991992e6472 Mon Sep 17 00:00:00 2001 From: Warm Beer Date: Fri, 7 Oct 2022 14:22:16 +0200 Subject: [PATCH 1/2] refactor: run tests with own udp tracker --- src/logging.rs | 2 ++ tests/udp.rs | 95 ++++++++++++++++++++++++-------------------------- 2 files changed, 47 insertions(+), 50 deletions(-) diff --git a/src/logging.rs b/src/logging.rs index 209c9f848..55f4c0091 100644 --- a/src/logging.rs +++ b/src/logging.rs @@ -18,6 +18,8 @@ pub fn setup_logging(cfg: &Configuration) { }, }; + if log_level == log::LevelFilter::Off { return; } + if let Err(_err) = fern::Dispatch::new() .format(|out, message, record| { out.finish(format_args!( diff --git a/tests/udp.rs b/tests/udp.rs index be4e42e41..a89d793cc 100644 --- a/tests/udp.rs +++ b/tests/udp.rs @@ -2,19 +2,14 @@ /// /// cargo test udp_tracker_server -- --nocapture -#[macro_use] -extern crate lazy_static; - extern crate rand; mod udp_tracker_server { - use core::panic; use std::io::Cursor; - use std::net::IpAddr; + use std::net::{Ipv4Addr}; use std::sync::atomic::{AtomicBool, Ordering}; use std::sync::Arc; - use std::sync::RwLock; use rand::{thread_rng, Rng}; @@ -34,19 +29,15 @@ mod udp_tracker_server { fn tracker_configuration() -> Arc { let mut config = Configuration::default(); - //config.log_level = Some("debug".to_owned()); // Uncomment to enable logging - config.external_ip = Some("127.0.0.1".to_owned()); - config.udp_trackers[0].bind_address = "127.0.0.1:6969".to_owned(); + config.log_level = Some("off".to_owned()); // "off" is necessary when running multiple trackers + config.udp_trackers[0].bind_address = format!("127.0.0.1:{}", ephemeral_random_port()); Arc::new(config) } - fn tracker_bind_address() -> String { - tracker_configuration().udp_trackers[0].bind_address.clone() - } - pub struct UdpServer { pub started: AtomicBool, pub job: Option>, + pub bind_address: Option } impl UdpServer { @@ -54,6 +45,7 @@ mod udp_tracker_server { Self { started: AtomicBool::new(false), job: None, + bind_address: None } } @@ -76,20 +68,22 @@ mod udp_tracker_server { // Initialize logging logging::setup_logging(&configuration); + let udp_tracker_config = &configuration.udp_trackers[0]; + // Start the UDP tracker job - self.job = Some(udp_tracker::start_job(&configuration.udp_trackers[0], tracker.clone())); + self.job = Some(udp_tracker::start_job(&udp_tracker_config, tracker.clone())); + + self.bind_address = Some(udp_tracker_config.bind_address.clone()); self.started.store(true, Ordering::Relaxed); } } } - lazy_static! { - static ref SERVER: RwLock = RwLock::new(UdpServer::new()); - } - - async fn start_udp_server(configuration: Arc) { - SERVER.write().unwrap().start(configuration.clone()).await; + async fn new_running_udp_server(configuration: Arc) -> UdpServer { + let mut udp_server = UdpServer::new(); + udp_server.start(configuration).await; + udp_server } struct UdpClient { @@ -207,43 +201,49 @@ mod udp_tracker_server { }; } - // #[tokio::test] - // async fn should_return_a_bad_request_response_when_the_client_sends_an_empty_request() { - // start_udp_server(tracker_configuration().clone()).await; + #[tokio::test] + async fn should_return_a_bad_request_response_when_the_client_sends_an_empty_request() { + let configuration = tracker_configuration(); + + let udp_server = new_running_udp_server(configuration).await; + + let client = new_connected_udp_client(&udp_server.bind_address.unwrap()).await; - // let client = new_connected_udp_client(&tracker_bind_address()).await; + client.send(&empty_udp_request()).await; - // client.send(&empty_udp_request()).await; + let mut buffer = empty_buffer(); + client.receive(&mut buffer).await; + let response = Response::from_bytes(&buffer, true).unwrap(); - // let mut buffer = empty_buffer(); - // client.receive(&mut buffer).await; - // let response = Response::from_bytes(&buffer, true).unwrap(); + assert!(is_error_response(&response, "bad request")); + } - // assert!(is_error_response(&response, "bad request")); - // } + #[tokio::test] + async fn should_return_a_connect_response_when_the_client_sends_a_connection_request() { + let configuration = tracker_configuration(); - // #[tokio::test] - // async fn should_return_a_connect_response_when_the_client_sends_a_connection_request() { - // start_udp_server(tracker_configuration().clone()).await; + let udp_server = new_running_udp_server(configuration).await; - // let client = new_connected_udp_tracker_client(&tracker_bind_address()).await; + let client = new_connected_udp_tracker_client(&udp_server.bind_address.unwrap()).await; - // let connect_request = ConnectRequest { - // transaction_id: TransactionId(123), - // }; + let connect_request = ConnectRequest { + transaction_id: TransactionId(123), + }; - // client.send(connect_request.into()).await; + client.send(connect_request.into()).await; - // let response = client.receive().await; + let response = client.receive().await; - // assert!(is_connect_response(&response, TransactionId(123))); - // } + assert!(is_connect_response(&response, TransactionId(123))); + } #[tokio::test] async fn should_return_an_announce_response_when_the_client_sends_an_announce_request() { - start_udp_server(tracker_configuration().clone()).await; + let configuration = tracker_configuration(); + + let udp_server = new_running_udp_server(configuration).await; - let client = new_connected_udp_tracker_client(&tracker_bind_address()).await; + let client = new_connected_udp_tracker_client(&udp_server.bind_address.unwrap()).await; // todo: extract client.connect() -> ConnectionId @@ -264,13 +264,8 @@ mod udp_tracker_server { // Send announce request - let client_ip = match client.udp_client.socket.local_addr().unwrap().ip() { - IpAddr::V4(ip4) => ip4, - _ => panic!("error: IPV6 addresses cannot be used for the client ip in the announce request. Try to use IPV4."), - }; - let announce_request = AnnounceRequest { - connection_id: ConnectionId(8724592475294857), + connection_id: ConnectionId(connection_id.0), transaction_id: TransactionId(123i32), info_hash: InfoHash([0u8; 20]), peer_id: PeerId([255u8; 20]), @@ -278,7 +273,7 @@ mod udp_tracker_server { bytes_uploaded: NumberOfBytes(0i64), bytes_left: NumberOfBytes(0i64), event: AnnounceEvent::Started, - ip_address: Some(client_ip), + ip_address: Some(Ipv4Addr::new(0, 0, 0, 0)), key: PeerKey(0u32), peers_wanted: NumberOfPeers(1i32), port: Port(client.udp_client.socket.local_addr().unwrap().port()), From d6fc356b8f299cb664141076c37d6889141b2cbb Mon Sep 17 00:00:00 2001 From: Warm Beer Date: Fri, 7 Oct 2022 14:25:55 +0200 Subject: [PATCH 2/2] fixup! refactor: run tests with own udp tracker --- src/logging.rs | 4 +++- tests/udp.rs | 7 +++---- 2 files changed, 6 insertions(+), 5 deletions(-) diff --git a/src/logging.rs b/src/logging.rs index 55f4c0091..7552a5459 100644 --- a/src/logging.rs +++ b/src/logging.rs @@ -18,7 +18,9 @@ pub fn setup_logging(cfg: &Configuration) { }, }; - if log_level == log::LevelFilter::Off { return; } + if log_level == log::LevelFilter::Off { + return; + } if let Err(_err) = fern::Dispatch::new() .format(|out, message, record| { diff --git a/tests/udp.rs b/tests/udp.rs index a89d793cc..ecfd879ce 100644 --- a/tests/udp.rs +++ b/tests/udp.rs @@ -1,13 +1,12 @@ /// Integration tests for UDP tracker server /// /// cargo test udp_tracker_server -- --nocapture - extern crate rand; mod udp_tracker_server { use core::panic; use std::io::Cursor; - use std::net::{Ipv4Addr}; + use std::net::Ipv4Addr; use std::sync::atomic::{AtomicBool, Ordering}; use std::sync::Arc; @@ -37,7 +36,7 @@ mod udp_tracker_server { pub struct UdpServer { pub started: AtomicBool, pub job: Option>, - pub bind_address: Option + pub bind_address: Option, } impl UdpServer { @@ -45,7 +44,7 @@ mod udp_tracker_server { Self { started: AtomicBool::new(false), job: None, - bind_address: None + bind_address: None, } }