more work towards getting service discovery working with load balancing

test/Ocelot.UnitTests/Configuration/FileConfigurationCreatorTests.cs

@@ -8,6 +8,7 @@ using Ocelot.Configuration.Creator;
 using Ocelot.Configuration.File;
 using Ocelot.Configuration.Parser;
 using Ocelot.Configuration.Validator;
+using Ocelot.LoadBalancer.LoadBalancers;
 using Ocelot.Responses;
 using Shouldly;
 using TestStack.BDDfy;
@@ -24,6 +25,8 @@ namespace Ocelot.UnitTests.Configuration
         private readonly Mock<IClaimToThingConfigurationParser> _configParser;
         private readonly Mock<ILogger<FileOcelotConfigurationCreator>> _logger;
         private readonly FileOcelotConfigurationCreator _ocelotConfigurationCreator;
+        private readonly Mock<ILoadBalancerFactory> _loadBalancerFactory;
+        private readonly Mock<ILoadBalancerHouse> _loadBalancerHouse;
 
         public FileConfigurationCreatorTests()
         {
@@ -32,7 +35,8 @@ namespace Ocelot.UnitTests.Configuration
             _validator = new Mock<IConfigurationValidator>();
             _fileConfig = new Mock<IOptions<FileConfiguration>>();
             _ocelotConfigurationCreator = new FileOcelotConfigurationCreator( 
-                _fileConfig.Object, _validator.Object, _configParser.Object, _logger.Object);
+                _fileConfig.Object, _validator.Object, _configParser.Object, _logger.Object,
+                _loadBalancerFactory.Object, _loadBalancerHouse.Object);
         }
 
         [Fact]

test/Ocelot.UnitTests/LoadBalancer/LoadBalancerFactoryTests.cs

@@ -14,12 +14,12 @@ namespace Ocelot.UnitTests.LoadBalancer
         private ReRoute _reRoute;
         private LoadBalancerFactory _factory;
         private ILoadBalancer _result;
-        private Mock<IServiceProvider> _serviceProvider;
+        private Mock<IServiceProviderFactory> _serviceProviderFactory;
         
         public LoadBalancerFactoryTests()
         {
-            _serviceProvider = new Mock<IServiceProvider>();
-            _factory = new LoadBalancerFactory(_serviceProvider.Object);
+            _serviceProviderFactory = new Mock<IServiceProviderFactory>();
+            _factory = new LoadBalancerFactory(_serviceProviderFactory.Object);
         }
 
         [Fact]
@@ -75,8 +75,8 @@ namespace Ocelot.UnitTests.LoadBalancer
 
         private void ThenTheServiceProviderIsCalledCorrectly()
         {
-            _serviceProvider
-                .Verify(x => x.Get(), Times.Once);
+            _serviceProviderFactory
+                .Verify(x => x.Get(It.IsAny<ServiceConfiguraion>()), Times.Once);
         }
 
         private void GivenAReRoute(ReRoute reRoute)
@@ -86,7 +86,7 @@ namespace Ocelot.UnitTests.LoadBalancer
 
         private void WhenIGetTheLoadBalancer()
         {
-            _result = _factory.Get(_reRoute.ServiceName, _reRoute.LoadBalancer);
+            _result = _factory.Get(_reRoute);
         }
 
         private void ThenTheLoadBalancerIsReturned<T>()

test/Ocelot.UnitTests/LoadBalancer/LoadBalancerMiddlewareTests.cs

