Struct StoreTestHarness 

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

Test harness combining Store + action channel + render capabilities.

Provides an integrated testing experience for applications using the standard Store with bool reducers.

Example

use tui_dispatch::testing::StoreTestHarness;

let mut harness = StoreTestHarness::new(AppState::default(), reducer);

// Dispatch and check state
harness.dispatch(Action::Increment);
harness.assert_state(|s| s.count == 1);

// Send keys through component
let actions = harness.send_keys::<NumericComponentId, _, _>("j j enter", |state, event| {
    component.handle_event(&event.kind, Props { state })
});
actions.assert_contains(Action::Select(2));

// Snapshot testing
let output = harness.render_plain(60, 24, |f, area, state| {
    component.render(f, area, Props { state });
});
assert!(output.contains("expected text"));

Implementations

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

pub fn new(state: S, reducer: Reducer<S, A>) -> Self

Create a new harness with initial state and reducer.

pub fn with_size(self, width: u16, height: u16) -> Self

Set the default terminal size for rendering.

pub fn dispatch(&mut self, action: A) -> bool

Dispatch an action to the store.

Returns true if the state changed.

pub fn dispatch_all( &mut self, actions: impl IntoIterator<Item = A>, ) -> Vec<bool>

Dispatch multiple actions in sequence.

Returns a vector of booleans indicating which dispatches changed state.

pub fn state(&self) -> &S

Get a reference to the current state.

pub fn state_mut(&mut self) -> &mut S

Get a mutable reference to the state for test setup.

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

Get a sender clone for simulating async action completions.

pub fn emit(&self, action: A)

Emit an action to the channel (simulates async completion).

pub fn complete_action(&self, action: A)

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

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

Simulate multiple async action completions.

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 process_emitted(&mut self) -> (usize, usize)

Process all emitted actions through the store.

Drains the channel and dispatches each action to the store. Returns (changed_count, total_count).

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

where C: ComponentId, I: IntoIterator<Item = A>, H: FnMut(&mut S, Event<C>) -> I,

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.

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

where C: ComponentId, I: IntoIterator<Item = A>, H: FnMut(&mut S, Event<C>) -> I,

Send keys and dispatch returned actions to the store.

Returns the actions that were dispatched.

pub fn assert_state<F>(&self, predicate: F)

where F: FnOnce(&S) -> bool,

Assert a condition on the current state.

Panics

Panics if the predicate returns false.

pub fn assert_state_msg<F>(&self, predicate: F, msg: &str)

where F: FnOnce(&S) -> bool,

Assert a condition with a custom message.

pub fn render<F>(&mut self, width: u16, height: u16, render_fn: F) -> String

where F: FnOnce(&mut Frame<'_>, Rect, &S),

Render using the provided function, returns string with ANSI codes.

pub fn render_plain<F>( &mut self, width: u16, height: u16, render_fn: F, ) -> String

where F: FnOnce(&mut Frame<'_>, Rect, &S),

Render to plain string (no ANSI codes).

pub fn render_default<F>(&mut self, render_fn: F) -> String

where F: FnOnce(&mut Frame<'_>, Rect, &S),

Render with default terminal size (set via Self::with_size).

pub fn render_default_plain<F>(&mut self, render_fn: F) -> String

where F: FnOnce(&mut Frame<'_>, Rect, &S),

Render with default size to plain string.

Trait Implementations

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

fn default() -> Self

Returns the “default value” for a type.