Tracer to wrap a DelegatingHandler.
Наследование: System.Net.Http.DelegatingHandler
        public void SendAsync_Traces_And_Invokes_Inner()
        {
            // Arrange
            HttpResponseMessage response = new HttpResponseMessage();
            MockDelegatingHandler mockHandler = new MockDelegatingHandler((rqst, cancellation) =>
                                                 TaskHelpers.FromResult<HttpResponseMessage>(response));

            TestTraceWriter traceWriter = new TestTraceWriter();
            MessageHandlerTracer tracer = new MessageHandlerTracer(mockHandler, traceWriter);
            MockHttpMessageHandler mockInnerHandler = new MockHttpMessageHandler((rqst, cancellation) =>
                                     TaskHelpers.FromResult<HttpResponseMessage>(response));
            tracer.InnerHandler = mockInnerHandler;

            HttpRequestMessage request = new HttpRequestMessage();
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, TraceCategories.MessageHandlersCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "SendAsync" },
                new TraceRecord(request, TraceCategories.MessageHandlersCategory, TraceLevel.Info) { Kind = TraceKind.End, Operation = "SendAsync" }
            };

            MethodInfo method = typeof(DelegatingHandler).GetMethod("SendAsync",
                                                                     BindingFlags.Public | BindingFlags.NonPublic |
                                                                     BindingFlags.Instance);

            // Act
            Task<HttpResponseMessage> task = method.Invoke(tracer, new object[] { request, CancellationToken.None }) as Task<HttpResponseMessage>;
            HttpResponseMessage actualResponse = task.Result;

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
            Assert.Same(response, actualResponse);
        }
        public void SendAsync_Traces_And_Throws_When_Inner_Throws()
        {
            // Arrange
            InvalidOperationException exception = new InvalidOperationException("test");
            MockDelegatingHandler mockHandler = new MockDelegatingHandler((rqst, cancellation) => { throw exception; });

            TestTraceWriter traceWriter = new TestTraceWriter();
            MessageHandlerTracer tracer = new MessageHandlerTracer(mockHandler, traceWriter);

            // DelegatingHandlers require an InnerHandler to run.  We create a mock one to simulate what
            // would happen when a DelegatingHandler executing after the tracer throws.
            MockHttpMessageHandler mockInnerHandler = new MockHttpMessageHandler((rqst, cancellation) => { throw exception; });
            tracer.InnerHandler = mockInnerHandler;

            HttpRequestMessage request = new HttpRequestMessage();
            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, TraceCategories.MessageHandlersCategory, TraceLevel.Info) { Kind = TraceKind.Begin, Operation = "SendAsync" },
                new TraceRecord(request, TraceCategories.MessageHandlersCategory, TraceLevel.Error) { Kind = TraceKind.End, Operation = "SendAsync" }
            };

            MethodInfo method = typeof(DelegatingHandler).GetMethod("SendAsync",
                                                                     BindingFlags.Public | BindingFlags.NonPublic |
                                                                     BindingFlags.Instance);

            // Act
            Exception thrown =
                Assert.Throws<TargetInvocationException>(
                    () => method.Invoke(tracer, new object[] { request, CancellationToken.None }));

            // Assert
            Assert.Equal<TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
            Assert.Same(exception, thrown.InnerException);
            Assert.Same(exception, traceWriter.Traces[1].Exception);
        }
        public void SendAsync_Traces_And_Throws_When_Inner_Throws()
        {
            // Arrange
            InvalidOperationException exception   = new InvalidOperationException("test");
            MockDelegatingHandler     mockHandler = new MockDelegatingHandler(
                (rqst, cancellation) =>
            {
                throw exception;
            }
                );

            TestTraceWriter      traceWriter = new TestTraceWriter();
            MessageHandlerTracer tracer      = new MessageHandlerTracer(mockHandler, traceWriter);

            // DelegatingHandlers require an InnerHandler to run.  We create a mock one to simulate what
            // would happen when a DelegatingHandler executing after the tracer throws.
            MockHttpMessageHandler mockInnerHandler = new MockHttpMessageHandler(
                (rqst, cancellation) =>
            {
                throw exception;
            }
                );

            tracer.InnerHandler = mockInnerHandler;

            HttpRequestMessage request = new HttpRequestMessage();

            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, TraceCategories.MessageHandlersCategory, TraceLevel.Info)
                {
                    Kind      = TraceKind.Begin,
                    Operation = "SendAsync"
                },
                new TraceRecord(request, TraceCategories.MessageHandlersCategory, TraceLevel.Error)
                {
                    Kind      = TraceKind.End,
                    Operation = "SendAsync"
                }
            };

            MethodInfo method = typeof(DelegatingHandler).GetMethod(
                "SendAsync",
                BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance
                );

            // Act
            Exception thrown = Assert.Throws <TargetInvocationException>(
                () => method.Invoke(tracer, new object[] { request, CancellationToken.None })
                );

            // Assert
            Assert.Equal <TraceRecord>(
                expectedTraces,
                traceWriter.Traces,
                new TraceRecordComparer()
                );
            Assert.Same(exception, thrown.InnerException);
            Assert.Same(exception, traceWriter.Traces[1].Exception);
        }
