Add test seams and runtime coverage across modules

configurator/src/app/entry.rs

@@ -30,3 +30,57 @@ fn should_force_tiny_skia() -> bool {
     let combined = combined.to_ascii_lowercase();
     combined.contains("gnome") || combined.contains("ubuntu")
 }
+
+#[cfg(test)]
+mod tests {
+    use std::sync::{Mutex, OnceLock};
+
+    use super::*;
+
+    fn env_mutex() -> &'static Mutex<()> {
+        static LOCK: OnceLock<Mutex<()>> = OnceLock::new();
+        LOCK.get_or_init(|| Mutex::new(()))
+    }
+
+    #[test]
+    fn should_force_tiny_skia_requires_wayland_and_gnome_like_desktop() {
+        let _guard = env_mutex().lock().unwrap();
+        let original_wayland = std::env::var_os("WAYLAND_DISPLAY");
+        let original_current = std::env::var_os("XDG_CURRENT_DESKTOP");
+        let original_session = std::env::var_os("XDG_SESSION_DESKTOP");
+
+        // SAFETY: serialized by env mutex in this test module.
+        unsafe {
+            std::env::set_var("WAYLAND_DISPLAY", "wayland-0");
+            std::env::set_var("XDG_CURRENT_DESKTOP", "GNOME");
+            std::env::set_var("XDG_SESSION_DESKTOP", "");
+        }
+        assert!(should_force_tiny_skia());
+
+        // SAFETY: serialized by env mutex in this test module.
+        unsafe {
+            std::env::set_var("XDG_CURRENT_DESKTOP", "KDE");
+            std::env::set_var("XDG_SESSION_DESKTOP", "plasma");
+        }
+        assert!(!should_force_tiny_skia());
+
+        // SAFETY: serialized by env mutex in this test module.
+        unsafe {
+            std::env::remove_var("WAYLAND_DISPLAY");
+        }
+        assert!(!should_force_tiny_skia());
+
+        match original_wayland {
+            Some(value) => unsafe { std::env::set_var("WAYLAND_DISPLAY", value) },
+            None => unsafe { std::env::remove_var("WAYLAND_DISPLAY") },
+        }
+        match original_current {
+            Some(value) => unsafe { std::env::set_var("XDG_CURRENT_DESKTOP", value) },
+            None => unsafe { std::env::remove_var("XDG_CURRENT_DESKTOP") },
+        }
+        match original_session {
+            Some(value) => unsafe { std::env::set_var("XDG_SESSION_DESKTOP", value) },
+            None => unsafe { std::env::remove_var("XDG_SESSION_DESKTOP") },
+        }
+    }
+}

configurator/src/app/state.rs

@@ -122,3 +122,54 @@ impl ConfiguratorApp {
         self.is_dirty = self.draft != self.baseline;
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::time::SystemTime;
+
+    use super::*;
+
+    fn temp_config_path(name: &str) -> PathBuf {
+        std::env::temp_dir().join(format!(
+            "wayscriber-configurator-state-{}-{name}.toml",
+            std::process::id()
+        ))
+    }
+
+    #[test]
+    fn refresh_dirty_flag_tracks_draft_vs_baseline() {
+        let (mut app, _cmd) = ConfiguratorApp::new_app();
+        app.refresh_dirty_flag();
+        assert!(!app.is_dirty);
+
+        app.draft.capture_enabled = !app.draft.capture_enabled;
+        app.refresh_dirty_flag();
+        assert!(app.is_dirty);
+    }
+
+    #[test]
+    fn config_changed_on_disk_detects_newer_file() {
+        let (mut app, _cmd) = ConfiguratorApp::new_app();
+        let path = temp_config_path("mtime");
+        std::fs::write(&path, "test").expect("write config");
+
+        app.config_path = Some(path.clone());
+        app.config_mtime = Some(SystemTime::UNIX_EPOCH);
+
+        assert!(app.config_changed_on_disk());
+
+        let _ = std::fs::remove_file(path);
+    }
+
+    #[test]
+    fn config_changed_on_disk_returns_false_without_path_or_mtime() {
+        let (mut app, _cmd) = ConfiguratorApp::new_app();
+        app.config_path = None;
+        app.config_mtime = Some(SystemTime::UNIX_EPOCH);
+        assert!(!app.config_changed_on_disk());
+
+        app.config_path = Some(temp_config_path("missing"));
+        app.config_mtime = None;
+        assert!(!app.config_changed_on_disk());
+    }
+}

