chore: add tests

Author: joncrangle

AGENTS.md

@@ -4,23 +4,21 @@
 - `cargo build` - Build the project
 - `cargo build --release` - Build optimized release version
 - `cargo test` - Run all tests
+- `cargo test <test_name>` - Run a single test (e.g., `cargo test test_validate_cli_with_all_flag`)
 - `cargo fmt` - Format code
 - `cargo clippy` - Run linting checks
 
 ## Code Style
-- Use `snake_case` for functions, variables, and modules
-- Use `PascalCase` for structs and enums
-- Import external crates at top, then `use` statements grouped by visibility
-- Error handling: Use `anyhow::Result<T>` for public APIs, `?` operator for propagation
-- String formatting: Use `format!()` macro for dynamic strings, string literals for static
+- Naming: `snake_case` for functions/variables/modules, `PascalCase` for structs/enums, `SCREAMING_SNAKE_CASE` for constants
+- Imports: External crates first, then local `mod` and `use` statements, group by visibility (pub before private)
+- Error handling: `anyhow::Result<T>` for fallible functions, `anyhow::bail!()` for errors, `?` for propagation, `.context()` for error context
+- String formatting: `format!()` for dynamic, string literals for static, `String::with_capacity()` for buffers
+- Function signatures: Accept `&str` slices, return owned `String` only when necessary
+- Testing: Place unit tests in `#[cfg(test)] mod tests` at bottom of each file, use descriptive names like `test_<function>_<scenario>`
 
 ## Architecture
 - Modular structure: `src/` contains `main.rs`, `cli.rs`, `sketchybar.rs`, and `stats/` module
-- Stats module exports individual stat functions via `mod.rs`
-- CLI uses `clap` with `Parser` derive macro
-- Async main with `tokio` runtime for event loop
-
-## Dependencies
-- Core: `anyhow`, `clap`, `sysinfo`, `tokio`
-- Build: `cc` for C bindings
-- Platform: macOS only (`#[cfg(target_os = "macos")]`)
+- Stats module: Individual stat files (`cpu.rs`, `disk.rs`, etc.) with public functions exported via `mod.rs`
+- CLI: `clap` with `Parser` derive, validation in separate `validate_cli()` function, constants for defaults/limits
+- Async runtime: `tokio::main` macro, `tokio::select!` for concurrent operations, `tokio::time::sleep` for intervals
+- Platform: macOS only - use `#[cfg(target_os = "macos")]` for platform-specific code

src/cli.rs

