Struct InMemoryCase 

pub struct InMemoryCase<W: PureWorkflow> { /* private fields */ }

An ExecutorFactory over InMemoryExecutor, for any workflow whose transitions are a pure function.

use turnframe_core::case::CaseRef;
use turnframe_core::ids::CaseRevision;
use turnframe_test::executors::{self, InMemoryCase};
use turnframe_test::workflows::trip::{
    TripCommand, TripWorkflow, complete_case, sample_new_extra,
};

let case = InMemoryCase::<TripWorkflow>::new(
    CaseRef::new("trip", "trip-conformance", CaseRevision(4)),
    Some(complete_case()),
    TripCommand::AddExtra { extra: sample_new_extra(1) },
    TripCommand::SetName { value: "Another name".to_owned() },
    TripCommand::Rebook,
);

let report = executors::run_all(&case).await;
assert!(report.passed(), "{report}");

Implementations

impl<W: PureWorkflow> InMemoryCase<W>

pub fn new( case_ref: CaseRef, seed_state: Option<W::State>, first: W::Command, second: W::Command, refused: W::Command, ) -> Self

Describes a case and the three commands the suite drives it with.

seed_state is the state the case starts from, installed at case_ref.expected_revision; None means the case does not exist yet, in which case the revision must be CaseRevision::ZERO and first must be the command that brings it into existence.

See SeededCase for what the three commands have to satisfy — in particular that first must not be naturally idempotent.

pub fn with_actor( self, account: impl Into<AccountId>, user: impl Into<UserId>, ) -> Self

Runs the suite as another tenant.

pub const fn case_ref(&self) -> &CaseRef

The case the factory seeds.

Trait Implementations

impl<W: PureWorkflow> Debug for InMemoryCase<W>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<W> ExecutorFactory for InMemoryCase<W>

where W: PureWorkflow + Default,

type Workflow = W

The workflow whose executor is under test.

type Executor = InMemoryExecutor<W>

The executor implementation being proven.

fn seed<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<SeedOf<Self>, String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Builds a fresh executor and seeds one case in it.

fn interrupt_after<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, seeded: &'life1 SeedOf<Self>, batch: &'life2 BatchOf<Self>, applied: usize, ) -> Pin<Box<dyn Future<Output = Result<(), String>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Commits only the first applied envelopes of batch, as a process that died mid-batch would have left them.