configurator/src/app/update/boards.rs

@@ -221,3 +221,52 @@ impl ConfiguratorApp {
         self.sync_board_color_picker_hex();
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::models::ColorPickerId;
+
+    #[test]
+    fn add_item_updates_boards_and_collapsed_state() {
+        let (mut app, _cmd) = ConfiguratorApp::new_app();
+        let before = app.draft.boards.items.len();
+
+        let _ = app.handle_boards_add_item();
+
+        assert_eq!(app.draft.boards.items.len(), before + 1);
+        assert_eq!(app.boards_collapsed.len(), app.draft.boards.items.len());
+        assert!(app.is_dirty);
+    }
+
+    #[test]
+    fn duplicate_item_inserts_copy_with_new_id() {
+        let (mut app, _cmd) = ConfiguratorApp::new_app();
+        let before = app.draft.boards.items.len();
+        let original_id = app
+            .draft
+            .boards
+            .items
+            .first()
+            .map(|item| item.id.clone())
+            .unwrap_or_default();
+
+        let _ = app.handle_boards_duplicate_item(0);
+
+        assert_eq!(app.draft.boards.items.len(), before + 1);
+        assert_eq!(app.boards_collapsed.len(), app.draft.boards.items.len());
+        assert_ne!(app.draft.boards.items[1].id, original_id);
+    }
+
+    #[test]
+    fn remove_item_clears_board_color_picker_when_targeting_board_entry() {
+        let (mut app, _cmd) = ConfiguratorApp::new_app();
+        let _ = app.handle_boards_add_item();
+        app.color_picker_open = Some(ColorPickerId::BoardBackground(0));
+
+        let _ = app.handle_boards_remove_item(0);
+
+        assert!(app.color_picker_open.is_none());
+        assert_eq!(app.boards_collapsed.len(), app.draft.boards.items.len());
+    }
+}

configurator/src/app/update/config.rs

