massive refactor to handle creating load balancer first time a re route is called

test/Ocelot.UnitTests/LoadBalancer/LoadBalancerCreatorTests.cs

@@ -1,57 +0,0 @@
-using Xunit;
-using Shouldly;
-using TestStack.BDDfy;
-using Ocelot.LoadBalancer;
-using Ocelot.LoadBalancer.LoadBalancers;
-using Moq;
-using Ocelot.Configuration;
-using System.Collections.Generic;
-using Ocelot.Values;
-using Ocelot.Configuration.Builder;
-
-namespace Ocelot.UnitTests.LoadBalancer
-{
-    public class LoadBalancerCreatorTests
-    {
-        private LoadBalancerCreator _creator;
-        private ILoadBalancerHouse _house;
-        private Mock<ILoadBalancerFactory> _factory;
-        private ReRoute _reRoute;
-
-        public LoadBalancerCreatorTests()
-        {
-            _house = new LoadBalancerHouse();
-            _factory = new Mock<ILoadBalancerFactory>();
-            _creator = new LoadBalancerCreator(_house, _factory.Object);
-        }
-
-        [Fact]
-        public void should_create_load_balancer()
-        {
-            var reRoute = new ReRouteBuilder().WithLoadBalancerKey("Test").Build();
-            this.Given(x => GivenTheFollowingReRoute(reRoute))
-                .When(x => WhenICallTheCreator())
-                .Then(x => x.ThenTheLoadBalancerIsCreated())
-                .BDDfy();
-        }
-
-        private void GivenTheFollowingReRoute(ReRoute reRoute)
-        {
-            _reRoute = reRoute;
-            _factory
-                .Setup(x => x.Get(It.IsAny<ReRoute>()))
-                .ReturnsAsync(new NoLoadBalancer(new List<Service>()));
-        }
-
-        private void WhenICallTheCreator()
-        {
-            _creator.SetupLoadBalancer(_reRoute).Wait();
-        }
-
-        private void ThenTheLoadBalancerIsCreated()
-        {
-            var lb = _house.Get(_reRoute.ReRouteKey);
-            lb.ShouldNotBeNull();
-        }
-    }
-}

test/Ocelot.UnitTests/LoadBalancer/LoadBalancerFactoryTests.cs

@@ -17,7 +17,8 @@ namespace Ocelot.UnitTests.LoadBalancer
         private ILoadBalancer _result;
         private Mock<IServiceDiscoveryProviderFactory> _serviceProviderFactory;
         private Mock<IServiceDiscoveryProvider> _serviceProvider;
