Struct InMemoryStore 

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

A Load/Save/Delete implementation backed by an in-memory HashMap, with last-write-wins semantics (see Save’s docs for what that means for PortErrorKind::Conflict).

Examples

See Save for a worked example of saving and loading through an InMemoryStore. The example below covers the store’s own inspection methods, useful for asserting on what a use case persisted.

use ddd_toolkit_core::domain::{AggregateRoot, DomainEvent, Entity, EntityId, ValueObject};
use ddd_toolkit_core::mock::repository::InMemoryStore;
use ddd_toolkit_core::port::repository::Save;
use std::fmt::Display;

let store = InMemoryStore::new();
assert!(store.is_empty());

let mut order = Order { id: OrderId(1), events: vec![OrderPlaced] };
block_on(store.save(&mut order))?;

assert_eq!(store.len(), 1);

// events recorded across every save() call so far, for asserting a use
// case published what it was supposed to
assert_eq!(store.take_recorded_events(), vec![OrderPlaced]);
assert_eq!(store.take_recorded_events(), vec![]); // drained

Implementations

impl<A> InMemoryStore<A>

where A: AggregateRoot,

pub fn new() -> InMemoryStore<A>

Creates a new, empty store.

pub fn take_recorded_events(&self) -> Vec<<A as AggregateRoot>::Event>

Returns and clears every event recorded by a save call so far.

pub fn len(&self) -> usize

The number of aggregates currently stored.

pub fn is_empty(&self) -> bool

Whether the store currently holds no aggregates.

Trait Implementations

impl<A> Debug for InMemoryStore<A>

where A: Debug + AggregateRoot,

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

Formats the value using the given formatter.

impl<A> Default for InMemoryStore<A>

where A: AggregateRoot,

fn default() -> InMemoryStore<A>

Returns the “default value” for a type.

impl<A> Delete<A> for InMemoryStore<A>

where A: AggregateRoot + Clone,

async fn delete(&self, id: &<A as Entity>::Id) -> Result<(), PortError>

Deletes the aggregate with the given id. See the trait-level docs for why deleting a missing id is not an error.

impl<A> Load<A> for InMemoryStore<A>

where A: AggregateRoot + Clone,

async fn load(&self, id: &<A as Entity>::Id) -> Result<Option<A>, PortError>

Returns the aggregate with the given id, or None if it doesn’t exist.

impl<A> Save<A> for InMemoryStore<A>

where A: AggregateRoot + Clone,

async fn save(&self, aggregate: &mut A) -> Result<(), PortError>

Persists the aggregate, draining and recording any events it has accumulated via AggregateRoot::take_events. See the trait-level docs for the Conflict contract.