public void Can_resolve_handlers()
        {
            var handlerResolver = new ProjectionHandlerResolver(new TestProjectionModule(new List<object>()));
            var handlers = handlerResolver.ResolveAll<TestEvent>().ToArray();

            handlers.Length.Should().Be(1);
        }
Exemple #2
0
 public void SetUp()
 {
     _resolver = Resolve.
                 WhenEqualToHandlerMessageType(new ProjectionHandler <object> [0]);
     _messages = new[] { new object(), new object() };
     _sut      = new ProjectionScenario <object>(_resolver).Given(_messages);
 }
Exemple #3
0
        public void ProjectAsyncTokenMessagesCancellationAfterSecondHandlerCausesExpectedResult()
        {
            var tcs = new CancellationTokenSource();

            Func <object, object, CancellationToken, Task> handler1 =
                (connection, message, token) => Task.FromResult <object>(null);
            Func <object, object, CancellationToken, Task> handler2 =
                (connection, message, token) =>
            {
                tcs.Cancel();
                return(Task.FromResult <object>(null));
            };
            Func <object, object, CancellationToken, Task> handler3 =
                (connection, message, token) =>
            {
                throw new InvalidOperationException("Should not happen!");
            };

            ProjectionHandlerResolver <object> resolver = Resolve.WhenEqualToHandlerMessageType(new[]
            {
                new ProjectionHandler <object>(typeof(object), handler1),
                new ProjectionHandler <object>(typeof(object), handler2),
                new ProjectionHandler <object>(typeof(object), handler3)
            });
            var sut = SutFactory(resolver);

            Assert.That(async() =>
                        await sut.ProjectAsync(new object(), new[] { new object(), new object(), new object() }, tcs.Token),
                        Throws.Nothing);
        }
        public async Task Can_dispatch_event()
        {
            List<object> projectedEvents = new List<object>();
            var handlerResolver = new ProjectionHandlerResolver(new TestProjectionModule(projectedEvents));
            const string streamId = "stream";
            var eventId = Guid.NewGuid();
            const int version = 2;
            var timeStamp = DateTimeOffset.UtcNow;
            var headers = new ReadOnlyDictionary<string, object>(new Dictionary<string, object>());

            using(var dispatcher = new TestProjectionDispatcher(handlerResolver, new InMemoryCheckpointRepository()))
            {
                await dispatcher.Start();
                await dispatcher.DoDispatch(streamId, eventId, version, timeStamp, "checkpoint", headers, new TestEvent());
            }

            projectedEvents.Count.Should().Be(1);
            
            var projectionEvent = projectedEvents[0].As<ProjectionEvent<TestEvent>>();
            projectionEvent.StreamId.Should().Be(streamId);
            projectionEvent.EventId.Should().Be(eventId);
            projectionEvent.Version.Should().Be(version);
            projectionEvent.TimeStamp.Should().Be(timeStamp);
            projectionEvent.Headers.Should().NotBeNull();
        }
Exemple #5
0
        public static IEnumerable <TestCaseData> ProjectMessageWithoutTokenCases()
        {
            var task = TaskFactory();
            //Match
            var message1 = new object();
            var handler1 = new ProjectionHandler <CallRecordingConnection>(
                typeof(object),
                (connection, message, token) =>
            {
                connection.RecordCall(1, message, token);
                return(task);
            });
            var resolver1 = new ProjectionHandlerResolver <CallRecordingConnection>(message => new[] { handler1 });

            yield return(new TestCaseData(
                             resolver1,
                             message1,
                             new[]
            {
                new Tuple <int, object, CancellationToken>(1, message1, CancellationToken.None),
            }));

            //Mismatch
            var message2  = new object();
            var resolver2 = new ProjectionHandlerResolver <CallRecordingConnection>(message => new ProjectionHandler <CallRecordingConnection> [0]);

            yield return(new TestCaseData(
                             resolver2,
                             message2,
                             new Tuple <int, object, CancellationToken> [0]));

            //Multimatch
            var message3 = new object();
            var handler3 = new ProjectionHandler <CallRecordingConnection>(
                typeof(object),
                (connection, message, token) =>
            {
                connection.RecordCall(3, message, token);
                return(task);
            });
            var handler4 = new ProjectionHandler <CallRecordingConnection>(
                typeof(object),
                (connection, message, token) =>
            {
                connection.RecordCall(4, message, token);
                return(task);
            });
            var resolver3 = new ProjectionHandlerResolver <CallRecordingConnection>(message => new[] { handler3, handler4 });

            yield return(new TestCaseData(
                             resolver3,
                             message3,
                             new[]
            {
                new Tuple <int, object, CancellationToken>(3, message3, CancellationToken.None),
                new Tuple <int, object, CancellationToken>(4, message3, CancellationToken.None)
            }));
        }
