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); }
public void SetUp() { _resolver = Resolve. WhenEqualToHandlerMessageType(new ProjectionHandler <object> [0]); _messages = new[] { new object(), new object() }; _sut = new ProjectionScenario <object>(_resolver).Given(_messages); }
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(); }
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) })); }
/// <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; }
/// <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]; }
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)); }
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); }
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(); } } }
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>()); }
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>()); }
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>()); }
private static Projector <TConnection> SutFactory <TConnection>(ProjectionHandlerResolver <TConnection> resolver) { return(new Projector <TConnection>(resolver)); }
private ProjectionScenario(ProjectionHandlerResolver <TConnection> resolver, object[] messages) { _resolver = resolver; _messages = messages; }
public static ProjectionScenario <TConnection> Create <TConnection>(ProjectionHandlerResolver <TConnection> resolver) { return(new ProjectionScenario <TConnection>(resolver)); }