Struct TestHarness 

pub struct TestHarness<S, A: Action> {
    pub state: S,
    /* private fields */
}

Generic test harness for tui-dispatch applications.

Provides:

• State management with a simple state field
• Action channel for capturing emitted actions
• Helper methods for dispatching and draining actions

Type Parameters

• S: The state type
• A: The action type (must implement Action)

Example

use tui_dispatch::testing::TestHarness;

#[derive(Clone, Debug, PartialEq)]
enum MyAction { Foo, Bar(i32) }

let mut harness = TestHarness::<MyState, MyAction>::new(MyState::default());

// Emit actions (simulating what handlers would do)
harness.emit(MyAction::Foo);
harness.emit(MyAction::Bar(42));

// Drain and verify
let actions = harness.drain_emitted();
assert_eq!(actions.len(), 2);

Fields

state: S

The application state under test

Implementations

impl<S, A: Action> TestHarness<S, A>

pub fn new(state: S) -> Self

Create a new test harness with the given initial state.

pub fn sender(&self) -> UnboundedSender<A>

Get a clone of the action sender for passing to handlers.

pub fn emit(&self, action: A)

Emit an action (simulates what a handler would do).

pub fn drain_emitted(&mut self) -> Vec<A>

Drain all emitted actions from the channel.

pub fn has_emitted(&mut self) -> bool

Check if any actions were emitted.

pub fn complete_action(&self, action: A)

Simulate async action completion (semantic alias for Self::emit).

Use this when simulating backend responses or async operation results.

Example

use tui_dispatch::testing::TestHarness;

harness.complete_action(Action::DidConnect { id: "conn-1", .. });
harness.complete_action(Action::DidScanKeys { keys: vec!["foo", "bar"] });

pub fn complete_actions(&self, actions: impl IntoIterator<Item = A>)

Simulate multiple async action completions.

Example

harness.complete_actions([
    Action::DidConnect { id: "conn-1" },
    Action::DidLoadValue { key: "foo", value: "bar" },
]);

pub fn send_keys<C, H>(&mut self, keys: &str, handler: H) -> Vec<A>

where C: ComponentId, H: FnMut(&mut S, Event<C>) -> Vec<A>,

Send a sequence of key events and collect actions from a handler.

Parses the space-separated key string and calls the handler for each event, collecting all returned actions.

Example

use tui_dispatch::testing::TestHarness;

let mut harness = TestHarness::<AppState, Action>::new(AppState::default());

// Send key sequence and collect actions
let actions = harness.send_keys("ctrl+p down down enter", |state, event| {
    component.handle_event(&event.kind, ComponentProps { state })
});

actions.assert_contains(Action::SelectItem(2));

pub fn send_keys_emit<C, H>(&mut self, keys: &str, handler: H)

where C: ComponentId, H: FnMut(&mut S, Event<C>) -> Vec<A>,

Send a sequence of key events, calling handler and emitting returned actions.

Unlike Self::send_keys, this method emits returned actions to the harness channel, allowing you to drain them later.

Example

harness.send_keys_emit("ctrl+p down enter", |state, event| {
    component.handle_event(&event.kind, props)
});

let actions = harness.drain_emitted();
actions.assert_contains(Action::Confirm);

impl<S, A: ActionCategory> TestHarness<S, A>

Category-aware methods for TestHarness.

These methods are available when the action type implements ActionCategory, enabling filtering and assertions by action category.

pub fn drain_category(&mut self, category: &str) -> Vec<A>

Drain all emitted actions that belong to a specific category.

Actions not matching the category remain in the channel for later draining.

Example

use tui_dispatch::testing::TestHarness;

let mut harness = TestHarness::<MyState, MyAction>::new(MyState::default());

// Emit various actions
harness.emit(MyAction::SearchStart);
harness.emit(MyAction::ConnectionFormOpen);
harness.emit(MyAction::SearchClear);

// Drain only search-related actions
let search_actions = harness.drain_category("search");
assert_eq!(search_actions.len(), 2);

// Other actions remain
let remaining = harness.drain_emitted();
assert_eq!(remaining.len(), 1);

pub fn has_category(&mut self, category: &str) -> bool

Check if any action of the given category was emitted.

This drains only the matching category, leaving other actions in the channel.

Trait Implementations

impl<S: Default, A: Action> Default for TestHarness<S, A>

fn default() -> Self

Returns the “default value” for a type.