Struct EventCollector 

pub struct EventCollector<E> { /* private fields */ }

A projector that collects events for testing assertions.

EventCollector stores events in shared, thread-safe storage (Arc<Mutex<Vec<E>>>) so that events can be inspected after projection completes. This is the primary mechanism for black-box integration testing in EventCore.

Type Parameters

• E: The event type to collect. Must be Clone so that events() can return owned copies without consuming the collector.

Thread Safety

The internal storage uses Arc<Mutex<_>> to allow the collector to be shared across threads (e.g., between the projection runner and test assertions).

Implementations

impl<E> EventCollector<E>

pub fn new(storage: Arc<Mutex<Vec<E>>>) -> Self

Creates a new EventCollector with the provided shared storage.

Arguments

• storage - An Arc<Mutex<Vec<E>>> that will hold collected events. The same storage can be cloned before passing to enable access to collected events after the collector is moved.

pub fn events(&self) -> Vec<E>

where E: Clone,

Returns a clone of all collected events.

This method clones the internal vector, allowing inspection without consuming the collector. The Clone bound on E enables this behavior.

Trait Implementations

impl<E: Debug> Debug for EventCollector<E>

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

Formats the value using the given formatter.

impl<E: Send + 'static> Projector for EventCollector<E>

type Event = E

The domain event type this projector handles.

type Error = Infallible

The error type returned when projection fails.

type Context = ()

Shared context for database connections, caches, etc.

fn apply( &mut self, event: Self::Event, _position: StreamPosition, _ctx: &mut Self::Context, ) -> Result<(), Self::Error>

Process a single event and update the read model.

fn name(&self) -> &str

Return a unique identifier for this projector.

fn on_error(&mut self, _ctx: FailureContext<'_, Self::Error>) -> FailureStrategy

Handle event processing errors and determine failure strategy.