public async Task When_handler_throws_Then_invoke_exception_callback()
{
using (IStoreEvents eventStore = Wireup.Init().UsingInMemoryPersistence().Build())
{
var projectedEvents = new List<DomainEventMessage<TestEvent>>();
var handlerModule = new TestHandlerModule(projectedEvents);
using (var host = new DurableCommitDispatcher(
new EventStoreClient(new PollingClient(eventStore.Advanced)),
new InMemoryCheckpointRepository(),
handlerModule.DispatchCommit))
{
await host.Start();
Guid streamId = Guid.NewGuid();
Guid commitId = Guid.NewGuid();
Task<ICommit> commitProjected = host
.CommitsProjectedStream
.Take(1)
.ToTask();
using (IEventStream stream = eventStore.CreateStream(streamId))
{
stream.Add(new EventMessage { Body = new TestEventThatThrows() });
stream.CommitChanges(commitId);
}
host.PollNow();
Func<Task> act = async () => await commitProjected;
act.ShouldThrow<Exception>();
}
}
}
public void Can_resolve_handler()
{
var module = new TestHandlerModule();
var resolver = new HandlerResolver(module);
var handlers = resolver.ResolveAll<TestEvent>();
handlers.Should().HaveCount(1);
}
public void Can_resolve_handler()
{
var module = new TestHandlerModule();
var resolver = new HandlerResolver(module);
var handlers = resolver.ResolveAll <TestEvent>();
handlers.Should().HaveCount(1);
}
public void Can_handle_message()
{
var handlerModule = new TestHandlerModule();
IEnumerable<Handler<TestMessage>> handlersFor = handlerModule.GetHandlersFor<TestMessage>();
foreach (var handler in handlersFor)
{
handler(new TestMessage(), CancellationToken.None);
}
handlerModule.MiddlewareCalled.Should().BeTrue();
handlerModule.FinallyCalled.Should().BeTrue();
}
public void Can_handle_message()
{
var handlerModule = new TestHandlerModule();
IEnumerable <Handler <TestMessage> > handlersFor = handlerModule.GetHandlersFor <TestMessage>();
foreach (var handler in handlersFor)
{
handler(new TestMessage(), CancellationToken.None);
}
handlerModule.MiddlewareCalled.Should().BeTrue();
handlerModule.FinallyCalled.Should().BeTrue();
}
public void Can_handle_message()
{
var module = new TestHandlerModule();
var resolver = new HandlerResolver(module);
IEnumerable<Handler<TestMessage>> handlersFor = resolver.ResolveAll<TestMessage>();
foreach (var handler in handlersFor)
{
handler(new TestMessage(), CancellationToken.None);
}
module.MiddlewareCalled.Should().BeTrue();
module.FinallyCalled.Should().BeTrue();
}
public void Can_handle_message()
{
var module = new TestHandlerModule();
var resolver = new HandlerResolver(module);
IEnumerable <Handler <TestMessage> > handlersFor = resolver.ResolveAll <TestMessage>();
foreach (var handler in handlersFor)
{
handler(new TestMessage(), CancellationToken.None);
}
module.MiddlewareCalled.Should().BeTrue();
module.FinallyCalled.Should().BeTrue();
}
public async Task When_new_commit_then_should_dispatch()
{
using (IStoreEvents eventStore = Wireup.Init().UsingInMemoryPersistence().Build())
{
var dispatchedEvents = new List <EventMessage <TestEvent> >();
var handlerModule = new TestHandlerModule(dispatchedEvents);
using (var host = new DurableCommitDispatcher(
new EventStoreClient(eventStore.Advanced),
new InMemoryCheckpointRepository(),
new HandlerResolver(handlerModule)))
{
var projectedCommits = host
.ProjectedCommits
.Replay();
using (projectedCommits.Connect())
{
await host.Start();
var streamId = Guid.NewGuid().ToString().FormatStreamIdWithBucket();
Guid commitId = Guid.NewGuid();
Task <ICommit> commitProjected = projectedCommits
.Take(1)
.ToTask();
using (IEventStream stream = eventStore.CreateStream(streamId))
{
stream.Add(new global::NEventStore.EventMessage {
Body = new TestEvent()
});
stream.CommitChanges(commitId);
}
host.PollNow();
await commitProjected;
dispatchedEvents.Count.Should().Be(1);
dispatchedEvents[0].Commit().Should().NotBeNull();
dispatchedEvents[0].Headers.Should().NotBeNull();
dispatchedEvents[0].Version.Should().Be(1);
dispatchedEvents[0].DomainEvent.Should().BeOfType <TestEvent>();
}
}
}
}
public async Task When_new_commit_then_should_dispatch()
{
using (IStoreEvents eventStore = Wireup.Init().UsingInMemoryPersistence().Build())
{
var dispatchedEvents = new List<EventMessage<TestEvent>>();
var handlerModule = new TestHandlerModule(dispatchedEvents);
using(var host = new DurableCommitDispatcher(
new EventStoreClient(eventStore.Advanced),
new InMemoryCheckpointRepository(),
new HandlerResolver(handlerModule)))
{
var projectedCommits = host
.ProjectedCommits
.Replay();
using(projectedCommits.Connect())
{
await host.Start();
var streamId = Guid.NewGuid().ToString().FormatStreamIdWithBucket();
Guid commitId = Guid.NewGuid();
Task<ICommit> commitProjected = projectedCommits
.Take(1)
.ToTask();
using(IEventStream stream = eventStore.CreateStream(streamId))
{
stream.Add(new global::NEventStore.EventMessage { Body = new TestEvent() });
stream.CommitChanges(commitId);
}
host.PollNow();
await commitProjected;
dispatchedEvents.Count.Should().Be(1);
dispatchedEvents[0].Commit().Should().NotBeNull();
dispatchedEvents[0].Headers.Should().NotBeNull();
dispatchedEvents[0].Version.Should().Be(1);
dispatchedEvents[0].DomainEvent.Should().BeOfType<TestEvent>();
}
}
}
}
public async Task When_handler_throws_Then_invoke_exception_callback()
{
using (IStoreEvents eventStore = Wireup.Init().UsingInMemoryPersistence().Build())
{
var projectedEvents = new List <EventMessage <TestEvent> >();
var handlerModule = new TestHandlerModule(projectedEvents);
using (var host = new DurableCommitDispatcher(
new EventStoreClient(eventStore.Advanced),
new InMemoryCheckpointRepository(),
new HandlerResolver(handlerModule)))
{
var projectedCommits = host
.ProjectedCommits
.Replay();
using (projectedCommits.Connect())
{
await host.Start();
var streamId = Guid.NewGuid().ToString().FormatStreamIdWithBucket();
Guid commitId = Guid.NewGuid();
Task <ICommit> commitProjected = projectedCommits
.Take(1)
.ToTask();
using (IEventStream stream = eventStore.CreateStream(streamId))
{
stream.Add(new global::NEventStore.EventMessage {
Body = new TestEventThatThrows()
});
stream.CommitChanges(commitId);
}
host.PollNow();
Func <Task> act = async() => await commitProjected;
act.ShouldThrow <Exception>();
}
}
}
}
public async Task When_new_resolved_event_then_should_dispatch()
{
await _nodeStarted;
var dispatchedEvents = new List <EventMessage <TestEvent> >();
var handlerModule = new TestHandlerModule(dispatchedEvents);
var serializer = new DefaultGetEventStoreJsonSerializer();
using (var host = new ResolvedEventDispatcher(
_connection, serializer,
new InMemoryCheckpointRepository(),
new HandlerResolver(handlerModule)))
{
var projectedEvents = host
.ProjectedEvents.Replay();
using (projectedEvents.Connect())
{
await host.Start();
Task <ResolvedEvent> commitProjected = projectedEvents
.Take(1)
.ToTask()
.WithTimeout(TimeSpan.FromSeconds(5));
var @event = new TestEvent();
var streamId = "events".FormatStreamIdWithBucket();
var eventId = DeterministicEventIdGenerator.Generate(@event, 1, streamId, Guid.NewGuid());
var eventData = serializer.SerializeEventData(@event, eventId);
await _connection.AppendToStreamAsync(streamId, ExpectedVersion.Any, eventData);
await commitProjected;
dispatchedEvents.Count.Should().Be(1);
dispatchedEvents[0].Headers.Should().NotBeNull();
dispatchedEvents[0].Version.Should().Be(0);
dispatchedEvents[0].DomainEvent.Should().BeOfType <TestEvent>();
}
}
}
public async Task When_new_resolved_event_then_should_dispatch()
{
await _nodeStarted;
var dispatchedEvents = new List<EventMessage<TestEvent>>();
var handlerModule = new TestHandlerModule(dispatchedEvents);
var serializer = new DefaultGetEventStoreJsonSerializer();
using(var host = new ResolvedEventDispatcher(
_connection, serializer,
new InMemoryCheckpointRepository(),
new HandlerResolver(handlerModule)))
{
var projectedEvents = host
.ProjectedEvents.Replay();
using(projectedEvents.Connect())
{
await host.Start();
Task<ResolvedEvent> commitProjected = projectedEvents
.Take(1)
.ToTask()
.WithTimeout(TimeSpan.FromSeconds(5));
var @event = new TestEvent();
var streamId = "events".FormatStreamIdWithBucket();
var eventId = DeterministicEventIdGenerator.Generate(@event, 1, streamId, Guid.NewGuid());
var eventData = serializer.SerializeEventData(@event, eventId);
await _connection.AppendToStreamAsync(streamId, ExpectedVersion.Any, eventData);
await commitProjected;
dispatchedEvents.Count.Should().Be(1);
dispatchedEvents[0].Headers.Should().NotBeNull();
dispatchedEvents[0].Version.Should().Be(0);
dispatchedEvents[0].DomainEvent.Should().BeOfType<TestEvent>();
}
}
}
public QueryHandlingFixture()
{
const string vendor = "vendor";
var handlerModule = new TestHandlerModule();
var queryTypeFromContentTypeResolver = new DefaultContentTypeMapper(
vendor,
new[]
{
typeof (TestQuery),
typeof (TestQueryWithoutHandler),
typeof (TestQueryWhoseHandlerThrows),
typeof(TestQueryResponse)
});
var options = new DefaultHandlerSettings(handlerModule, queryTypeFromContentTypeResolver);
_midFunc = QueryHandlingMiddleware.HandleQueries(options);
_messageExecutionSettings = new QueryExecutionSettings(vendor);
}
public async Task When_handler_throws_Then_invoke_exception_callback()
{
await _nodeStarted;
var serializer = new DefaultGetEventStoreJsonSerializer();
var handlerModule = new TestHandlerModule(new List <EventMessage <TestEvent> >());
using (var host = new ResolvedEventDispatcher(
_connection, serializer,
new InMemoryCheckpointRepository(),
new HandlerResolver(handlerModule)))
{
var projectedEvents = host
.ProjectedEvents.Replay();
using (projectedEvents.Connect())
{
await host.Start();
Task <ResolvedEvent> commitProjected = projectedEvents
.Take(1)
.ToTask()
.WithTimeout(TimeSpan.FromSeconds(5));
var @event = new TestEventThatThrows();
var streamId = "events";
var eventId = DeterministicEventIdGenerator.Generate(@event, 1, streamId, Guid.NewGuid());
var eventData = serializer.SerializeEventData(@event, eventId);
await _connection.AppendToStreamAsync(streamId, ExpectedVersion.Any, eventData);
Func <Task> act = async() => await commitProjected;
act.ShouldThrow <Exception>();
}
}
}
public async Task When_handler_throws_Then_invoke_exception_callback()
{
await _nodeStarted;
var serializer = new DefaultGetEventStoreJsonSerializer();
var handlerModule = new TestHandlerModule(new List<EventMessage<TestEvent>>());
using(var host = new ResolvedEventDispatcher(
_connection, serializer,
new InMemoryCheckpointRepository(),
new HandlerResolver(handlerModule)))
{
var projectedEvents = host
.ProjectedEvents.Replay();
using(projectedEvents.Connect())
{
await host.Start();
Task<ResolvedEvent> commitProjected = projectedEvents
.Take(1)
.ToTask()
.WithTimeout(TimeSpan.FromSeconds(5));
var @event = new TestEventThatThrows();
var streamId = "events";
var eventId = DeterministicEventIdGenerator.Generate(@event, 1, streamId, Guid.NewGuid());
var eventData = serializer.SerializeEventData(@event, eventId);
await _connection.AppendToStreamAsync(streamId, ExpectedVersion.Any,eventData);
Func<Task> act = async () => await commitProjected;
act.ShouldThrow<Exception>();
}
}
}
