Delegating Handlers from container (#266)

* #259 quickly hacked poc for this together, needs tidying up maybe

* #266 +semver: breaking removed adding delegating handler funcs directly...i feel from container is enough

test/Ocelot.UnitTests/Requester/DelegatingHandlerHandlerHouseTests.cs

@@ -1,137 +0,0 @@
-using System;
-using System.Net.Http;
-using Moq;
-using Ocelot.Configuration;
-using Ocelot.Configuration.Builder;
-using Ocelot.Errors;
-using Ocelot.Requester;
-using Ocelot.Responses;
-using Shouldly;
-using TestStack.BDDfy;
-using Xunit;
-
-namespace Ocelot.UnitTests.Requester
-{
-    public class DelegatingHandlerHandlerHouseTests
-    {
-        private readonly DelegatingHandlerHandlerHouse _house;
-        private Mock<IDelegatingHandlerHandlerProviderFactory> _factory;
-        private readonly Mock<IDelegatingHandlerHandlerProvider> _provider;
-        private DownstreamReRoute _request;
-        private Response<IDelegatingHandlerHandlerProvider> _result;
-
-        public DelegatingHandlerHandlerHouseTests()
-        {
-            _provider = new Mock<IDelegatingHandlerHandlerProvider>();
-            _factory = new Mock<IDelegatingHandlerHandlerProviderFactory>();
-            _house = new DelegatingHandlerHandlerHouse(_factory.Object);
-        }
-
-        [Fact]
-        public void should_create_and_store_provider()
-        {
-            var reRoute = new DownstreamReRouteBuilder().WithIsQos(true)
-                .WithHttpHandlerOptions(new HttpHandlerOptions(true, true, false)).WithReRouteKey("key").Build();
-
-            this.Given(x => GivenTheRequest(reRoute))
-                .And(x => GivenTheProviderReturns())
-                .When(x => WhenIGet())
-                .Then(x => ThenTheFactoryIsCalled(1))
-                .And(x => ThenTheProviderIsNotNull())
-                .BDDfy();
-        }
-
-        [Fact]
-        public void should_get_provider()
-        {
-            var reRoute = new DownstreamReRouteBuilder().WithIsQos(true)
-                .WithHttpHandlerOptions(new HttpHandlerOptions(true, true, false)).WithReRouteKey("key").Build();
-
-            this.Given(x => GivenTheRequest(reRoute))
-                .And(x => GivenTheProviderReturns())
-                .And(x => WhenIGet())
-                .And(x => GivenTheFactoryIsCleared())
-                .When(x => WhenIGet())
-                .Then(x => ThenTheFactoryIsCalled(0))
-                .And(x => ThenTheProviderIsNotNull())
-                .BDDfy();
-        }
-
-        [Fact]
-        public void should_return_error()
-        {
-            var reRoute = new DownstreamReRouteBuilder().WithIsQos(true)
-                .WithHttpHandlerOptions(new HttpHandlerOptions(true, true, false)).WithReRouteKey("key").Build();
-
-            this.Given(x => GivenTheRequest(reRoute))
-                .And(x => GivenTheProviderThrows())
-                .When(x => WhenIGet())
-                .And(x => ThenAnErrorIsReturned())
-                .BDDfy();
-        }
-
-        [Fact]
-        public void should_return_error_if_factory_errors()
-        {
-            var reRoute = new DownstreamReRouteBuilder().WithIsQos(true)
-                .WithHttpHandlerOptions(new HttpHandlerOptions(true, true, false)).WithReRouteKey("key").Build();
-
-            this.Given(x => GivenTheRequest(reRoute))
-                .And(x => GivenTheProviderReturnsError())
-                .When(x => WhenIGet())
-                .Then(x => ThenAnUnknownErrorIsReturned())
-                .BDDfy();
-        }
-
-        private void ThenAnUnknownErrorIsReturned()
-        {
-            _result.IsError.ShouldBeTrue();
-        }
-
-        private void ThenAnErrorIsReturned()
-        {
-            _result.IsError.ShouldBeTrue();
-            _result.Errors[0].ShouldBeOfType<UnableToFindDelegatingHandlerProviderError>();
-        }
-
-        private void GivenTheProviderThrows()
-        {
-            _factory.Setup(x => x.Get(It.IsAny<DownstreamReRoute>())).Throws<Exception>();
-        }
-
-        private void GivenTheFactoryIsCleared()
-        {
-            _factory = new Mock<IDelegatingHandlerHandlerProviderFactory>();
-        }
-
-        private void ThenTheProviderIsNotNull()
-        {
-            _result.Data.ShouldBe(_provider.Object);
-        }
-
-        private void WhenIGet()
-        {
-            _result = _house.Get(_request);
-        }
-
-        private void GivenTheRequest(DownstreamReRoute request)
-        {
-            _request = request;
-        }
-
-        private void GivenTheProviderReturns()
-        {
-            _factory.Setup(x => x.Get(It.IsAny<DownstreamReRoute>())).Returns(new OkResponse<IDelegatingHandlerHandlerProvider>(_provider.Object));
-        }
-
-        private void GivenTheProviderReturnsError()
-        {
-            _factory.Setup(x => x.Get(It.IsAny<DownstreamReRoute>())).Returns(new ErrorResponse<IDelegatingHandlerHandlerProvider>(It.IsAny<Error>()));
-        }
-
-        private void ThenTheFactoryIsCalled(int times)
-        {
-            _factory.Verify(x => x.Get(_request), Times.Exactly(times));
-        }
-    }
-}

test/Ocelot.UnitTests/Requester/DelegatingHandlerHandlerProviderFactoryTests.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Net.Http;
+using Microsoft.Extensions.DependencyInjection;
 using Moq;
 using Ocelot.Configuration;
 using Ocelot.Configuration.Builder;
@@ -17,50 +18,35 @@ namespace Ocelot.UnitTests.Requester
 {
     public class DelegatingHandlerHandlerProviderFactoryTests
     {
-        private readonly DelegatingHandlerHandlerProviderFactory _factory;
+        private DelegatingHandlerHandlerFactory _factory;
         private Mock<IOcelotLoggerFactory> _loggerFactory;
         private DownstreamReRoute _request;
-        private Response<IDelegatingHandlerHandlerProvider> _provider;
-        private readonly Mock<IDelegatingHandlerHandlerProvider> _allRoutesProvider;
+        private Response<List<Func<DelegatingHandler>>> _provider;
         private readonly Mock<IQosProviderHouse> _qosProviderHouse;
         private readonly Mock<ITracingHandlerFactory> _tracingFactory;
+        private IServiceProvider _serviceProvider;
 
         public DelegatingHandlerHandlerProviderFactoryTests()
         {
             _tracingFactory = new Mock<ITracingHandlerFactory>();
             _qosProviderHouse = new Mock<IQosProviderHouse>();
-            _allRoutesProvider = new Mock<IDelegatingHandlerHandlerProvider>();
             _loggerFactory = new Mock<IOcelotLoggerFactory>();
-            _factory = new DelegatingHandlerHandlerProviderFactory(_loggerFactory.Object, _allRoutesProvider.Object, _tracingFactory.Object, _qosProviderHouse.Object);
-        }
-
-        private void GivenTheQosProviderHouseReturns(Response<IQoSProvider> qosProvider)
-        {
-            _qosProviderHouse
-                .Setup(x => x.Get(It.IsAny<DownstreamReRoute>()))
-                .Returns(qosProvider);
         }
 
         [Fact]
         public void should_all_from_all_routes_provider_and_qos()
         {
-            var handlers = new List<Func<DelegatingHandler>>
-            {
-                () => new FakeDelegatingHandler(0),
-                () => new FakeDelegatingHandler(1)
-            };
-
             var reRoute = new DownstreamReRouteBuilder().WithIsQos(true)
                 .WithHttpHandlerOptions(new HttpHandlerOptions(true, true, false)).WithReRouteKey("").Build();
 
             this.Given(x => GivenTheFollowingRequest(reRoute))
                 .And(x => GivenTheQosProviderHouseReturns(new OkResponse<IQoSProvider>(It.IsAny<PollyQoSProvider>())))
-                .And(x => GivenTheAllRoutesProviderReturns(handlers))
+                .And(x => GivenTheServiceProviderReturns<FakeDelegatingHandler, FakeDelegatingHandlerTwo>())
                 .When(x => WhenIGet())
                 .Then(x => ThenThereIsDelegatesInProvider(3))
                 .And(x => ThenTheDelegatesAreAddedCorrectly())
                 .And(x => ThenItIsPolly(2))
-                .BDDfy();
+                .BDDfy(); 
         }
 
         [Fact]
@@ -70,7 +56,7 @@ namespace Ocelot.UnitTests.Requester
                 .WithHttpHandlerOptions(new HttpHandlerOptions(true, true, false)).WithReRouteKey("").Build();
 
             this.Given(x => GivenTheFollowingRequest(reRoute))
-                .And(x => GivenTheAllRoutesProviderReturns())
+                .And(x => GivenTheServiceProviderReturnsNothing())
                 .When(x => WhenIGet())
                 .Then(x => ThenNoDelegatesAreInTheProvider())
                 .BDDfy();
@@ -84,7 +70,7 @@ namespace Ocelot.UnitTests.Requester
 
             this.Given(x => GivenTheFollowingRequest(reRoute))
                 .And(x => GivenTheQosProviderHouseReturns(new OkResponse<IQoSProvider>(It.IsAny<PollyQoSProvider>())))
-                .And(x => GivenTheAllRoutesProviderReturns())
+                .And(x => GivenTheServiceProviderReturnsNothing())
                 .When(x => WhenIGet())
                 .Then(x => ThenThereIsDelegatesInProvider(1))
                 .And(x => ThenItIsPolly(0))
@@ -99,12 +85,28 @@ namespace Ocelot.UnitTests.Requester
 
             this.Given(x => GivenTheFollowingRequest(reRoute))
                 .And(x => GivenTheQosProviderHouseReturns(new ErrorResponse<IQoSProvider>(It.IsAny<Error>())))
-                .And(x => GivenTheAllRoutesProviderReturns())
+                .And(x => GivenTheServiceProviderReturnsNothing())
                 .When(x => WhenIGet())
                 .Then(x => ThenAnErrorIsReturned())
                 .BDDfy();
         }
 
+        private void GivenTheServiceProviderReturns<TOne, TTwo>() 
+            where TOne : DelegatingHandler
+            where TTwo : DelegatingHandler
+        {
+            IServiceCollection services = new ServiceCollection();
+            services.AddSingleton<DelegatingHandler, TOne>();
+            services.AddSingleton<DelegatingHandler, TTwo>();
+            _serviceProvider = services.BuildServiceProvider();
+        }
+
+         private void GivenTheServiceProviderReturnsNothing()
+        {
+            IServiceCollection services = new ServiceCollection();
+            _serviceProvider = services.BuildServiceProvider();
+        }
+
         private void ThenAnErrorIsReturned()
         {
             _provider.IsError.ShouldBeTrue();
@@ -112,29 +114,27 @@ namespace Ocelot.UnitTests.Requester
 
         private void ThenTheDelegatesAreAddedCorrectly()
         {
-            var delegates = _provider.Data.Get();
+            var delegates = _provider.Data;
+
             var del = delegates[0].Invoke();
             var handler = (FakeDelegatingHandler) del;
-            handler.Order.ShouldBe(0);
+            handler.Order.ShouldBe(1);
 
             del = delegates[1].Invoke();
-            handler = (FakeDelegatingHandler)del;
-            handler.Order.ShouldBe(1);
+            var handlerTwo = (FakeDelegatingHandlerTwo) del;
+            handlerTwo.Order.ShouldBe(2);
         }
 
-        private void GivenTheAllRoutesProviderReturns()
+        private void GivenTheQosProviderHouseReturns(Response<IQoSProvider> qosProvider)
         {
-            _allRoutesProvider.Setup(x => x.Get()).Returns(new List<Func<DelegatingHandler>>());
-        }
-
-        private void GivenTheAllRoutesProviderReturns(List<Func<DelegatingHandler>> handlers)
-        {
-            _allRoutesProvider.Setup(x => x.Get()).Returns(handlers);
+            _qosProviderHouse
+                .Setup(x => x.Get(It.IsAny<DownstreamReRoute>()))
+                .Returns(qosProvider);
         }
 
         private void ThenItIsPolly(int i)
         {
-            var delegates = _provider.Data.Get();
+            var delegates = _provider.Data;
             var del = delegates[i].Invoke();
             del.ShouldBeOfType<PollyCircuitBreakingDelegatingHandler>();
         }
@@ -142,7 +142,7 @@ namespace Ocelot.UnitTests.Requester
         private void ThenThereIsDelegatesInProvider(int count)
         {
             _provider.ShouldNotBeNull();
-            _provider.Data.Get().Count.ShouldBe(count);
+            _provider.Data.Count.ShouldBe(count);
         }
 
         private void GivenTheFollowingRequest(DownstreamReRoute request)
@@ -152,13 +152,14 @@ namespace Ocelot.UnitTests.Requester
 
         private void WhenIGet()
         {
+            _factory = new DelegatingHandlerHandlerFactory(_loggerFactory.Object, _tracingFactory.Object, _qosProviderHouse.Object, _serviceProvider);
             _provider = _factory.Get(_request);
         }
 
         private void ThenNoDelegatesAreInTheProvider()
         {
             _provider.ShouldNotBeNull();
-            _provider.Data.Get().Count.ShouldBe(0);
+            _provider.Data.Count.ShouldBe(0);
         }
     }
 }

test/Ocelot.UnitTests/Requester/DelegatingHandlerHandlerProviderTests.cs

@@ -1,62 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Net.Http;
-using Ocelot.Requester;
-using Shouldly;
-using TestStack.BDDfy;
-using Xunit;
-
-namespace Ocelot.UnitTests.Requester
-{
-    public class DelegatingHandlerHandlerProviderTests
-    {
-        private readonly DelegatingHandlerHandlerProvider _provider;
-        private List<Func<DelegatingHandler>> _handlers;
-
-        public DelegatingHandlerHandlerProviderTests()
-        {
-            _provider = new DelegatingHandlerHandlerProvider();
-        }
-
-        [Fact]
-        public void should_return_empty_list()
-        {
-            this.When(x => WhenIGet())
-                .Then(x => ThenAnEmptyListIsReturned())
-                .BDDfy();
-        }
-
-        [Fact]
-        public void should_get_delegating_handlers_in_order_first_in_first_out()
-        {   
-            this.Given(x => GivenTheHandlers())
-                .When(x => WhenIGet())
-                .Then(x => ThenTheHandlersAreReturnedInOrder())
-                .BDDfy();
-        }
-
-        private void ThenAnEmptyListIsReturned()
-        {
-            _handlers.Count.ShouldBe(0);
-        }
-
-        private void ThenTheHandlersAreReturnedInOrder()
-        {
-             var handler = (FakeDelegatingHandler)_handlers[0].Invoke();
-            handler.Order.ShouldBe(0);
-            handler = (FakeDelegatingHandler)_handlers[1].Invoke();
-            handler.Order.ShouldBe(1);
-        }
-
-        private void WhenIGet()
-        {
-            _handlers = _provider.Get();
-        }
-
-        private void GivenTheHandlers()
-        {
-            _provider.Add(() => new FakeDelegatingHandler(0));
-            _provider.Add(() => new FakeDelegatingHandler(1));
-        }
-    }
-}

test/Ocelot.UnitTests/Requester/FakeDelegatingHandler.cs

@@ -9,6 +9,7 @@ namespace Ocelot.UnitTests.Requester
     {
         public FakeDelegatingHandler()
         {
+            Order = 1;
         }
 
         public FakeDelegatingHandler(int order)
@@ -26,4 +27,21 @@ namespace Ocelot.UnitTests.Requester
             return Task.FromResult(new HttpResponseMessage());
         }
     }