Exemple #6
0
        /// <summary>
        /// Initializes a new instance of the <see cref="Projector{TConnection}"/> class.
        /// </summary>
        /// <param name="resolver">The handler resolver.</param>
        /// <exception cref="System.ArgumentNullException">Thrown when <paramref name="resolver"/> is <c>null</c>.</exception>
        public Projector(ProjectionHandlerResolver <TConnection> resolver)
        {
            if (resolver == null)
            {
                throw new ArgumentNullException("resolver");
            }

            _resolver = resolver;
        }
Exemple #7
0
 /// <summary>
 /// Initializes a new instance of the <see cref="ProjectionScenario{TConnection}"/> class.
 /// </summary>
 /// <param name="resolver">The projection handler resolver.</param>
 /// <exception cref="System.ArgumentNullException">Thrown when <paramref name="resolver"/> is <c>null</c>.</exception>
 public ProjectionScenario(ProjectionHandlerResolver <TConnection> resolver)
 {
     if (resolver == null)
     {
         throw new ArgumentNullException("resolver");
     }
     _resolver = resolver;
     _messages = new object[0];
 }
Exemple #8
0
        public async Task ProjectAsyncMessageCausesExpectedCalls(
            ProjectionHandlerResolver <CallRecordingConnection> resolver,
            object message,
            Tuple <int, object, CancellationToken>[] expectedCalls)
        {
            var connection = new CallRecordingConnection();
            var sut        = SutFactory(resolver);

            await sut.ProjectAsync(connection, message);

            Assert.That(connection.RecordedCalls, Is.EquivalentTo(expectedCalls));
        }
Exemple #9
0
        public void ProjectAsyncTokenMessagesResolverFailureCausesExpectedResult()
        {
            ProjectionHandlerResolver <object> resolver = m =>
            {
                throw new Exception("message");
            };
            var sut = SutFactory(resolver);

            Assert.That(async() =>
                        await sut.ProjectAsync(new object(), new[] { new object(), new object() }, new CancellationToken()),
                        Throws.TypeOf <Exception>().And.Message.EqualTo("message"));
        }
        public void Can_invoke_handlers()
        {
            List<object> projectedEvents = new List<object>();
            var handlerResolver = new ProjectionHandlerResolver(new TestProjectionModule(projectedEvents));
            var handlers = handlerResolver.ResolveAll<TestEvent>().ToArray();
            var projectionEvent = new ProjectionEvent<TestEvent>("streamid", Guid.NewGuid(), 1, DateTimeOffset.UtcNow, null, new TestEvent());

            foreach(var handler in handlers)
            {
                handler(projectionEvent, CancellationToken.None);
            }

            projectedEvents.Count.Should().Be(1);
        }
Exemple #11
0
        public void ProjectAsyncTokenMessagesFirstHandlerFailureCausesExpectedResult()
        {
            Func <object, object, CancellationToken, Task> handler =
                (connection, message, token) =>
            {
                var source = new TaskCompletionSource <object>();
                source.SetException(new Exception("message"));
                return(source.Task);
            };
            ProjectionHandlerResolver <object> resolver = m => new[] { new ProjectionHandler <object>(typeof(object), handler) };
            var sut = SutFactory(resolver);

            Assert.That(async() =>
                        await sut.ProjectAsync(new object(), new[] { new object(), new object() }, new CancellationToken()),
                        Throws.TypeOf <Exception>().And.Message.EqualTo("message"));
        }
 /// <summary>
 /// Initializes a new instance of the <see cref="ProjectionTestSpecification{TConnection}"/> class.
 /// </summary>
 /// <param name="resolver">The projection handler resolver.</param>
 /// <param name="messages">The messages to project.</param>
 /// <param name="verification">The verification method.</param>
 /// <exception cref="System.ArgumentNullException">Thrown when
 /// <paramref name="resolver"/>
 /// or
 /// <paramref name="messages"/>
 /// or
 /// <paramref name="verification"/> is null.
 /// </exception>
 public ProjectionTestSpecification(ProjectionHandlerResolver <TConnection> resolver, object[] messages, Func <TConnection, CancellationToken, Task <VerificationResult> > verification)
 {
     if (resolver == null)
     {
         throw new ArgumentNullException("resolver");
     }
     if (messages == null)
     {
         throw new ArgumentNullException("messages");
     }
     if (verification == null)
     {
         throw new ArgumentNullException("verification");
     }
     _resolver     = resolver;
     _messages     = messages;
     _verification = verification;
 }
        public async Task Blah()
        {
            using(var eventStore = Wireup
                .Init()
                .UsingInMemoryPersistence()
                .Build())
            {
                using(var client = new EventStoreClient(eventStore.Advanced))
                {
                    var handlerResolver = new ProjectionHandlerResolver(new TestProjectionModule());
                    var dispatcher = new NEventStoreProjectionDispatcher(
                        client,
                        handlerResolver,
                        new InMemoryCheckpointRepository());

                    await dispatcher.Start();
                }
            }
        }