Пример #4
0
        public void Decorator_GetInner_On_MessageHandlerTracer_Returns_DelegatingHandler()
        {
            // Arrange
            DelegatingHandler    expectedInner    = new Mock <DelegatingHandler>().Object;
            MessageHandlerTracer productUnderTest = new MessageHandlerTracer(expectedInner, new TestTraceWriter());

            // Act
            DelegatingHandler actualInner = Decorator.GetInner(productUnderTest as DelegatingHandler);

            // Assert
            Assert.Same(expectedInner, actualInner);
        }
Пример #5
0
        public void Inner_Property_On_MessageHandlerTracer_Returns_DelegatingHandler()
        {
            // Arrange
            DelegatingHandler    expectedInner    = new Mock <DelegatingHandler>().Object;
            MessageHandlerTracer productUnderTest = new MessageHandlerTracer(expectedInner, new TestTraceWriter());

            // Act
            DelegatingHandler actualInner = productUnderTest.Inner;

            // Assert
            Assert.Same(expectedInner, actualInner);
        }
        public async Task SendAsync_Traces_And_Invokes_Inner()
        {
            // Arrange
            HttpResponseMessage   response    = new HttpResponseMessage();
            MockDelegatingHandler mockHandler = new MockDelegatingHandler(
                (rqst, cancellation) => Task.FromResult <HttpResponseMessage>(response)
                );

            TestTraceWriter        traceWriter      = new TestTraceWriter();
            MessageHandlerTracer   tracer           = new MessageHandlerTracer(mockHandler, traceWriter);
            MockHttpMessageHandler mockInnerHandler = new MockHttpMessageHandler(
                (rqst, cancellation) => Task.FromResult <HttpResponseMessage>(response)
                );

            tracer.InnerHandler = mockInnerHandler;

            HttpRequestMessage request = new HttpRequestMessage();

            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, TraceCategories.MessageHandlersCategory, TraceLevel.Info)
                {
                    Kind      = TraceKind.Begin,
                    Operation = "SendAsync"
                },
                new TraceRecord(request, TraceCategories.MessageHandlersCategory, TraceLevel.Info)
                {
                    Kind      = TraceKind.End,
                    Operation = "SendAsync"
                }
            };

            MethodInfo method = typeof(DelegatingHandler).GetMethod(
                "SendAsync",
                BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance
                );

            // Act
            Task <HttpResponseMessage> task =
                method.Invoke(tracer, new object[] { request, CancellationToken.None })
                as Task <HttpResponseMessage>;
            HttpResponseMessage actualResponse = await task;

            // Assert
            Assert.Equal <TraceRecord>(
                expectedTraces,
                traceWriter.Traces,
                new TraceRecordComparer()
                );
            Assert.Same(response, actualResponse);
        }
