changes to create load balancers and qos providers on first request to reroute and then check if they have changed on subsequent requests but not create again if they havent..quite a few breaking changes here.

test/Ocelot.AcceptanceTests/ConfigurationInConsulTests.cs

@@ -3,7 +3,6 @@ using System.Collections.Generic;
 using System.IO;
 using System.Net;
 using System.Text;
-using System.Threading;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.Http;
@@ -11,7 +10,6 @@ using Newtonsoft.Json;
 using Ocelot.Configuration;
 using Ocelot.Configuration.Builder;
 using Ocelot.Configuration.File;
-using Ocelot.ServiceDiscovery;
 using TestStack.BDDfy;
 using Xunit;
 
@@ -50,7 +48,6 @@ namespace Ocelot.AcceptanceTests
                 {
                     ServiceDiscoveryProvider = new FileServiceDiscoveryProvider()
                     {
-                        Provider = "Consul",
                         Host = "localhost",
                         Port = 9500
                     }
@@ -59,12 +56,10 @@ namespace Ocelot.AcceptanceTests
 
             var fakeConsulServiceDiscoveryUrl = "http://localhost:9500";
 
-            var consulConfig = new ConsulRegistryConfiguration("localhost", 9500, "Ocelot");
-
             this.Given(x => GivenThereIsAFakeConsulServiceDiscoveryProvider(fakeConsulServiceDiscoveryUrl))
                 .And(x => x.GivenThereIsAServiceRunningOn("http://localhost:51779", "", 200, "Hello from Laura"))
                 .And(x => _steps.GivenThereIsAConfiguration(configuration))
-                .And(x => _steps.GivenOcelotIsRunningUsingConsulToStoreConfig(consulConfig))
+                .And(x => _steps.GivenOcelotIsRunningUsingConsulToStoreConfig())
                 .When(x => _steps.WhenIGetUrlOnTheApiGateway("/"))
                 .Then(x => _steps.ThenTheStatusCodeShouldBe(HttpStatusCode.OK))
                 .And(x => _steps.ThenTheResponseBodyShouldBe("Hello from Laura"))
@@ -73,31 +68,25 @@ namespace Ocelot.AcceptanceTests
 
         [Fact]
         public void should_fix_issue_142()
-        {            
+        {
+            var consulPort = 8500;
             var configuration = new FileConfiguration
             {
-                ReRoutes = new List<FileReRoute>
-                    {
-                    },
                 GlobalConfiguration = new FileGlobalConfiguration()
                 {
                     ServiceDiscoveryProvider = new FileServiceDiscoveryProvider()
                     {
-                        Provider = "Consul",
                         Host = "localhost",
-                        Port = 9500
+                        Port = consulPort
                     }
                 }
             };
 
-            var fakeConsulServiceDiscoveryUrl = "http://localhost:9500";
-
-            var consulConfig = new ConsulRegistryConfiguration("localhost", 9500, "Ocelot");
+            var fakeConsulServiceDiscoveryUrl = $"http://localhost:{consulPort}";
 
             var serviceProviderConfig = new ServiceProviderConfigurationBuilder()
-                .WithServiceDiscoveryProvider("Consul")
                 .WithServiceDiscoveryProviderHost("localhost")
-                .WithServiceDiscoveryProviderPort(8500)
+                .WithServiceDiscoveryProviderPort(consulPort)
                 .Build();
 
             var reRoute = new ReRouteBuilder()
@@ -108,10 +97,8 @@ namespace Ocelot.AcceptanceTests
                 .WithDownstreamPort(51779)
                 .WithUpstreamPathTemplate("/cs/status")
                 .WithUpstreamHttpMethod(new List<string> {"Get"})
-                .WithLoadBalancer("LeastConnection")
-                .WithLoadBalancerKey("/cs/status|Get")
-                .WithServiceName("")
-                .WithUseServiceDiscovery(true)
+                .WithReRouteKey("/cs/status|Get")
+                .WithHttpHandlerOptions(new HttpHandlerOptions(true, false))
                 .Build();
 
             var reRoutes = new List<ReRoute> { reRoute };
@@ -122,7 +109,7 @@ namespace Ocelot.AcceptanceTests
                 .And(x => GivenThereIsAFakeConsulServiceDiscoveryProvider(fakeConsulServiceDiscoveryUrl))
                 .And(x => x.GivenThereIsAServiceRunningOn("http://localhost:51779", "/status", 200, "Hello from Laura"))
                 .And(x => _steps.GivenThereIsAConfiguration(configuration))
-                .And(x => _steps.GivenOcelotIsRunningUsingConsulToStoreConfig(consulConfig))
+                .And(x => _steps.GivenOcelotIsRunningUsingConsulToStoreConfig())
                 .When(x => _steps.WhenIGetUrlOnTheApiGateway("/cs/status"))
                 .Then(x => _steps.ThenTheStatusCodeShouldBe(HttpStatusCode.OK))
                 .And(x => _steps.ThenTheResponseBodyShouldBe("Hello from Laura"))

test/Ocelot.AcceptanceTests/ServiceDiscoveryTests.cs

@@ -33,10 +33,11 @@ namespace Ocelot.AcceptanceTests
         [Fact]
         public void should_use_service_discovery_and_load_balance_request()
         {
+            var consulPort = 8501;
             var serviceName = "product";
             var downstreamServiceOneUrl = "http://localhost:50879";
             var downstreamServiceTwoUrl = "http://localhost:50880";
-            var fakeConsulServiceDiscoveryUrl = "http://localhost:8500";
+            var fakeConsulServiceDiscoveryUrl = $"http://localhost:{consulPort}";
             var serviceEntryOne = new ServiceEntry()
             {
                 Service = new AgentService()
@@ -79,9 +80,8 @@ namespace Ocelot.AcceptanceTests
                     {
                         ServiceDiscoveryProvider = new FileServiceDiscoveryProvider()
                         {
-                            Provider = "Consul",
                             Host = "localhost",
-                            Port = 8500
+                            Port = consulPort
                         }
                     }
             };

test/Ocelot.AcceptanceTests/Startup.cs

@@ -44,4 +44,39 @@ namespace Ocelot.AcceptanceTests
             app.UseOcelot().Wait();
         }
     }
+
+    public class ConsulStartup
+    {
+        public ConsulStartup(IHostingEnvironment env)
+        {
+            var builder = new ConfigurationBuilder()
+                .SetBasePath(env.ContentRootPath)
+                .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
+                .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true)
+                .AddJsonFile("configuration.json")
+                .AddEnvironmentVariables();
+
+            Configuration = builder.Build();
+        }
+
+        public IConfigurationRoot Configuration { get; }
+
+        public void ConfigureServices(IServiceCollection services)
+        {
+            Action<ConfigurationBuilderCachePart> settings = (x) =>
+            {
+                x.WithDictionaryHandle();
+            };
+
+            services.AddOcelot(Configuration, settings);
+            services.AddStoreOcelotConfigurationInConsul(Configuration);
+        }
+
+        public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory)
+        {
+            loggerFactory.AddConsole(Configuration.GetSection("Logging"));
+
+            app.UseOcelot().Wait();
+        }
+    }
 }