@@ -138,3 +138,175 @@ pub fn all_system_flags() -> Vec<&'static str> {
 pub fn all_uptime_flags() -> Vec<&'static str> {
     vec!["week", "day", "hour", "min", "sec"]
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_validate_cli_with_all_flag() {
+        let cli = Cli {
+            all: true,
+            cpu: None,
+            disk: None,
+            memory: None,
+            network: None,
+            system: None,
+            uptime: None,
+            interval: DEFAULT_INTERVAL,
+            network_refresh_rate: DEFAULT_NETWORK_REFRESH_RATE,
+            bar: None,
+            verbose: false,
+            no_units: false,
+        };
+        assert!(validate_cli(&cli).is_ok());
+    }
+
+    #[test]
+    fn test_validate_cli_with_cpu_flag() {
+        let cli = Cli {
+            all: false,
+            cpu: Some(vec!["usage".to_string()]),
+            disk: None,
+            memory: None,
+            network: None,
+            system: None,
+            uptime: None,
+            interval: DEFAULT_INTERVAL,
+            network_refresh_rate: DEFAULT_NETWORK_REFRESH_RATE,
+            bar: None,
+            verbose: false,
+            no_units: false,
+        };
+        assert!(validate_cli(&cli).is_ok());
+    }
+
+    #[test]
+    fn test_validate_cli_no_flags() {
+        let cli = Cli {
+            all: false,
+            cpu: None,
+            disk: None,
+            memory: None,
+            network: None,
+            system: None,
+            uptime: None,
+            interval: DEFAULT_INTERVAL,
+            network_refresh_rate: DEFAULT_NETWORK_REFRESH_RATE,
+            bar: None,
+            verbose: false,
+            no_units: false,
+        };
+        assert!(validate_cli(&cli).is_err());
+    }
+
+    #[test]
+    fn test_validate_cli_interval_too_low() {
+        let cli = Cli {
+            all: true,
+            cpu: None,
+            disk: None,
+            memory: None,
+            network: None,
+            system: None,
+            uptime: None,
+            interval: 0,
+            network_refresh_rate: DEFAULT_NETWORK_REFRESH_RATE,
+            bar: None,
+            verbose: false,
+            no_units: false,
+        };
+        assert!(validate_cli(&cli).is_err());
+    }
+
+    #[test]
+    fn test_validate_cli_interval_too_high() {
+        let cli = Cli {
+            all: true,
+            cpu: None,
+            disk: None,
+            memory: None,
+            network: None,
+            system: None,
+            uptime: None,
+            interval: MAX_INTERVAL + 1,
+            network_refresh_rate: DEFAULT_NETWORK_REFRESH_RATE,
+            bar: None,
+            verbose: false,
+            no_units: false,
+        };
+        assert!(validate_cli(&cli).is_err());
+    }
+
+    #[test]
+    fn test_validate_cli_network_refresh_rate_too_low() {
+        let cli = Cli {
+            all: true,
+            cpu: None,
+            disk: None,
+            memory: None,
+            network: None,
+            system: None,
+            uptime: None,
+            interval: DEFAULT_INTERVAL,
+            network_refresh_rate: 0,
+            bar: None,
+            verbose: false,
+            no_units: false,
+        };
+        assert!(validate_cli(&cli).is_err());
+    }
+
+    #[test]
+    fn test_validate_cli_network_refresh_rate_too_high() {
+        let cli = Cli {
+            all: true,
+            cpu: None,
+            disk: None,
+            memory: None,
+            network: None,
+            system: None,
+            uptime: None,
+            interval: DEFAULT_INTERVAL,
+            network_refresh_rate: MAX_NETWORK_REFRESH_RATE + 1,
+            bar: None,
+            verbose: false,
+            no_units: false,
+        };
+        assert!(validate_cli(&cli).is_err());
+    }
+
+    #[test]
+    fn test_all_cpu_flags_returns_correct_flags() {
+        let flags = all_cpu_flags();
+        assert_eq!(flags, vec!["count", "frequency", "temperature", "usage"]);
+    }
+
+    #[test]
+    fn test_all_disk_flags_returns_correct_flags() {
+        let flags = all_disk_flags();
+        assert_eq!(flags, vec!["count", "free", "total", "usage", "used"]);
+    }
+
+    #[test]
+    fn test_all_memory_flags_contains_ram_and_swap() {
+        let flags = all_memory_flags();
+        assert!(flags.contains(&"ram_available"));
+        assert!(flags.contains(&"swp_total"));
+        assert_eq!(flags.len(), 8);
+    }
+
+    #[test]
+    fn test_all_system_flags_returns_correct_flags() {
+        let flags = all_system_flags();
+        assert!(flags.contains(&"arch"));
+        assert!(flags.contains(&"distro"));
+        assert_eq!(flags.len(), 7);
+    }
+
+    #[test]
+    fn test_all_uptime_flags_returns_correct_flags() {
+        let flags = all_uptime_flags();
+        assert_eq!(flags, vec!["week", "day", "hour", "min", "sec"]);
+    }
+}

src/main.rs

@@ -18,26 +18,20 @@ struct ProcessedFlags<'a> {
     uptime_flags: Option<&'a [String]>,
 }
 
