fix: show measurements incrementally and remove status code from display

Author: code-inflation

examples/download_test.rs

@@ -4,7 +4,7 @@ use cfspeedtest::OutputFormat;
 fn main() {
     println!("Testing download speed with 10MB of payload");
 
-    let download_speed = test_download(
+    let (download_speed, _) = test_download(
         &reqwest::blocking::Client::new(),
         10_000_000,
         OutputFormat::None, // don't write to stdout while running the test

src/progress.rs

@@ -9,7 +9,7 @@ impl Progress {
         let bar = ProgressBar::new(max as u64);
         bar.set_style(
             ProgressStyle::default_bar()
-                .template("{prefix:<15} [{bar:30}]")
+                .template("{prefix:<15} [{bar:30}] {msg}")
                 .unwrap()
                 .progress_chars("=-"),
         );
@@ -24,4 +24,8 @@ impl Progress {
     pub fn finish(&self) {
         self.bar.finish();
     }
+
+    pub fn set_message(&self, msg: impl Into<std::borrow::Cow<'static, str>>) {
+        self.bar.set_message(msg);
+    }
 }

src/speedtest.rs

@@ -7,7 +7,7 @@ use crate::OutputFormat;
 use crate::SpeedTestCLIOptions;
 use log;
 use regex::Regex;
-use reqwest::{blocking::Client, StatusCode};
+use reqwest::blocking::Client;
 use serde::Serialize;
 use std::{
     fmt::Display,
@@ -233,7 +233,7 @@ const TIME_THRESHOLD: Duration = Duration::from_secs(5);
 
 pub fn run_tests(
     client: &Client,
-    test_fn: fn(&Client, usize, OutputFormat) -> f64,
+    test_fn: fn(&Client, usize, OutputFormat) -> (f64, String),
     test_type: TestType,
     payload_sizes: Vec<usize>,
     nr_tests: u32,
@@ -255,10 +255,11 @@ pub fn run_tests(
         };
 
         for i in 0..nr_tests {
+            let (mbit, message) = test_fn(client, payload_size, output_format);
             if let Some(ref pb) = progress {
-                pb.set_position(i);
+                pb.set_position(i + 1);
+                pb.set_message(message);
             }
-            let mbit = test_fn(client, payload_size, output_format);
             measurements.push(Measurement {
                 test_type,
                 payload_size,
@@ -267,7 +268,6 @@ pub fn run_tests(
         }
 
         if let Some(pb) = progress {
-            pb.set_position(nr_tests);
             pb.finish();
             println!()
         }
@@ -283,62 +283,63 @@ pub fn run_tests(
     measurements
 }
 
-pub fn test_upload(client: &Client, payload_size_bytes: usize, output_format: OutputFormat) -> f64 {
+pub fn test_upload(
+    client: &Client,
+    payload_size_bytes: usize,
+    output_format: OutputFormat,
+) -> (f64, String) {
     let url = &format!("{BASE_URL}/{UPLOAD_URL}");
     let payload: Vec<u8> = vec![1; payload_size_bytes];
     let req_builder = client.post(url).body(payload);
-    let (mut response, status_code, mbits, duration) = {
+    let (mut response, mbits, duration) = {
         let start = Instant::now();
         let response = req_builder.send().expect("failed to get response");
-        let status_code = response.status();
         let duration = start.elapsed();
         let mbits = (payload_size_bytes as f64 * 8.0 / 1_000_000.0) / duration.as_secs_f64();
-        (response, status_code, mbits, duration)
+        (response, mbits, duration)
     };
     // Drain response after timing so we don't skew upload measurement.
     let _ = std::io::copy(&mut response, &mut std::io::sink());
-    if output_format == OutputFormat::StdOut {
-        print_current_speed(mbits, duration, status_code, payload_size_bytes);
-    }
-    mbits
+    let message = if output_format == OutputFormat::StdOut {
+        format!(
+            "  {:>6.2} mbit/s | {:>5} in {:>4}ms",
+            mbits,
+            format_bytes(payload_size_bytes),
+            duration.as_millis()
+        )
+    } else {
+        String::new()
+    };
+    (mbits, message)
 }
 
 pub fn test_download(
     client: &Client,
     payload_size_bytes: usize,
     output_format: OutputFormat,
-) -> f64 {
+) -> (f64, String) {
     let url = &format!("{BASE_URL}/{DOWNLOAD_URL}{payload_size_bytes}");
     let req_builder = client.get(url);
-    let (status_code, mbits, duration) = {
+    let (mbits, duration) = {
         let start = Instant::now();
         let mut response = req_builder.send().expect("failed to get response");
-        let status_code = response.status();
         // Stream the body to avoid buffering the full payload in memory.
         let _ = std::io::copy(&mut response, &mut std::io::sink());
         let duration = start.elapsed();
         let mbits = (payload_size_bytes as f64 * 8.0 / 1_000_000.0) / duration.as_secs_f64();
-        (status_code, mbits, duration)
+        (mbits, duration)
     };
-    if output_format == OutputFormat::StdOut {
-        print_current_speed(mbits, duration, status_code, payload_size_bytes);
-    }
-    mbits
-}
-
-fn print_current_speed(
-    mbits: f64,
-    duration: Duration,
-    status_code: StatusCode,
-    payload_size_bytes: usize,
-) {
-    print!(
-        "  {:>6.2} mbit/s | {:>5} in {:>4}ms -> status: {}  ",
-        mbits,
-        format_bytes(payload_size_bytes),
-        duration.as_millis(),
-        status_code
-    );
+    let message = if output_format == OutputFormat::StdOut {
+        format!(
+            "  {:>6.2} mbit/s | {:>5} in {:>4}ms",
+            mbits,
+            format_bytes(payload_size_bytes),
+            duration.as_millis()
+        )
+    } else {
+        String::new()
+    };
+    (mbits, message)
 }
 
 pub fn fetch_metadata(client: &Client) -> Result<Metadata, reqwest::Error> {