Add tests for prefix support

Author: TBThomas56

src/app.rs

@@ -437,3 +437,146 @@ impl App<'_> {
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // Helper function to test numeric prefix parsing logic
+    fn test_process_numeric_prefix_logic(
+        numeric_prefix: &str,
+        user_event: UserEvent,
+    ) -> Option<UserEventWithCount> {
+        let count = if numeric_prefix.is_empty() {
+            1
+        } else {
+            numeric_prefix.parse::<usize>().unwrap_or(1)
+        };
+
+        match user_event {
+            UserEvent::NavigateUp | UserEvent::NavigateDown | UserEvent::NavigateLeft | UserEvent::NavigateRight |
+            UserEvent::ScrollUp | UserEvent::ScrollDown | UserEvent::PageUp | UserEvent::PageDown |
+            UserEvent::HalfPageUp | UserEvent::HalfPageDown => {
+                Some(UserEventWithCount::new(user_event, count))
+            }
+            _ => {
+                if numeric_prefix.is_empty() {
+                    Some(UserEventWithCount::new(user_event, 1))
+                } else {
+                    None
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn test_process_numeric_prefix_no_prefix() {
+        let result = test_process_numeric_prefix_logic("", UserEvent::NavigateDown);
+
+        assert!(result.is_some());
+        let event_with_count = result.unwrap();
+        assert_eq!(event_with_count.event, UserEvent::NavigateDown);
+        assert_eq!(event_with_count.count, 1);
+    }
+
+    #[test]
+    fn test_process_numeric_prefix_with_prefix() {
+        let result = test_process_numeric_prefix_logic("5", UserEvent::NavigateDown);
+
+        assert!(result.is_some());
+        let event_with_count = result.unwrap();
+        assert_eq!(event_with_count.event, UserEvent::NavigateDown);
+        assert_eq!(event_with_count.count, 5);
+    }
+
+    #[test]
+    fn test_process_numeric_prefix_invalid_number() {
+        let result = test_process_numeric_prefix_logic("abc", UserEvent::NavigateDown);
+
+        assert!(result.is_some());
+        let event_with_count = result.unwrap();
+        assert_eq!(event_with_count.event, UserEvent::NavigateDown);
+        assert_eq!(event_with_count.count, 1); // Should fallback to 1
+    }
+
+    #[test]
+    fn test_process_numeric_prefix_countable_events() {
+        let countable_events = [
+            UserEvent::NavigateUp,
+            UserEvent::NavigateDown,
+            UserEvent::NavigateLeft,
+            UserEvent::NavigateRight,
+            UserEvent::ScrollUp,
+            UserEvent::ScrollDown,
+            UserEvent::PageUp,
+            UserEvent::PageDown,
+            UserEvent::HalfPageUp,
+            UserEvent::HalfPageDown,
+        ];
+
+        for event in countable_events {
+            let result = test_process_numeric_prefix_logic("3", event);
+            assert!(result.is_some());
+            let event_with_count = result.unwrap();
+            assert_eq!(event_with_count.event, event);
+            assert_eq!(event_with_count.count, 3);
+        }
+    }
+
+    #[test]
+    fn test_process_numeric_prefix_non_countable_events() {
+        let non_countable_events = [
+            UserEvent::Quit,
+            UserEvent::Confirm,
+            UserEvent::Cancel,
+            UserEvent::HelpToggle,
+            UserEvent::Search,
+            UserEvent::ShortCopy,
+            UserEvent::FullCopy,
+        ];
+
+        for event in non_countable_events {
+            let result = test_process_numeric_prefix_logic("5", event);
+            assert!(result.is_none()); // Should return None when prefix exists but event isn't countable
+        }
+    }
+
+    #[test]
+    fn test_process_numeric_prefix_non_countable_events_no_prefix() {
+        let result = test_process_numeric_prefix_logic("", UserEvent::Confirm);
+        assert!(result.is_some());
+        let event_with_count = result.unwrap();
+        assert_eq!(event_with_count.event, UserEvent::Confirm);
+        assert_eq!(event_with_count.count, 1);
+    }
+
+    #[test]
+    fn test_process_numeric_prefix_large_numbers() {
+        let result = test_process_numeric_prefix_logic("999", UserEvent::NavigateDown);
+
+        assert!(result.is_some());
+        let event_with_count = result.unwrap();
+        assert_eq!(event_with_count.event, UserEvent::NavigateDown);
+        assert_eq!(event_with_count.count, 999);
+    }
+
+    #[test]
+    fn test_process_numeric_prefix_zero() {
+        let result = test_process_numeric_prefix_logic("0", UserEvent::NavigateUp);
+
+        assert!(result.is_some());
+        let event_with_count = result.unwrap();
+        assert_eq!(event_with_count.event, UserEvent::NavigateUp);
+        assert_eq!(event_with_count.count, 1); // UserEventWithCount::new converts 0 to 1
+    }
+
+    #[test]
+    fn test_process_numeric_prefix_multi_digit() {
+        let result = test_process_numeric_prefix_logic("42", UserEvent::ScrollDown);
+
+        assert!(result.is_some());
+        let event_with_count = result.unwrap();
+        assert_eq!(event_with_count.event, UserEvent::ScrollDown);
+        assert_eq!(event_with_count.count, 42);
+    }
+}

src/event.rs

@@ -136,3 +136,39 @@ impl UserEventWithCount {
         Self::new(event, 1)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_user_event_with_count_new() {
+        let event = UserEventWithCount::new(UserEvent::NavigateUp, 5);
+        assert_eq!(event.event, UserEvent::NavigateUp);
+        assert_eq!(event.count, 5);
+    }
+
+    #[test]
+    fn test_user_event_with_count_new_zero_count() {
+        let event = UserEventWithCount::new(UserEvent::NavigateDown, 0);
+        assert_eq!(event.event, UserEvent::NavigateDown);
+        assert_eq!(event.count, 1); // zero should be converted to 1
+    }
+
+    #[test]
+    fn test_user_event_with_count_from_event() {
+        let event = UserEventWithCount::from_event(UserEvent::NavigateLeft);
+        assert_eq!(event.event, UserEvent::NavigateLeft);
+        assert_eq!(event.count, 1);
+    }
+
+    #[test]
+    fn test_user_event_with_count_equality() {
+        let event1 = UserEventWithCount::new(UserEvent::ScrollUp, 3);
+        let event2 = UserEventWithCount::new(UserEvent::ScrollUp, 3);
+        let event3 = UserEventWithCount::new(UserEvent::ScrollDown, 3);
+
+        assert_eq!(event1, event2);
+        assert_ne!(event1, event3);
+    }
+}

tests/numeric_prefix.rs

@@ -0,0 +1,99 @@
+use ratatui::crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
+
+/// Test helper to check if a character is a valid numeric prefix digit
+fn is_valid_numeric_prefix_char(c: char, current_prefix: &str) -> bool {
+    c.is_ascii_digit() && (c != '0' || !current_prefix.is_empty())
+}
+
+/// Test helper to simulate the numeric prefix accumulation logic
+fn simulate_numeric_input(inputs: &[char]) -> String {
+    let mut prefix = String::new();
+
+    for &c in inputs {
+        if is_valid_numeric_prefix_char(c, &prefix) {
+            prefix.push(c);
+        } else {
+            // Non-numeric character would trigger command processing
+            break;
+        }
+    }
+
+    prefix
+}
+
+#[test]
+fn test_numeric_prefix_single_digit() {
+    assert_eq!(simulate_numeric_input(&['5']), "5");
+    assert_eq!(simulate_numeric_input(&['1']), "1");
+    assert_eq!(simulate_numeric_input(&['9']), "9");
+}
+
+#[test]
+fn test_numeric_prefix_multiple_digits() {
+    assert_eq!(simulate_numeric_input(&['1', '2', '3']), "123");
+    assert_eq!(simulate_numeric_input(&['4', '2']), "42");
+    assert_eq!(simulate_numeric_input(&['9', '9', '9']), "999");
+}
+
+#[test]
+fn test_numeric_prefix_zero_rules() {
+    // Zero should not be accepted as the first character
+    assert_eq!(simulate_numeric_input(&['0']), "");
+
+    // But zero should be accepted after other digits
+    assert_eq!(simulate_numeric_input(&['1', '0']), "10");
+    assert_eq!(simulate_numeric_input(&['2', '0', '5']), "205");
+}
+
+#[test]
+fn test_numeric_prefix_stops_at_non_digit() {
+    assert_eq!(simulate_numeric_input(&['5', 'j']), "5");
+    assert_eq!(simulate_numeric_input(&['1', '2', 'k']), "12");
+    assert_eq!(simulate_numeric_input(&['3', ' ']), "3");
+}
+
+#[test]
+fn test_numeric_prefix_empty_for_non_numeric_start() {
+    assert_eq!(simulate_numeric_input(&['j']), "");
+    assert_eq!(simulate_numeric_input(&['k']), "");
+    assert_eq!(simulate_numeric_input(&[' ']), "");
+}
+
+#[test]
+fn test_numeric_prefix_parsing() {
+    assert_eq!("5".parse::<usize>().unwrap_or(1), 5);
+    assert_eq!("42".parse::<usize>().unwrap_or(1), 42);
+    assert_eq!("999".parse::<usize>().unwrap_or(1), 999);
+    assert_eq!("".parse::<usize>().unwrap_or(1), 1);
+    assert_eq!("abc".parse::<usize>().unwrap_or(1), 1);
+}
+
+#[test]
+fn test_key_event_digit_detection() {
+    let digit_events = [
+        KeyEvent::new(KeyCode::Char('0'), KeyModifiers::empty()),
+        KeyEvent::new(KeyCode::Char('1'), KeyModifiers::empty()),
+        KeyEvent::new(KeyCode::Char('5'), KeyModifiers::empty()),
+        KeyEvent::new(KeyCode::Char('9'), KeyModifiers::empty()),
+    ];
+
+    for event in digit_events {
+        if let KeyCode::Char(c) = event.code {
+            assert!(c.is_ascii_digit());
+        }
+    }
+
+    let non_digit_events = [
+        KeyEvent::new(KeyCode::Char('j'), KeyModifiers::empty()),
+        KeyEvent::new(KeyCode::Char('k'), KeyModifiers::empty()),
+        KeyEvent::new(KeyCode::Enter, KeyModifiers::empty()),
+        KeyEvent::new(KeyCode::Esc, KeyModifiers::empty()),
+    ];
+
+    for event in non_digit_events {
+        match event.code {
+            KeyCode::Char(c) => assert!(!c.is_ascii_digit()),
+            _ => {} // Non-char keys are also non-digits
+        }
+    }
+}