Struct InMemoryRepository 

pub struct InMemoryRepository<A>
where
    A: AggregateRoot,
{ /* private fields */ }

A thread-safe, in-memory Repository implementation for tests.

Keys aggregates by their id (A::Id: Eq + Hash + Clone) and stores cloned state. On save it drains the aggregate’s pending events (as a real repository would, e.g. into an outbox) and records them for later inspection via drained_events.

Its Error is Infallible: nothing here can fail.

Implementations

impl<A> InMemoryRepository<A>

where A: AggregateRoot, A::Id: Eq + Hash + Clone,

pub fn new() -> Self

An empty repository.

pub fn len(&self) -> usize

The number of stored aggregates.

pub fn is_empty(&self) -> bool

Whether the repository holds no aggregates.

pub fn contains(&self, id: &A::Id) -> bool

Whether an aggregate with id is stored.

pub fn insert(&self, aggregate: A)

Insert (or replace) an aggregate’s state directly, without draining its events — a convenience for seeding fixtures.

pub fn drained_events(&self) -> Vec<A::Event>

Remove and return all events captured from save calls so far.

Each save appends the aggregate’s drained events here, preserving order across saves. Calling this clears the buffer.

pub fn drained_event_count(&self) -> usize

The number of events captured from save calls (without draining them).

Trait Implementations

impl<A> Default for InMemoryRepository<A>

where A: AggregateRoot, A::Id: Eq + Hash + Clone,

fn default() -> Self

Returns the “default value” for a type.

impl<A> Repository<A> for InMemoryRepository<A>

where A: AggregateRoot + Clone + Send + Sync, A::Id: Eq + Hash + Clone + Send + Sync, A::Event: Send,

type Error = Infallible

The error type the implementation reports.

fn find<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 A::Id, ) -> Pin<Box<dyn Future<Output = Result<Option<A>, Infallible>> + Send + 'async_trait>>

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

Load an aggregate by id, or None if it does not exist.

fn save<'life0, 'life1, 'async_trait>( &'life0 self, aggregate: &'life1 mut A, ) -> Pin<Box<dyn Future<Output = Result<(), Infallible>> + Send + 'async_trait>>

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

Persist an aggregate. Takes &mut so the implementation may drain its events (e.g. into an outbox) as part of the save.

fn delete<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 A::Id, ) -> Pin<Box<dyn Future<Output = Result<(), Infallible>> + Send + 'async_trait>>

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

Delete an aggregate by id.