started adding consul acceptance test

test/Ocelot.AcceptanceTests/ServiceDiscoveryTests.cs

@@ -0,0 +1,135 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Net;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.Http;
+using Ocelot.Configuration.File;
+using Shouldly;
+using TestStack.BDDfy;
+using Xunit;
+
+namespace Ocelot.AcceptanceTests
+{
+    public class ServiceDiscoveryTests : IDisposable
+    {
+        private IWebHost _builder;
+        private IWebHost _fakeConsulBuilder;
+        private readonly Steps _steps;
+
+        public ServiceDiscoveryTests()
+        {
+            _steps = new Steps();
+        }
+
+        [Fact]
+        public void should_use_service_discovery_and_load_balance_request()
+        {
+            var serviceName = "product";
+            var downstreamServiceOneUrl = "http://localhost:51879";
+            var downstreamServiceTwoUrl = "http://localhost:51880";
+            var fakeConsulServiceDiscoveryUrl = "http://localhost:9500";
+            var downstreamServiceOneCounter = 0;
+            var downstreamServiceTwoCounter = 0;
+
+            var configuration = new FileConfiguration
+            {
+                ReRoutes = new List<FileReRoute>
+                    {
+                        new FileReRoute
+                        {
+                            DownstreamPathTemplate = "/",
+                            DownstreamScheme = "http",
+                            UpstreamTemplate = "/",
+                            UpstreamHttpMethod = "Get",
+                            ServiceName = serviceName,
+                            LoadBalancer = "LeastConnection",
+                        }
+                    },
+                    GlobalConfiguration = new FileGlobalConfiguration()
+                    {
+                        ServiceDiscoveryProvider = new FileServiceDiscoveryProvider()
+                        {
+                            Provider = "Consul"
+                        }
+                    }
+            };
+
+            this.Given(x => x.GivenThereIsAServiceRunningOn(downstreamServiceOneUrl, 200, downstreamServiceOneCounter))
+                .And(x => x.GivenThereIsAServiceRunningOn(downstreamServiceTwoUrl, 200, downstreamServiceTwoCounter))
+                .And(x => x.GivenThereIsAFakeConsulServiceDiscoveryProvider(fakeConsulServiceDiscoveryUrl))
+                .And(x => x.GivenTheServicesAreRegisteredWithConsul(serviceName, downstreamServiceOneUrl, downstreamServiceTwoUrl))
+                .And(x => _steps.GivenThereIsAConfiguration(configuration))
+                .And(x => _steps.GivenOcelotIsRunning())
+                .When(x => _steps.WhenIGetUrlOnTheApiGatewayMultipleTimes("/", 50))
+                .Then(x => x.ThenTheTwoServicesShouldHaveBeenCalledTimes(50, downstreamServiceOneCounter, downstreamServiceTwoCounter))
+                .And(x => x.ThenBothServicesCalledRealisticAmountOfTimes(downstreamServiceOneCounter,downstreamServiceTwoCounter))
+                .BDDfy();
+        }
+
+        private void ThenBothServicesCalledRealisticAmountOfTimes(int counterOne, int counterTwo)
+        {
+            counterOne.ShouldBeGreaterThan(10);
+            counterTwo.ShouldBeGreaterThan(10);
+        }
+
+        private void ThenTheTwoServicesShouldHaveBeenCalledTimes(int expected, int counterOne, int counterTwo)
+        {
+            var total = counterOne + counterTwo;
+            total.ShouldBe(expected);
+        }
+
+        private void GivenTheServicesAreRegisteredWithConsul(string serviceName, params string[] urls)
+        {
+            //register these services with fake consul
+        }
+
+        private void GivenThereIsAFakeConsulServiceDiscoveryProvider(string url)
+        {
+            _fakeConsulBuilder = new WebHostBuilder()
+                            .UseUrls(url)
+                            .UseKestrel()
+                            .UseContentRoot(Directory.GetCurrentDirectory())
+                            .UseIISIntegration()
+                            .UseUrls(url)
+                            .Configure(app =>
+                            {
+                                app.Run(async context =>
+                                {
+                                    //do consul shit
+                                });
+                            })
+                            .Build();
+
+            _fakeConsulBuilder.Start();
+        }
+
+        private void GivenThereIsAServiceRunningOn(string url, int statusCode, int counter)
+        {
+            _builder = new WebHostBuilder()
+                .UseUrls(url)
+                .UseKestrel()
+                .UseContentRoot(Directory.GetCurrentDirectory())
+                .UseIISIntegration()
+                .UseUrls(url)
+                .Configure(app =>
+                {
+                    app.Run(async context =>
+                    {   
+                        counter++;
+                        context.Response.StatusCode = statusCode;
+                    });
+                })
+                .Build();
+
+            _builder.Start();
+        }
+
+        public void Dispose()
+        {
+            _builder?.Dispose();
+            _steps.Dispose();
+        }
+    }
+}

