private void InitializeEventJournal(TIdentity aggregateId, params IAggregateEvent <TIdentity>[] events)
{
var writerGuid = Guid.NewGuid().ToString();
var writes = new AtomicWrite[events.Length];
for (var i = 0; i < events.Length; i++)
{
var committedEvent = new CommittedEvent <TIdentity, IAggregateEvent <TIdentity> >(aggregateId, events[i], new EventMetadata(), DateTimeOffset.UtcNow, i + 1);
writes[i] = new AtomicWrite(new Persistent(committedEvent, i + 1, aggregateId.Value, String.Empty, false, ActorRefs.NoSender, writerGuid));
}
var journal = Persistence.Instance.Apply(_testKit.Sys).JournalFor(null);
journal.Tell(new WriteMessages(writes, AggregateEventTestProbe.Ref, 1));
AggregateEventTestProbe.ExpectMsg <WriteMessagesSuccessful>();
for (var i = 0; i < events.Length; i++)
{
var seq = i;
AggregateEventTestProbe.ExpectMsg <WriteMessageSuccess>(x =>
x.Persistent.PersistenceId == aggregateId.ToString() &&
x.Persistent.Payload is CommittedEvent <TIdentity, IAggregateEvent <TIdentity> > &&
x.Persistent.SequenceNr == (Int64)seq + 1);
}
}
public IFixtureArranger <TAggregate, TIdentity> Using <TAggregateManager>(
Expression <Func <TAggregateManager> > aggregateManagerFactory, TIdentity aggregateId)
where TAggregateManager : ReceiveActor, IAggregateManager <TAggregate, TIdentity>
{
if (aggregateId == null)
{
throw new ArgumentNullException(nameof(aggregateId));
}
if (!AggregateEventTestProbe.IsNobody())
{
throw new InvalidOperationException(nameof(AggregateEventTestProbe));
}
if (!AggregateReplyTestProbe.IsNobody())
{
throw new InvalidOperationException(nameof(AggregateReplyTestProbe));
}
AggregateId = aggregateId;
AggregateEventTestProbe = _testKit.CreateTestProbe("aggregate-event-test-probe");
AggregateReplyTestProbe = _testKit.CreateTestProbe("aggregate-reply-test-probe");
AggregateRef = _testKit.Sys.ActorOf(Props.Create(aggregateManagerFactory), "aggregate-manager");
UsesAggregateManager = false;
AggregateProps = Props.Empty;
return(this);
}
private void InitializeSnapshotStore <TAggregateSnapshot>(TIdentity aggregateId, TAggregateSnapshot aggregateSnapshot, Int64 sequenceNumber)
where TAggregateSnapshot : IAggregateSnapshot <TAggregate, TIdentity>
{
var snapshotStore = Persistence.Instance.Apply(_testKit.Sys).SnapshotStoreFor(null);
var committedSnapshot = new CommittedSnapshot <TAggregate, TIdentity, TAggregateSnapshot>(aggregateId, aggregateSnapshot, new SnapshotMetadata(), DateTimeOffset.UtcNow, sequenceNumber);
var metadata = new AkkaSnapshotMetadata(aggregateId.ToString(), sequenceNumber);
snapshotStore.Tell(new SaveSnapshot(metadata, committedSnapshot), AggregateEventTestProbe.Ref);
AggregateEventTestProbe.ExpectMsg <SaveSnapshotSuccess>(x =>
x.Metadata.SequenceNr == sequenceNumber &&
x.Metadata.PersistenceId == aggregateId.ToString());
}
public IFixtureAsserter <TAggregate, TIdentity> ThenExpectDomainEvent <TAggregateEvent>(Predicate <IDomainEvent <TIdentity, TAggregateEvent> > domainEventPredicate = null, TimeSpan?timeout = null)
where TAggregateEvent : class, IAggregateEvent <TIdentity>
{
_testKit.Sys.EventStream.Subscribe(AggregateEventTestProbe, typeof(IDomainEvent <TIdentity, TAggregateEvent>));
if (domainEventPredicate == null)
{
AggregateEventTestProbe.ExpectMsg <DomainEvent <TIdentity, TAggregateEvent> >(duration: timeout);
}
else
{
AggregateEventTestProbe.ExpectMsg <DomainEvent <TIdentity, TAggregateEvent> >(domainEventPredicate, timeout: timeout);
}
return(this);
}
public IFixtureAsserter <TAggregate, TIdentity> ThenExpect <TAggregateEvent>(Predicate <TAggregateEvent> aggregateEventPredicate = null)
where TAggregateEvent : class, IAggregateEvent <TAggregate, TIdentity>
{
_testKit.Sys.EventStream.Subscribe(AggregateEventTestProbe, typeof(IDomainEvent <TAggregate, TIdentity, TAggregateEvent>));
if (aggregateEventPredicate == null)
{
AggregateEventTestProbe.ExpectMsg <DomainEvent <TAggregate, TIdentity, TAggregateEvent> >();
}
else
{
AggregateEventTestProbe.ExpectMsg <DomainEvent <TAggregate, TIdentity, TAggregateEvent> >(x => aggregateEventPredicate(x.AggregateEvent));
}
return(this);
}
public IFixtureArranger <TAggregate, TIdentity> For(TIdentity aggregateId)
{
if (aggregateId == null)
{
throw new ArgumentNullException(nameof(aggregateId));
}
if (!AggregateEventTestProbe.IsNobody())
{
throw new InvalidOperationException(nameof(AggregateEventTestProbe));
}
AggregateId = aggregateId;
AggregateEventTestProbe = _testKit.CreateTestProbe("aggregate-event-test-probe");
AggregateReplyTestProbe = _testKit.CreateTestProbe("aggregate-reply-test-probe");
return(this);
}
public IFixtureArranger <TAggregate, TIdentity> For(TIdentity aggregateId)
{
if (aggregateId == null)
{
throw new ArgumentNullException(nameof(aggregateId));
}
if (!AggregateEventTestProbe.IsNobody())
{
throw new InvalidOperationException(nameof(AggregateEventTestProbe));
}
AggregateId = aggregateId;
AggregateEventTestProbe = _testKit.CreateTestProbe("aggregate-event-test-probe");
AggregateReplyTestProbe = _testKit.CreateTestProbe("aggregate-reply-test-probe");
AggregateProps = Props.Create <TAggregate>(args: aggregateId);
AggregateRef = ActorRefs.Nobody;
UsesAggregateManager = false;
return(this);
}
