From b163c0eed95f09988be16fa40e49d1517dd5abe5 Mon Sep 17 00:00:00 2001 From: Lorenzo Leonardo Date: Sat, 28 Oct 2023 10:01:32 +0800 Subject: [PATCH] add unit test --- src/collector.rs | 42 +++++++++++++---------------------- src/test/download.rs | 49 ++++++++++++++++++++++++++++++++++++++++ src/test/upload.rs | 53 ++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 118 insertions(+), 26 deletions(-) diff --git a/src/collector.rs b/src/collector.rs index 510fbce..3808872 100644 --- a/src/collector.rs +++ b/src/collector.rs @@ -13,7 +13,7 @@ use tokio::sync::mpsc::Sender; pub struct TransferSpeed(f64); impl TransferSpeed { - fn as_bytes_per_sec(&self) -> u64 { + pub fn as_bytes_per_sec(&self) -> u64 { self.0 as u64 } } @@ -100,6 +100,17 @@ impl FileInfo { } } +fn send_transfer_info(info: &FileInfo) { + if let Some(tx) = info.send_speed_info.clone() { + let transfer_speed = info.transfer_speed(); + tokio::spawn(async move { + tx.send(transfer_speed).await.map_err(|e| { + eprintln!("{:?}", e); + }) + }); + } +} + /// The Collector will handle two types in order to store data, via File or via RAM. /// Collector::File(FileInfo) is useful to be able to download and upload files. /// Collector::Ram(`Vec`) is used to store response body into Memory. @@ -133,19 +144,8 @@ impl Handler for Collector { })?; info.update_bytes_transferred(data.len()); - println!( - "Download speed: {} kB/s", - info.transfer_speed().as_bytes_per_sec() - ); - - if let Some(tx) = info.send_speed_info.clone() { - let transfer_speed = info.transfer_speed(); - tokio::spawn(async move { - tx.send(transfer_speed).await.map_err(|e| { - eprintln!("{:?}", e); - }) - }); - } + + send_transfer_info(&info); Ok(data.len()) } Collector::Ram(container) => { @@ -176,18 +176,8 @@ impl Handler for Collector { })?; info.update_bytes_transferred(read_size); - println!( - "Upload speed: {} kB/s", - info.transfer_speed().as_bytes_per_sec() - ); - if let Some(tx) = info.send_speed_info.clone() { - let transfer_speed = info.transfer_speed(); - tokio::spawn(async move { - tx.send(transfer_speed).await.map_err(|e| { - eprintln!("{:?}", e); - }) - }); - } + + send_transfer_info(&info); Ok(read_size) } Collector::Ram(_) => Ok(0), diff --git a/src/test/download.rs b/src/test/download.rs index f4da91f..eb8414a 100644 --- a/src/test/download.rs +++ b/src/test/download.rs @@ -3,6 +3,7 @@ use std::fs; use async_curl::async_curl::AsyncCurl; use http::{HeaderMap, Method, StatusCode}; use test_case::test_case; +use tokio::sync::mpsc::channel; use url::Url; use crate::collector::{Collector, FileInfo}; @@ -106,3 +107,51 @@ async fn test_resume_download(offset: usize, expected_status_code: StatusCode) { assert_eq!(response.body, None); assert_eq!(fs::read(save_to).unwrap(), include_bytes!("sample.jpg")); } + +#[tokio::test] +async fn test_download_with_transfer_speed_sender() { + let responder = MockResponder::new(ResponderType::File); + let (server, tempdir) = setup_test_environment(responder).await; + let target_url = Url::parse(format!("{}/test", server.uri()).as_str()).unwrap(); + + let save_to = tempdir.path().join("downloaded_file.jpg"); + + let curl = AsyncCurl::new(); + + let (tx, mut rx) = channel(1); + + let file_info = FileInfo::path(save_to.clone()).with_transfer_speed_sender(tx); + let collector = Collector::File(file_info); + let request = HttpRequest { + url: target_url, + method: Method::GET, + headers: HeaderMap::new(), + body: None, + }; + + let handle = tokio::spawn(async move { + loop { + if let Some(speed) = rx.recv().await { + println!("Download Speed: {} kB/s", speed.as_bytes_per_sec()); + } else { + break; + } + } + }); + + let response = HttpClient::new(curl, collector) + .download_speed(BytesPerSec::from(4000000)) + .unwrap() + .request(request) + .unwrap() + .perform() + .await + .unwrap(); + + println!("Response: {:?}", response); + assert_eq!(response.status_code, StatusCode::OK); + assert_eq!(response.body, None); + assert_eq!(fs::read(save_to).unwrap(), include_bytes!("sample.jpg")); + + handle.abort(); +} diff --git a/src/test/upload.rs b/src/test/upload.rs index 192bd98..90dcf9d 100644 --- a/src/test/upload.rs +++ b/src/test/upload.rs @@ -2,6 +2,7 @@ use std::fs; use async_curl::async_curl::AsyncCurl; use http::{HeaderMap, Method, StatusCode}; +use tokio::sync::mpsc::channel; use url::Url; use crate::collector::{Collector, FileInfo}; @@ -74,3 +75,55 @@ async fn test_upload_with_speed_control() { assert_eq!(response.status_code, StatusCode::OK); assert_eq!(response.body, None); } + +#[tokio::test] +async fn test_upload_with_transfer_speed_sender() { + let responder = MockResponder::new(ResponderType::File); + let (server, tempdir) = setup_test_environment(responder).await; + let target_url = Url::parse(format!("{}/test", server.uri()).as_str()).unwrap(); + + let to_be_uploaded = tempdir.path().join("file_to_be_uploaded.jpg"); + fs::write(to_be_uploaded.clone(), include_bytes!("sample.jpg")).unwrap(); + + let file_size = fs::metadata(to_be_uploaded.as_path()).unwrap().len() as usize; + + let curl = AsyncCurl::new(); + + let (tx, mut rx) = channel(1); + + let file_info = FileInfo::path(to_be_uploaded).with_transfer_speed_sender(tx); + let collector = Collector::File(file_info); + let request = HttpRequest { + url: target_url, + method: Method::PUT, + headers: HeaderMap::new(), + body: None, + }; + + let handle = tokio::spawn(async move { + loop { + if let Some(speed) = rx.recv().await { + println!("Upload Speed: {} kB/s", speed.as_bytes_per_sec()); + } else { + break; + } + } + }); + + let response = HttpClient::new(curl, collector) + .upload_file_size(FileSize::from(file_size)) + .unwrap() + .upload_speed(BytesPerSec::from(4000000)) + .unwrap() + .request(request) + .unwrap() + .perform() + .await + .unwrap(); + + println!("Response: {:?}", response); + assert_eq!(response.status_code, StatusCode::OK); + assert_eq!(response.body, None); + + handle.abort(); +}