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