public EventConsumerGrainTests() { state.Position = initialPosition; consumerName = eventConsumer.GetType().Name; A.CallTo(() => store.WithSnapshots(A <Type> .Ignored, consumerName, A <Func <EventConsumerState, Task> > .Ignored)) .Invokes(new Action <Type, string, Func <EventConsumerState, Task> >((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, true)).Returns(envelope); sut = new MyEventConsumerGrain( x => eventConsumer, store, eventStore, formatter, log); }
private async Task DoAndUpdateStateAsync(Func <Task> action, [CallerMemberName] string caller = null) { try { await action(); } catch (Exception ex) { try { Unsubscribe(); } catch (Exception unsubscribeException) { ex = new AggregateException(ex, unsubscribeException); } log.LogFatal(ex, w => w .WriteProperty("action", caller) .WriteProperty("status", "Failed") .WriteProperty("eventConsumer", eventConsumer.Name)); state = state.Failed(ex); } await persistence.WriteSnapshotAsync(state); }
private void AssertGrainState(bool isStopped = false, string?position = null, string?error = null, int count = 0) { var expected = new EventConsumerState { IsStopped = isStopped, Position = position, Error = error, Count = count }; grainState.Value.Should().BeEquivalentTo(expected); }
public Task ResetAsync() { return(DoAndUpdateStateAsync(async() => { Unsubscribe(); await ClearAsync(); Subscribe(null); state = state.Reset(); })); }
public Task OnErrorAsync(Immutable <IEventSubscription> subscription, Immutable <Exception> exception) { if (subscription.Value != currentSubscription) { return(TaskHelper.Done); } return(DoAndUpdateStateAsync(() => { Unsubscribe(); state = state.Failed(exception.Value); })); }
public Task StopAsync() { if (state.IsStopped) { return(TaskHelper.Done); } return(DoAndUpdateStateAsync(() => { Unsubscribe(); state = state.Stopped(); })); }
public Task StartAsync() { if (!state.IsStopped) { return(TaskHelper.Done); } return(DoAndUpdateStateAsync(() => { Subscribe(state.Position); state = state.Started(); })); }
private Task HandleErrorAsync(IEventSubscription subscription, Exception exception) { if (subscription != currentSubscription) { return(TaskHelper.Done); } return(DoAndUpdateStateAsync(() => { Unsubscribe(); state = state.Failed(exception); })); }
public void Should_serialize_and_deserialize() { var state = new EventConsumerState { Count = 1, IsStopped = true, Error = "Error", Position = "Position" }; var serialized = state.SerializeAndDeserialize(); serialized.Should().BeEquivalentTo(state); }
public async Task Should_not_subscribe_to_event_store_when_stopped_in_db() { state = state.Stopped(); await sut.OnActivateAsync(consumerName); await sut.ActivateAsync(); state.Should().BeEquivalentTo(new EventConsumerState { IsStopped = true, Position = initialPosition, Error = null }); A.CallTo(() => eventStore.CreateSubscription(A <IEventSubscriber> .Ignored, A <string> .Ignored, A <string> .Ignored)) .MustNotHaveHappened(); }
public Task OnEventAsync(Immutable <IEventSubscription> subscription, Immutable <StoredEvent> storedEvent) { if (subscription.Value != currentSubscription) { return(TaskHelper.Done); } return(DoAndUpdateStateAsync(async() => { var @event = ParseKnownEvent(storedEvent.Value); if (@event != null) { await DispatchConsumerAsync(@event); } state = state.Handled(storedEvent.Value.EventPosition); })); }
private Task HandleEventAsync(IEventSubscription subscription, StoredEvent storedEvent) { if (subscription != currentSubscription) { return(TaskHelper.Done); } return(DoAndUpdateStateAsync(async() => { var @event = ParseKnownEvent(storedEvent); if (@event != null) { await DispatchConsumerAsync(@event); } state = state.Handled(storedEvent.EventPosition); })); }
private void AssetGrainState(EventConsumerState state) { grainState.Value.Should().BeEquivalentTo(state); }
public override Task OnActivateAsync(string key) { scheduler = TaskScheduler.Current; eventConsumer = eventConsumerFactory(key); persistence = store.WithSnapshots <EventConsumerState, string>(GetType(), eventConsumer.Name, s => state = s); return(persistence.ReadAsync()); }
public Task ActivateAsync(string key, IStore <string> store) { persistence = store.WithSnapshots <EventConsumerState, string>(key, s => state = s); return(persistence.ReadAsync()); }