Struct cqrs_proptest::AggregateFromEventSequence

pub struct AggregateFromEventSequence<A, E> where
    A: Aggregate,
    E: AggregateEvent<A>,  { /* fields omitted */ }

A wrapper for an aggregate that was generated from an arbitrary sequence of events.

Examples

use cqrs_core::{Aggregate, AggregateEvent, Event};
use cqrs_proptest::AggregateFromEventSequence;
use proptest::{prelude::*, strategy::{LazyTupleUnion, ValueTree, WA}, test_runner::TestRunner, prop_oneof};

#[derive(Debug, Default)]
struct MyAggregate {
    active: bool
}

impl Aggregate for MyAggregate {
    fn aggregate_type() -> &'static str {
        "my_aggregate"
    }
}

#[derive(Clone, Copy, Debug)]
struct CreatedEvent{};

impl Event for CreatedEvent {
    fn event_type(&self) -> &'static str {
        "created"
    }
}

impl AggregateEvent<MyAggregate> for CreatedEvent {
    fn apply_to(self, aggregate: &mut MyAggregate) {
        aggregate.active = true;
    }
}

#[derive(Clone, Copy, Debug)]
struct DeletedEvent{};

impl Event for DeletedEvent {
    fn event_type(&self) -> &'static str {
        "deleted"
    }
}

impl AggregateEvent<MyAggregate> for DeletedEvent {
    fn apply_to(self, aggregate: &mut MyAggregate) {
        aggregate.active = false;
    }
}

#[derive(Clone, Copy, Debug)]
enum MyEvents {
    Created(CreatedEvent),
    Deleted(DeletedEvent),
}

impl Event for MyEvents {
    fn event_type(&self) -> &'static str {
        match *self {
            MyEvents::Created(ref e) => e.event_type(),
            MyEvents::Deleted(ref e) => e.event_type(),
        }
    }
}

impl AggregateEvent<MyAggregate> for MyEvents {
    fn apply_to(self, aggregate: &mut MyAggregate) {
        match self {
            MyEvents::Created(e) => e.apply_to(aggregate),
            MyEvents::Deleted(e) => e.apply_to(aggregate),
        }
    }
}

impl Arbitrary for MyEvents {
    type Parameters = ();

    fn arbitrary_with(_: Self::Parameters) -> Self::Strategy {
        prop_oneof![
            Just(MyEvents::Created(CreatedEvent{})),
            Just(MyEvents::Deleted(DeletedEvent{})),
        ]
    }

    type Strategy = LazyTupleUnion<(WA<Just<Self>>, WA<Just<Self>>)>;
}

any::<AggregateFromEventSequence<MyAggregate, MyEvents>>()
    .new_tree(&mut TestRunner::default())
    .unwrap()
    .current()
    .into_aggregate();

let parameters = (prop::collection::SizeRange::from(1..10), ());
any_with::<AggregateFromEventSequence<MyAggregate, MyEvents>>(parameters)
    .new_tree(&mut TestRunner::default())
    .unwrap()
    .current();

Methods

impl<A, E> AggregateFromEventSequence<A, E> where
    A: Aggregate,
    E: AggregateEvent<A>, 

pub fn into_aggregate(self) -> A

Unwraps the generated aggregate.

Trait Implementations

impl<A: Copy, E: Copy> Copy for AggregateFromEventSequence<A, E> where
    A: Aggregate,
    E: AggregateEvent<A>, 

impl<A: Default, E: Default> Default for AggregateFromEventSequence<A, E> where
    A: Aggregate,
    E: AggregateEvent<A>, 

fn default() -> AggregateFromEventSequence<A, E>

Returns the "default value" for a type.

impl<A: Clone, E: Clone> Clone for AggregateFromEventSequence<A, E> where
    A: Aggregate,
    E: AggregateEvent<A>, 

fn clone(&self) -> AggregateFromEventSequence<A, E>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<A: PartialEq, E: PartialEq> PartialEq<AggregateFromEventSequence<A, E>> for AggregateFromEventSequence<A, E> where
    A: Aggregate,
    E: AggregateEvent<A>, 

fn eq(&self, other: &AggregateFromEventSequence<A, E>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &AggregateFromEventSequence<A, E>) -> bool

This method tests for !=.

impl<A, E> From<A> for AggregateFromEventSequence<A, E> where
    A: Aggregate,
    E: AggregateEvent<A>, 

fn from(aggregate: A) -> Self

Performs the conversion.

impl<A: Eq, E: Eq> Eq for AggregateFromEventSequence<A, E> where
    A: Aggregate,
    E: AggregateEvent<A>, 

impl<A, E> Debug for AggregateFromEventSequence<A, E> where
    A: Aggregate + Debug,
    E: AggregateEvent<A>, 

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

Formats the value using the given formatter.

impl<A: Hash, E: Hash> Hash for AggregateFromEventSequence<A, E> where
    A: Aggregate,
    E: AggregateEvent<A>, 

fn hash<__HAE: Hasher>(&self, state: &mut __HAE)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl<A, E> Arbitrary for AggregateFromEventSequence<A, E> where
    A: Aggregate + Debug,
    E: AggregateEvent<A> + Arbitrary + 'static, 

type Parameters = (SizeRange, <E as Arbitrary>::Parameters)

The type of parameters that [arbitrary_with] accepts for configuration of the generated [Strategy]. Parameters must implement [Default].

type Strategy = BoxedStrategy<Self>

The type of [Strategy] used to generate values of type Self.

fn arbitrary_with(args: Self::Parameters) -> Self::Strategy

Generates a [Strategy] for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args.

fn arbitrary() -> Self::Strategy

Generates a [Strategy] for producing arbitrary values of type the implementing type (Self).