test/Ocelot.AcceptanceTests/Steps.cs

@@ -107,18 +107,17 @@ namespace Ocelot.AcceptanceTests
             _ocelotClient = _ocelotServer.CreateClient();
         }
 
-        public void GivenOcelotIsRunningUsingConsulToStoreConfig(ConsulRegistryConfiguration consulConfig)
+        public void GivenOcelotIsRunningUsingConsulToStoreConfig(/*ConsulRegistryConfiguration consulConfig*/)
         {
             _webHostBuilder = new WebHostBuilder();
 
             _webHostBuilder.ConfigureServices(s =>
             {
                 s.AddSingleton(_webHostBuilder);
-                s.AddOcelotStoreConfigurationInConsul(consulConfig);
             });
 
             _ocelotServer = new TestServer(_webHostBuilder
-                .UseStartup<Startup>());
+                .UseStartup<ConsulStartup>());
 
             _ocelotClient = _ocelotServer.CreateClient();
         }
@@ -131,7 +130,6 @@ namespace Ocelot.AcceptanceTests
             response.GlobalConfiguration.RequestIdKey.ShouldBe(expected.GlobalConfiguration.RequestIdKey);
             response.GlobalConfiguration.ServiceDiscoveryProvider.Host.ShouldBe(expected.GlobalConfiguration.ServiceDiscoveryProvider.Host);
             response.GlobalConfiguration.ServiceDiscoveryProvider.Port.ShouldBe(expected.GlobalConfiguration.ServiceDiscoveryProvider.Port);
-            response.GlobalConfiguration.ServiceDiscoveryProvider.Provider.ShouldBe(expected.GlobalConfiguration.ServiceDiscoveryProvider.Provider);
 
             for(var i = 0; i < response.ReRoutes.Count; i++)
             {

test/Ocelot.IntegrationTests/AdministrationTests.cs

@@ -107,7 +107,6 @@ namespace Ocelot.IntegrationTests
                     ServiceDiscoveryProvider = new FileServiceDiscoveryProvider
                     {
                         Host = "127.0.0.1",
-                        Provider = "test"
                     }
 
                 },
@@ -332,7 +331,6 @@ namespace Ocelot.IntegrationTests
             response.GlobalConfiguration.RequestIdKey.ShouldBe(expected.GlobalConfiguration.RequestIdKey);
             response.GlobalConfiguration.ServiceDiscoveryProvider.Host.ShouldBe(expected.GlobalConfiguration.ServiceDiscoveryProvider.Host);
             response.GlobalConfiguration.ServiceDiscoveryProvider.Port.ShouldBe(expected.GlobalConfiguration.ServiceDiscoveryProvider.Port);
