public async Task GivenPiplelineWithThreeStages_WhenHandlingRequest_ThenAllThreeHandlersHandleRequest()
        {
            var testHandlerA = new TestHandlerA <TestRequestA>();
            var testHandlerB = new TestHandlerB <TestRequestA>();
            var testHandlerC = new TestHandlerC <TestRequestA>();

            Dictionary <Type, Object> dictionary = new Dictionary <Type, object>
            {
                [typeof(TestHandlerA <TestRequestA>)] = testHandlerA,
                [typeof(TestHandlerB <TestRequestA>)] = testHandlerB,
                [typeof(TestHandlerC <TestRequestA>)] = testHandlerC,
            };

            PipelineDefinitionBuilder builder = new PipelineDefinitionBuilder(type => dictionary[type]);

            var pipeline = builder.StartWith <TestHandlerA <TestRequestA>, TestRequestA>()
                           .ThenWith <TestHandlerB <TestRequestA> >()
                           .ThenWith <TestHandlerC <TestRequestA> >()
                           .Build();

            var testRequest = new TestRequestA();
            await pipeline.HandleAsync(testRequest, new Context());

            Assert.Multiple(() =>
            {
                Assert.That(testHandlerA._request, Is.EqualTo(testRequest));
                Assert.That(testHandlerB._request, Is.EqualTo(testRequest));
                Assert.That(testHandlerC._request, Is.EqualTo(testRequest));
            });
        }
Exemple #2
0
        public void GivenPipelineThatChangesRequest_WhenHandlingRequest_ThenChangesRequestInPipeline()
        {
            var testHandlerA        = new TestHandler <TestRequestA>();
            var testHandlerB        = new TestHandler <TestRequestA>();
            var testMutationHandler = new TestMutationHandler();
            var testHandlerC        = new TestHandler <TestRequestB>();


            var pipeline = PipelineDefinitionBuilder <TestRequestA, TestResponse>
                           .StartWith(testHandlerA)
                           .ThenWith(testHandlerB)
                           .ThenWithMutation(testMutationHandler)
                           .ThenWith(testHandlerC)
                           .Build();

            var testRequest = new TestRequestA();

            pipeline.Handle(testRequest);

            Assert.Multiple(() =>
            {
                Assert.That(testHandlerA._request, Is.EqualTo(testRequest));
                Assert.That(testHandlerB._request, Is.EqualTo(testRequest));
                Assert.That(testMutationHandler._request, Is.EqualTo(testRequest));
                Assert.That(testHandlerC._request, Is.Not.EqualTo(testRequest));
                Assert.That(testHandlerC._request, Is.TypeOf <TestRequestB>());
            });
        }
Exemple #3
0
        public void GivenPiplelineWithThreeStages_WhenHandlingRequest_ThenAllThreeHandlersAreCalledInOrder()
        {
            var testHandlerA = new TestHandler <TestRequestA>();
            var testHandlerB = new TestHandler <TestRequestA>();
            var testHandlerC = new TestHandler <TestRequestA>();

            var pipeline = PipelineDefinitionBuilder <TestRequestA, TestResponse>
                           .StartWith(testHandlerA)
                           .ThenWith(testHandlerB)
                           .ThenWith(testHandlerC)
                           .Build();

            var testRequest = new TestRequestA();

            pipeline.Handle(testRequest);

            var callOrder = new[]
            {
                testHandlerA,
                testHandlerB,
                testHandlerC
            }.OrderBy(x => x._timestamp)
            .ToArray();

            Assert.Multiple(() =>
            {
                Assert.That(callOrder[0], Is.EqualTo(testHandlerA));
                Assert.That(callOrder[1], Is.EqualTo(testHandlerB));
                Assert.That(callOrder[2], Is.EqualTo(testHandlerC));
            });
        }