@@ -131,3 +131,110 @@ impl ConfiguratorApp {
         Command::none()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use std::path::PathBuf;
+    use std::sync::Arc;
+    use std::time::SystemTime;
+
+    use super::*;
+    use crate::models::ColorPickerId;
+
+    fn status_contains(status: &StatusMessage, needle: &str) -> bool {
+        match status {
+            StatusMessage::Info(text)
+            | StatusMessage::Success(text)
+            | StatusMessage::Error(text) => text.contains(needle),
+            StatusMessage::Idle => false,
+        }
+    }
+
+    fn temp_config_path(name: &str) -> PathBuf {
+        std::env::temp_dir().join(format!(
+            "wayscriber-configurator-update-config-{}-{name}.toml",
+            std::process::id()
+        ))
+    }
+
+    #[test]
+    fn handle_config_loaded_success_resets_loading_and_dirty_state() {
+        let (mut app, _cmd) = ConfiguratorApp::new_app();
+        app.color_picker_open = Some(ColorPickerId::StatusBarBg);
+        app.is_dirty = true;
+
+        let _ = app.handle_config_loaded(Ok(Arc::new(Config::default())));
+
+        assert!(!app.is_loading);
+        assert!(!app.is_dirty);
+        assert!(app.color_picker_open.is_none());
+        assert_eq!(app.boards_collapsed.len(), app.draft.boards.items.len());
+        assert!(status_contains(
+            &app.status,
+            "Configuration loaded from disk."
+        ));
+    }
+
+    #[test]
+    fn handle_config_loaded_error_updates_status() {
+        let (mut app, _cmd) = ConfiguratorApp::new_app();
+        let _ = app.handle_config_loaded(Err("broken".to_string()));
+
+        assert!(!app.is_loading);
+        assert!(status_contains(
+            &app.status,
+            "Failed to load config from disk: broken"
+        ));
+    }
+
+    #[test]
+    fn handle_save_requested_blocks_when_config_changed_on_disk() {
+        let (mut app, _cmd) = ConfiguratorApp::new_app();
+        let path = temp_config_path("mtime");
+        std::fs::write(&path, "x").expect("write config");
+        app.config_path = Some(path.clone());
+        app.config_mtime = Some(SystemTime::UNIX_EPOCH);
+
+        let _ = app.handle_save_requested();
+
+        assert!(!app.is_saving);
+        assert!(status_contains(
+            &app.status,
+            "Configuration changed on disk. Reload before saving."
+        ));
+        let _ = std::fs::remove_file(path);
+    }
+
+    #[test]
+    fn handle_save_requested_sets_saving_for_valid_draft() {
+        let (mut app, _cmd) = ConfiguratorApp::new_app();
+        app.is_saving = false;
+        app.config_path = None;
+        app.config_mtime = None;
+
+        let _ = app.handle_save_requested();
+
+        assert!(app.is_saving);
+        assert!(status_contains(&app.status, "Saving configuration..."));
+    }
+
+    #[test]
+    fn handle_config_saved_success_clears_dirty_and_records_backup() {
+        let (mut app, _cmd) = ConfiguratorApp::new_app();
+        app.is_saving = true;
+        app.is_dirty = true;
+        app.draft.capture_enabled = !app.draft.capture_enabled;
+        let backup = PathBuf::from("/tmp/wayscriber-config.bak");
+
+        let _ = app.handle_config_saved(Ok((Some(backup.clone()), Arc::new(Config::default()))));
+
+        assert!(!app.is_saving);
+        assert!(!app.is_dirty);
+        assert_eq!(app.last_backup_path, Some(backup));
+        assert_eq!(app.draft, app.baseline);
+        assert!(status_contains(
+            &app.status,
+            "Configuration saved successfully."
+        ));
+    }
+}

configurator/src/app/view/widgets/validation.rs

@@ -115,3 +115,57 @@ pub(in crate::app::view) fn validate_usize_min(value: &str, min: usize) -> Optio
         Err(_) => Some("Expected a whole number".to_string()),
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn validate_f64_range_accepts_bounds_and_rejects_outside() {
+        assert_eq!(validate_f64_range("0.5", 0.5, 2.0), None);
+        assert_eq!(validate_f64_range("2.0", 0.5, 2.0), None);
+        assert_eq!(
+            validate_f64_range("2.1", 0.5, 2.0),
+            Some("Range: 0.5-2".to_string())
+        );
+        assert_eq!(
+            validate_f64_range("", 0.5, 2.0),
+            Some("Expected a numeric value".to_string())
+        );
+    }
+
+    #[test]
+    fn validate_u32_range_reports_expected_errors() {
+        assert_eq!(validate_u32_range("10", 1, 100), None);
+        assert_eq!(
+            validate_u32_range("0", 1, 100),
+            Some("Range: 1-100".to_string())
+        );
+        assert_eq!(
+            validate_u32_range("abc", 1, 100),
+            Some("Expected a whole number".to_string())
+        );
+    }
+
+    #[test]
+    fn validate_u64_helpers_enforce_range_and_minimum() {
+        assert_eq!(validate_u64_range("5", 1, 10), None);
+        assert_eq!(
+            validate_u64_range("11", 1, 10),
+            Some("Range: 1-10".to_string())
+        );
+        assert_eq!(validate_u64_min("10", 10), None);
+        assert_eq!(validate_u64_min("9", 10), Some("Minimum: 10".to_string()));
+    }
+
+    #[test]
+    fn validate_usize_helpers_enforce_range_and_minimum() {
+        assert_eq!(validate_usize_range("3", 1, 5), None);
+        assert_eq!(
+            validate_usize_range("6", 1, 5),
+            Some("Range: 1-5".to_string())
+        );
+        assert_eq!(validate_usize_min("3", 3), None);
+        assert_eq!(validate_usize_min("2", 3), Some("Minimum: 3".to_string()));
+    }
+}