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)); }