test/Ocelot.AcceptanceTests/Steps.cs

@@ -5,6 +5,7 @@ using System.Linq;
 using System.Net;
 using System.Net.Http;
 using System.Net.Http.Headers;
+using System.Threading.Tasks;
 using CacheManager.Core;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.TestHost;
@@ -153,6 +154,18 @@ namespace Ocelot.AcceptanceTests
             _response = _ocelotClient.GetAsync(url).Result;
         }
 
+        public void WhenIGetUrlOnTheApiGatewayMultipleTimes(string url, int times)
+        {
+            var tasks = new Task[times];
+            
+            for (int i = 0; i < times; i++)
+            {
+                tasks[i] = _ocelotClient.GetAsync(url);
+            }
+
+            Task.WaitAll(tasks);
+        }
+
         public void WhenIGetUrlOnTheApiGateway(string url, string requestId)
         {
             _ocelotClient.DefaultRequestHeaders.TryAddWithoutValidation(RequestIdKey, requestId);

test/Ocelot.UnitTests/LoadBalancer/LoadBalancerFactoryTests.cs

@@ -14,20 +14,20 @@ namespace Ocelot.UnitTests.LoadBalancer
         private ReRoute _reRoute;
         private LoadBalancerFactory _factory;
         private ILoadBalancer _result;
-        private Mock<IServiceProviderFactory> _serviceProviderFactory;
-        private Mock<IServiceProvider> _serviceProvider;
+        private Mock<IServiceDiscoveryProviderFactory> _serviceProviderFactory;
+        private Mock<IServiceDiscoveryProvider> _serviceProvider;
         
         public LoadBalancerFactoryTests()
         {
-            _serviceProviderFactory = new Mock<IServiceProviderFactory>();
-            _serviceProvider = new Mock<IServiceProvider>();
+            _serviceProviderFactory = new Mock<IServiceDiscoveryProviderFactory>();
+            _serviceProvider = new Mock<IServiceDiscoveryProvider>();
             _factory = new LoadBalancerFactory(_serviceProviderFactory.Object);
         }
 
         private void GivenTheServiceProviderFactoryReturns()
         {
             _serviceProviderFactory
-                .Setup(x => x.Get(It.IsAny<ServiceConfiguraion>()))
+                .Setup(x => x.Get(It.IsAny<ServiceProviderConfiguraion>()))
                 .Returns(_serviceProvider.Object);
         }
 
@@ -89,7 +89,7 @@ namespace Ocelot.UnitTests.LoadBalancer
         private void ThenTheServiceProviderIsCalledCorrectly()
         {
             _serviceProviderFactory
-                .Verify(x => x.Get(It.IsAny<ServiceConfiguraion>()), Times.Once);
+                .Verify(x => x.Get(It.IsAny<ServiceProviderConfiguraion>()), Times.Once);
         }
 
         private void GivenAReRoute(ReRoute reRoute)

test/Ocelot.UnitTests/ServiceDiscovery/ServiceProviderFactoryTests.cs

@@ -7,19 +7,19 @@ namespace Ocelot.UnitTests.ServiceDiscovery
 {
     public class ServiceProviderFactoryTests
     {
-        private ServiceConfiguraion _serviceConfig;
-        private IServiceProvider _result;
-        private readonly ServiceProviderFactory _factory;
+        private ServiceProviderConfiguraion _serviceConfig;
+        private IServiceDiscoveryProvider _result;
+        private readonly ServiceDiscoveryProviderFactory _factory;
 
         public ServiceProviderFactoryTests()
         {
-            _factory = new ServiceProviderFactory();
+            _factory = new ServiceDiscoveryProviderFactory();
         }
         
         [Fact]
         public void should_return_no_service_provider()
         {
-            var serviceConfig = new ServiceConfiguraion("product", "127.0.0.1", 80, false);
+            var serviceConfig = new ServiceProviderConfiguraion("product", "127.0.0.1", 80, false, "Does not matter");
 
             this.Given(x => x.GivenTheReRoute(serviceConfig))
                 .When(x => x.WhenIGetTheServiceProvider())
@@ -27,7 +27,7 @@ namespace Ocelot.UnitTests.ServiceDiscovery
                 .BDDfy();
         }
 
-        private void GivenTheReRoute(ServiceConfiguraion serviceConfig)
+        private void GivenTheReRoute(ServiceProviderConfiguraion serviceConfig)
         {
             _serviceConfig = serviceConfig;
         }