-            response.GlobalConfiguration.ServiceDiscoveryProvider.Provider.ShouldBe(expected.GlobalConfiguration.ServiceDiscoveryProvider.Provider);
 
             for (var i = 0; i < response.ReRoutes.Count; i++)
             {

test/Ocelot.UnitTests/Configuration/FileConfigurationCreatorTests.cs

@@ -1,5 +1,4 @@
 using System.Collections.Generic;
-using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using Moq;
 using Ocelot.Cache;
@@ -8,9 +7,7 @@ using Ocelot.Configuration.Builder;
 using Ocelot.Configuration.Creator;
 using Ocelot.Configuration.File;
 using Ocelot.Configuration.Validator;
-using Ocelot.LoadBalancer.LoadBalancers;
 using Ocelot.Logging;
-using Ocelot.Requester.QoS;
 using Ocelot.Responses;
 using Shouldly;
 using TestStack.BDDfy;
@@ -18,8 +15,6 @@ using Xunit;
 
 namespace Ocelot.UnitTests.Configuration
 {
-    using System.Collections;
-    using Ocelot.LoadBalancer;
     using Ocelot.UnitTests.TestData;
 
     public class FileConfigurationCreatorTests
@@ -30,10 +25,6 @@ namespace Ocelot.UnitTests.Configuration
         private FileConfiguration _fileConfiguration;
         private readonly Mock<IOcelotLoggerFactory> _logger;
         private readonly FileOcelotConfigurationCreator _ocelotConfigurationCreator;
-        private readonly Mock<ILoadBalancer> _loadBalancer;
-        private readonly Mock<IQoSProviderFactory> _qosProviderFactory;
-        private readonly Mock<IQosProviderHouse> _qosProviderHouse;
-        private readonly Mock<IQoSProvider> _qosProvider;
         private Mock<IClaimsToThingCreator> _claimsToThingCreator;
         private Mock<IAuthenticationOptionsCreator> _authOptionsCreator;
         private Mock<IUpstreamTemplatePatternCreator> _upstreamTemplatePatternCreator;
@@ -47,13 +38,9 @@ namespace Ocelot.UnitTests.Configuration
 
         public FileConfigurationCreatorTests()
         {
-            _qosProviderFactory = new Mock<IQoSProviderFactory>();
-            _qosProviderHouse = new Mock<IQosProviderHouse>();
-            _qosProvider = new Mock<IQoSProvider>();
             _logger = new Mock<IOcelotLoggerFactory>();
             _validator = new Mock<IConfigurationValidator>();
             _fileConfig = new Mock<IOptions<FileConfiguration>>();
-            _loadBalancer = new Mock<ILoadBalancer>();
             _claimsToThingCreator = new Mock<IClaimsToThingCreator>();
             _authOptionsCreator = new Mock<IAuthenticationOptionsCreator>();
             _upstreamTemplatePatternCreator = new Mock<IUpstreamTemplatePatternCreator>();
@@ -67,7 +54,7 @@ namespace Ocelot.UnitTests.Configuration
 
             _ocelotConfigurationCreator = new FileOcelotConfigurationCreator( 
                 _fileConfig.Object, _validator.Object, _logger.Object,
-                _qosProviderFactory.Object, _qosProviderHouse.Object, _claimsToThingCreator.Object,
+                _claimsToThingCreator.Object,
                 _authOptionsCreator.Object, _upstreamTemplatePatternCreator.Object, _requestIdKeyCreator.Object,
                 _serviceProviderConfigCreator.Object, _qosOptionsCreator.Object, _fileReRouteOptionsCreator.Object,
                 _rateLimitOptions.Object, _regionCreator.Object, _httpHandlerOptionsCreator.Object);
@@ -86,7 +73,6 @@ namespace Ocelot.UnitTests.Configuration
                     {
                         Host = "localhost",
                         Port = 8500,
-                        Provider = "consul"
                     }
                 }
             }))
@@ -201,12 +187,9 @@ namespace Ocelot.UnitTests.Configuration
             }))
                 .And(x => x.GivenTheConfigIsValid())
                 .And(x => x.GivenTheFollowingOptionsAreReturned(serviceOptions))
-                .And(x => x.GivenTheQosProviderFactoryReturns())
                 .And(x => x.GivenTheQosOptionsCreatorReturns(expected))
                 .When(x => x.WhenICreateTheConfig())
                 .Then(x => x.ThenTheQosOptionsAre(expected))
-                .And(x => x.TheQosProviderFactoryIsCalledCorrectly())
-                .And(x => x.ThenTheQosProviderHouseIsCalledCorrectly())
                 .BDDfy();
         }
 
@@ -301,7 +284,6 @@ namespace Ocelot.UnitTests.Configuration
                             {
                                 ServiceDiscoveryProvider = new FileServiceDiscoveryProvider
                                 {
-                                     Provider = "consul",
                                      Host = "127.0.0.1"
                                 }
                             }
@@ -603,25 +585,6 @@ namespace Ocelot.UnitTests.Configuration
             }
         }
 
