134 lines
3.4 KiB
Rust
134 lines
3.4 KiB
Rust
extern crate alloc;
|
|
|
|
use tui_orchestrator::component::{Component, ComponentAction};
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
|
|
enum TestFocus {
|
|
FieldA,
|
|
FieldB,
|
|
ButtonC,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
enum TestEvent {
|
|
ButtonCPressed,
|
|
TextTyped(char),
|
|
}
|
|
|
|
struct TestComponent {
|
|
field_a: alloc::string::String,
|
|
field_b: alloc::string::String,
|
|
}
|
|
|
|
impl Component for TestComponent {
|
|
type Focus = TestFocus;
|
|
type Action = ComponentAction;
|
|
type Event = TestEvent;
|
|
|
|
fn targets(&self) -> &[Self::Focus] {
|
|
&[
|
|
Self::Focus::FieldA,
|
|
Self::Focus::FieldB,
|
|
Self::Focus::ButtonC,
|
|
]
|
|
}
|
|
|
|
fn handle(
|
|
&mut self,
|
|
focus: &Self::Focus,
|
|
action: Self::Action,
|
|
) -> Result<Option<Self::Event>, tui_orchestrator::component::error::ComponentError> {
|
|
match (focus, action) {
|
|
(Self::Focus::ButtonC, ComponentAction::Select) => {
|
|
Ok(Some(Self::Event::ButtonCPressed))
|
|
}
|
|
_ => Ok(None),
|
|
}
|
|
}
|
|
|
|
fn on_enter(&mut self) -> Result<(), tui_orchestrator::component::error::ComponentError> {
|
|
self.field_a.clear();
|
|
self.field_b.clear();
|
|
Ok(())
|
|
}
|
|
|
|
fn handle_text(
|
|
&mut self,
|
|
focus: &Self::Focus,
|
|
ch: char,
|
|
) -> Result<Option<Self::Event>, tui_orchestrator::component::error::ComponentError> {
|
|
match focus {
|
|
Self::Focus::FieldA | Self::Focus::FieldB => Ok(Some(Self::Event::TextTyped(ch))),
|
|
_ => Ok(None),
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_component_targets() {
|
|
let component = TestComponent {
|
|
field_a: alloc::string::String::new(),
|
|
field_b: alloc::string::String::new(),
|
|
};
|
|
|
|
let targets = component.targets();
|
|
assert_eq!(targets.len(), 3);
|
|
assert_eq!(targets[0], TestFocus::FieldA);
|
|
}
|
|
|
|
#[test]
|
|
fn test_component_handle_select() {
|
|
let mut component = TestComponent {
|
|
field_a: alloc::string::String::new(),
|
|
field_b: alloc::string::String::new(),
|
|
};
|
|
|
|
let focus = TestFocus::ButtonC;
|
|
let action = ComponentAction::Select;
|
|
|
|
let event = component.handle(&focus, action);
|
|
assert!(event.is_ok());
|
|
assert!(matches!(event.unwrap(), Some(TestEvent::ButtonCPressed)));
|
|
}
|
|
|
|
#[test]
|
|
fn test_component_handle_text() {
|
|
let mut component = TestComponent {
|
|
field_a: alloc::string::String::new(),
|
|
field_b: alloc::string::String::new(),
|
|
};
|
|
|
|
let focus = TestFocus::FieldA;
|
|
let ch = 'x';
|
|
|
|
let event = component.handle_text(&focus, ch);
|
|
assert!(event.is_ok());
|
|
assert!(matches!(event.unwrap(), Some(TestEvent::TextTyped('x'))));
|
|
}
|
|
|
|
#[test]
|
|
fn test_component_on_enter_clears() {
|
|
let mut component = TestComponent {
|
|
field_a: alloc::string::String::from("test"),
|
|
field_b: alloc::string::String::from("test"),
|
|
};
|
|
|
|
component.on_enter().unwrap();
|
|
assert_eq!(component.field_a.as_str(), "");
|
|
assert_eq!(component.field_b.as_str(), "");
|
|
}
|
|
|
|
#[test]
|
|
fn test_component_defaults() {
|
|
let mut component = TestComponent {
|
|
field_a: alloc::string::String::new(),
|
|
field_b: alloc::string::String::new(),
|
|
};
|
|
|
|
assert!(component.on_exit().is_ok());
|
|
assert!(component.on_focus(&TestFocus::FieldA).is_ok());
|
|
assert!(component.on_blur(&TestFocus::FieldA).is_ok());
|
|
assert!(component.can_navigate_forward(&TestFocus::FieldA));
|
|
assert!(component.can_navigate_backward(&TestFocus::FieldA));
|
|
}
|