add unit test

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<u8>`) 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),

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();
+}

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();
+}