Struct EffectStoreTestHarness 

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

Test harness for effect-based stores.

Similar to StoreTestHarness but for applications using EffectStore with DispatchResult reducers.

Example

use tui_dispatch::testing::EffectStoreTestHarness;

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

// Dispatch and collect effects
harness.dispatch_collect(Action::WeatherFetch);
harness.assert_state(|s| s.is_loading);

// Check emitted effects
let effects = harness.drain_effects();
effects.assert_count(1);
effects.assert_first_matches(|e| matches!(e, Effect::FetchWeather { .. }));

// Simulate async completion
harness.complete_action(Action::WeatherDidLoad(data));
harness.process_emitted();
harness.assert_state(|s| s.weather.is_some());

Implementations

impl<S, A: Action, E> EffectStoreTestHarness<S, A, E>

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

Create a new harness with initial state and effect 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) -> DispatchResult<E>

Dispatch an action to the store.

Returns the DispatchResult with change status and effects.

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

Dispatch an action and automatically collect its effects.

Returns true if state changed. Effects are collected internally and can be retrieved with Self::drain_effects.

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

Dispatch multiple actions, collecting all effects.

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 drain_effects(&mut self) -> Vec<E>

Drain all collected effects.

pub fn has_effects(&self) -> bool

Check if any effects were collected.

pub fn effect_count(&self) -> usize

Get the number of collected effects.

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, collecting effects.

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.

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. Effects are collected.

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

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

Assert a condition on the current state.

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.

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.