Make project usable as a library by adding lib.rs (#8)

* add lib.rs and move main.rs code

* upgrade deps

* bump version

* rename speedtest options to CLI options

* add examples for library usage

* make OutputFormat no longer optional

* minor version bump

* run examples and CLI in GitHub CI

Author: code-inflation

.github/workflows/CI.yml

@@ -22,3 +22,11 @@ jobs:
       run: cargo build --verbose
     - name: Run tests
       run: cargo test --verbose
+    - name: Run example - simple_speedtest
+      run: cargo run --example simple_speedtest
+    - name: Run example - download_test
+      run: cargo run --example download_test
+    - name: Run example - latency_test
+      run: cargo run --example latency_test
+    - name: Run CLI
+      run: cargo run

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "cfspeedtest"
-version = "1.0.4"
+version = "1.1.0"
 edition = "2021"
 license = "MIT"
 description = "Unofficial CLI for speed.cloudflare.com"

Cargo.toml

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

examples/download_test.rs

@@ -0,0 +1,19 @@
+use cfspeedtest::speedtest::run_latency_test;
+use cfspeedtest::OutputFormat;
+
+fn main() {
+    println!("Testing latency");
+
+    let (latency_results, avg_latency) = run_latency_test(
+        &reqwest::blocking::Client::new(),
+        25,
+        OutputFormat::None, // don't write to stdout while running the test
+    );
+
+    println!("average latancy in ms: {avg_latency}");
+
+    println!("all latency test results");
+    for latency_result in latency_results {
+        println!("latency in ms: {latency_result}");
+    }
+}

examples/latency_test.rs

@@ -0,0 +1,22 @@
+use cfspeedtest::speedtest::speed_test;
+use cfspeedtest::speedtest::PayloadSize;
+use cfspeedtest::OutputFormat;
+use cfspeedtest::SpeedTestCLIOptions;
+
+fn main() {
+    // define speedtest options
+    let options = SpeedTestCLIOptions {
+        output_format: OutputFormat::None, // don't write to stdout
+        ipv4: false,                       // don't force ipv4 usage
+        ipv6: false,                       // don't force ipv6 usage
+        verbose: false,
+        nr_tests: 5,
+        nr_latency_tests: 20,
+        max_payload_size: PayloadSize::M10,
+    };
+
+    let measurements = speed_test(reqwest::blocking::Client::new(), options);
+    measurements
+        .iter()
+        .for_each(|measurement| println!("{measurement}"));
+}

examples/simple_speedtest.rs

@@ -0,0 +1,78 @@
+pub mod boxplot;
+pub mod measurements;
+pub mod progress;
+pub mod speedtest;
+use std::fmt;
+use std::fmt::Display;
+
+use clap::Parser;
+use speedtest::PayloadSize;
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum OutputFormat {
+    Csv,
+    Json,
+    JsonPretty,
+    StdOut,
+    None,
+}
+
+impl Display for OutputFormat {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
+
+impl OutputFormat {
+    pub fn from(output_format_string: String) -> Result<Self, String> {
+        match output_format_string.to_lowercase().as_str() {
+            "csv" => Ok(Self::Csv),
+            "json" => Ok(Self::Json),
+            "json_pretty" | "json-pretty" => Ok(Self::JsonPretty),
+            "stdout" => Ok(Self::StdOut),
+            _ => Err("Value needs to be one of csv, json or json-pretty".to_string()),
+        }
+    }
+}
+
+/// Unofficial CLI for speed.cloudflare.com
+#[derive(Parser, Debug)]
+#[command(author, version, about, long_about = None)]
+pub struct SpeedTestCLIOptions {
+    /// Number of test runs per payload size. Needs to be at least 4
+    #[arg(value_parser = clap::value_parser!(u32).range(4..1000), short, long, default_value_t = 10)]
+    pub nr_tests: u32,
+
+    /// Number of latency tests to run
+    #[arg(long, default_value_t = 25)]
+    pub nr_latency_tests: u32,
+
+    /// The max payload size in bytes to use [100k, 1m, 10m, 25m or 100m]
+    #[arg(value_parser = parse_payload_size, short, long, default_value_t = PayloadSize::M10)]
+    pub max_payload_size: PayloadSize,
+
+    /// Set the output format [csv, json or json-pretty] >
+    /// This silences all other output to stdout
+    #[arg(value_parser = parse_output_format, short, long, default_value_t = OutputFormat::StdOut)]
+    pub output_format: OutputFormat,
+
+    /// Enable verbose output i.e. print out boxplots of the measurements
+    #[arg(short, long)]
+    pub verbose: bool,
+
+    /// Force usage of IPv4
+    #[arg(long)]
+    pub ipv4: bool,
+
+    /// Force usage of IPv6
+    #[arg(long)]
+    pub ipv6: bool,
+}
+
+fn parse_payload_size(input_string: &str) -> Result<PayloadSize, String> {
+    PayloadSize::from(input_string.to_string())
+}
+
+fn parse_output_format(input_string: &str) -> Result<OutputFormat, String> {
+    OutputFormat::from(input_string.to_string())
+}

src/lib.rs

@@ -1,68 +1,15 @@
-pub mod boxplot;
-pub mod measurements;
-pub mod progress;
-pub mod speedtest;
-
+use cfspeedtest::speedtest;
+use cfspeedtest::OutputFormat;
+use cfspeedtest::SpeedTestCLIOptions;
 use clap::Parser;
-use speedtest::speed_test;
-use speedtest::PayloadSize;
-
-#[derive(Clone, Copy, Debug)]
-enum OutputFormat {
-    Csv,
-    Json,
-    JsonPretty,
-}
-
-impl OutputFormat {
-    pub fn from(output_format_string: String) -> Result<Self, String> {
-        match output_format_string.to_lowercase().as_str() {
-            "csv" => Ok(Self::Csv),
-            "json" => Ok(Self::Json),
-            "json_pretty" | "json-pretty" => Ok(Self::JsonPretty),
-            _ => Err("Value needs to be one of csv, json or json-pretty".to_string()),
-        }
-    }
-}
-
-/// Unofficial CLI for speed.cloudflare.com
-#[derive(Parser, Debug)]
-#[command(author, version, about, long_about = None)]
-pub(crate) struct SpeedTestOptions {
-    /// Number of test runs per payload size. Needs to be at least 4
-    #[arg(value_parser = clap::value_parser!(u32).range(4..1000), short, long, default_value_t = 10)]
-    nr_tests: u32,
-
-    /// Number of latency tests to run
-    #[arg(long, default_value_t = 25)]
-    nr_latency_tests: u32,
-
-    /// The max payload size in bytes to use [100k, 1m, 10m, 25m or 100m]
-    #[arg(value_parser = parse_payload_size, short, long, default_value_t = PayloadSize::M10)]
-    max_payload_size: PayloadSize,
-
-    /// Set the output format [csv, json or json-pretty] >
-    /// This silences all other output to stdout
-    #[arg(value_parser = parse_output_format, short, long)]
-    output_format: Option<OutputFormat>,
-
-    /// Enable verbose output i.e. print out boxplots of the measurements
-    #[arg(short, long)]
-    verbose: bool,
+use std::net::IpAddr;
 
-    /// Force usage of IPv4
-    #[arg(long)]
-    ipv4: bool,
+use speedtest::speed_test;
 
-    /// Force usage of IPv6
-    #[arg(long)]
-    ipv6: bool,
-}
-use std::net::IpAddr;
 fn main() {
     env_logger::init();
-    let options = SpeedTestOptions::parse();
-    if options.output_format.is_none() {
+    let options = SpeedTestCLIOptions::parse();
+    if options.output_format == OutputFormat::StdOut {
         println!("Starting Cloudflare speed test");
     }
     let client;
@@ -82,11 +29,3 @@ fn main() {
         options,
     );
 }
-
-fn parse_payload_size(input_string: &str) -> Result<PayloadSize, String> {
-    PayloadSize::from(input_string.to_string())
-}
-
-fn parse_output_format(input_string: &str) -> Result<OutputFormat, String> {
-    OutputFormat::from(input_string.to_string())
-}