-        
+        private ServiceProviderConfiguration _serviceProviderConfig;
+
         public LoadBalancerFactoryTests()
         {
             _serviceProviderFactory = new Mock<IServiceDiscoveryProviderFactory>();
@@ -29,11 +30,11 @@ namespace Ocelot.UnitTests.LoadBalancer
         public void should_return_no_load_balancer()
         {
             var reRoute = new ReRouteBuilder()
-                .WithServiceProviderConfiguraion(new ServiceProviderConfigurationBuilder().Build())
                 .WithUpstreamHttpMethod(new List<string> { "Get" })
                 .Build();
 
             this.Given(x => x.GivenAReRoute(reRoute))
+                .And(x => GivenAServiceProviderConfig(new ServiceProviderConfigurationBuilder().Build()))
                 .And(x => x.GivenTheServiceProviderFactoryReturns())
                 .When(x => x.WhenIGetTheLoadBalancer())
                 .Then(x => x.ThenTheLoadBalancerIsReturned<NoLoadBalancer>())
@@ -46,10 +47,10 @@ namespace Ocelot.UnitTests.LoadBalancer
              var reRoute = new ReRouteBuilder()
                 .WithLoadBalancer("RoundRobin")
                 .WithUpstreamHttpMethod(new List<string> { "Get" })
-                .WithServiceProviderConfiguraion(new ServiceProviderConfigurationBuilder().Build())
                 .Build();
 
             this.Given(x => x.GivenAReRoute(reRoute))
+                .And(x => GivenAServiceProviderConfig(new ServiceProviderConfigurationBuilder().Build()))
                 .And(x => x.GivenTheServiceProviderFactoryReturns())
                 .When(x => x.WhenIGetTheLoadBalancer())
                 .Then(x => x.ThenTheLoadBalancerIsReturned<RoundRobinLoadBalancer>())
@@ -62,10 +63,10 @@ namespace Ocelot.UnitTests.LoadBalancer
              var reRoute = new ReRouteBuilder()
                 .WithLoadBalancer("LeastConnection")
                 .WithUpstreamHttpMethod(new List<string> { "Get" })
-                .WithServiceProviderConfiguraion(new ServiceProviderConfigurationBuilder().Build())
                 .Build();
 
             this.Given(x => x.GivenAReRoute(reRoute))
+                .And(x => GivenAServiceProviderConfig(new ServiceProviderConfigurationBuilder().Build()))
                 .And(x => x.GivenTheServiceProviderFactoryReturns())
                 .When(x => x.WhenIGetTheLoadBalancer())
                 .Then(x => x.ThenTheLoadBalancerIsReturned<LeastConnectionLoadBalancer>())
@@ -78,27 +79,32 @@ namespace Ocelot.UnitTests.LoadBalancer
             var reRoute = new ReRouteBuilder()
                 .WithLoadBalancer("RoundRobin")
                 .WithUpstreamHttpMethod(new List<string> { "Get" })
-                .WithServiceProviderConfiguraion(new ServiceProviderConfigurationBuilder().Build())
                 .Build();
 
             this.Given(x => x.GivenAReRoute(reRoute))
+                .And(x => GivenAServiceProviderConfig(new ServiceProviderConfigurationBuilder().Build()))
                 .And(x => x.GivenTheServiceProviderFactoryReturns())
                 .When(x => x.WhenIGetTheLoadBalancer())
                 .Then(x => x.ThenTheServiceProviderIsCalledCorrectly())
                 .BDDfy();
         }
 
+        private void GivenAServiceProviderConfig(ServiceProviderConfiguration serviceProviderConfig)
+        {
+            _serviceProviderConfig = serviceProviderConfig;
+        }
+
         private void GivenTheServiceProviderFactoryReturns()
         {
             _serviceProviderFactory
-                .Setup(x => x.Get(It.IsAny<ServiceProviderConfiguration>()))
+                .Setup(x => x.Get(It.IsAny<ServiceProviderConfiguration>(), It.IsAny<ReRoute>()))
                 .Returns(_serviceProvider.Object);
         }
 
         private void ThenTheServiceProviderIsCalledCorrectly()
         {
             _serviceProviderFactory
-                .Verify(x => x.Get(It.IsAny<ServiceProviderConfiguration>()), Times.Once);
+                .Verify(x => x.Get(It.IsAny<ServiceProviderConfiguration>(), It.IsAny<ReRoute>()), Times.Once);
         }
 
         private void GivenAReRoute(ReRoute reRoute)
@@ -108,7 +114,7 @@ namespace Ocelot.UnitTests.LoadBalancer
 
         private void WhenIGetTheLoadBalancer()
         {
-            _result = _factory.Get(_reRoute).Result;
+            _result = _factory.Get(_reRoute, _serviceProviderConfig).Result;
         }
 
         private void ThenTheLoadBalancerIsReturned<T>()

test/Ocelot.UnitTests/LoadBalancer/LoadBalancerHouseTests.cs

@@ -1,5 +1,8 @@
 using System;
 using System.Threading.Tasks;
+using Moq;
+using Ocelot.Configuration;
+using Ocelot.Configuration.Builder;
 using Ocelot.LoadBalancer.LoadBalancers;
 using Ocelot.Responses;
 using Ocelot.Values;
@@ -11,35 +14,38 @@ namespace Ocelot.UnitTests.LoadBalancer
 {
     public class LoadBalancerHouseTests
     {
+        private ReRoute _reRoute;
         private ILoadBalancer _loadBalancer;
         private readonly LoadBalancerHouse _loadBalancerHouse;
         private Response _addResult;
         private Response<ILoadBalancer> _getResult;
         private string _key;
+        private Mock<ILoadBalancerFactory> _factory;
+        private ServiceProviderConfiguration _serviceProviderConfig;
 
         public LoadBalancerHouseTests()
         {
-            _loadBalancerHouse = new LoadBalancerHouse();
+            _factory = new Mock<ILoadBalancerFactory>();
+            _loadBalancerHouse = new LoadBalancerHouse(_factory.Object);
         }
 
         [Fact]
-        public void should_store_load_balancer()
+        public void should_store_load_balancer_on_first_request()
         {
-            var key = "test";
+            var reRoute = new ReRouteBuilder().WithLoadBalancerKey("test").Build();
 
-            this.Given(x => x.GivenThereIsALoadBalancer(key, new FakeLoadBalancer()))
-                .When(x => x.WhenIAddTheLoadBalancer())
+            this.Given(x => x.GivenThereIsALoadBalancer(reRoute, new FakeLoadBalancer()))
                 .Then(x => x.ThenItIsAdded())
                 .BDDfy();
         }
 
         [Fact]
-        public void should_get_load_balancer()
+        public void should_not_store_load_balancer_on_second_request()
         {
-            var key = "test";
+            var reRoute = new ReRouteBuilder().WithLoadBalancerKey("test").Build();
 
-            this.Given(x => x.GivenThereIsALoadBalancer(key, new FakeLoadBalancer()))
-                .When(x => x.WhenWeGetTheLoadBalancer(key))
+            this.Given(x => x.GivenThereIsALoadBalancer(reRoute, new FakeLoadBalancer()))
+                .When(x => x.WhenWeGetTheLoadBalancer(reRoute))
                 .Then(x => x.ThenItIsReturned())
                 .BDDfy();
         }
@@ -47,26 +53,50 @@ namespace Ocelot.UnitTests.LoadBalancer
         [Fact]
         public void should_store_load_balancers_by_key()
         {
-            var key = "test";
-            var keyTwo = "testTwo";
+            var reRoute = new ReRouteBuilder().WithLoadBalancerKey("test").Build();
+            var reRouteTwo = new ReRouteBuilder().WithLoadBalancerKey("testtwo").Build();
 
-            this.Given(x => x.GivenThereIsALoadBalancer(key, new FakeLoadBalancer()))
-                .And(x => x.GivenThereIsALoadBalancer(keyTwo, new FakeRoundRobinLoadBalancer()))
-                .When(x => x.WhenWeGetTheLoadBalancer(key))
+            this.Given(x => x.GivenThereIsALoadBalancer(reRoute, new FakeLoadBalancer()))
+                .And(x => x.GivenThereIsALoadBalancer(reRouteTwo, new FakeRoundRobinLoadBalancer()))
+                .When(x => x.WhenWeGetTheLoadBalancer(reRoute))
                 .Then(x => x.ThenTheLoadBalancerIs<FakeLoadBalancer>())
-                .When(x => x.WhenWeGetTheLoadBalancer(keyTwo))
+                .When(x => x.WhenWeGetTheLoadBalancer(reRouteTwo))
                 .Then(x => x.ThenTheLoadBalancerIs<FakeRoundRobinLoadBalancer>())
                 .BDDfy();
         }
 
         [Fact]
-        public void should_return_error_if_no_load_balancer_with_key()
+        public void should_return_error_if_exception()
         {
-            this.When(x => x.WhenWeGetTheLoadBalancer("test"))
+            var reRoute = new ReRouteBuilder().Build();
+
+            this.When(x => x.WhenWeGetTheLoadBalancer(reRoute))
             .Then(x => x.ThenAnErrorIsReturned())
             .BDDfy();
         }
 
+        [Fact]
+        public void should_get_new_load_balancer_if_reroute_load_balancer_has_changed()
+        {
+            var reRoute = new ReRouteBuilder().WithLoadBalancerKey("test").Build();
+
+            var reRouteTwo = new ReRouteBuilder().WithLoadBalancer("LeastConnection").WithLoadBalancerKey("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>())
+                .BDDfy();
+        }
+
+        private void WhenIGetTheReRouteWithTheSameKeyButDifferentLoadBalancer(ReRoute reRoute)
+        {
+            _reRoute = reRoute;
+            _factory.Setup(x => x.Get(_reRoute, _serviceProviderConfig)).ReturnsAsync(new LeastConnectionLoadBalancer(null, null));
+            _getResult = _loadBalancerHouse.Get(_reRoute, _serviceProviderConfig).Result;
+        }
+
          private void ThenAnErrorIsReturned()
         {
             _getResult.IsError.ShouldBeTrue();
@@ -80,31 +110,30 @@ namespace Ocelot.UnitTests.LoadBalancer
 
         private void ThenItIsAdded()
         {
-            _addResult.IsError.ShouldBe(false);
-            _addResult.ShouldBeOfType<OkResponse>();
-        }
-
-        private void WhenIAddTheLoadBalancer()
-        {
-            _addResult = _loadBalancerHouse.Add(_key, _loadBalancer);
+            _getResult.IsError.ShouldBe(false);
+            _getResult.ShouldBeOfType<OkResponse<ILoadBalancer>>();
+            _getResult.Data.ShouldBe(_loadBalancer);
+            _factory.Verify(x => x.Get(_reRoute, _serviceProviderConfig), Times.Once);
         }
 
 
-        private void GivenThereIsALoadBalancer(string key, ILoadBalancer loadBalancer)
+        private void GivenThereIsALoadBalancer(ReRoute reRoute, ILoadBalancer loadBalancer)
         {
-            _key = key;
+            _reRoute = reRoute;
             _loadBalancer = loadBalancer;
-            WhenIAddTheLoadBalancer();
+            _factory.Setup(x => x.Get(_reRoute, _serviceProviderConfig)).ReturnsAsync(loadBalancer);
+            _getResult = _loadBalancerHouse.Get(reRoute, _serviceProviderConfig).Result;
         }
 
-        private void WhenWeGetTheLoadBalancer(string key)
+        private void WhenWeGetTheLoadBalancer(ReRoute reRoute)
         {
-            _getResult = _loadBalancerHouse.Get(key);
+            _getResult = _loadBalancerHouse.Get(reRoute, _serviceProviderConfig).Result;
         }
 
         private void ThenItIsReturned()
         {
             _getResult.Data.ShouldBe(_loadBalancer);
+            _factory.Verify(x => x.Get(_reRoute, _serviceProviderConfig), Times.Once);
         }
 
         class FakeLoadBalancer : ILoadBalancer

test/Ocelot.UnitTests/LoadBalancer/LoadBalancerMiddlewareTests.cs

@@ -5,6 +5,7 @@ namespace Ocelot.UnitTests.LoadBalancer
     using Microsoft.AspNetCore.Builder;
     using Microsoft.Extensions.DependencyInjection;
     using Moq;
+    using Ocelot.Configuration;
     using Ocelot.Configuration.Builder;
     using Ocelot.DownstreamRouteFinder;
     using Ocelot.Errors;
@@ -137,8 +138,8 @@ namespace Ocelot.UnitTests.LoadBalancer
         private void GivenTheLoadBalancerHouseReturns()
         {
             _loadBalancerHouse
-                .Setup(x => x.Get(It.IsAny<string>()))
-                .Returns(new OkResponse<ILoadBalancer>(_loadBalancer.Object));
+                .Setup(x => x.Get(It.IsAny<ReRoute>(), It.IsAny<ServiceProviderConfiguration>()))
+                .ReturnsAsync(new OkResponse<ILoadBalancer>(_loadBalancer.Object));
         }
 
         private void GivenTheLoadBalancerHouseReturnsAnError()
@@ -149,8 +150,8 @@ namespace Ocelot.UnitTests.LoadBalancer
             });
 
             _loadBalancerHouse
-                .Setup(x => x.Get(It.IsAny<string>()))
-                .Returns(_getLoadBalancerHouseError);
+                .Setup(x => x.Get(It.IsAny<ReRoute>(), It.IsAny<ServiceProviderConfiguration>()))
+                .ReturnsAsync(_getLoadBalancerHouseError);
         }
 
         private void ThenAnErrorStatingLoadBalancerCouldNotBeFoundIsSetOnPipeline()