+
+    public class FakeDelegatingHandlerTwo : DelegatingHandler
+    {
+        public FakeDelegatingHandlerTwo()
+        {
+            Order = 2;
+        }
+
+        public int Order {get;private set;}
+        public DateTime TimeCalled {get;private set;}
+
+        protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
+        {
+            TimeCalled = DateTime.Now;
+            return new HttpResponseMessage();
+        }
+    }
 }

test/Ocelot.UnitTests/Requester/HttpClientBuilderTests.cs

@@ -15,25 +15,22 @@ namespace Ocelot.UnitTests.Requester
     public class HttpClientBuilderTests
     {
         private readonly HttpClientBuilder _builder;
-        private readonly Mock<IDelegatingHandlerHandlerHouse> _house;
-        private readonly Mock<IDelegatingHandlerHandlerProvider> _provider;
+        private readonly Mock<IDelegatingHandlerHandlerFactory> _factory;
         private IHttpClient _httpClient;
         private HttpResponseMessage _response;
         private DownstreamReRoute _request;
 
         public HttpClientBuilderTests()
         {
-            _provider = new Mock<IDelegatingHandlerHandlerProvider>();
-            _house = new Mock<IDelegatingHandlerHandlerHouse>();
-            _builder = new HttpClientBuilder(_house.Object);
+            _factory = new Mock<IDelegatingHandlerHandlerFactory>();
+            _builder = new HttpClientBuilder(_factory.Object);
         }
 
         [Fact]
         public void should_build_http_client()
         {
-            this.Given(x => GivenTheProviderReturns())
+            this.Given(x => GivenTheFactoryReturns())
                 .And(x => GivenARequest())
-                .And(x => GivenTheHouseReturns())
                 .When(x => WhenIBuild())
                 .Then(x => ThenTheHttpClientShouldNotBeNull())
                 .BDDfy();
@@ -51,9 +48,8 @@ namespace Ocelot.UnitTests.Requester
                 () => fakeTwo
             };
 
-            this.Given(x => GivenTheProviderReturns(handlers))
+            this.Given(x => GivenTheFactoryReturns(handlers))
                 .And(x => GivenARequest())
-                .And(x => GivenTheHouseReturns())
                 .And(x => WhenIBuild())
                 .When(x => WhenICallTheClient())
                 .Then(x => ThenTheFakeAreHandledInOrder(fakeOne, fakeTwo))
@@ -69,13 +65,6 @@ namespace Ocelot.UnitTests.Requester
             _request = reRoute;
         }
 