-        private void GivenTheQosProviderFactoryReturns()
-        {
-            _qosProviderFactory
-                .Setup(x => x.Get(It.IsAny<ReRoute>()))
-                .Returns(_qosProvider.Object);
-        }
-
-        private void TheQosProviderFactoryIsCalledCorrectly()
-        {
-            _qosProviderFactory
-                .Verify(x => x.Get(It.IsAny<ReRoute>()), Times.Once);
-        }
-
-        private void ThenTheQosProviderHouseIsCalledCorrectly()
-        {
-            _qosProviderHouse
-                .Verify(x => x.Add(It.IsAny<string>(), _qosProvider.Object), Times.Once);
-        }
-
         private void GivenTheClaimsToThingCreatorReturns(List<ClaimToThing> claimsToThing)
         {
             _claimsToThingCreator

test/Ocelot.UnitTests/Configuration/FileConfigurationRepositoryTests.cs

@@ -43,7 +43,6 @@ namespace Ocelot.UnitTests.Configuration
                 AdministrationPath = "testy",
                 ServiceDiscoveryProvider = new FileServiceDiscoveryProvider
                 {
-                    Provider = "consul",
                     Port = 198,
                     Host = "blah"
                 }
@@ -78,7 +77,6 @@ namespace Ocelot.UnitTests.Configuration
                 AdministrationPath = "asdas",
                 ServiceDiscoveryProvider = new FileServiceDiscoveryProvider
                 {
-                    Provider = "consul",
                     Port = 198,
                     Host = "blah"
                 }
@@ -111,7 +109,6 @@ namespace Ocelot.UnitTests.Configuration
             _result.GlobalConfiguration.RequestIdKey.ShouldBe(expected.GlobalConfiguration.RequestIdKey);
             _result.GlobalConfiguration.ServiceDiscoveryProvider.Host.ShouldBe(expected.GlobalConfiguration.ServiceDiscoveryProvider.Host);
             _result.GlobalConfiguration.ServiceDiscoveryProvider.Port.ShouldBe(expected.GlobalConfiguration.ServiceDiscoveryProvider.Port);
-            _result.GlobalConfiguration.ServiceDiscoveryProvider.Provider.ShouldBe(expected.GlobalConfiguration.ServiceDiscoveryProvider.Provider);
 
             for(var i = 0; i < _result.ReRoutes.Count; i++)
             {
@@ -147,7 +144,6 @@ namespace Ocelot.UnitTests.Configuration
             _result.GlobalConfiguration.RequestIdKey.ShouldBe(expected.GlobalConfiguration.RequestIdKey);
             _result.GlobalConfiguration.ServiceDiscoveryProvider.Host.ShouldBe(expected.GlobalConfiguration.ServiceDiscoveryProvider.Host);
             _result.GlobalConfiguration.ServiceDiscoveryProvider.Port.ShouldBe(expected.GlobalConfiguration.ServiceDiscoveryProvider.Port);
-            _result.GlobalConfiguration.ServiceDiscoveryProvider.Provider.ShouldBe(expected.GlobalConfiguration.ServiceDiscoveryProvider.Provider);
 
             for(var i = 0; i < _result.ReRoutes.Count; i++)
             {

test/Ocelot.UnitTests/Configuration/ServiceProviderCreatorTests.cs

@@ -29,14 +29,12 @@ namespace Ocelot.UnitTests.Configuration
             {
                 ServiceDiscoveryProvider = new FileServiceDiscoveryProvider
                 {
-                    Provider = "consul",
                     Host = "127.0.0.1",
                     Port = 1234
                 }
             };
 
             var expected = new ServiceProviderConfigurationBuilder()
-                .WithServiceDiscoveryProvider("consul")
                 .WithServiceDiscoveryProviderHost("127.0.0.1")
                 .WithServiceDiscoveryProviderPort(1234)
                 .Build();
@@ -65,7 +63,6 @@ namespace Ocelot.UnitTests.Configuration
 
         private void ThenTheConfigIs(ServiceProviderConfiguration expected)
         {
-            _result.ServiceDiscoveryProvider.ShouldBe(expected.ServiceDiscoveryProvider);
             _result.ServiceProviderHost.ShouldBe(expected.ServiceProviderHost);
             _result.ServiceProviderPort.ShouldBe(expected.ServiceProviderPort);
         }

test/Ocelot.UnitTests/LoadBalancer/LeastConnectionTests.cs

@@ -14,7 +14,7 @@ namespace Ocelot.UnitTests.LoadBalancer
     {
         private HostAndPort _hostAndPort;
         private Response<HostAndPort> _result;
-        private LeastConnectionLoadBalancer _leastConnection;
+        private LeastConnection _leastConnection;
         private List<Service> _services;
         private Random _random;
 
@@ -35,7 +35,7 @@ namespace Ocelot.UnitTests.LoadBalancer
             };
 
             _services = availableServices;
-            _leastConnection = new LeastConnectionLoadBalancer(() => Task.FromResult(_services), serviceName);
+            _leastConnection = new LeastConnection(() => Task.FromResult(_services), serviceName);
 
             var tasks = new Task[100];
            
@@ -86,7 +86,7 @@ namespace Ocelot.UnitTests.LoadBalancer
             };
 
             _services = availableServices;
-            _leastConnection = new LeastConnectionLoadBalancer(() => Task.FromResult(_services), serviceName);
+            _leastConnection = new LeastConnection(() => Task.FromResult(_services), serviceName);
 
             var response = _leastConnection.Lease().Result;
 
@@ -113,7 +113,7 @@ namespace Ocelot.UnitTests.LoadBalancer
             };
 
             _services = availableServices;
-            _leastConnection = new LeastConnectionLoadBalancer(() => Task.FromResult(_services), serviceName);
+            _leastConnection = new LeastConnection(() => Task.FromResult(_services), serviceName);
 
             var response = _leastConnection.Lease().Result;
 
@@ -144,7 +144,7 @@ namespace Ocelot.UnitTests.LoadBalancer
             };
 
             _services = availableServices;
-            _leastConnection = new LeastConnectionLoadBalancer(() => Task.FromResult(_services), serviceName);
+            _leastConnection = new LeastConnection(() => Task.FromResult(_services), serviceName);
 
             var response = _leastConnection.Lease().Result;
 
@@ -211,7 +211,7 @@ namespace Ocelot.UnitTests.LoadBalancer
         private void GivenTheLoadBalancerStarts(List<Service> services, string serviceName)
         {
             _services = services;
-            _leastConnection = new LeastConnectionLoadBalancer(() => Task.FromResult(_services), serviceName);
+            _leastConnection = new LeastConnection(() => Task.FromResult(_services), serviceName);
         }
 
         private void WhenTheLoadBalancerStarts(List<Service> services, string serviceName)

test/Ocelot.UnitTests/LoadBalancer/LoadBalancerFactoryTests.cs

@@ -53,7 +53,7 @@ namespace Ocelot.UnitTests.LoadBalancer
                 .And(x => GivenAServiceProviderConfig(new ServiceProviderConfigurationBuilder().Build()))
                 .And(x => x.GivenTheServiceProviderFactoryReturns())
                 .When(x => x.WhenIGetTheLoadBalancer())
-                .Then(x => x.ThenTheLoadBalancerIsReturned<RoundRobinLoadBalancer>())
+                .Then(x => x.ThenTheLoadBalancerIsReturned<RoundRobin>())
                 .BDDfy();
         }
 
@@ -69,7 +69,7 @@ namespace Ocelot.UnitTests.LoadBalancer
                 .And(x => GivenAServiceProviderConfig(new ServiceProviderConfigurationBuilder().Build()))
                 .And(x => x.GivenTheServiceProviderFactoryReturns())
                 .When(x => x.WhenIGetTheLoadBalancer())
-                .Then(x => x.ThenTheLoadBalancerIsReturned<LeastConnectionLoadBalancer>())
+                .Then(x => x.ThenTheLoadBalancerIsReturned<LeastConnection>())
                 .BDDfy();
         }
 

test/Ocelot.UnitTests/LoadBalancer/LoadBalancerHouseTests.cs