Пример #7
0
        public async Task SendAsync_Traces_And_Faults_When_Inner_Faults()
        {
            // Arrange
            InvalidOperationException exception            = new InvalidOperationException("test");
            TaskCompletionSource <HttpResponseMessage> tcs = new TaskCompletionSource <HttpResponseMessage>();

            tcs.TrySetException(exception);
            MockDelegatingHandler mockHandler = new MockDelegatingHandler((rqst, cancellation) => { return(tcs.Task); });

            TestTraceWriter      traceWriter = new TestTraceWriter();
            MessageHandlerTracer tracer      = new MessageHandlerTracer(mockHandler, traceWriter);

            // DelegatingHandlers require an InnerHandler to run.  We create a mock one to simulate what
            // would happen when a DelegatingHandler executing after the tracer returns a Task that throws.
            MockHttpMessageHandler mockInnerHandler = new MockHttpMessageHandler((rqst, cancellation) => { return(tcs.Task); });

            tracer.InnerHandler = mockInnerHandler;

            HttpRequestMessage request = new HttpRequestMessage();

            TraceRecord[] expectedTraces = new TraceRecord[]
            {
                new TraceRecord(request, TraceCategories.MessageHandlersCategory, TraceLevel.Info)
                {
                    Kind = TraceKind.Begin, Operation = "SendAsync"
                },
                new TraceRecord(request, TraceCategories.MessageHandlersCategory, TraceLevel.Error)
                {
                    Kind = TraceKind.End, Operation = "SendAsync"
                }
            };

            MethodInfo method = typeof(DelegatingHandler).GetMethod("SendAsync",
                                                                    BindingFlags.Public | BindingFlags.NonPublic |
                                                                    BindingFlags.Instance);

            // Act
            Task <HttpResponseMessage> task =
                method.Invoke(tracer, new object[] { request, CancellationToken.None }) as Task <HttpResponseMessage>;

            // Assert
            Exception thrown = await Assert.ThrowsAsync <InvalidOperationException>(() => task);

            Assert.Equal <TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
            Assert.Same(exception, thrown);
            Assert.Same(exception, traceWriter.Traces[1].Exception);
        }
        public void Decorator_GetInner_On_MessageHandlerTracer_Returns_DelegatingHandler()
        {
            // Arrange
            DelegatingHandler expectedInner = new Mock<DelegatingHandler>().Object;
            MessageHandlerTracer productUnderTest = new MessageHandlerTracer(expectedInner, new TestTraceWriter());

            // Act
            DelegatingHandler actualInner = Decorator.GetInner(productUnderTest as DelegatingHandler);

            // Assert
            Assert.Same(expectedInner, actualInner);
        }
        public void Inner_Property_On_MessageHandlerTracer_Returns_DelegatingHandler()
        {
            // Arrange
            DelegatingHandler expectedInner = new Mock<DelegatingHandler>().Object;
            MessageHandlerTracer productUnderTest = new MessageHandlerTracer(expectedInner, new TestTraceWriter());

            // Act
            DelegatingHandler actualInner = productUnderTest.Inner;

            // Assert
            Assert.Same(expectedInner, actualInner);
        }
Пример #10
0
        public void Initialize_Repairs_Handler_Collection_If_RequestTracer_Inserted()
        {
            // Arrange
            HttpConfiguration config = new HttpConfiguration();
            config.Services.Replace(typeof(ITraceWriter), new TestTraceWriter());
            TestTraceWriter traceWriter = new TestTraceWriter();
            DelegatingHandler messageHandler = new Mock<DelegatingHandler>().Object;
            DelegatingHandler msgHandlerTracer = new MessageHandlerTracer(messageHandler, traceWriter);
            RequestMessageHandlerTracer requestMsgtracer = new RequestMessageHandlerTracer(traceWriter);
            List<DelegatingHandler> handlerList = new List<DelegatingHandler>() { messageHandler, msgHandlerTracer, requestMsgtracer };
            foreach (var eachHandler in handlerList)
            {
                config.MessageHandlers.Add(eachHandler);
            }
            TraceManager traceManager = new TraceManager();
            traceManager.Initialize(config);
            Collection<DelegatingHandler> expectedMessageHandlers = config.MessageHandlers;

            // Act
            config.MessageHandlers.Insert(0, requestMsgtracer);
            traceManager.Initialize(config);

            // Assert
            Collection<DelegatingHandler> actualMessageHandlers = config.MessageHandlers;
            Assert.Equal(expectedMessageHandlers, actualMessageHandlers);
            Assert.True(IsMessageHandlerCollectionValid(config.MessageHandlers));
        }
Пример #11
0
        private static void CreateMessageHandlerTracers(HttpConfiguration configuration, ITraceWriter traceWriter)
        {
            // Insert a tracing handler before each existing message handler (in execution order)
            int handlerCount = configuration.MessageHandlers.Count;
            for (int i = 0; i < handlerCount * 2; i += 2)
            {
                DelegatingHandler innerHandler = configuration.MessageHandlers[i];
                DelegatingHandler handlerTracer = new MessageHandlerTracer(innerHandler, traceWriter);
                configuration.MessageHandlers.Insert(i + 1, handlerTracer);
            }

            configuration.MessageHandlers.Add(new RequestMessageHandlerTracer(traceWriter));
        }