Struct TestRunner 

pub struct TestRunner<A: App> { /* private fields */ }

A test runner for TEA applications

Provides a convenient way to test update logic without running the UI.

Implementations

impl<A: App> TestRunner<A>

pub fn new() -> Self

Create a new test runner with initial model

pub fn with_model(model: A::Model) -> Self

Create a test runner with a custom initial model

pub fn send(&mut self, msg: A::Msg) -> &mut Self

Send a message and process the update

pub fn send_all(&mut self, msgs: impl IntoIterator<Item = A::Msg>) -> &mut Self

Send multiple messages in sequence

pub fn model(&self) -> &A::Model

Get a reference to the current model

pub fn model_mut(&mut self) -> &mut A::Model

Get a mutable reference to the model (for setup)

pub fn last_cmd(&self) -> Option<&CmdRecord<A::Msg>>

Get the last command record

pub fn commands(&self) -> &[CmdRecord<A::Msg>]

Get all command records

pub fn clear_commands(&mut self) -> &mut Self

Clear command history

pub fn last_was_none(&self) -> bool

Check if the last command was Cmd::None

pub fn last_was_task(&self) -> bool

Check if the last command was Cmd::Task

pub fn last_was_msg(&self) -> bool

Check if the last command was Cmd::Msg

pub fn pending_task_count(&self) -> usize

Get the number of pending async tasks

pub fn has_pending_tasks(&self) -> bool

Check if there are any pending async tasks

pub async fn process_task(&mut self) -> bool

Process one pending async task

Executes the first pending task, awaits its result, and sends the resulting message through update.

Returns true if a task was processed, false if no tasks were pending.

Example

runner.send(Msg::FetchData);
assert!(runner.has_pending_tasks());

runner.process_task().await;
assert!(!runner.has_pending_tasks());

pub async fn process_tasks(&mut self) -> &mut Self

Process all pending async tasks

Processes tasks until none remain. Note that processing a task may add new tasks (if the resulting message produces new Cmd::Task), so this processes until the queue is fully drained.

Example

runner.send(Msg::FetchData);
runner.process_tasks().await;
// All tasks completed, results sent through update

pub async fn process_n_tasks(&mut self, n: usize) -> &mut Self

Process exactly N pending tasks

Useful when you want to control the order of task execution or test intermediate states.

Panics

Panics if there are fewer than N pending tasks.

pub fn expect_model( &mut self, predicate: impl FnOnce(&A::Model) -> bool, ) -> &mut Self

Assert that the model satisfies a predicate

Example

runner
    .send(Msg::Inc)
    .expect_model(|m| m.count == 1)
    .send(Msg::Inc)
    .expect_model(|m| m.count == 2);

Panics

Panics if the predicate returns false

pub fn expect_model_msg( &mut self, predicate: impl FnOnce(&A::Model) -> bool, msg: &str, ) -> &mut Self

Assert that the model satisfies a predicate with custom message

Panics

Panics with the provided message if the predicate returns false

pub fn expect_cmd_none(&mut self) -> &mut Self

Assert that the last command was Cmd::None

Example

runner
    .send(Msg::SetValue(42))
    .expect_cmd_none();

Panics

Panics if the last command was not Cmd::None

pub fn expect_cmd_task(&mut self) -> &mut Self

Assert that the last command was Cmd::Task

Example

runner
    .send(Msg::FetchData)
    .expect_cmd_task();

Panics

Panics if the last command was not Cmd::Task

pub fn expect_cmd_msg(&mut self) -> &mut Self

Assert that the last command was Cmd::Msg

Example

runner
    .send(Msg::TriggerDelayed)
    .expect_cmd_msg();

Panics

Panics if the last command was not Cmd::Msg

pub fn expect_cmd_msg_eq(&mut self, expected: A::Msg) -> &mut Self

where A::Msg: PartialEq + Debug,

Assert that the last command was Cmd::Msg and verify its content

Example

runner
    .send(Msg::TriggerDelayed)
    .expect_cmd_msg_eq(Msg::Inc);

Panics

Panics if the last command was not Cmd::Msg or the message doesn’t match

pub fn expect_cmd_batch(&mut self) -> &mut Self

Assert that the last command was Cmd::Batch

Example

runner
    .send(Msg::MultiAction)
    .expect_cmd_batch();

Panics

Panics if the last command was not Cmd::Batch

pub fn expect_cmd_batch_size(&mut self, expected_size: usize) -> &mut Self

Assert that the last command was Cmd::Batch with expected size

Example

runner
    .send(Msg::MultiAction)
    .expect_cmd_batch_size(3);

Panics

Panics if the last command was not Cmd::Batch or size doesn’t match

Trait Implementations

impl<A: App> Default for TestRunner<A>

fn default() -> Self

Returns the “default value” for a type.

impl<A: App> ModelAssert<<A as App>::Model> for TestRunner<A>

fn assert_that(&self, predicate: impl FnOnce(&A::Model) -> bool, msg: &str)

Assert with a predicate