public EventConsumerGrainTests()
{
state.Position = initialPosition;
consumerName = eventConsumer.GetType().Name;
A.CallTo(() => store.WithSnapshots(A <Type> .Ignored, consumerName, A <HandleSnapshot <EventConsumerState> > .Ignored))
.Invokes(new Action <Type, string, HandleSnapshot <EventConsumerState> >((t, key, a) =>
{
apply = a;
}))
.Returns(persistence);
A.CallTo(() => eventStore.CreateSubscription(A <IEventSubscriber> .Ignored, A <string> .Ignored, A <string> .Ignored))
.Returns(eventSubscription);
A.CallTo(() => eventConsumer.Name)
.Returns(consumerName);
A.CallTo(() => persistence.ReadAsync(EtagVersion.Any))
.Invokes(new Action <long>(s => apply(state)));
A.CallTo(() => persistence.WriteSnapshotAsync(A <EventConsumerState> .Ignored))
.Invokes(new Action <EventConsumerState>(s => state = s));
A.CallTo(() => formatter.Parse(eventData, null))
.Returns(envelope);
sut = new MyEventConsumerGrain(
x => eventConsumer,
store,
eventStore,
formatter,
log);
}
public SnapshotInstance(T initial)
{
Value = initial;
Write = (state, _) =>
{
Value = state;
};
}
public GrainOfGuidTests()
{
A.CallTo(() => persistence.ReadAsync(EtagVersion.Any))
.Invokes(_ =>
{
read(new MyGrain.GrainState {
Id = id
});
});
A.CallTo(() => store.WithSnapshots(typeof(MyGrain), id, A <HandleSnapshot <MyGrain.GrainState> > .Ignored))
.Invokes(new Action <Type, Guid, HandleSnapshot <MyGrain.GrainState> >((type, id, callback) =>
{
read = callback;
}))
.Returns(persistence);
sut = new MyGrain(store);
}
public Persistence(TKey ownerKey, Type ownerType,
IEventStore eventStore,
IEventDataFormatter eventDataFormatter,
ISnapshotStore <TSnapshot, TKey> snapshotStore,
IStreamNameResolver streamNameResolver,
PersistenceMode persistenceMode,
HandleSnapshot <TSnapshot> applyState,
HandleEvent applyEvent)
{
this.ownerKey = ownerKey;
this.ownerType = ownerType;
this.applyState = applyState;
this.applyEvent = applyEvent;
this.eventStore = eventStore;
this.eventDataFormatter = eventDataFormatter;
this.persistenceMode = persistenceMode;
this.snapshotStore = snapshotStore;
this.streamNameResolver = streamNameResolver;
}
private IPersistence <T> CreatePersistence(Type owner, DomainId key, PersistenceMode mode, HandleSnapshot <T>?applySnapshot, HandleEvent?applyEvent)
{
Guard.NotNull(key, nameof(key));
return(new Persistence <T>(key, owner,
snapshotStore,
eventStore,
eventDataFormatter,
streamNameResolver,
mode,
applySnapshot,
applyEvent));
}
public IPersistence <T> WithSnapshotsAndEventSourcing(Type owner, DomainId key, HandleSnapshot <T>?applySnapshot, HandleEvent?applyEvent)
{
return(CreatePersistence(owner, key, PersistenceMode.SnapshotsAndEventSourcing, applySnapshot, applyEvent));
}
public IPersistence <T> WithSnapshots(Type owner, DomainId key, HandleSnapshot <T>?applySnapshot)
{
return(CreatePersistence(owner, key, PersistenceMode.Snapshots, applySnapshot, null));
}
private IPersistence <TState> CreatePersistence <TState>(Type owner, TKey key, PersistenceMode mode, HandleSnapshot <TState> applySnapshot, HandleEvent applyEvent)
{
Guard.NotNull(key, nameof(key));
var snapshotStore = GetSnapshotStore <TState>();
return(new Persistence <TState, TKey>(key, owner, eventStore, eventEnricher, eventDataFormatter, snapshotStore, streamNameResolver, mode, applySnapshot, applyEvent));
}
public IPersistence <TState> WithSnapshotsAndEventSourcing <TState>(Type owner, TKey key, HandleSnapshot <TState> applySnapshot, HandleEvent applyEvent)
{
return(CreatePersistence(owner, key, PersistenceMode.SnapshotsAndEventSourcing, applySnapshot, applyEvent));
}
public IPersistence <TState> WithSnapshots <TState>(Type owner, TKey key, HandleSnapshot <TState> applySnapshot)
{
return(CreatePersistence(owner, key, PersistenceMode.Snapshots, applySnapshot, null));
}