@@ -0,0 +1,124 @@
+using System.Collections.Generic;
+using System.IO;
+using System.Net.Http;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.TestHost;
+using Microsoft.Extensions.DependencyInjection;
+using Moq;
+using Ocelot.Configuration.Builder;
+using Ocelot.DownstreamRouteFinder;
+using Ocelot.Infrastructure.RequestData;
+using Ocelot.LoadBalancer.LoadBalancers;
+using Ocelot.LoadBalancer.Middleware;
+using Ocelot.Logging;
+using Ocelot.Responses;
+using Ocelot.Values;
+using TestStack.BDDfy;
+using Xunit;
+
+namespace Ocelot.UnitTests.LoadBalancer
+{
+    public class LoadBalancerMiddlewareTests
+    {
+        private readonly Mock<ILoadBalancerHouse> _loadBalancerHouse;
+        private readonly Mock<IRequestScopedDataRepository> _scopedRepository;
+        private readonly Mock<ILoadBalancer> _loadBalancer;
+        private readonly string _url;
+        private readonly TestServer _server;
+        private readonly HttpClient _client;
+        private HttpResponseMessage _result;
+        private OkResponse<Ocelot.Request.Request> _request;
+        private OkResponse<string> _downstreamUrl;
+        private OkResponse<DownstreamRoute> _downstreamRoute;
+
+        public LoadBalancerMiddlewareTests()
+        {
+            _url = "http://localhost:51879";
+            _loadBalancerHouse = new Mock<ILoadBalancerHouse>();
+            _scopedRepository = new Mock<IRequestScopedDataRepository>();
+            var builder = new WebHostBuilder()
+              .ConfigureServices(x =>
+              {
+                  x.AddSingleton<IOcelotLoggerFactory, AspDotNetLoggerFactory>();
+                  x.AddLogging();
+                  x.AddSingleton(_loadBalancerHouse.Object);
+                  x.AddSingleton(_scopedRepository.Object);
+              })
+              .UseUrls(_url)
+              .UseKestrel()
+              .UseContentRoot(Directory.GetCurrentDirectory())
+              .UseIISIntegration()
+              .UseUrls(_url)
+              .Configure(app =>
+              {
+                  app.UseLoadBalancingMiddlewareExtensions();
+              });
+
+            _server = new TestServer(builder);
+            _client = _server.CreateClient();
+        }
+
+        [Fact]
+        public void should_call_scoped_data_repository_correctly()
+        {
+            var downstreamRoute = new DownstreamRoute(new List<Ocelot.DownstreamRouteFinder.UrlMatcher.UrlPathPlaceholderNameAndValue>(),
+                new ReRouteBuilder()
+                    .Build());
+
+            this.Given(x => x.GivenTheDownStreamUrlIs("any old string"))
+                .And(x => x.GivenTheDownStreamRouteIs(downstreamRoute))
+                .And(x => x.GivenTheLoadBalancerHouseReturns())
+                .And(x => x.GivenTheLoadBalancerReturns())
+                .When(x => x.WhenICallTheMiddleware())
+                .Then(x => x.ThenTheScopedDataRepositoryIsCalledCorrectly())
+                .BDDfy();
+        }
+
+        private void GivenTheLoadBalancerReturns()
+        {
+            _loadBalancer
+                .Setup(x => x.Lease())
+                .Returns(new OkResponse<HostAndPort>(new HostAndPort("127.0.0.1", 80)));
+        }
+
+        private void GivenTheDownStreamRouteIs(DownstreamRoute downstreamRoute)
+        {
+            _downstreamRoute = new OkResponse<DownstreamRoute>(downstreamRoute);
+            _scopedRepository
+                .Setup(x => x.Get<DownstreamRoute>(It.IsAny<string>()))
+                .Returns(_downstreamRoute);
+        }
+
+        private void GivenTheLoadBalancerHouseReturns()
+        {
+            _loadBalancerHouse
+                .Setup(x => x.Get(It.IsAny<string>()))
+                .Returns(new OkResponse<ILoadBalancer>(_loadBalancer.Object));
+        }
+
+        private void ThenTheScopedDataRepositoryIsCalledCorrectly()
+        {
+            _scopedRepository
+                .Verify(x => x.Add("Request", _request.Data), Times.Once());
+        }
+
+        private void WhenICallTheMiddleware()
+        {
+            _result = _client.GetAsync(_url).Result;
+        }
+
+        private void GivenTheDownStreamUrlIs(string downstreamUrl)
+        {
+            _downstreamUrl = new OkResponse<string>(downstreamUrl);
+            _scopedRepository
+                .Setup(x => x.Get<string>(It.IsAny<string>()))
+                .Returns(_downstreamUrl);
+        }
+
+        public void Dispose()
+        {
+            _client.Dispose();
+            _server.Dispose();
+        }
+    }
+}

test/Ocelot.UnitTests/ServiceDiscovery/ServiceProviderHouseTests.cs