-impl<'a> ProcessedFlags<'a> {
-    fn cpu_flag_refs(&self) -> Option<Vec<&str>> {
-        self.cpu_flags
-            .map(|flags| flags.iter().map(String::as_str).collect())
-    }
-
-    fn disk_flag_refs(&self) -> Option<Vec<&str>> {
-        self.disk_flags
-            .map(|flags| flags.iter().map(String::as_str).collect())
-    }
-
-    fn memory_flag_refs(&self) -> Option<Vec<&str>> {
-        self.memory_flags
-            .map(|flags| flags.iter().map(String::as_str).collect())
-    }
+macro_rules! flag_refs_method {
+    ($method_name:ident, $field:ident) => {
+        fn $method_name(&self) -> Option<Vec<&str>> {
+            self.$field
+                .map(|flags| flags.iter().map(String::as_str).collect())
+        }
+    };
+}
 
-    fn uptime_flag_refs(&self) -> Option<Vec<&str>> {
-        self.uptime_flags
-            .map(|flags| flags.iter().map(String::as_str).collect())
-    }
+impl<'a> ProcessedFlags<'a> {
+    flag_refs_method!(cpu_flag_refs, cpu_flags);
+    flag_refs_method!(disk_flag_refs, disk_flags);
+    flag_refs_method!(memory_flag_refs, memory_flags);
+    flag_refs_method!(uptime_flag_refs, uptime_flags);
 }
 
 struct StatsContext<'a> {
@@ -69,20 +63,24 @@ fn validate_network_interfaces(
 ) -> Result<()> {
     let available_interfaces: Vec<String> = networks.keys().map(|name| name.to_string()).collect();
 
+    if available_interfaces.is_empty() {
+        anyhow::bail!("No network interfaces available on this system");
+    }
+
     for interface in requested_interfaces {
-        if !available_interfaces.contains(interface) && verbose {
-            eprintln!(
-                "Warning: Network interface '{}' not found. Available interfaces: {}",
+        if !available_interfaces.contains(interface) {
+            let msg = format!(
+                "Network interface '{}' not found. Available interfaces: {}",
                 interface,
                 available_interfaces.join(", ")
             );
+            if verbose {
+                eprintln!("Warning: {}", msg);
+            }
+            anyhow::bail!("{}", msg);
         }
     }
 
-    if available_interfaces.is_empty() {
-        anyhow::bail!("No network interfaces available on this system");
-    }
-
     Ok(())
 }
 
@@ -272,3 +270,68 @@ async fn main() -> Result<()> {
 
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_process_cli_flags() {
+        let cli = cli::Cli {
+            all: false,
+            cpu: Some(vec!["usage".to_string()]),
+            disk: None,
+            memory: Some(vec!["ram_total".to_string()]),
+            network: None,
+            system: None,
+            uptime: None,
+            interval: 5,
+            network_refresh_rate: 5,
+            bar: None,
+            verbose: false,
+            no_units: false,
+        };
+
+        let flags = process_cli_flags(&cli);
+
+        assert!(flags.cpu_flags.is_some());
+        assert!(flags.disk_flags.is_none());
+        assert!(flags.memory_flags.is_some());
+        assert!(flags.network_flags.is_none());
+    }
+
+    #[test]
+    fn test_processed_flags_cpu_flag_refs() {
+        let cpu_flags = vec!["usage".to_string(), "count".to_string()];
+        let flags = ProcessedFlags {
+            cpu_flags: Some(&cpu_flags),
+            disk_flags: None,
+            memory_flags: None,
+            network_flags: None,
+            uptime_flags: None,
+        };
+
+        let refs = flags.cpu_flag_refs();
+        assert!(refs.is_some());
+        let refs_vec = refs.unwrap();
+        assert_eq!(refs_vec.len(), 2);
+        assert_eq!(refs_vec[0], "usage");
+        assert_eq!(refs_vec[1], "count");
+    }
+
+    #[test]
+    fn test_processed_flags_returns_none_when_empty() {
+        let flags = ProcessedFlags {
+            cpu_flags: None,
+            disk_flags: None,
+            memory_flags: None,
+            network_flags: None,
+            uptime_flags: None,
+        };
+
+        assert!(flags.cpu_flag_refs().is_none());
+        assert!(flags.disk_flag_refs().is_none());
+        assert!(flags.memory_flag_refs().is_none());
+        assert!(flags.uptime_flag_refs().is_none());
+    }
+}

src/sketchybar.rs

@@ -6,6 +6,8 @@ use tokio::sync::Mutex;
 use tokio::time::{Duration, Instant};
 
 // Modified from sketchybar-rs (https://github.com/johnallen3d/sketchybar-rs)
+const PORT_REFRESH_INTERVAL_SECS: u64 = 300;
+
 #[link(name = "sketchybar", kind = "static")]
 extern "C" {
     fn sketchybar(message: *const c_char, bar_name: *const c_char) -> *mut c_char;
@@ -34,7 +36,7 @@ impl Sketchybar {
             bar_name: c_string,
             port_state: Mutex::new(PortState {
                 last_refresh: Instant::now(),
-                refresh_interval: Duration::from_secs(300), // 5 minutes
+                refresh_interval: Duration::from_secs(PORT_REFRESH_INTERVAL_SECS),
             }),
         })
     }