@@ -32,7 +32,7 @@ namespace Ocelot.UnitTests.LoadBalancer
         [Fact]
         public void should_store_load_balancer_on_first_request()
         {
-            var reRoute = new ReRouteBuilder().WithLoadBalancerKey("test").Build();
+            var reRoute = new ReRouteBuilder().WithReRouteKey("test").Build();
 
             this.Given(x => x.GivenThereIsALoadBalancer(reRoute, new FakeLoadBalancer()))
                 .Then(x => x.ThenItIsAdded())
@@ -42,7 +42,7 @@ namespace Ocelot.UnitTests.LoadBalancer
         [Fact]
         public void should_not_store_load_balancer_on_second_request()
         {
-            var reRoute = new ReRouteBuilder().WithLoadBalancerKey("test").Build();
+            var reRoute = new ReRouteBuilder().WithLoadBalancer("FakeLoadBalancer").WithReRouteKey("test").Build();
 
             this.Given(x => x.GivenThereIsALoadBalancer(reRoute, new FakeLoadBalancer()))
                 .When(x => x.WhenWeGetTheLoadBalancer(reRoute))
@@ -53,8 +53,8 @@ namespace Ocelot.UnitTests.LoadBalancer
         [Fact]
         public void should_store_load_balancers_by_key()
         {
-            var reRoute = new ReRouteBuilder().WithLoadBalancerKey("test").Build();
-            var reRouteTwo = new ReRouteBuilder().WithLoadBalancerKey("testtwo").Build();
+            var reRoute = new ReRouteBuilder().WithReRouteKey("test").Build();
+            var reRouteTwo = new ReRouteBuilder().WithReRouteKey("testtwo").Build();
 
             this.Given(x => x.GivenThereIsALoadBalancer(reRoute, new FakeLoadBalancer()))
                 .And(x => x.GivenThereIsALoadBalancer(reRouteTwo, new FakeRoundRobinLoadBalancer()))
@@ -78,22 +78,22 @@ namespace Ocelot.UnitTests.LoadBalancer
         [Fact]
         public void should_get_new_load_balancer_if_reroute_load_balancer_has_changed()
         {
-            var reRoute = new ReRouteBuilder().WithLoadBalancerKey("test").Build();
+            var reRoute = new ReRouteBuilder().WithLoadBalancer("FakeLoadBalancer").WithReRouteKey("test").Build();
 
-            var reRouteTwo = new ReRouteBuilder().WithLoadBalancer("LeastConnection").WithLoadBalancerKey("test").Build();
+            var reRouteTwo = new ReRouteBuilder().WithLoadBalancer("LeastConnection").WithReRouteKey("test").Build();
 
             this.Given(x => x.GivenThereIsALoadBalancer(reRoute, new FakeLoadBalancer()))
                 .When(x => x.WhenWeGetTheLoadBalancer(reRoute))
                 .Then(x => x.ThenTheLoadBalancerIs<FakeLoadBalancer>())
                 .When(x => x.WhenIGetTheReRouteWithTheSameKeyButDifferentLoadBalancer(reRouteTwo))
-                .Then(x => x.ThenTheLoadBalancerIs<LeastConnectionLoadBalancer>())
+                .Then(x => x.ThenTheLoadBalancerIs<LeastConnection>())
                 .BDDfy();
         }
 
         private void WhenIGetTheReRouteWithTheSameKeyButDifferentLoadBalancer(ReRoute reRoute)
         {
             _reRoute = reRoute;
-            _factory.Setup(x => x.Get(_reRoute, _serviceProviderConfig)).ReturnsAsync(new LeastConnectionLoadBalancer(null, null));
+            _factory.Setup(x => x.Get(_reRoute, _serviceProviderConfig)).ReturnsAsync(new LeastConnection(null, null));
             _getResult = _loadBalancerHouse.Get(_reRoute, _serviceProviderConfig).Result;
         }
 

test/Ocelot.UnitTests/LoadBalancer/RoundRobinTests.cs

@@ -12,7 +12,7 @@ namespace Ocelot.UnitTests.LoadBalancer
 {
     public class RoundRobinTests
     {
-        private readonly RoundRobinLoadBalancer _roundRobin;
+        private readonly RoundRobin _roundRobin;
         private readonly List<Service> _services;
         private Response<HostAndPort> _hostAndPort;
 
@@ -25,7 +25,7 @@ namespace Ocelot.UnitTests.LoadBalancer
                 new Service("product", new HostAndPort("127.0.0.1", 5001), string.Empty, string.Empty, new string[0])
             };
 
-            _roundRobin = new RoundRobinLoadBalancer(() => Task.FromResult(_services));
+            _roundRobin = new RoundRobin(() => Task.FromResult(_services));
         }
 
         [Fact]

test/Ocelot.UnitTests/Request/HttpRequestBuilderMiddlewareTests.cs

@@ -1,122 +1,122 @@
-namespace Ocelot.UnitTests.Request
-{
-    using System.Collections.Generic;
-    using System.Net.Http;
-    using Microsoft.Extensions.DependencyInjection;
-    using Moq;
-    using Ocelot.Configuration.Builder;
-    using Ocelot.DownstreamRouteFinder;
-    using Ocelot.DownstreamRouteFinder.UrlMatcher;
-    using Ocelot.Infrastructure.RequestData;
-    using Ocelot.Logging;
-    using Ocelot.Request.Builder;
-    using Ocelot.Request.Middleware;
-    using Ocelot.Responses;
-    using TestStack.BDDfy;
-    using Xunit;
-    using Ocelot.Requester.QoS;
-    using Ocelot.Configuration;
+namespace Ocelot.UnitTests.Request
+{
+    using System.Collections.Generic;
+    using System.Net.Http;
+    using Microsoft.Extensions.DependencyInjection;
+    using Moq;
+    using Ocelot.Configuration.Builder;
+    using Ocelot.DownstreamRouteFinder;
+    using Ocelot.DownstreamRouteFinder.UrlMatcher;
+    using Ocelot.Infrastructure.RequestData;
+    using Ocelot.Logging;
+    using Ocelot.Request.Builder;
+    using Ocelot.Request.Middleware;
+    using Ocelot.Responses;
+    using TestStack.BDDfy;
+    using Xunit;
+    using Ocelot.Requester.QoS;
+    using Ocelot.Configuration;
     using Microsoft.AspNetCore.Builder;
 
-    public class HttpRequestBuilderMiddlewareTests : ServerHostedMiddlewareTest
-    {
-        private readonly Mock<IRequestCreator> _requestBuilder;
-        private readonly Mock<IRequestScopedDataRepository> _scopedRepository;
-        private readonly Mock<IQosProviderHouse> _qosProviderHouse;
-        private readonly HttpRequestMessage _downstreamRequest;
-        private OkResponse<Ocelot.Request.Request> _request;
-        private OkResponse<string> _downstreamUrl;
-        private OkResponse<DownstreamRoute> _downstreamRoute;
-
-        public HttpRequestBuilderMiddlewareTests()
-        {
-            _qosProviderHouse = new Mock<IQosProviderHouse>();
-            _requestBuilder = new Mock<IRequestCreator>();
-            _scopedRepository = new Mock<IRequestScopedDataRepository>();
-
-            _downstreamRequest = new HttpRequestMessage();
-
-            _scopedRepository
-                .Setup(sr => sr.Get<HttpRequestMessage>("DownstreamRequest"))
-                .Returns(new OkResponse<HttpRequestMessage>(_downstreamRequest));
-
-            GivenTheTestServerIsConfigured();
-        }
-
-        [Fact]
-        public void should_call_scoped_data_repository_correctly()
-        {
-
-            var downstreamRoute = new DownstreamRoute(new List<UrlPathPlaceholderNameAndValue>(),
-                new ReRouteBuilder()
-                    .WithRequestIdKey("LSRequestId")
-                    .WithUpstreamHttpMethod(new List<string> { "Get" })
-                    .WithHttpHandlerOptions(new HttpHandlerOptions(true, true))
-                    .Build());
-
-            this.Given(x => x.GivenTheDownStreamUrlIs("any old string"))
-                .And(x => x.GivenTheQosProviderHouseReturns(new OkResponse<IQoSProvider>(new NoQoSProvider())))
-                .And(x => x.GivenTheDownStreamRouteIs(downstreamRoute))
-                .And(x => x.GivenTheRequestBuilderReturns(new Ocelot.Request.Request(new HttpRequestMessage(), true, new NoQoSProvider(), false, false)))
-                .When(x => x.WhenICallTheMiddleware())
-                .Then(x => x.ThenTheScopedDataRepositoryIsCalledCorrectly())
-                .BDDfy();
-        }
-
-        protected override void GivenTheTestServerServicesAreConfigured(IServiceCollection services)
-        {
-            services.AddSingleton<IOcelotLoggerFactory, AspDotNetLoggerFactory>();
-            services.AddLogging();
-            services.AddSingleton(_qosProviderHouse.Object);
-            services.AddSingleton(_requestBuilder.Object);
-            services.AddSingleton(_scopedRepository.Object);
-        }
-
-        protected override void GivenTheTestServerPipelineIsConfigured(IApplicationBuilder app)
-        {
-            app.UseHttpRequestBuilderMiddleware();
-        }
-
-        private void GivenTheDownStreamUrlIs(string downstreamUrl)
-        {
-            _downstreamUrl = new OkResponse<string>(downstreamUrl);
-            _scopedRepository
-                .Setup(x => x.Get<string>(It.IsAny<string>()))
-                .Returns(_downstreamUrl);
-        }
-
-        private void GivenTheQosProviderHouseReturns(Response<IQoSProvider> qosProvider)
-        {
-            _qosProviderHouse
-                .Setup(x => x.Get(It.IsAny<string>()))
-                .Returns(qosProvider);
-        }
-
-        private void GivenTheDownStreamRouteIs(DownstreamRoute downstreamRoute)
-        {
-            _downstreamRoute = new OkResponse<DownstreamRoute>(downstreamRoute);
-            _scopedRepository
-                .Setup(x => x.Get<DownstreamRoute>(It.IsAny<string>()))
-                .Returns(_downstreamRoute);
-        }
-
-        private void GivenTheRequestBuilderReturns(Ocelot.Request.Request request)
-        {
-            _request = new OkResponse<Ocelot.Request.Request>(request);
-
-            _requestBuilder
-                .Setup(x => x.Build(It.IsAny<HttpRequestMessage>(),
-                                    It.IsAny<bool>(),
-                                    It.IsAny<IQoSProvider>(),
-                                    It.IsAny<bool>(),
-                                    It.IsAny<bool>()))
-                .ReturnsAsync(_request);
-        }
-
-        private void ThenTheScopedDataRepositoryIsCalledCorrectly()
-        {
-            _scopedRepository
-                .Verify(x => x.Add("Request", _request.Data), Times.Once());
-        }
-    }
-}
+    public class HttpRequestBuilderMiddlewareTests : ServerHostedMiddlewareTest
+    {
+        private readonly Mock<IRequestCreator> _requestBuilder;
+        private readonly Mock<IRequestScopedDataRepository> _scopedRepository;
+        private readonly Mock<IQosProviderHouse> _qosProviderHouse;
+        private readonly HttpRequestMessage _downstreamRequest;
+        private OkResponse<Ocelot.Request.Request> _request;
+        private OkResponse<string> _downstreamUrl;
+        private OkResponse<DownstreamRoute> _downstreamRoute;
+
+        public HttpRequestBuilderMiddlewareTests()
+        {
+            _qosProviderHouse = new Mock<IQosProviderHouse>();
+            _requestBuilder = new Mock<IRequestCreator>();
+            _scopedRepository = new Mock<IRequestScopedDataRepository>();
+
+            _downstreamRequest = new HttpRequestMessage();
+
+            _scopedRepository
+                .Setup(sr => sr.Get<HttpRequestMessage>("DownstreamRequest"))
+                .Returns(new OkResponse<HttpRequestMessage>(_downstreamRequest));
+
+            GivenTheTestServerIsConfigured();
+        }
+
+        [Fact]
+        public void should_call_scoped_data_repository_correctly()
+        {
+
+            var downstreamRoute = new DownstreamRoute(new List<UrlPathPlaceholderNameAndValue>(),
+                new ReRouteBuilder()
+                    .WithRequestIdKey("LSRequestId")
+                    .WithUpstreamHttpMethod(new List<string> { "Get" })
+                    .WithHttpHandlerOptions(new HttpHandlerOptions(true, true))
+                    .Build());
+
+            this.Given(x => x.GivenTheDownStreamUrlIs("any old string"))
+                .And(x => x.GivenTheQosProviderHouseReturns(new OkResponse<IQoSProvider>(new NoQoSProvider())))
+                .And(x => x.GivenTheDownStreamRouteIs(downstreamRoute))
+                .And(x => x.GivenTheRequestBuilderReturns(new Ocelot.Request.Request(new HttpRequestMessage(), true, new NoQoSProvider(), false, false)))
+                .When(x => x.WhenICallTheMiddleware())
+                .Then(x => x.ThenTheScopedDataRepositoryIsCalledCorrectly())
+                .BDDfy();
+        }
+
+        protected override void GivenTheTestServerServicesAreConfigured(IServiceCollection services)
+        {
+            services.AddSingleton<IOcelotLoggerFactory, AspDotNetLoggerFactory>();
+            services.AddLogging();
+            services.AddSingleton(_qosProviderHouse.Object);
+            services.AddSingleton(_requestBuilder.Object);
+            services.AddSingleton(_scopedRepository.Object);
+        }
+
+        protected override void GivenTheTestServerPipelineIsConfigured(IApplicationBuilder app)
+        {
+            app.UseHttpRequestBuilderMiddleware();
+        }
+
+        private void GivenTheDownStreamUrlIs(string downstreamUrl)
+        {
+            _downstreamUrl = new OkResponse<string>(downstreamUrl);
+            _scopedRepository
+                .Setup(x => x.Get<string>(It.IsAny<string>()))
+                .Returns(_downstreamUrl);
+        }
+
+        private void GivenTheQosProviderHouseReturns(Response<IQoSProvider> qosProvider)
+        {
+            _qosProviderHouse
+                .Setup(x => x.Get(It.IsAny<ReRoute>()))
+                .Returns(qosProvider);
+        }
+
+        private void GivenTheDownStreamRouteIs(DownstreamRoute downstreamRoute)
+        {
+            _downstreamRoute = new OkResponse<DownstreamRoute>(downstreamRoute);
+            _scopedRepository
+                .Setup(x => x.Get<DownstreamRoute>(It.IsAny<string>()))
+                .Returns(_downstreamRoute);
+        }
+
+        private void GivenTheRequestBuilderReturns(Ocelot.Request.Request request)
+        {
+            _request = new OkResponse<Ocelot.Request.Request>(request);
+
+            _requestBuilder
+                .Setup(x => x.Build(It.IsAny<HttpRequestMessage>(),
+                                    It.IsAny<bool>(),
+                                    It.IsAny<IQoSProvider>(),
+                                    It.IsAny<bool>(),
+                                    It.IsAny<bool>()))
+                .ReturnsAsync(_request);
+        }
+
+        private void ThenTheScopedDataRepositoryIsCalledCorrectly()
+        {
+            _scopedRepository
+                .Verify(x => x.Add("Request", _request.Data), Times.Once());
+        }
+    }
+}

test/Ocelot.UnitTests/Requester/QosProviderHouseTests.cs

@@ -1,5 +1,10 @@
-using Ocelot.Requester.QoS;
+using Moq;
+using Ocelot.Configuration;
+using Ocelot.Configuration.Builder;
+using Ocelot.LoadBalancer.LoadBalancers;
+using Ocelot.Requester.QoS;
 using Ocelot.Responses;
+using Ocelot.UnitTests.LoadBalancer;
 using Shouldly;
 using TestStack.BDDfy;
 using Xunit;
@@ -12,31 +17,32 @@ namespace Ocelot.UnitTests.Requester
         private readonly QosProviderHouse _qosProviderHouse;
         private Response _addResult;
         private Response<IQoSProvider> _getResult;
-        private string _key;
+        private ReRoute _reRoute;
+        private readonly Mock<IQoSProviderFactory> _factory;
 
         public QosProviderHouseTests()
         {
-            _qosProviderHouse = new QosProviderHouse();
+            _factory = new Mock<IQoSProviderFactory>();
+            _qosProviderHouse = new QosProviderHouse(_factory.Object);
         }
 
         [Fact]
-        public void should_store_qos_provider()
+        public void should_store_qos_provider_on_first_request()
         {
-            var key = "test";
+            var reRoute = new ReRouteBuilder().WithReRouteKey("test").Build();
 
-            this.Given(x => x.GivenThereIsAQoSProvider(key, new FakeQoSProvider()))
-                .When(x => x.WhenIAddTheQoSProvider())
+            this.Given(x => x.GivenThereIsAQoSProvider(reRoute, new FakeQoSProvider()))
                 .Then(x => x.ThenItIsAdded())
                 .BDDfy();
         }
 
         [Fact]
-        public void should_get_qos_provider()
+        public void should_not_store_qos_provider_on_first_request()
         {
-            var key = "test";
+            var reRoute = new ReRouteBuilder().WithReRouteKey("test").Build();
 
-            this.Given(x => x.GivenThereIsAQoSProvider(key, new FakeQoSProvider()))
-                .When(x => x.WhenWeGetTheQoSProvider(key))
+            this.Given(x => x.GivenThereIsAQoSProvider(reRoute, new FakeQoSProvider()))
+                .When(x => x.WhenWeGetTheQoSProvider(reRoute))
                 .Then(x => x.ThenItIsReturned())
                 .BDDfy();
         }
@@ -44,14 +50,14 @@ namespace Ocelot.UnitTests.Requester
         [Fact]
         public void should_store_qos_providers_by_key()
         {
-            var key = "test";
-            var keyTwo = "testTwo";
+            var reRoute = new ReRouteBuilder().WithReRouteKey("test").Build();
+            var reRouteTwo = new ReRouteBuilder().WithReRouteKey("testTwo").Build();
 
-            this.Given(x => x.GivenThereIsAQoSProvider(key, new FakeQoSProvider()))
-                .And(x => x.GivenThereIsAQoSProvider(keyTwo, new FakePollyQoSProvider()))
-                .When(x => x.WhenWeGetTheQoSProvider(key))
+            this.Given(x => x.GivenThereIsAQoSProvider(reRoute, new FakeQoSProvider()))
+                .And(x => x.GivenThereIsAQoSProvider(reRouteTwo, new FakePollyQoSProvider()))
+                .When(x => x.WhenWeGetTheQoSProvider(reRoute))
                 .Then(x => x.ThenTheQoSProviderIs<FakeQoSProvider>())
-                .When(x => x.WhenWeGetTheQoSProvider(keyTwo))
+                .When(x => x.WhenWeGetTheQoSProvider(reRouteTwo))
                 .Then(x => x.ThenTheQoSProviderIs<FakePollyQoSProvider>())
                 .BDDfy();
         }
@@ -59,11 +65,35 @@ namespace Ocelot.UnitTests.Requester
         [Fact]
         public void should_return_error_if_no_qos_provider_with_key()
         {
-            this.When(x => x.WhenWeGetTheQoSProvider("test"))
+            var reRoute = new ReRouteBuilder().Build();
+
+            this.When(x => x.WhenWeGetTheQoSProvider(reRoute))
             .Then(x => x.ThenAnErrorIsReturned())
             .BDDfy();
         }
 
+        [Fact]
+        public void should_get_new_qos_provider_if_reroute_qos_provider_has_changed()
+        {
+            var reRoute = new ReRouteBuilder().WithReRouteKey("test").Build();
+
+            var reRouteTwo = new ReRouteBuilder().WithReRouteKey("test").WithIsQos(true).Build();
+
+            this.Given(x => x.GivenThereIsAQoSProvider(reRoute, new FakeQoSProvider()))
+                .When(x => x.WhenWeGetTheQoSProvider(reRoute))
+                .Then(x => x.ThenTheQoSProviderIs<FakeQoSProvider>())
+                .When(x => x.WhenIGetTheReRouteWithTheSameKeyButDifferentQosProvider(reRouteTwo))
+                .Then(x => x.ThenTheQoSProviderIs<FakePollyQoSProvider>())
+                .BDDfy();
+        }
+
+        private void WhenIGetTheReRouteWithTheSameKeyButDifferentQosProvider(ReRoute reRoute)
+        {
+            _reRoute = reRoute;
+            _factory.Setup(x => x.Get(_reRoute)).Returns(new FakePollyQoSProvider());
+            _getResult = _qosProviderHouse.Get(_reRoute);
+        }
+
         private void ThenAnErrorIsReturned()
         {
             _getResult.IsError.ShouldBeTrue();
@@ -77,31 +107,30 @@ namespace Ocelot.UnitTests.Requester
 
         private void ThenItIsAdded()
         {
-            _addResult.IsError.ShouldBe(false);
-            _addResult.ShouldBeOfType<OkResponse>();
-        }
-
-        private void WhenIAddTheQoSProvider()
-        {
-            _addResult = _qosProviderHouse.Add(_key, _qoSProvider);
+            _getResult.IsError.ShouldBe(false);
+            _getResult.ShouldBeOfType<OkResponse<IQoSProvider>>();
+            _factory.Verify(x => x.Get(_reRoute), Times.Once);
+            _getResult.Data.ShouldBe(_qoSProvider);
         }
 
 
-        private void GivenThereIsAQoSProvider(string key, IQoSProvider qoSProvider)
+        private void GivenThereIsAQoSProvider(ReRoute reRoute, IQoSProvider qoSProvider)
         {
-            _key = key;
+            _reRoute = reRoute;
             _qoSProvider = qoSProvider;
-            WhenIAddTheQoSProvider();
+            _factory.Setup(x => x.Get(_reRoute)).Returns(_qoSProvider);
+            _getResult = _qosProviderHouse.Get(reRoute);
         }
 
-        private void WhenWeGetTheQoSProvider(string key)
+        private void WhenWeGetTheQoSProvider(ReRoute reRoute)
         {
-            _getResult = _qosProviderHouse.Get(key);
+            _getResult = _qosProviderHouse.Get(reRoute);
         }
 
         private void ThenItIsReturned()
         {
             _getResult.Data.ShouldBe(_qoSProvider);
+            _factory.Verify(x => x.Get(_reRoute), Times.Once);
         }
 
         class FakeQoSProvider : IQoSProvider

test/Ocelot.UnitTests/ServiceDiscovery/ServiceProviderFactoryTests.cs

@@ -42,7 +42,6 @@ namespace Ocelot.UnitTests.ServiceDiscovery
                 .Build();
 
             var serviceConfig = new ServiceProviderConfigurationBuilder()
-                .WithServiceDiscoveryProvider("Consul")
                 .Build();
 
             this.Given(x => x.GivenTheReRoute(serviceConfig, reRoute))