public RetrySubscriptionTests()
{
A.CallTo(() => eventStore.CreateSubscription(A <IEventSubscriber> .Ignored, A <string> .Ignored, A <string> .Ignored)).Returns(eventSubscription);
sut = new RetrySubscription(eventStore, eventSubscriber, streamFilter, null)
{
ReconnectWaitMs = 50
};
sutSubscriber = sut;
}
public EventConsumerGrainTests()
{
grainState.Value.Position = initialPosition;
consumerName = eventConsumer.GetType().Name;
A.CallTo(() => eventStore.CreateSubscription(A <IEventSubscriber> ._, A <string> ._, A <string> ._))
.Returns(eventSubscription);
A.CallTo(() => eventConsumer.Name)
.Returns(consumerName);
A.CallTo(() => eventConsumer.Handles(A <StoredEvent> ._))
.Returns(true);
A.CallTo(() => formatter.Parse(eventData))
.Returns(envelope);
sut = new MyEventConsumerGrain(
x => eventConsumer,
grainState,
eventStore,
formatter,
log);
}
public RetrySubscriptionTests()
{
A.CallTo(() => eventStore.CreateSubscription(A <IEventSubscriber> ._, A <string> ._, A <string> ._))
.Returns(eventSubscription);
A.CallTo(() => eventSubscription.Sender)
.Returns(eventSubscription);
sut = new RetrySubscription(eventSubscriber, s => eventStore.CreateSubscription(s))
{
ReconnectWaitMs = 50
};
sutSubscriber = sut;
}
private void Subscribe()
{
if (currentSubscription == null)
{
currentSubscription = eventStore.CreateSubscription(this, streamFilter, position);
}
}
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, null))
.Returns(envelope);
sut = new MyEventConsumerGrain(
x => eventConsumer,
store,
eventStore,
formatter,
log);
}
public EventConsumerGrainTests()
{
state.Position = initialPosition;
consumerName = eventConsumer.GetType().Name;
A.CallTo(() => eventStore.CreateSubscription(A <IEventSubscriber> .Ignored, A <string> .Ignored, A <string> .Ignored))
.Returns(eventSubscription);
A.CallTo(() => eventConsumer.Name).
Returns(consumerName);
A.CallTo(() => stateHolder.State)
.ReturnsLazily(() => state);
A.CallToSet(() => stateHolder.State)
.Invokes(new Action <EventConsumerState>(s => state = s));
A.CallTo(() => formatter.Parse(eventData, true)).Returns(envelope);
sut = new MyEventConsumerGrain(formatter, eventStore, log);
sutSubscriber = sut;
sut.ActivateAsync(stateHolder).Wait();
}
private Task SubscribeThisAsync(string position)
{
if (eventSubscription == null)
{
eventSubscription = eventStore.CreateSubscription(this, eventConsumer.EventsFilter, position);
}
return(TaskHelper.Done);
}
public EventConsumerGrainTests()
{
grainState.Value = new EventConsumerState
{
Position = initialPosition
};
consumerName = eventConsumer.GetType().Name;
A.CallTo(() => eventStore.CreateSubscription(A <IEventSubscriber> ._, A <string> ._, A <string> ._))
.Returns(eventSubscription);
A.CallTo(() => eventConsumer.Name)
.Returns(consumerName);
A.CallTo(() => eventConsumer.Handles(A <StoredEvent> ._))
.Returns(true);
A.CallTo(() => eventConsumer.On(A <IEnumerable <Envelope <IEvent> > > ._))
.Invokes((IEnumerable <Envelope <IEvent> > events) =>
{
foreach (var @event in events)
{
eventConsumer.On(@event).Wait();
}
});
A.CallTo(() => eventSubscription.Sender)
.Returns(eventSubscription);
storedEvent = new StoredEvent("Stream", Guid.NewGuid().ToString(), 123, eventData);
A.CallTo(() => formatter.ParseIfKnown(storedEvent))
.Returns(envelope);
var log = A.Fake <ILogger <EventConsumerGrain> >();
sut = new MyEventConsumerGrain(
x => eventConsumer,
grainState,
eventStore,
formatter,
log);
}
public EventConsumerActorTests()
{
consumerInfo.Position = Guid.NewGuid().ToString();
consumerName = eventConsumer.GetType().Name;
A.CallTo(() => eventStore.CreateSubscription(A <IEventSubscriber> .Ignored, A <string> .Ignored, A <string> .Ignored)).Returns(eventSubscription);
A.CallTo(() => eventConsumer.Name).Returns(consumerName);
A.CallTo(() => eventConsumerInfoRepository.FindAsync(consumerName)).Returns(consumerInfo);
A.CallTo(() => formatter.Parse(eventData, true)).Returns(envelope);
sut = new EventConsumerActor(formatter, eventStore, eventConsumerInfoRepository, log)
{
ReconnectWaitMs = 0
};
sutActor = sut;
sutSubscriber = sut;
}
public EventConsumerGrainTests()
{
grainState.Value = new EventConsumerState
{
Position = initialPosition
};
consumerName = eventConsumer.GetType().Name;
A.CallTo(() => eventStore.CreateSubscription(A <IEventSubscriber> ._, A <string> ._, A <string> ._))
.Returns(eventSubscription);
A.CallTo(() => eventConsumer.Name)
.Returns(consumerName);
A.CallTo(() => eventConsumer.Handles(A <StoredEvent> ._))
.Returns(true);
A.CallTo(() => eventConsumer.On(A <IEnumerable <Envelope <IEvent> > > ._))
.Invokes((IEnumerable <Envelope <IEvent> > events) =>
{
foreach (var @event in events)
{
eventConsumer.On(@event).Wait();
}
});
A.CallTo(() => eventSubscription.Sender)
.Returns(eventSubscription);
A.CallTo(() => formatter.ParseIfKnown(A <StoredEvent> .That.Matches(x => x.Data == eventData)))
.Returns(envelope);
sut = new MyEventConsumerGrain(
x => eventConsumer,
grainState,
eventStore,
formatter,
log);
}
private async Task SubscribeAsync(IEventConsumer eventConsumer, string position)
{
var consumerName = eventConsumer.Name;
var subscription = eventStore.CreateSubscription(eventConsumer.EventsFilter, position);
await subscription.SubscribeAsync(async storedEvent =>
{
await DispatchConsumerAsync(ParseEvent(storedEvent), eventConsumer, eventConsumer.Name);
await eventConsumerInfoRepository.SetPositionAsync(eventConsumer.Name, storedEvent.EventPosition, false);
}, async exception =>
{
await eventConsumerInfoRepository.StopAsync(consumerName, exception.ToString());
subscription.Dispose();
});
currentSubscription = subscription;
}
protected override IEventSubscription CreateSubscription(IEventStore store, IEventSubscriber subscriber, string streamFilter, string position)
{
return(store.CreateSubscription(subscriber, streamFilter, position));
}
protected override IEventSubscription CreateSubscription(IEventStore eventStore, string streamFilter, string position)
{
return(eventStore.CreateSubscription(this, streamFilter, position));
}
