public void When_multiple_projector_handlers_are_chained_then_the_last_added_is_called_first()
{
// arrange
var bus = new InProcessEventBus();
var handlerCalls = new List <string>();
// act
var handler = new TestProjector()
.WrapAll((e, next) =>
{
handlerCalls.Add("c");
next(e);
})
.WrapAll((e, next) =>
{
handlerCalls.Add("b");
next(e);
})
.WrapAll((e, next) =>
{
handlerCalls.Add("a");
next(e);
});
bus.Subscribe(handler);
bus.PublishAsync(new Order.Created()).Wait();
// assert
handlerCalls.Should().BeInAscendingOrder();
}
public void Basic_persistence_of_snapshot_memento()
{
const string streamId = "test2_a";
TestProjector unfolder = new TestProjector();
unfolder.ApplyEvent(new TestDomainEvent()
{
Value = 42
});
var memento = unfolder.GetSnapshot();
Snapshot s = new Snapshot(_bucket, streamId, 1, memento);
sut.Persist(s, _type);
var reloaded = sut.Load(streamId, 1, _type);
Assert.That(reloaded, Is.Not.Null);
Assert.That(reloaded.BucketId, Is.EqualTo(_bucket));
Assert.That(reloaded.StreamId, Is.EqualTo(streamId));
Assert.That(reloaded.StreamRevision, Is.EqualTo(1));
TestProjector unfolderReloaded = new TestProjector();
unfolderReloaded.Restore((IMementoEx)reloaded.Payload);
var readmodel = unfolderReloaded.GetProjection();
Assert.That(readmodel.Sum, Is.EqualTo(42));
}
public void Handler_chains_can_be_specified_for_all_event_types_on_a_single_projector()
{
// arrange
var bus = new InProcessEventBus();
var createdWasCalled = false;
var cancelledWasCalled = false;
var deliveredWasCalled = false;
var handledEvents = new List <IEvent>();
// act
var handler = new TestProjector(
onCreated: e => createdWasCalled = true,
onCancelled: e => cancelledWasCalled = true,
onDelivered: e => deliveredWasCalled = true)
.WrapAll((e, nextHandler) =>
{
handledEvents.Add(e);
nextHandler(e);
});
bus.Subscribe(handler);
bus.PublishAsync(new Order.Created()).Wait();
bus.PublishAsync(new Order.Cancelled()).Wait();
bus.PublishAsync(new Order.Delivered()).Wait();
// assert
handledEvents.Count.Should().Be(3);
createdWasCalled.Should().BeTrue("created was called");
cancelledWasCalled.Should().BeTrue("cancelled was called");
deliveredWasCalled.Should().BeTrue("delivered was called");
}
public async Task invoke_business_event_handler()
{
var mockSubFactory = new Mock <ISubscriberFactory>();
var businessEvent = new TestEvent();
var streamId = "s";
var position = 5;
var subEvent = new SubscriberEvent(null, streamId, position, null, businessEvent);
var dependencies = new ProjectorDependencies(null, mockSubFactory.Object, null, null, null, null, null);
var projector = new TestProjector(dependencies);
var token = CancellationToken.None;
var called = false;
projector.MockBusinessEventHandler = (pStreamId, pPosition, pEvent, pToken) =>
{
Assert.Equal(streamId, pStreamId);
Assert.Equal(position, pPosition);
Assert.Equal(businessEvent, pEvent);
Assert.Equal(token, pToken);
called = true;
return(Task.CompletedTask);
};
await projector.HandleSubscriberEventAsync(subEvent, token);
Assert.True(called);
}
public void Smoke_persistence_of_memento_snapshot()
{
TestProjector unfolder = new TestProjector();
unfolder.ApplyEvent(new TestDomainEvent()
{
Value = 42
});
var memento = unfolder.GetSnapshot();
Snapshot s = new Snapshot("test1_a", 1, memento);
sut.Persist(s, _type);
}
public async Task ShouldProjectMessages()
{
var cancellationSource = new CancellationTokenSource();
var completionSource = new TaskCompletionSource <bool>();
cancellationSource.Token.Register(s => ((TaskCompletionSource <bool>)s).SetResult(true), completionSource);
_events
.Watch(Arg.Any <Checkpoint?>(), Arg.Any <CancellationToken>())
.Returns(new[] {
new Envelope(
"invariantId1",
"Invariant",
0,
new ChooseProduct("customerId", "productId")
),
new Envelope(
"invariantId2",
"Invariant",
0,
new ChooseProduct("customerId", "productId")
)
}.ToAsync());
var envelopes = new List <Envelope>();
var projections = default(Projection[]);
var processor = new TestProjector(
_logger,
_events,
new TestProject(async e => {
envelopes.Add(e);
}),
2,
TimeSpan.FromMilliseconds(100),
async results => {
projections = results.Select(r => r.Projection).ToArray();
cancellationSource.Cancel();
}
);
await processor.ExecuteAsync(cancellationSource.Token);
await await Task.WhenAny(
completionSource.Task,
Task.Delay(10000)
);
envelopes.Count.ShouldBe(2);
projections.ShouldNotBeNull();
}
public async Task subscribe_when_run()
{
var mockSubFactory = new Mock <ISubscriberFactory>();
var mockSubscriber = new Mock <ISubscriber>();
mockSubFactory.Setup(x => x.Create(
It.IsAny <IStandardLogger>(), It.IsAny <IStreamClientFactory>(), It.IsAny <IStreamStateRepo>(),
It.IsAny <IBusinessEventResolver>(), It.IsAny <ISubscriberEventSorter>(), It.IsAny <ISubscriberEventHandler>(),
It.IsAny <SubscriberFactoryOptions>(), It.IsAny <IList <SubscriptionStreamId> >()
)).Returns(mockSubscriber.Object);
var dependencies = new ProjectorDependencies(null, mockSubFactory.Object, null, null, null, null, null);
var projector = new TestProjector(dependencies);
var tokenSource = new CancellationTokenSource(5000);
await projector.RunAsync(tokenSource.Token);
Assert.False(tokenSource.IsCancellationRequested);
mockSubscriber.Verify(x => x.SubscribeAsync(tokenSource.Token));
}
public void create_subscriber_when_construct()
{
var mockLogger = new Mock <IStandardLogger>();
var mockSubFactory = new Mock <ISubscriberFactory>();
var subFactoryOptions = new SubscriberFactoryOptions(0, 0, 0, 0);
var mockStreamClientFactory = new Mock <IStreamClientFactory>();
var mockStreamStateRepo = new Mock <IStreamStateRepo>();
var mockEventResolver = new Mock <IBusinessEventResolver>();
var streamIds = new List <SubscriptionStreamId>();
var dependencies = new ProjectorDependencies(
mockLogger.Object, mockSubFactory.Object, subFactoryOptions, mockStreamClientFactory.Object, mockStreamStateRepo.Object,
mockEventResolver.Object, streamIds
);
var projector = new TestProjector(dependencies);
mockSubFactory.Verify(x => x.Create(
mockLogger.Object, mockStreamClientFactory.Object, mockStreamStateRepo.Object,
mockEventResolver.Object, projector, projector, subFactoryOptions, streamIds
));
}
public EF6EntityEventProjectorTests()
{
ef6CrudRepository = Substitute.ForPartsOf <EF6InMemoryCrudRepository>();
sut = new TestProjector(ef6CrudRepository);
}