-        private void GivenTheHouseReturns()
-        {
-            _house
-                .Setup(x => x.Get(It.IsAny<DownstreamReRoute>()))
-                .Returns(new OkResponse<IDelegatingHandlerHandlerProvider>(_provider.Object));
-        }
-
         private void ThenSomethingIsReturned()
         {
             _response.ShouldNotBeNull();
@@ -91,18 +80,20 @@ namespace Ocelot.UnitTests.Requester
             fakeOne.TimeCalled.ShouldBeGreaterThan(fakeTwo.TimeCalled);
         }
 
-        private void GivenTheProviderReturns()
+        private void GivenTheFactoryReturns()
         {
-            _provider
-                .Setup(x => x.Get())
-                .Returns(new List<Func<DelegatingHandler>>(){ () => new FakeDelegatingHandler()});
+            var handlers = new List<Func<DelegatingHandler>>(){ () => new FakeDelegatingHandler()};
+
+            _factory
+                .Setup(x => x.Get(It.IsAny<DownstreamReRoute>()))
+                .Returns(new OkResponse<List<Func<DelegatingHandler>>>(handlers));
         }
 
-        private void GivenTheProviderReturns(List<Func<DelegatingHandler>> handlers)
+        private void GivenTheFactoryReturns(List<Func<DelegatingHandler>> handlers)
         {
-            _provider
-                .Setup(x => x.Get())
-                .Returns(handlers);
+             _factory
+                .Setup(x => x.Get(It.IsAny<DownstreamReRoute>()))
+                .Returns(new OkResponse<List<Func<DelegatingHandler>>>(handlers));
         }
 
         private void WhenIBuild()