Exemple #4
0
		public void Test_WorkItemRequest_subclass_roundtrip()
		{
			var requestA = new TestRequestA();
			var requestB = new TestRequestB();

			var a = Serializer.SerializeWorkItemRequest(requestA);
			var b = Serializer.SerializeWorkItemRequest(requestB);

			// ensure that we get instances of the correct sub-classes back, even if we ask for the base-class
            Assert.IsInstanceOf(typeof(TestRequestA), Serializer.DeserializeWorkItemRequest(a));
            Assert.IsInstanceOf(typeof(TestRequestB), Serializer.DeserializeWorkItemRequest(b));
		}
        public void Test_WorkItemRequest_subclass_roundtrip()
        {
            var requestA = new TestRequestA();
            var requestB = new TestRequestB();

            var a = Serializer.SerializeWorkItemRequest(requestA);
            var b = Serializer.SerializeWorkItemRequest(requestB);

            // ensure that we get instances of the correct sub-classes back, even if we ask for the base-class
            Assert.IsInstanceOf(typeof(TestRequestA), Serializer.DeserializeWorkItemRequest(a));
            Assert.IsInstanceOf(typeof(TestRequestB), Serializer.DeserializeWorkItemRequest(b));
        }
        public async Task GivenPiplelineWithThreeStages_WhenHandlingRequest_ThenAllThreeHandlersAreCalledInOrder()
        {
            var testHandlerA = new TestHandlerA <TestRequestA>();
            var testHandlerB = new TestHandlerB <TestRequestA>();
            var testHandlerC = new TestHandlerC <TestRequestA>();

            Dictionary <Type, Object> dictionary = new Dictionary <Type, object>
            {
                [typeof(TestHandlerA <TestRequestA>)] = testHandlerA,
                [typeof(TestHandlerB <TestRequestA>)] = testHandlerB,
                [typeof(TestHandlerC <TestRequestA>)] = testHandlerC,
            };

            PipelineDefinitionBuilder builder = new
                                                PipelineDefinitionBuilder(type => dictionary[type]);

            var pipeline = builder.StartWith <TestHandlerA <TestRequestA>, TestRequestA>()
                           .ThenWith <TestHandlerB <TestRequestA> >()
                           .ThenWith <TestHandlerC <TestRequestA> >()
                           .Build();

            var testRequest = new TestRequestA();

            await pipeline.HandleAsync(testRequest, new Context());

            var callOrder = new TestHandler <TestRequestA>[]
            {
                testHandlerA,
                testHandlerB,
                testHandlerC
            }.OrderBy(x => x._timestamp)
            .ToArray();

            Assert.Multiple(() =>
            {
                Assert.That(callOrder[0], Is.EqualTo(testHandlerA));
                Assert.That(callOrder[1], Is.EqualTo(testHandlerB));
                Assert.That(callOrder[2], Is.EqualTo(testHandlerC));
            });
        }
Exemple #7
0
        public void GivenPiplelineWithThreeStages_WhenHandlingRequest_ThenAllThreeHandlersHandleRequest()
        {
            var testHandlerA = new TestHandler <TestRequestA>();
            var testHandlerB = new TestHandler <TestRequestA>();
            var testHandlerC = new TestHandler <TestRequestA>();

            var pipeline = PipelineDefinitionBuilder <TestRequestA, TestResponse>
                           .StartWith(testHandlerA)
                           .ThenWith(testHandlerB)
                           .ThenWith(testHandlerC)
                           .Build();

            var testRequest = new TestRequestA();

            pipeline.Handle(testRequest);
            Assert.Multiple(() =>
            {
                Assert.That(testHandlerA._request, Is.EqualTo(testRequest));
                Assert.That(testHandlerB._request, Is.EqualTo(testRequest));
                Assert.That(testHandlerC._request, Is.EqualTo(testRequest));
            });
        }
        public async Task GivenPipelineThatChangesRequest_WhenHandlingRequest_ThenChangesRequestInPipeline()
        {
            var testHandlerA        = new TestHandlerA <TestRequestA>();
            var testHandlerB        = new TestHandlerB <TestRequestA>();
            var testMutationHandler = new TestMutationHandler();
            var testHandlerC        = new TestHandlerC <TestRequestB>();

            Dictionary <Type, Object> dictionary = new Dictionary <Type, object>
            {
                [typeof(TestHandlerA <TestRequestA>)] = testHandlerA,
                [typeof(TestHandlerB <TestRequestA>)] = testHandlerB,
                [typeof(TestHandlerC <TestRequestB>)] = testHandlerC,
                [typeof(TestMutationHandler)]         = testMutationHandler,
            };

            PipelineDefinitionBuilder builder = new
                                                PipelineDefinitionBuilder(type => dictionary[type]);


            var pipeline = builder.StartWith <TestHandlerA <TestRequestA>, TestRequestA> ()
                           .ThenWith <TestHandlerB <TestRequestA> >()
                           .ThenWithMutation <TestMutationHandler, TestRequestB>()
                           .ThenWith <TestHandlerC <TestRequestB> >()
                           .Build();

            var testRequest = new TestRequestA();

            await pipeline.HandleAsync(testRequest, new Context());

            Assert.Multiple(() =>
            {
                Assert.That(testHandlerA._request, Is.EqualTo(testRequest));
                Assert.That(testHandlerB._request, Is.EqualTo(testRequest));
                Assert.That(testMutationHandler._request, Is.EqualTo(testRequest));
                Assert.That(testHandlerC._request, Is.Not.EqualTo(testRequest));
                Assert.That(testHandlerC._request, Is.TypeOf <TestRequestB>());
            });
        }