@@ -1,126 +0,0 @@
-using System;
-using System.Collections.Generic;
-using Ocelot.LoadBalancer.LoadBalancers;
-using Ocelot.Responses;
-using Ocelot.ServiceDiscovery;
-using Ocelot.Values;
-using Shouldly;
-using TestStack.BDDfy;
-using Xunit;
-
-namespace Ocelot.UnitTests.LoadBalancer
-{
-    public class ServiceProviderHouseTests
-    {
-        private Ocelot.ServiceDiscovery.IServiceProvider _serviceProvider;
-        private readonly ServiceProviderHouse _serviceProviderHouse;
-        private Response _addResult;
-        private Response<Ocelot.ServiceDiscovery.IServiceProvider> _getResult;
-        private string _key;
-
-        public ServiceProviderHouseTests()
-        {
-            _serviceProviderHouse = new ServiceProviderHouse();
-        }
-
-        [Fact]
-        public void should_store_service_provider()
-        {
-            var key = "test";
-
-            this.Given(x => x.GivenThereIsAServiceProvider(key, new FakeServiceProvider()))
-                .When(x => x.WhenIAddTheServiceProvider())
-                .Then(x => x.ThenItIsAdded())
-                .BDDfy();
-        }
-
-        [Fact]
-        public void should_get_service_provider()
-        {
-            var key = "test";
-
-            this.Given(x => x.GivenThereIsAServiceProvider(key, new FakeServiceProvider()))
-                .When(x => x.WhenWeGetTheServiceProvider(key))
-                .Then(x => x.ThenItIsReturned())
-                .BDDfy();
-        }
-
-        [Fact]
-        public void should_store_service_providers_by_key()
-        {
-            var key = "test";
-            var keyTwo = "testTwo";
-
-            this.Given(x => x.GivenThereIsAServiceProvider(key, new FakeServiceProvider()))
-                .And(x => x.GivenThereIsAServiceProvider(keyTwo, new FakeConsulServiceProvider()))
-                .When(x => x.WhenWeGetTheServiceProvider(key))
-                .Then(x => x.ThenTheServiceProviderIs<FakeServiceProvider>())
-                .When(x => x.WhenWeGetTheServiceProvider(keyTwo))
-                .Then(x => x.ThenTheServiceProviderIs<FakeConsulServiceProvider>())
-                .BDDfy();
-        }
-
-        [Fact]
-        public void should_return_error_if_no_service_provider_house_with_key()
-        {
-            this.When(x => x.WhenWeGetTheServiceProvider("test"))
-            .Then(x => x.ThenAnErrorIsReturned())
-            .BDDfy();
-        }
-
-        private void ThenAnErrorIsReturned()
-        {
-            _getResult.IsError.ShouldBeTrue();
-            _getResult.Errors[0].ShouldBeOfType<UnableToFindServiceProviderError>();
-        }
-
-        private void ThenTheServiceProviderIs<T>()
-        {
-            _getResult.Data.ShouldBeOfType<T>();
-        }
-
-        private void ThenItIsAdded()
-        {
-            _addResult.IsError.ShouldBe(false);
-            _addResult.ShouldBeOfType<OkResponse>();
-        }
-
-        private void WhenIAddTheServiceProvider()
-        {
-            _addResult = _serviceProviderHouse.Add(_key, _serviceProvider);
-        }
-
-        private void GivenThereIsAServiceProvider(string key, Ocelot.ServiceDiscovery.IServiceProvider serviceProvider)
-        {
-            _key = key;
-            _serviceProvider = serviceProvider;
-            WhenIAddTheServiceProvider();
-        }
-
-        private void WhenWeGetTheServiceProvider(string key)
-        {
-            _getResult = _serviceProviderHouse.Get(key);
-        }
-
-        private void ThenItIsReturned()
-        {
-            _getResult.Data.ShouldBe(_serviceProvider);
-        }
-
-        class FakeServiceProvider : Ocelot.ServiceDiscovery.IServiceProvider
-        {
-          public List<Service> Get()
-            {
-                throw new NotImplementedException();
-            }
-        }
-
-        class FakeConsulServiceProvider : Ocelot.ServiceDiscovery.IServiceProvider
-        {
-            public List<Service> Get()
-            {
-                throw new NotImplementedException();
-            }
-        }
-    }
-}