Exemple #14
0
        public void ProjectAsyncTokenMessagesSecondHandlerCancellationCausesExpectedResult()
        {
            Func <object, object, CancellationToken, Task> handler1 =
                (connection, message, token) => Task.FromResult <object>(null);
            Func <object, object, CancellationToken, Task> handler2 =
                (connection, message, token) =>
            {
                var source = new TaskCompletionSource <object>();
                source.SetCanceled();
                return(source.Task);
            };
            ProjectionHandlerResolver <object> resolver = Resolve.WhenEqualToHandlerMessageType(new[]
            {
                new ProjectionHandler <object>(typeof(object), handler1),
                new ProjectionHandler <object>(typeof(int), handler2)
            });
            var sut = SutFactory(resolver);

            Assert.That(async() =>
                        await sut.ProjectAsync(new object(), new[] { new object(), new int() }, new CancellationToken()),
                        Throws.TypeOf <TaskCanceledException>());
        }
Exemple #15
0
        public void ProjectAsyncTokenMessagesHandlerObservingCancelledTokenCausesExpectedResult()
        {
            var tcs = new CancellationTokenSource();

            Func <object, object, CancellationToken, Task> handler1 =
                (connection, message, token) =>
            {
                var source = new TaskCompletionSource <object>();
                token.Register(() => source.SetCanceled());

                tcs.Cancel();
                return(source.Task);
            };

            ProjectionHandlerResolver <object> resolver = Resolve.WhenEqualToHandlerMessageType(new[]
            {
                new ProjectionHandler <object>(typeof(object), handler1),
            });
            var sut = SutFactory(resolver);

            Assert.That(async() =>
                        await sut.ProjectAsync(new object(), new[] { new object() }, tcs.Token),
                        Throws.TypeOf <TaskCanceledException>());
        }
Exemple #16
0
        public void ProjectAsyncTokenMessagesCancellationAfterSecondHandlerInContinuationCausesExpectedResult()
        {
            var tcs = new CancellationTokenSource();

            tcs.Cancel();

            Func <object, object, CancellationToken, Task> handler1 =
                async(connection, message, token) =>
            {
                await Task.Yield();

                await Task.Delay(TimeSpan.FromDays(1), token);
            };

            ProjectionHandlerResolver <object> resolver = Resolve.WhenEqualToHandlerMessageType(new[]
            {
                new ProjectionHandler <object>(typeof(object), handler1),
            });
            var sut = SutFactory(resolver);

            Assert.That(async() =>
                        await sut.ProjectAsync(new object(), new[] { new object() }, tcs.Token),
                        Throws.TypeOf <TaskCanceledException>());
        }
Exemple #17
0
 private static Projector <TConnection> SutFactory <TConnection>(ProjectionHandlerResolver <TConnection> resolver)
 {
     return(new Projector <TConnection>(resolver));
 }
Exemple #18
0
 private ProjectionScenario(ProjectionHandlerResolver <TConnection> resolver, object[] messages)
 {
     _resolver = resolver;
     _messages = messages;
 }
Exemple #19
0
 public static ProjectionScenario <TConnection> Create <TConnection>(ProjectionHandlerResolver <TConnection> resolver)
 {
     return(new ProjectionScenario <TConnection>(resolver));
 }