test/Ocelot.UnitTests/Requester/HttpClientHttpRequesterTest.cs

@@ -18,8 +18,7 @@ namespace Ocelot.UnitTests.Requester
     public class HttpClientHttpRequesterTest
     {
         private readonly Mock<IHttpClientCache> _cacheHandlers;
-        private Mock<IDelegatingHandlerHandlerHouse> _house;
-        private Mock<IDelegatingHandlerHandlerProvider> _provider;
+        private Mock<IDelegatingHandlerHandlerFactory> _house;
         private Response<HttpResponseMessage> _response;
         private readonly HttpClientHttpRequester _httpClientRequester;
         private DownstreamContext _request;
@@ -28,10 +27,8 @@ namespace Ocelot.UnitTests.Requester
 
         public HttpClientHttpRequesterTest()
         {
-            _provider = new Mock<IDelegatingHandlerHandlerProvider>();
-            _provider.Setup(x => x.Get()).Returns(new List<Func<DelegatingHandler>>());
-            _house = new Mock<IDelegatingHandlerHandlerHouse>();
-            _house.Setup(x => x.Get(It.IsAny<DownstreamReRoute>())).Returns(new OkResponse<IDelegatingHandlerHandlerProvider>(_provider.Object));
+            _house = new Mock<IDelegatingHandlerHandlerFactory>();
+            _house.Setup(x => x.Get(It.IsAny<DownstreamReRoute>())).Returns(new OkResponse<List<Func<DelegatingHandler>>>(new List<Func<DelegatingHandler>>()));
             _logger = new Mock<IOcelotLogger>();
             _loggerFactory = new Mock<IOcelotLoggerFactory>();
             _loggerFactory