Merge pull request #44 from ThreeMammals/develop

merge newest code

.editorconfig

@@ -1,7 +1,7 @@
 root = true
 
 [*]
-end_of_line = crlf
+end_of_line = lf
 insert_final_newline = true
 
 [*.cs]

README.md

@@ -11,8 +11,7 @@
 
 Ocelot is a .NET Api Gateway. This project is aimed at people using .NET running 
 a micro services / service orientated architecture 
-that need a unified point of entry into their system. However it will worth with anything that
-speaks HTTP and run on any platform that asp.net core supports.
+that need a unified point of entry into their system. However it will work with anything that speaks HTTP and run on any platform that asp.net core supports.
 
 In particular I want easy integration with 
 IdentityServer reference and bearer tokens. 

docs/features/loadbalancer.rst

@@ -11,6 +11,8 @@ The type of load balancer available are:
     
     NoLoadBalancer - takes the first available service from config or service discovery.
 
+    CookieStickySessions - uses a cookie to stick all requests to a specific server. More info below.
+
 You must choose in your configuration which load balancer to use.
 
 Configuration
@@ -34,7 +36,9 @@ The following shows how to set up multiple downstream services for a ReRoute usi
                 }
             ],
         "UpstreamPathTemplate": "/posts/{postId}",
-        "LoadBalancer": "LeastConnection",
+        "LoadBalancerOptions": {
+            "Type": "LeastConnection"
+        },
         "UpstreamHttpMethod": [ "Put", "Delete" ]
     }
 
@@ -52,9 +56,56 @@ The following shows how to set up a ReRoute using service discovery then select
         "UpstreamPathTemplate": "/posts/{postId}",
         "UpstreamHttpMethod": [ "Put" ],
         "ServiceName": "product",
-        "LoadBalancer": "LeastConnection",
+        "LoadBalancerOptions": {
+            "Type": "LeastConnection"
+        },
         "UseServiceDiscovery": true
     }
 
 When this is set up Ocelot will lookup the downstream host and port from the service discover provider and load balance requests across any available services. If you add and remove services from the 
-service discovery provider (consul) then Ocelot should respect this and stop calling services that have been removed and start calling services that have been added.
+service discovery provider (consul) then Ocelot should respect this and stop calling services that have been removed and start calling services that have been added.
+
+CookieStickySessions
+^^^^^^^^^^^^^^^^^^^^
+
+I've implemented a really basic sticky session type of load balancer. The scenario it is meant to support is you have a bunch of downstream 
+servers that don't share session state so if you get more than one request for one of these servers then it should go to the same box each 
+time or the session state might be incorrect for the given user. This feature was requested in `Issue #322 <https://github.com/ThreeMammals/Ocelot/issues/322>`_
+though what the user wants is more complicated than just sticky sessions :) anyway I thought this would be a nice feature to have!
+
+In order to set up CookieStickySessions load balancer you need to do something like the following.
+
+.. code-block:: json
+
+    {
+        "DownstreamPathTemplate": "/api/posts/{postId}",
+        "DownstreamScheme": "https",
+        "DownstreamHostAndPorts": [
+                {
+                    "Host": "10.0.1.10",
+                    "Port": 5000,
+                },
+                {
+                    "Host": "10.0.1.11",
+                    "Port": 5000,
+                }
+            ],
+        "UpstreamPathTemplate": "/posts/{postId}",
+        "LoadBalancerOptions": {
+            "Type": "CookieStickySessions",
+            "Key": "ASP.NET_SessionId",
+            "Expiry": 1800000
+        },
+        "UpstreamHttpMethod": [ "Put", "Delete" ]
+    }
+
+The LoadBalancerOptions are Type this needs to be CookieStickySessions, Key this is the key of the cookie you 
+wish to use for the sticky sessions, Expiry this is how long in milliseconds you want to the session to be stuck for. Remember this 
+refreshes on every request which is meant to mimick how sessions work usually.
+
+If you have multiple ReRoutes with the same LoadBalancerOptions then all of those ReRoutes will use the same load balancer for there 
+subsequent requests. This means the sessions will be stuck across ReRoutes.
+
+Please note that if you give more than one DownstreamHostAndPort or you are using a Service Discovery provider such as Consul 
+and this returns more than one service then CookieStickySessions uses round robin to select the next server. This is hard coded at the 
+moment but could be changed.

samples/OcelotEureka/ApiGateway/ApiGateway.csproj

@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp2.0</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Folder Include="wwwroot\" />
+  </ItemGroup>
+  
+  <ItemGroup>
+    <None Update="ocelot.json;appsettings.json">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.AspNetCore.All" Version="2.0.6" />
+    <PackageReference Include="Ocelot" Version="5.5.7" />
+  </ItemGroup>
+
+</Project>

samples/OcelotEureka/ApiGateway/Program.cs

@@ -0,0 +1,38 @@
+namespace ApiGateway
+{
+    using Microsoft.AspNetCore;
+    using Microsoft.AspNetCore.Hosting;
+    using Microsoft.Extensions.Configuration;
+    using Ocelot.DependencyInjection;
+    using Ocelot.Middleware;
+
+    public class Program
+    {
+        public static void Main(string[] args)
+        {
+            BuildWebHost(args).Run();
+        }
+
+        public static IWebHost BuildWebHost(string[] args) =>
+            WebHost.CreateDefaultBuilder(args)
+                .UseUrls("http://localhost:5000")
+                .ConfigureAppConfiguration((hostingContext, config) =>
+                {
+                    config
+                        .SetBasePath(hostingContext.HostingEnvironment.ContentRootPath)
+                        .AddJsonFile("appsettings.json", true, true)
+                        .AddJsonFile($"appsettings.{hostingContext.HostingEnvironment.EnvironmentName}.json", true, true)
+                        .AddJsonFile("ocelot.json")
+                        .AddEnvironmentVariables();
+                })
+                .ConfigureServices(s =>
+                {
+                    s.AddOcelot();
+                })
+                .Configure(a =>
+                {
+                    a.UseOcelot().Wait();
+                })
+                .Build();
+    }
+}

samples/OcelotEureka/ApiGateway/Properties/launchSettings.json

@@ -0,0 +1,27 @@
+{
+  "iisSettings": {
+    "windowsAuthentication": false,
+    "anonymousAuthentication": true,
+    "iisExpress": {
+      "applicationUrl": "http://localhost:54060/",
+      "sslPort": 0
+    }
+  },
+  "profiles": {
+    "IIS Express": {
+      "commandName": "IISExpress",
+      "launchBrowser": true,
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    },
+    "ApiGateway": {
+      "commandName": "Project",
+      "launchBrowser": true,
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      },
+      "applicationUrl": "http://localhost:54061/"
+    }
+  }
+}

samples/OcelotEureka/ApiGateway/appsettings.json

@@ -0,0 +1,26 @@
+{
+  "Logging": {
+    "IncludeScopes": true,
+    "LogLevel": {
+      "Default": "Trace",
+      "System": "Information",
+      "Microsoft": "Information"
+    }
+  },
+  "spring": {
+    "application": { "name": "Ocelot-Gateway" },
+    "cloud": {
+      "config": {
+        "uri": "http://localhost:5000",
+        "validateCertificates": false
+      }
+    }
+  },
+  "eureka": {
+    "client": {
+      "serviceUrl": "http://localhost:8761/eureka/",
+      "shouldRegisterWithEureka": false,
+      "validateCertificates": false
+    }
+  }
+}

samples/OcelotEureka/ApiGateway/ocelot.json

@@ -0,0 +1,23 @@
+{
+  "ReRoutes": [
+    {
+      "DownstreamPathTemplate": "/api/Category",
+      "DownstreamScheme": "http",
+      "UpstreamPathTemplate": "/Category",
+      "UseServiceDiscovery": true,
+      "ServiceName": "ncore-rat",
+      "UpstreamHttpMethod": [ "Get" ],
+      "QoSOptions": {
+        "ExceptionsAllowedBeforeBreaking": 3,
+        "DurationOfBreak": 10000,
+        "TimeoutValue": 5000
+      },
+      "FileCacheOptions": { "TtlSeconds": 15 }
+    }
+  ],
+  "GlobalConfiguration": {
+    "RequestIdKey": "OcRequestId",
+    "AdministrationPath": "/administration",
+    "ServiceDiscoveryProvider": { "Type": "Eureka" }
+  }
+}

samples/OcelotEureka/DownstreamService/Controllers/CategoryController.cs

@@ -0,0 +1,16 @@
+using System.Collections.Generic;
+using Microsoft.AspNetCore.Mvc;
+
+namespace DownstreamService.Controllers
+{
+    [Route("api/[controller]")]
+    public class CategoryController : Controller
+    {
+        // GET api/values
+        [HttpGet]
+        public IEnumerable<string> Get()
+        {
+            return new[] { "category1", "category2" };
+        }
+    }
+}

samples/OcelotEureka/DownstreamService/DownstreamService.csproj

@@ -0,0 +1,20 @@
+<Project Sdk="Microsoft.NET.Sdk.Web">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp2.0</TargetFramework>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <Folder Include="wwwroot\" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.AspNetCore.All" Version="2.0.6" />
+    <PackageReference Include="Steeltoe.Discovery.Client" Version="1.1.0" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <DotNetCliToolReference Include="Microsoft.VisualStudio.Web.CodeGeneration.Tools" Version="2.0.3" />
+  </ItemGroup>
+
+</Project>

samples/OcelotEureka/DownstreamService/Program.cs

@@ -0,0 +1,20 @@
+using System;
+using Microsoft.AspNetCore;
+using Microsoft.AspNetCore.Hosting;
+
+namespace DownstreamService
+{
+    public class Program
+    {
+        public static void Main(string[] args)
+        {
+            BuildWebHost(args).Run();
+        }
+
+        public static IWebHost BuildWebHost(string[] args) =>
+            WebHost.CreateDefaultBuilder(args)
+                .UseUrls($"http://{Environment.MachineName}:5001")
+                .UseStartup<Startup>()
+                .Build();
+    }
+}

samples/OcelotEureka/DownstreamService/Properties/launchSettings.json

@@ -0,0 +1,29 @@
+{
+  "iisSettings": {
+    "windowsAuthentication": false,
+    "anonymousAuthentication": true,
+    "iisExpress": {
+      "applicationUrl": "http://localhost:53908/",
+      "sslPort": 0
+    }
+  },
+  "profiles": {
+    "IIS Express": {
+      "commandName": "IISExpress",
+      "launchBrowser": true,
+      "launchUrl": "api/values",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      }
+    },
+    "DownstreamService": {
+      "commandName": "Project",
+      "launchBrowser": true,
+      "launchUrl": "api/values",
+      "environmentVariables": {
+        "ASPNETCORE_ENVIRONMENT": "Development"
+      },
+      "applicationUrl": "http://localhost:53909/"
+    }
+  }
+}

samples/OcelotEureka/DownstreamService/Startup.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+
+namespace DownstreamService
+{
+    using Steeltoe.Discovery.Client;
+
+    public class Startup
+    {
+        public Startup(IConfiguration configuration)
+        {
+            Configuration = configuration;
+        }
+
+        public IConfiguration Configuration { get; }
+
+        // This method gets called by the runtime. Use this method to add services to the container.
+        public void ConfigureServices(IServiceCollection services)
+        {
+            services.AddDiscoveryClient(Configuration);
+            services.AddMvc();
+        }
+
+        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
+        public void Configure(IApplicationBuilder app, IHostingEnvironment env)
+        {
+            if (env.IsDevelopment())
+            {
+                app.UseDeveloperExceptionPage();
+            }
+
+            app.UseDiscoveryClient();
+            app.UseMvc();
+        }
+    }
+}

samples/OcelotEureka/DownstreamService/appsettings.Development.json

@@ -0,0 +1,10 @@
+{
+  "Logging": {
+    "IncludeScopes": false,
+    "LogLevel": {
+      "Default": "Debug",
+      "System": "Information",
+      "Microsoft": "Information"
+    }
+  }
+}

samples/OcelotEureka/DownstreamService/appsettings.json

@@ -0,0 +1,24 @@
+{
+  "Logging": {
+    "IncludeScopes": false,
+    "LogLevel": { "Default": "Warning" }
+  },
+  "spring": {
+    "application": { "name": "ncore-rat" },
+    "cloud": {
+      "config": {
+        "uri": "http://localhost:5001",
+        "validate_certificates": false
+      }
+    }
+  },
+  "eureka": {
+    "client": {
+      "serviceUrl": "http://localhost:8761/eureka/",
+      "shouldFetchRegistry": false,
+      "validateCertificates": false
+    },
+    "instance": { "port": 5001 }
+  }
+}
+

samples/OcelotEureka/OcelotEureka.sln

@@ -0,0 +1,31 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 15
+VisualStudioVersion = 15.0.27428.2027
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DownstreamService", "./DownstreamService/DownstreamService.csproj", "{2982C147-9446-47FE-862E-E689B64CC7E7}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "ApiGateway", "./ApiGateway/ApiGateway.csproj", "{006CF27E-5400-43E9-B511-C54EC1B9C546}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{2982C147-9446-47FE-862E-E689B64CC7E7}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{2982C147-9446-47FE-862E-E689B64CC7E7}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{2982C147-9446-47FE-862E-E689B64CC7E7}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{2982C147-9446-47FE-862E-E689B64CC7E7}.Release|Any CPU.Build.0 = Release|Any CPU
+		{006CF27E-5400-43E9-B511-C54EC1B9C546}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{006CF27E-5400-43E9-B511-C54EC1B9C546}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{006CF27E-5400-43E9-B511-C54EC1B9C546}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{006CF27E-5400-43E9-B511-C54EC1B9C546}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {2C604707-2EA1-4CCF-A89C-22B613052C8D}
+	EndGlobalSection
+EndGlobal

samples/OcelotEureka/README.md

@@ -0,0 +1,39 @@
+#Example how to use Eureka service discovery
+
+I created this becasue users are having trouble getting Eureka to work with Ocelot, hopefully this helps. 
+Please review the implementation of the individual servics to understand how everything fits together.
+
+##Instructions
+
+1. Get Eureka installed and running...
+
+    ```
+    $ git clone https://github.com/spring-cloud-samples/eureka.git
+    $ cd eureka
+    $ mvnw spring-boot:run
+    ```
+    Leave the service running
+    
+2. Get Downstream service running and registered with Eureka
+
+    ```
+    cd ./DownstreamService/
+    dotnet run
+    ```
+
+    Leave the service running
+
+3. Get API Gateway running and collecting services from Eureka
+
+    ```
+    cd ./ApiGateway/
+    dotnet run
+    ```
+
+    Leave the service running
+
+4. Make a http request to http://localhost:5000/category you should get the following response
+
+    ```json
+    ["category1","category2"]
+    ```

src/Ocelot/Configuration/Builder/DownstreamReRouteBuilder.cs

@@ -24,7 +24,7 @@ namespace Ocelot.Configuration.Builder
         private bool _isCached;
         private CacheOptions _fileCacheOptions;
         private string _downstreamScheme;
-        private string _loadBalancer;
+        private LoadBalancerOptions _loadBalancerOptions;
         private bool _useQos;
         private QoSOptions _qosOptions;
         private HttpHandlerOptions _httpHandlerOptions;
@@ -41,6 +41,7 @@ namespace Ocelot.Configuration.Builder
         private List<AddHeader> _addHeadersToDownstream;
         private List<AddHeader> _addHeadersToUpstream;
         private bool _dangerousAcceptAnyServerCertificateValidator;
+        private string _qosKey;
 
         public DownstreamReRouteBuilder()
         {
@@ -62,9 +63,9 @@ namespace Ocelot.Configuration.Builder
             return this;
         }
 
-        public DownstreamReRouteBuilder WithLoadBalancer(string loadBalancer)
+        public DownstreamReRouteBuilder WithLoadBalancerOptions(LoadBalancerOptions loadBalancerOptions)
         {
-          _loadBalancer = loadBalancer;
+          _loadBalancerOptions = loadBalancerOptions;
             return this;
         }
 
@@ -170,6 +171,12 @@ namespace Ocelot.Configuration.Builder
             return this;
         }
 
+        public DownstreamReRouteBuilder WithQosKey(string qosKey)
+        {
+            _qosKey = qosKey;
+            return this;
+        }
+
         public DownstreamReRouteBuilder WithAuthenticationOptions(AuthenticationOptions authenticationOptions)
         {
             _authenticationOptions = authenticationOptions;
@@ -266,7 +273,7 @@ namespace Ocelot.Configuration.Builder
                 _requestIdHeaderKey, 
                 _isCached, 
                 _fileCacheOptions, 
-                _loadBalancer, 
+                _loadBalancerOptions, 
                 _rateLimitOptions,
                 _routeClaimRequirement, 
                 _claimToQueries, 
@@ -280,7 +287,8 @@ namespace Ocelot.Configuration.Builder
                 _delegatingHandlers,
                 _addHeadersToDownstream,
                 _addHeadersToUpstream,
-                _dangerousAcceptAnyServerCertificateValidator);
+                _dangerousAcceptAnyServerCertificateValidator,
+                _qosKey);
         }
     }
 }

src/Ocelot/Configuration/Creator/FileInternalConfigurationCreator.cs

@@ -1,229 +1,251 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using Microsoft.Extensions.Options;
-using Ocelot.Cache;
-using Ocelot.Configuration.Builder;
-using Ocelot.Configuration.File;
-using Ocelot.Configuration.Validator;
-using Ocelot.DependencyInjection;
-using Ocelot.Logging;
-using Ocelot.Responses;
-
-namespace Ocelot.Configuration.Creator
-{
-    /// <summary>
-    /// Register as singleton
-    /// </summary>
-    public class FileInternalConfigurationCreator : IInternalConfigurationCreator
-    {
-        private readonly IConfigurationValidator _configurationValidator;
-        private readonly IOcelotLogger _logger;
-        private readonly IClaimsToThingCreator _claimsToThingCreator;
-        private readonly IAuthenticationOptionsCreator _authOptionsCreator;
-        private readonly IUpstreamTemplatePatternCreator _upstreamTemplatePatternCreator;
-        private readonly IRequestIdKeyCreator _requestIdKeyCreator;
-        private readonly IServiceProviderConfigurationCreator _serviceProviderConfigCreator;
-        private readonly IQoSOptionsCreator _qosOptionsCreator;
-        private readonly IReRouteOptionsCreator _fileReRouteOptionsCreator;
-        private readonly IRateLimitOptionsCreator _rateLimitOptionsCreator;
-        private readonly IRegionCreator _regionCreator;
-        private readonly IHttpHandlerOptionsCreator _httpHandlerOptionsCreator;
-        private readonly IAdministrationPath _adminPath;
-        private readonly IHeaderFindAndReplaceCreator _headerFAndRCreator;
-        private readonly IDownstreamAddressesCreator _downstreamAddressesCreator;
-
-        public FileInternalConfigurationCreator(
-            IConfigurationValidator configurationValidator,
-            IOcelotLoggerFactory loggerFactory,
-            IClaimsToThingCreator claimsToThingCreator,
-            IAuthenticationOptionsCreator authOptionsCreator,
-            IUpstreamTemplatePatternCreator upstreamTemplatePatternCreator,
-            IRequestIdKeyCreator requestIdKeyCreator,
-            IServiceProviderConfigurationCreator serviceProviderConfigCreator,
-            IQoSOptionsCreator qosOptionsCreator,
-            IReRouteOptionsCreator fileReRouteOptionsCreator,
-            IRateLimitOptionsCreator rateLimitOptionsCreator,
-            IRegionCreator regionCreator,
-            IHttpHandlerOptionsCreator httpHandlerOptionsCreator,
-            IAdministrationPath adminPath,
-            IHeaderFindAndReplaceCreator headerFAndRCreator,
-            IDownstreamAddressesCreator downstreamAddressesCreator
-            )
-        {
-            _downstreamAddressesCreator = downstreamAddressesCreator;
-            _headerFAndRCreator = headerFAndRCreator;
-            _adminPath = adminPath;
-            _regionCreator = regionCreator;
-            _rateLimitOptionsCreator = rateLimitOptionsCreator;
-            _requestIdKeyCreator = requestIdKeyCreator;
-            _upstreamTemplatePatternCreator = upstreamTemplatePatternCreator;
-            _authOptionsCreator = authOptionsCreator;
-            _configurationValidator = configurationValidator;
-            _logger = loggerFactory.CreateLogger<FileInternalConfigurationCreator>();
-            _claimsToThingCreator = claimsToThingCreator;
-            _serviceProviderConfigCreator = serviceProviderConfigCreator;
-            _qosOptionsCreator = qosOptionsCreator;
-            _fileReRouteOptionsCreator = fileReRouteOptionsCreator;
-            _httpHandlerOptionsCreator = httpHandlerOptionsCreator;
-        }
-        
-        public async Task<Response<IInternalConfiguration>> Create(FileConfiguration fileConfiguration)
-        {     
-            var config = await SetUpConfiguration(fileConfiguration);
-            return config;
-        }
-
-        private async Task<Response<IInternalConfiguration>> SetUpConfiguration(FileConfiguration fileConfiguration)
-        {
-            var response = await _configurationValidator.IsValid(fileConfiguration);
-
-            if (response.Data.IsError)
-            {
-                return new ErrorResponse<IInternalConfiguration>(response.Data.Errors);
-            }
-
-            var reRoutes = new List<ReRoute>();
-
-            foreach (var reRoute in fileConfiguration.ReRoutes)
-            {
-                var downstreamReRoute = SetUpDownstreamReRoute(reRoute, fileConfiguration.GlobalConfiguration);
-
-                var ocelotReRoute = SetUpReRoute(reRoute, downstreamReRoute);
-                
-                reRoutes.Add(ocelotReRoute);
-            }
-
-            foreach (var aggregate in fileConfiguration.Aggregates)
-            {
-                var ocelotReRoute = SetUpAggregateReRoute(reRoutes, aggregate, fileConfiguration.GlobalConfiguration);
-                reRoutes.Add(ocelotReRoute);
-            }
-
-            var serviceProviderConfiguration = _serviceProviderConfigCreator.Create(fileConfiguration.GlobalConfiguration);
-            
-            var config = new InternalConfiguration(reRoutes, _adminPath.Path, serviceProviderConfiguration, fileConfiguration.GlobalConfiguration.RequestIdKey);
-
-            return new OkResponse<IInternalConfiguration>(config);
-        }
-
-        public ReRoute SetUpAggregateReRoute(List<ReRoute> reRoutes, FileAggregateReRoute aggregateReRoute, FileGlobalConfiguration globalConfiguration)
-        {
-            var applicableReRoutes = reRoutes
-                .SelectMany(x => x.DownstreamReRoute)
-                .Where(r => aggregateReRoute.ReRouteKeys.Contains(r.Key))
-                .ToList();
-
-            if(applicableReRoutes.Count != aggregateReRoute.ReRouteKeys.Count)
-            {
-                //todo - log or throw or return error whatever?
-            }
-
-            //make another re route out of these
-            var upstreamTemplatePattern = _upstreamTemplatePatternCreator.Create(aggregateReRoute);
-
-            var reRoute = new ReRouteBuilder()
-                .WithUpstreamPathTemplate(aggregateReRoute.UpstreamPathTemplate)
-                .WithUpstreamHttpMethod(aggregateReRoute.UpstreamHttpMethod)
-                .WithUpstreamTemplatePattern(upstreamTemplatePattern)
-                .WithDownstreamReRoutes(applicableReRoutes)
-                .WithUpstreamHost(aggregateReRoute.UpstreamHost)
-                .WithAggregator(aggregateReRoute.Aggregator)
-                .Build();
-
-            return reRoute;
-        }
-
-        private ReRoute SetUpReRoute(FileReRoute fileReRoute, DownstreamReRoute downstreamReRoutes)
-        {
-            var upstreamTemplatePattern = _upstreamTemplatePatternCreator.Create(fileReRoute);
-
-            var reRoute = new ReRouteBuilder()
-                .WithUpstreamPathTemplate(fileReRoute.UpstreamPathTemplate)
-                .WithUpstreamHttpMethod(fileReRoute.UpstreamHttpMethod)
-                .WithUpstreamTemplatePattern(upstreamTemplatePattern)
-                .WithDownstreamReRoute(downstreamReRoutes)
-                .WithUpstreamHost(fileReRoute.UpstreamHost)
-                .Build();
-
-            return reRoute;
-        }
-
-         private DownstreamReRoute SetUpDownstreamReRoute(FileReRoute fileReRoute, FileGlobalConfiguration globalConfiguration)
-        {
-            var fileReRouteOptions = _fileReRouteOptionsCreator.Create(fileReRoute);
-
-            var requestIdKey = _requestIdKeyCreator.Create(fileReRoute, globalConfiguration);
-
-            var reRouteKey = CreateReRouteKey(fileReRoute);
-
-            var upstreamTemplatePattern = _upstreamTemplatePatternCreator.Create(fileReRoute);
-
-            var authOptionsForRoute = _authOptionsCreator.Create(fileReRoute);
-
-            var claimsToHeaders = _claimsToThingCreator.Create(fileReRoute.AddHeadersToRequest);
-
-            var claimsToClaims = _claimsToThingCreator.Create(fileReRoute.AddClaimsToRequest);
-
-            var claimsToQueries = _claimsToThingCreator.Create(fileReRoute.AddQueriesToRequest);
-
-            var qosOptions = _qosOptionsCreator.Create(fileReRoute);
-
-            var rateLimitOption = _rateLimitOptionsCreator.Create(fileReRoute, globalConfiguration, fileReRouteOptions.EnableRateLimiting);
-
-            var region = _regionCreator.Create(fileReRoute);
-
-            var httpHandlerOptions = _httpHandlerOptionsCreator.Create(fileReRoute);
-
-            var hAndRs = _headerFAndRCreator.Create(fileReRoute);
-
-            var downstreamAddresses = _downstreamAddressesCreator.Create(fileReRoute);
-
-            var reRoute = new DownstreamReRouteBuilder()
-                .WithKey(fileReRoute.Key)
-                .WithDownstreamPathTemplate(fileReRoute.DownstreamPathTemplate)
-                .WithUpstreamPathTemplate(fileReRoute.UpstreamPathTemplate)
-                .WithUpstreamHttpMethod(fileReRoute.UpstreamHttpMethod)
-                .WithUpstreamTemplatePattern(upstreamTemplatePattern)
-                .WithIsAuthenticated(fileReRouteOptions.IsAuthenticated)
-                .WithAuthenticationOptions(authOptionsForRoute)
-                .WithClaimsToHeaders(claimsToHeaders)
-                .WithClaimsToClaims(claimsToClaims)
-                .WithRouteClaimsRequirement(fileReRoute.RouteClaimsRequirement)
-                .WithIsAuthorised(fileReRouteOptions.IsAuthorised)
-                .WithClaimsToQueries(claimsToQueries)
-                .WithRequestIdKey(requestIdKey)
-                .WithIsCached(fileReRouteOptions.IsCached)
-                .WithCacheOptions(new CacheOptions(fileReRoute.FileCacheOptions.TtlSeconds, region))
-                .WithDownstreamScheme(fileReRoute.DownstreamScheme)
-                .WithLoadBalancer(fileReRoute.LoadBalancer)
-                .WithDownstreamAddresses(downstreamAddresses)
-                .WithReRouteKey(reRouteKey)
-                .WithIsQos(fileReRouteOptions.IsQos)
-                .WithQosOptions(qosOptions)
-                .WithEnableRateLimiting(fileReRouteOptions.EnableRateLimiting)
-                .WithRateLimitOptions(rateLimitOption)
-                .WithHttpHandlerOptions(httpHandlerOptions)
-                .WithServiceName(fileReRoute.ServiceName)
-                .WithUseServiceDiscovery(fileReRoute.UseServiceDiscovery)
-                .WithUpstreamHeaderFindAndReplace(hAndRs.Upstream)
-                .WithDownstreamHeaderFindAndReplace(hAndRs.Downstream)
-                .WithUpstreamHost(fileReRoute.UpstreamHost)
-                .WithDelegatingHandlers(fileReRoute.DelegatingHandlers)
-                .WithAddHeadersToDownstream(hAndRs.AddHeadersToDownstream)
-                .WithAddHeadersToUpstream(hAndRs.AddHeadersToUpstream)
-                .WithDangerousAcceptAnyServerCertificateValidator(fileReRoute.DangerousAcceptAnyServerCertificateValidator)
-                .Build();
-
-            return reRoute;
-        }
-
-        private string CreateReRouteKey(FileReRoute fileReRoute)
-        {
-            //note - not sure if this is the correct key, but this is probably the only unique key i can think of given my poor brain
-            var loadBalancerKey = $"{fileReRoute.UpstreamPathTemplate}|{string.Join(",", fileReRoute.UpstreamHttpMethod)}";
-            return loadBalancerKey;
-        }
-    }
-}
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Options;
+using Ocelot.Cache;
+using Ocelot.Configuration.Builder;
+using Ocelot.Configuration.File;
+using Ocelot.Configuration.Validator;
+using Ocelot.DependencyInjection;
+using Ocelot.Logging;
+using Ocelot.Responses;
+
+namespace Ocelot.Configuration.Creator
+{
+    using LoadBalancer.LoadBalancers;
+
+    /// <summary>
+    /// Register as singleton
+    /// </summary>
+    public class FileInternalConfigurationCreator : IInternalConfigurationCreator
+    {
+        private readonly IConfigurationValidator _configurationValidator;
+        private readonly IOcelotLogger _logger;
+        private readonly IClaimsToThingCreator _claimsToThingCreator;
+        private readonly IAuthenticationOptionsCreator _authOptionsCreator;
+        private readonly IUpstreamTemplatePatternCreator _upstreamTemplatePatternCreator;
+        private readonly IRequestIdKeyCreator _requestIdKeyCreator;
+        private readonly IServiceProviderConfigurationCreator _serviceProviderConfigCreator;
+        private readonly IQoSOptionsCreator _qosOptionsCreator;
+        private readonly IReRouteOptionsCreator _fileReRouteOptionsCreator;
+        private readonly IRateLimitOptionsCreator _rateLimitOptionsCreator;
+        private readonly IRegionCreator _regionCreator;
+        private readonly IHttpHandlerOptionsCreator _httpHandlerOptionsCreator;
+        private readonly IAdministrationPath _adminPath;
+        private readonly IHeaderFindAndReplaceCreator _headerFAndRCreator;
+        private readonly IDownstreamAddressesCreator _downstreamAddressesCreator;
+
+        public FileInternalConfigurationCreator(
+            IConfigurationValidator configurationValidator,
+            IOcelotLoggerFactory loggerFactory,
+            IClaimsToThingCreator claimsToThingCreator,
+            IAuthenticationOptionsCreator authOptionsCreator,
+            IUpstreamTemplatePatternCreator upstreamTemplatePatternCreator,
+            IRequestIdKeyCreator requestIdKeyCreator,
+            IServiceProviderConfigurationCreator serviceProviderConfigCreator,
+            IQoSOptionsCreator qosOptionsCreator,
+            IReRouteOptionsCreator fileReRouteOptionsCreator,
+            IRateLimitOptionsCreator rateLimitOptionsCreator,
+            IRegionCreator regionCreator,
+            IHttpHandlerOptionsCreator httpHandlerOptionsCreator,
+            IAdministrationPath adminPath,
+            IHeaderFindAndReplaceCreator headerFAndRCreator,
+            IDownstreamAddressesCreator downstreamAddressesCreator
+            )
+        {
+            _downstreamAddressesCreator = downstreamAddressesCreator;
+            _headerFAndRCreator = headerFAndRCreator;
+            _adminPath = adminPath;
+            _regionCreator = regionCreator;
+            _rateLimitOptionsCreator = rateLimitOptionsCreator;
+            _requestIdKeyCreator = requestIdKeyCreator;
+            _upstreamTemplatePatternCreator = upstreamTemplatePatternCreator;
+            _authOptionsCreator = authOptionsCreator;
+            _configurationValidator = configurationValidator;
+            _logger = loggerFactory.CreateLogger<FileInternalConfigurationCreator>();
+            _claimsToThingCreator = claimsToThingCreator;
+            _serviceProviderConfigCreator = serviceProviderConfigCreator;
+            _qosOptionsCreator = qosOptionsCreator;
+            _fileReRouteOptionsCreator = fileReRouteOptionsCreator;
+            _httpHandlerOptionsCreator = httpHandlerOptionsCreator;
+        }
+        
+        public async Task<Response<IInternalConfiguration>> Create(FileConfiguration fileConfiguration)
+        {     
+            var config = await SetUpConfiguration(fileConfiguration);
+            return config;
+        }
+
+        private async Task<Response<IInternalConfiguration>> SetUpConfiguration(FileConfiguration fileConfiguration)
+        {
+            var response = await _configurationValidator.IsValid(fileConfiguration);
+
+            if (response.Data.IsError)
+            {
+                return new ErrorResponse<IInternalConfiguration>(response.Data.Errors);
+            }
+
+            var reRoutes = new List<ReRoute>();
+
+            foreach (var reRoute in fileConfiguration.ReRoutes)
+            {
+                var downstreamReRoute = SetUpDownstreamReRoute(reRoute, fileConfiguration.GlobalConfiguration);
+
+                var ocelotReRoute = SetUpReRoute(reRoute, downstreamReRoute);
+                
+                reRoutes.Add(ocelotReRoute);
+            }
+
+            foreach (var aggregate in fileConfiguration.Aggregates)
+            {
+                var ocelotReRoute = SetUpAggregateReRoute(reRoutes, aggregate, fileConfiguration.GlobalConfiguration);
+                reRoutes.Add(ocelotReRoute);
+            }
+
+            var serviceProviderConfiguration = _serviceProviderConfigCreator.Create(fileConfiguration.GlobalConfiguration);
+            
+            var config = new InternalConfiguration(reRoutes, _adminPath.Path, serviceProviderConfiguration, fileConfiguration.GlobalConfiguration.RequestIdKey);
+
+            return new OkResponse<IInternalConfiguration>(config);
+        }
+
+        public ReRoute SetUpAggregateReRoute(List<ReRoute> reRoutes, FileAggregateReRoute aggregateReRoute, FileGlobalConfiguration globalConfiguration)
+        {
+            var applicableReRoutes = reRoutes
+                .SelectMany(x => x.DownstreamReRoute)
+                .Where(r => aggregateReRoute.ReRouteKeys.Contains(r.Key))
+                .ToList();
+
+            if(applicableReRoutes.Count != aggregateReRoute.ReRouteKeys.Count)
+            {
+                //todo - log or throw or return error whatever?
+            }
+
+            //make another re route out of these
+            var upstreamTemplatePattern = _upstreamTemplatePatternCreator.Create(aggregateReRoute);
+
+            var reRoute = new ReRouteBuilder()
+                .WithUpstreamPathTemplate(aggregateReRoute.UpstreamPathTemplate)
+                .WithUpstreamHttpMethod(aggregateReRoute.UpstreamHttpMethod)
+                .WithUpstreamTemplatePattern(upstreamTemplatePattern)
+                .WithDownstreamReRoutes(applicableReRoutes)
+                .WithUpstreamHost(aggregateReRoute.UpstreamHost)
+                .WithAggregator(aggregateReRoute.Aggregator)
+                .Build();
+
+            return reRoute;
+        }
+
+        private ReRoute SetUpReRoute(FileReRoute fileReRoute, DownstreamReRoute downstreamReRoutes)
+        {
+            var upstreamTemplatePattern = _upstreamTemplatePatternCreator.Create(fileReRoute);
+
+            var reRoute = new ReRouteBuilder()
+                .WithUpstreamPathTemplate(fileReRoute.UpstreamPathTemplate)
+                .WithUpstreamHttpMethod(fileReRoute.UpstreamHttpMethod)
+                .WithUpstreamTemplatePattern(upstreamTemplatePattern)
+                .WithDownstreamReRoute(downstreamReRoutes)
+                .WithUpstreamHost(fileReRoute.UpstreamHost)
+                .Build();
+
+            return reRoute;
+        }
+
+         private DownstreamReRoute SetUpDownstreamReRoute(FileReRoute fileReRoute, FileGlobalConfiguration globalConfiguration)
+        {
+            var fileReRouteOptions = _fileReRouteOptionsCreator.Create(fileReRoute);
+
+            var requestIdKey = _requestIdKeyCreator.Create(fileReRoute, globalConfiguration);
+
+            var reRouteKey = CreateReRouteKey(fileReRoute);
+
+            var qosKey = CreateQosKey(fileReRoute);
+
+            var upstreamTemplatePattern = _upstreamTemplatePatternCreator.Create(fileReRoute);
+
+            var authOptionsForRoute = _authOptionsCreator.Create(fileReRoute);
+
+            var claimsToHeaders = _claimsToThingCreator.Create(fileReRoute.AddHeadersToRequest);
+
+            var claimsToClaims = _claimsToThingCreator.Create(fileReRoute.AddClaimsToRequest);
+
+            var claimsToQueries = _claimsToThingCreator.Create(fileReRoute.AddQueriesToRequest);
+
+            var qosOptions = _qosOptionsCreator.Create(fileReRoute);
+
+            var rateLimitOption = _rateLimitOptionsCreator.Create(fileReRoute, globalConfiguration, fileReRouteOptions.EnableRateLimiting);
+
+            var region = _regionCreator.Create(fileReRoute);
+
+            var httpHandlerOptions = _httpHandlerOptionsCreator.Create(fileReRoute);
+
+            var hAndRs = _headerFAndRCreator.Create(fileReRoute);
+
+            var downstreamAddresses = _downstreamAddressesCreator.Create(fileReRoute);
+
+            var lbOptions = CreateLoadBalancerOptions(fileReRoute);
+
+            var reRoute = new DownstreamReRouteBuilder()
+                .WithKey(fileReRoute.Key)
+                .WithDownstreamPathTemplate(fileReRoute.DownstreamPathTemplate)
+                .WithUpstreamPathTemplate(fileReRoute.UpstreamPathTemplate)
+                .WithUpstreamHttpMethod(fileReRoute.UpstreamHttpMethod)
+                .WithUpstreamTemplatePattern(upstreamTemplatePattern)
+                .WithIsAuthenticated(fileReRouteOptions.IsAuthenticated)
+                .WithAuthenticationOptions(authOptionsForRoute)
+                .WithClaimsToHeaders(claimsToHeaders)
+                .WithClaimsToClaims(claimsToClaims)
+                .WithRouteClaimsRequirement(fileReRoute.RouteClaimsRequirement)
+                .WithIsAuthorised(fileReRouteOptions.IsAuthorised)
+                .WithClaimsToQueries(claimsToQueries)
+                .WithRequestIdKey(requestIdKey)
+                .WithIsCached(fileReRouteOptions.IsCached)
+                .WithCacheOptions(new CacheOptions(fileReRoute.FileCacheOptions.TtlSeconds, region))
+                .WithDownstreamScheme(fileReRoute.DownstreamScheme)
+                .WithLoadBalancerOptions(lbOptions)
+                .WithDownstreamAddresses(downstreamAddresses)
+                .WithReRouteKey(reRouteKey)
+                .WithQosKey(qosKey)
+                .WithIsQos(fileReRouteOptions.IsQos)
+                .WithQosOptions(qosOptions)
+                .WithEnableRateLimiting(fileReRouteOptions.EnableRateLimiting)
+                .WithRateLimitOptions(rateLimitOption)
+                .WithHttpHandlerOptions(httpHandlerOptions)
+                .WithServiceName(fileReRoute.ServiceName)
+                .WithUseServiceDiscovery(fileReRoute.UseServiceDiscovery)
+                .WithUpstreamHeaderFindAndReplace(hAndRs.Upstream)
+                .WithDownstreamHeaderFindAndReplace(hAndRs.Downstream)
+                .WithUpstreamHost(fileReRoute.UpstreamHost)
+                .WithDelegatingHandlers(fileReRoute.DelegatingHandlers)
+                .WithAddHeadersToDownstream(hAndRs.AddHeadersToDownstream)
+                .WithAddHeadersToUpstream(hAndRs.AddHeadersToUpstream)
+                .WithDangerousAcceptAnyServerCertificateValidator(fileReRoute.DangerousAcceptAnyServerCertificateValidator)
+                .Build();
+
+            return reRoute;
+        }
+
+        private LoadBalancerOptions CreateLoadBalancerOptions(FileReRoute fileReRoute)
+        {
+            return new LoadBalancerOptions(fileReRoute.LoadBalancerOptions.Type, fileReRoute.LoadBalancerOptions.Key, fileReRoute.LoadBalancerOptions.Expiry);
+        }
+
+        private string CreateReRouteKey(FileReRoute fileReRoute)
+        {
+            if (!string.IsNullOrEmpty(fileReRoute.LoadBalancerOptions.Type) && !string.IsNullOrEmpty(fileReRoute.LoadBalancerOptions.Key) && fileReRoute.LoadBalancerOptions.Type == nameof(CookieStickySessions))
+            {
+                return $"{nameof(CookieStickySessions)}:{fileReRoute.LoadBalancerOptions.Key}";
+            }
+
+            return CreateQosKey(fileReRoute);
+        }
+
+        private string CreateQosKey(FileReRoute fileReRoute)
+        {
+            //note - not sure if this is the correct key, but this is probably the only unique key i can think of given my poor brain
+            var loadBalancerKey = $"{fileReRoute.UpstreamPathTemplate}|{string.Join(",", fileReRoute.UpstreamHttpMethod)}";
+            return loadBalancerKey;
+        }
+    }
+}

src/Ocelot/Configuration/DownstreamReRoute.cs

@@ -1,42 +1,43 @@
-using System.Collections.Generic;
-using Ocelot.Configuration.Creator;
-using Ocelot.Values;
-
 namespace Ocelot.Configuration
 {
+    using System.Collections.Generic;
+    using Creator;
+    using Values;
+
     public class DownstreamReRoute
     {
         public DownstreamReRoute(
             string key,
             PathTemplate upstreamPathTemplate,
             List<HeaderFindAndReplace> upstreamHeadersFindAndReplace,
-            List<HeaderFindAndReplace> downstreamHeadersFindAndReplace, 
-            List<DownstreamHostAndPort> downstreamAddresses, 
-            string serviceName, 
-            HttpHandlerOptions httpHandlerOptions, 
-            bool useServiceDiscovery, 
-            bool enableEndpointEndpointRateLimiting, 
-            bool isQos, 
-            QoSOptions qosOptionsOptions, 
-            string downstreamScheme, 
-            string requestIdKey, 
-            bool isCached, 
-            CacheOptions cacheOptions, 
-            string loadBalancer, 
-            RateLimitOptions rateLimitOptions, 
-            Dictionary<string, string> routeClaimsRequirement, 
-            List<ClaimToThing> claimsToQueries, 
-            List<ClaimToThing> claimsToHeaders, 
-            List<ClaimToThing> claimsToClaims, 
-            bool isAuthenticated, 
-            bool isAuthorised, 
-            AuthenticationOptions authenticationOptions, 
-            PathTemplate downstreamPathTemplate, 
-            string reRouteKey,
+            List<HeaderFindAndReplace> downstreamHeadersFindAndReplace,
+            List<DownstreamHostAndPort> downstreamAddresses,
+            string serviceName,
+            HttpHandlerOptions httpHandlerOptions,
+            bool useServiceDiscovery,
+            bool enableEndpointEndpointRateLimiting,
+            bool isQos,
+            QoSOptions qosOptionsOptions,
+            string downstreamScheme,
+            string requestIdKey,
+            bool isCached,
+            CacheOptions cacheOptions,
+            LoadBalancerOptions loadBalancerOptions,
+            RateLimitOptions rateLimitOptions,
+            Dictionary<string, string> routeClaimsRequirement,
+            List<ClaimToThing> claimsToQueries,
+            List<ClaimToThing> claimsToHeaders,
+            List<ClaimToThing> claimsToClaims,
+            bool isAuthenticated,
+            bool isAuthorised,
+            AuthenticationOptions authenticationOptions,
+            PathTemplate downstreamPathTemplate,
+            string loadBalancerKey,
             List<string> delegatingHandlers,
             List<AddHeader> addHeadersToDownstream,
             List<AddHeader> addHeadersToUpstream,
-            bool dangerousAcceptAnyServerCertificateValidator)
+            bool dangerousAcceptAnyServerCertificateValidator,
+            string qosKey)
         {
             DangerousAcceptAnyServerCertificateValidator = dangerousAcceptAnyServerCertificateValidator;
             AddHeadersToDownstream = addHeadersToDownstream;
@@ -56,7 +57,7 @@ namespace Ocelot.Configuration
             RequestIdKey = requestIdKey;
             IsCached = isCached;
             CacheOptions = cacheOptions;
-            LoadBalancer = loadBalancer;
+            LoadBalancerOptions = loadBalancerOptions;
             RateLimitOptions = rateLimitOptions;
             RouteClaimsRequirement = routeClaimsRequirement;
             ClaimsToQueries = claimsToQueries ?? new List<ClaimToThing>();
@@ -66,39 +67,41 @@ namespace Ocelot.Configuration
             IsAuthorised = isAuthorised;
             AuthenticationOptions = authenticationOptions;
             DownstreamPathTemplate = downstreamPathTemplate;
-            ReRouteKey = reRouteKey;
+            LoadBalancerKey = loadBalancerKey;
             AddHeadersToUpstream = addHeadersToUpstream;
+            QosKey = qosKey;
         }
 
-        public string Key { get; private set; }
-        public PathTemplate UpstreamPathTemplate { get;private set; }
-        public List<HeaderFindAndReplace> UpstreamHeadersFindAndReplace {get;private set;}
-        public List<HeaderFindAndReplace> DownstreamHeadersFindAndReplace { get; private set; }
-        public List<DownstreamHostAndPort> DownstreamAddresses { get; private set; }
-        public string ServiceName { get; private set; }
-        public HttpHandlerOptions HttpHandlerOptions { get; private set; }
-        public bool UseServiceDiscovery { get; private set; }
-        public bool EnableEndpointEndpointRateLimiting { get; private set; }
-        public bool IsQos { get; private set; }
-        public QoSOptions QosOptionsOptions { get; private set; }
-        public string DownstreamScheme { get; private set; }
-        public string RequestIdKey { get; private set; }
-        public bool IsCached { get; private set; }
-        public CacheOptions CacheOptions { get; private set; }
-        public string LoadBalancer { get; private set; }
-        public RateLimitOptions RateLimitOptions { get; private set; }
-        public Dictionary<string, string> RouteClaimsRequirement { get; private set; }
-        public List<ClaimToThing> ClaimsToQueries { get; private set; }
-        public List<ClaimToThing> ClaimsToHeaders { get; private set; }
-        public List<ClaimToThing> ClaimsToClaims { get; private set; }
-        public bool IsAuthenticated { get; private set; }
-        public bool IsAuthorised { get; private set; }
-        public AuthenticationOptions AuthenticationOptions { get; private set; }
-        public PathTemplate DownstreamPathTemplate { get; private set; }
-        public string ReRouteKey { get; private set; }
-        public List<string> DelegatingHandlers {get;private set;}
-        public List<AddHeader> AddHeadersToDownstream {get;private set;}
-        public List<AddHeader> AddHeadersToUpstream { get; private set; }
-        public bool DangerousAcceptAnyServerCertificateValidator { get; private set; }
+        public string QosKey { get; }
+        public string Key { get; }
+        public PathTemplate UpstreamPathTemplate { get; }
+        public List<HeaderFindAndReplace> UpstreamHeadersFindAndReplace { get; }
+        public List<HeaderFindAndReplace> DownstreamHeadersFindAndReplace { get; }
+        public List<DownstreamHostAndPort> DownstreamAddresses { get; }
+        public string ServiceName { get; }
+        public HttpHandlerOptions HttpHandlerOptions { get; }
+        public bool UseServiceDiscovery { get; }
+        public bool EnableEndpointEndpointRateLimiting { get; }
+        public bool IsQos { get; }
+        public QoSOptions QosOptionsOptions { get; }
+        public string DownstreamScheme { get; }
+        public string RequestIdKey { get; }
+        public bool IsCached { get; }
+        public CacheOptions CacheOptions { get; }
+        public LoadBalancerOptions LoadBalancerOptions { get; }
+        public RateLimitOptions RateLimitOptions { get; }
+        public Dictionary<string, string> RouteClaimsRequirement { get; }
+        public List<ClaimToThing> ClaimsToQueries { get; }
+        public List<ClaimToThing> ClaimsToHeaders { get; }
+        public List<ClaimToThing> ClaimsToClaims { get; }
+        public bool IsAuthenticated { get; }
+        public bool IsAuthorised { get; }
+        public AuthenticationOptions AuthenticationOptions { get; }
+        public PathTemplate DownstreamPathTemplate { get; }
+        public string LoadBalancerKey { get; }
+        public List<string> DelegatingHandlers { get; }
+        public List<AddHeader> AddHeadersToDownstream { get; }
+        public List<AddHeader> AddHeadersToUpstream { get; }
+        public bool DangerousAcceptAnyServerCertificateValidator { get; }
     }
 }

src/Ocelot/Configuration/File/FileLoadBalancerOptions.cs

@@ -0,0 +1,9 @@
+namespace Ocelot.Configuration.File
+{
+    public class FileLoadBalancerOptions
+    {
+        public string Type { get; set; }
+        public string Key { get; set; }
+        public int Expiry { get; set; } 
+    }
+}

src/Ocelot/Configuration/File/FileReRoute.cs

@@ -1,54 +1,55 @@
-using System.Collections.Generic;
-
-namespace Ocelot.Configuration.File
-{
-    public class FileReRoute : IReRoute
-    {
-        public FileReRoute()
-        {
-            UpstreamHttpMethod = new List<string>();
-            AddHeadersToRequest = new Dictionary<string, string>();
-            AddClaimsToRequest = new Dictionary<string, string>();
-            RouteClaimsRequirement = new Dictionary<string, string>();
-            AddQueriesToRequest = new Dictionary<string, string>();
-            DownstreamHeaderTransform = new Dictionary<string, string>();
-            FileCacheOptions = new FileCacheOptions();
-            QoSOptions = new FileQoSOptions();
-            RateLimitOptions = new FileRateLimitRule();
-            AuthenticationOptions = new FileAuthenticationOptions();
-            HttpHandlerOptions = new FileHttpHandlerOptions();
-            UpstreamHeaderTransform = new Dictionary<string, string>();
-            DownstreamHostAndPorts = new List<FileHostAndPort>();
-            DelegatingHandlers = new List<string>();
-            Priority = 1;
-        }
-
-        public string DownstreamPathTemplate { get; set; }
-        public string UpstreamPathTemplate { get; set; }
-        public List<string> UpstreamHttpMethod { get; set; }
-        public Dictionary<string, string> AddHeadersToRequest { get; set; }
-        public Dictionary<string, string> UpstreamHeaderTransform { get; set; }
-        public Dictionary<string, string> DownstreamHeaderTransform { get; set; }
-        public Dictionary<string, string> AddClaimsToRequest { get; set; }
-        public Dictionary<string, string> RouteClaimsRequirement { get; set; }
-        public Dictionary<string, string> AddQueriesToRequest { get; set; }
-        public string RequestIdKey { get; set; }
-        public FileCacheOptions FileCacheOptions { get; set; }
-        public bool ReRouteIsCaseSensitive { get; set; }
-        public string ServiceName { get; set; }
-        public string DownstreamScheme {get;set;}
-        public FileQoSOptions QoSOptions { get; set; }
-        public string LoadBalancer { get;set; }
-        public FileRateLimitRule RateLimitOptions { get; set; }
-        public FileAuthenticationOptions AuthenticationOptions { get; set; }
-        public FileHttpHandlerOptions HttpHandlerOptions { get; set; }
-        public bool UseServiceDiscovery { get;set; }
-        public List<FileHostAndPort> DownstreamHostAndPorts {get;set;}
-        public string UpstreamHost { get; set; }
-        public string Key { get;set; }
-        public List<string> DelegatingHandlers {get;set;}
-        public int Priority { get;set; }
-        public int Timeout { get; set; }
-        public bool DangerousAcceptAnyServerCertificateValidator { get; set; }
-    }
-}
+using System.Collections.Generic;
+
+namespace Ocelot.Configuration.File
+{
+    public class FileReRoute : IReRoute
+    {
+        public FileReRoute()
+        {
+            UpstreamHttpMethod = new List<string>();
+            AddHeadersToRequest = new Dictionary<string, string>();
+            AddClaimsToRequest = new Dictionary<string, string>();
+            RouteClaimsRequirement = new Dictionary<string, string>();
+            AddQueriesToRequest = new Dictionary<string, string>();
+            DownstreamHeaderTransform = new Dictionary<string, string>();
+            FileCacheOptions = new FileCacheOptions();
+            QoSOptions = new FileQoSOptions();
+            RateLimitOptions = new FileRateLimitRule();
+            AuthenticationOptions = new FileAuthenticationOptions();
+            HttpHandlerOptions = new FileHttpHandlerOptions();
+            UpstreamHeaderTransform = new Dictionary<string, string>();
+            DownstreamHostAndPorts = new List<FileHostAndPort>();
+            DelegatingHandlers = new List<string>();
+            LoadBalancerOptions = new FileLoadBalancerOptions();
+            Priority = 1;
+        }
+
+        public string DownstreamPathTemplate { get; set; }
+        public string UpstreamPathTemplate { get; set; }
+        public List<string> UpstreamHttpMethod { get; set; }
+        public Dictionary<string, string> AddHeadersToRequest { get; set; }
+        public Dictionary<string, string> UpstreamHeaderTransform { get; set; }
+        public Dictionary<string, string> DownstreamHeaderTransform { get; set; }
+        public Dictionary<string, string> AddClaimsToRequest { get; set; }
+        public Dictionary<string, string> RouteClaimsRequirement { get; set; }
+        public Dictionary<string, string> AddQueriesToRequest { get; set; }
+        public string RequestIdKey { get; set; }
+        public FileCacheOptions FileCacheOptions { get; set; }
+        public bool ReRouteIsCaseSensitive { get; set; }
+        public string ServiceName { get; set; }
+        public string DownstreamScheme {get;set;}
+        public FileQoSOptions QoSOptions { get; set; }
+        public FileLoadBalancerOptions LoadBalancerOptions { get; set; }
+        public FileRateLimitRule RateLimitOptions { get; set; }
+        public FileAuthenticationOptions AuthenticationOptions { get; set; }
+        public FileHttpHandlerOptions HttpHandlerOptions { get; set; }
+        public bool UseServiceDiscovery { get;set; }
+        public List<FileHostAndPort> DownstreamHostAndPorts {get;set;}
+        public string UpstreamHost { get; set; }
+        public string Key { get;set; }
+        public List<string> DelegatingHandlers {get;set;}
+        public int Priority { get;set; }
+        public int Timeout { get; set; }
+        public bool DangerousAcceptAnyServerCertificateValidator { get; set; }
+    }
+}

src/Ocelot/Configuration/LoadBalancerOptions.cs

@@ -0,0 +1,18 @@
+namespace Ocelot.Configuration
+{
+    public class LoadBalancerOptions
+    {
+        public LoadBalancerOptions(string type, string key, int expiryInMs)
+        {
+            Type = type;
+            Key = key;
+            ExpiryInMs = expiryInMs;
+        }
+
+        public string Type { get; }
+
+        public string Key { get; }
+        
+        public int ExpiryInMs { get; } 
+    }
+}

src/Ocelot/LoadBalancer/LoadBalancers/CookieStickySessions.cs

@@ -0,0 +1,93 @@
+namespace Ocelot.LoadBalancer.LoadBalancers
+{
+    using System;
+    using System.Collections.Concurrent;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Threading;
+    using System.Threading.Tasks;
+    using Ocelot.Middleware;
+    using Responses;
+    using Values;
+
+    public class CookieStickySessions : ILoadBalancer, IDisposable
+    {
+        private readonly int _expiryInMs;
+        private readonly string _key;
+        private readonly ILoadBalancer _loadBalancer;
+        private readonly ConcurrentDictionary<string, StickySession> _stored;
+        private readonly Timer _timer;
+        private bool _expiring;
+
+        public CookieStickySessions(ILoadBalancer loadBalancer, string key, int expiryInMs)
+        {
+            _key = key;
+            _expiryInMs = expiryInMs;
+            _loadBalancer = loadBalancer;
+            _stored = new ConcurrentDictionary<string, StickySession>();
+            _timer = new Timer(x =>
+            {
+                if (_expiring)
+                {
+                    return;
+                }
+
+                _expiring = true;
+
+                Expire();
+
+                _expiring = false;
+            }, null, 0, 50);
+        }
+
+        public void Dispose()
+        {
+            _timer?.Dispose();
+        }
+
+        public async Task<Response<ServiceHostAndPort>> Lease(DownstreamContext context)
+        {
+            var value = context.HttpContext.Request.Cookies[_key];
+
+            if (!string.IsNullOrEmpty(value) && _stored.ContainsKey(value))
+            {
+                var cached = _stored[value];
+
+                var updated = new StickySession(cached.HostAndPort, DateTime.UtcNow.AddMilliseconds(_expiryInMs));
+
+                _stored[value] = updated;
+
+                return new OkResponse<ServiceHostAndPort>(updated.HostAndPort);
+            }
+
+            var next = await _loadBalancer.Lease(context);
+
+            if (next.IsError)
+            {
+                return new ErrorResponse<ServiceHostAndPort>(next.Errors);
+            }
+
+            if (!string.IsNullOrEmpty(value) && !_stored.ContainsKey(value))
+            {
+                _stored[value] = new StickySession(next.Data, DateTime.UtcNow.AddMilliseconds(_expiryInMs));
+            }
+
+            return new OkResponse<ServiceHostAndPort>(next.Data);
+        }
+
+        public void Release(ServiceHostAndPort hostAndPort)
+        {
+        }
+
+        private void Expire()
+        {
+            var expired = _stored.Where(x => x.Value.Expiry < DateTime.UtcNow);
+
+            foreach (var expire in expired)
+            {
+                _stored.Remove(expire.Key, out _);
+                _loadBalancer.Release(expire.Value.HostAndPort);
+            }
+        }
+    }
+}

src/Ocelot/LoadBalancer/LoadBalancers/ILoadBalancer.cs

@@ -1,12 +1,13 @@
-using System.Threading.Tasks;
-using Ocelot.Responses;
-using Ocelot.Values;
-
-namespace Ocelot.LoadBalancer.LoadBalancers
-{
-    public interface ILoadBalancer
-    {
-        Task<Response<ServiceHostAndPort>> Lease();
-        void Release(ServiceHostAndPort hostAndPort);
-    }
-}
+using System.Threading.Tasks;
+using Ocelot.Middleware;
+using Ocelot.Responses;
+using Ocelot.Values;
+
+namespace Ocelot.LoadBalancer.LoadBalancers
+{
+    public interface ILoadBalancer
+    {
+        Task<Response<ServiceHostAndPort>> Lease(DownstreamContext context);
+        void Release(ServiceHostAndPort hostAndPort);
+    }
+}

src/Ocelot/LoadBalancer/LoadBalancers/ILoadBalancerFactory.cs

@@ -1,10 +1,10 @@
-using System.Threading.Tasks;
-using Ocelot.Configuration;
-
-namespace Ocelot.LoadBalancer.LoadBalancers
-{
-    public interface ILoadBalancerFactory
-    {
-        Task<ILoadBalancer> Get(DownstreamReRoute reRoute, ServiceProviderConfiguration config);
-    }
-}
+using System.Threading.Tasks;
+using Ocelot.Configuration;
+
+namespace Ocelot.LoadBalancer.LoadBalancers
+{
+    public interface ILoadBalancerFactory
+    {
+        Task<ILoadBalancer> Get(DownstreamReRoute reRoute, ServiceProviderConfiguration config);
+    }
+}

src/Ocelot/LoadBalancer/LoadBalancers/ILoadBalancerHouse.cs

@@ -1,11 +1,11 @@
-using System.Threading.Tasks;
-using Ocelot.Configuration;
-using Ocelot.Responses;
-
-namespace Ocelot.LoadBalancer.LoadBalancers
-{
-    public interface ILoadBalancerHouse
-    {
-        Task<Response<ILoadBalancer>> Get(DownstreamReRoute reRoute, ServiceProviderConfiguration config);
-    }
-}
+using System.Threading.Tasks;
+using Ocelot.Configuration;
+using Ocelot.Responses;
+
+namespace Ocelot.LoadBalancer.LoadBalancers
+{
+    public interface ILoadBalancerHouse
+    {
+        Task<Response<ILoadBalancer>> Get(DownstreamReRoute reRoute, ServiceProviderConfiguration config);
+    }
+}

src/Ocelot/LoadBalancer/LoadBalancers/LeastConnection.cs

@@ -1,145 +1,146 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using Ocelot.Errors;
-using Ocelot.Responses;
-using Ocelot.Values;
-
-namespace Ocelot.LoadBalancer.LoadBalancers
-{
-    public class LeastConnection : ILoadBalancer
-    {
-        private readonly Func<Task<List<Service>>> _services;
-        private readonly List<Lease> _leases;
-        private readonly string _serviceName;
-        private static readonly object _syncLock = new object();
-
-        public LeastConnection(Func<Task<List<Service>>> services, string serviceName)
-        {
-            _services = services;
-            _serviceName = serviceName;
-            _leases = new List<Lease>();
-        }
-
-        public async Task<Response<ServiceHostAndPort>> Lease()
-        {
-            var services = await _services.Invoke();
-
-            if (services == null)
-            {
-                return new ErrorResponse<ServiceHostAndPort>(new ServicesAreNullError($"services were null for {_serviceName}") );
-            }
-
-            if (!services.Any())
-            {
-                return new ErrorResponse<ServiceHostAndPort>(new ServicesAreEmptyError($"services were empty for {_serviceName}"));
-            }
-
-            lock(_syncLock)
-            {        
-                //todo - maybe this should be moved somewhere else...? Maybe on a repeater on seperate thread? loop every second and update or something?
-                UpdateServices(services);
-
-                var leaseWithLeastConnections = GetLeaseWithLeastConnections();
-
-                _leases.Remove(leaseWithLeastConnections);
-
-                leaseWithLeastConnections = AddConnection(leaseWithLeastConnections);
-
-                _leases.Add(leaseWithLeastConnections);
-            
-                return new OkResponse<ServiceHostAndPort>(new ServiceHostAndPort(leaseWithLeastConnections.HostAndPort.DownstreamHost, leaseWithLeastConnections.HostAndPort.DownstreamPort));
-            }
-        }
-
-        public void Release(ServiceHostAndPort hostAndPort)
-        {
-            lock(_syncLock)
-            {
-                var matchingLease = _leases.FirstOrDefault(l => l.HostAndPort.DownstreamHost == hostAndPort.DownstreamHost
-                    && l.HostAndPort.DownstreamPort == hostAndPort.DownstreamPort);
-
-                if (matchingLease != null)
-                {
-                    var replacementLease = new Lease(hostAndPort, matchingLease.Connections - 1);
-
-                    _leases.Remove(matchingLease);
-
-                    _leases.Add(replacementLease);
-                }
-            }
-        }
-
-        private Lease AddConnection(Lease lease)
-        {
-            return new Lease(lease.HostAndPort, lease.Connections + 1);
-        }
-
-        private Lease GetLeaseWithLeastConnections()
-        {
-            //now get the service with the least connections?
-            Lease leaseWithLeastConnections = null;
-
-            for (var i = 0; i < _leases.Count; i++)
-            {
-                if (i == 0)
-                {
-                    leaseWithLeastConnections = _leases[i];
-                }
-                else
-                {
-                    if (_leases[i].Connections < leaseWithLeastConnections.Connections)
-                    {
-                        leaseWithLeastConnections = _leases[i];
-                    }
-                }
-            }
-
-            return leaseWithLeastConnections;
-        }
-
-        private Response UpdateServices(List<Service> services)
-        {
-            if (_leases.Count > 0)
-            {
-                var leasesToRemove = new List<Lease>();
-
-                foreach (var lease in _leases)
-                {
-                    var match = services.FirstOrDefault(s => s.HostAndPort.DownstreamHost == lease.HostAndPort.DownstreamHost
-                        && s.HostAndPort.DownstreamPort == lease.HostAndPort.DownstreamPort);
-
-                    if (match == null)
-                    {
-                        leasesToRemove.Add(lease);
-                    }
-                }
-
-                foreach (var lease in leasesToRemove)
-                {
-                    _leases.Remove(lease);
-                }
-
-                foreach (var service in services)
-                {
-                    var exists = _leases.FirstOrDefault(l => l.HostAndPort.DownstreamHost == service.HostAndPort.DownstreamHost && l.HostAndPort.DownstreamPort == service.HostAndPort.DownstreamPort);
-
-                    if (exists == null)
-                    {
-                        _leases.Add(new Lease(service.HostAndPort, 0));
-                    }
-                }
-            }
-            else
-            {
-                foreach (var service in services)
-                {
-                    _leases.Add(new Lease(service.HostAndPort, 0));
-                }
-            }
-
-            return new OkResponse();
-        }
-    }
-}
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Ocelot.Errors;
+using Ocelot.Middleware;
+using Ocelot.Responses;
+using Ocelot.Values;
+
+namespace Ocelot.LoadBalancer.LoadBalancers
+{
+    public class LeastConnection : ILoadBalancer
+    {
+        private readonly Func<Task<List<Service>>> _services;
+        private readonly List<Lease> _leases;
+        private readonly string _serviceName;
+        private static readonly object _syncLock = new object();
+
+        public LeastConnection(Func<Task<List<Service>>> services, string serviceName)
+        {
+            _services = services;
+            _serviceName = serviceName;
+            _leases = new List<Lease>();
+        }
+
+        public async Task<Response<ServiceHostAndPort>> Lease(DownstreamContext downstreamContext)
+        {
+            var services = await _services.Invoke();
+
+            if (services == null)
+            {
+                return new ErrorResponse<ServiceHostAndPort>(new ServicesAreNullError($"services were null for {_serviceName}") );
+            }
+
+            if (!services.Any())
+            {
+                return new ErrorResponse<ServiceHostAndPort>(new ServicesAreEmptyError($"services were empty for {_serviceName}"));
+            }
+
+            lock(_syncLock)
+            {        
+                //todo - maybe this should be moved somewhere else...? Maybe on a repeater on seperate thread? loop every second and update or something?
+                UpdateServices(services);
+
+                var leaseWithLeastConnections = GetLeaseWithLeastConnections();
+
+                _leases.Remove(leaseWithLeastConnections);
+
+                leaseWithLeastConnections = AddConnection(leaseWithLeastConnections);
+
+                _leases.Add(leaseWithLeastConnections);
+            
+                return new OkResponse<ServiceHostAndPort>(new ServiceHostAndPort(leaseWithLeastConnections.HostAndPort.DownstreamHost, leaseWithLeastConnections.HostAndPort.DownstreamPort));
+            }
+        }
+
+        public void Release(ServiceHostAndPort hostAndPort)
+        {
+            lock(_syncLock)
+            {
+                var matchingLease = _leases.FirstOrDefault(l => l.HostAndPort.DownstreamHost == hostAndPort.DownstreamHost
+                    && l.HostAndPort.DownstreamPort == hostAndPort.DownstreamPort);
+
+                if (matchingLease != null)
+                {
+                    var replacementLease = new Lease(hostAndPort, matchingLease.Connections - 1);
+
+                    _leases.Remove(matchingLease);
+
+                    _leases.Add(replacementLease);
+                }
+            }
+        }
+
+        private Lease AddConnection(Lease lease)
+        {
+            return new Lease(lease.HostAndPort, lease.Connections + 1);
+        }
+
+        private Lease GetLeaseWithLeastConnections()
+        {
+            //now get the service with the least connections?
+            Lease leaseWithLeastConnections = null;
+
+            for (var i = 0; i < _leases.Count; i++)
+            {
+                if (i == 0)
+                {
+                    leaseWithLeastConnections = _leases[i];
+                }
+                else
+                {
+                    if (_leases[i].Connections < leaseWithLeastConnections.Connections)
+                    {
+                        leaseWithLeastConnections = _leases[i];
+                    }
+                }
+            }
+
+            return leaseWithLeastConnections;
+        }
+
+        private Response UpdateServices(List<Service> services)
+        {
+            if (_leases.Count > 0)
+            {
+                var leasesToRemove = new List<Lease>();
+
+                foreach (var lease in _leases)
+                {
+                    var match = services.FirstOrDefault(s => s.HostAndPort.DownstreamHost == lease.HostAndPort.DownstreamHost
+                        && s.HostAndPort.DownstreamPort == lease.HostAndPort.DownstreamPort);
+
+                    if (match == null)
+                    {
+                        leasesToRemove.Add(lease);
+                    }
+                }
+
+                foreach (var lease in leasesToRemove)
+                {
+                    _leases.Remove(lease);
+                }
+
+                foreach (var service in services)
+                {
+                    var exists = _leases.FirstOrDefault(l => l.HostAndPort.DownstreamHost == service.HostAndPort.DownstreamHost && l.HostAndPort.DownstreamPort == service.HostAndPort.DownstreamPort);
+
+                    if (exists == null)
+                    {
+                        _leases.Add(new Lease(service.HostAndPort, 0));
+                    }
+                }
+            }
+            else
+            {
+                foreach (var service in services)
+                {
+                    _leases.Add(new Lease(service.HostAndPort, 0));
+                }
+            }
+
+            return new OkResponse();
+        }
+    }
+}

src/Ocelot/LoadBalancer/LoadBalancers/LoadBalancerFactory.cs

@@ -1,30 +1,34 @@
-using System.Threading.Tasks;
-using Ocelot.Configuration;
-using Ocelot.ServiceDiscovery;
-
-namespace Ocelot.LoadBalancer.LoadBalancers
-{
-    public class LoadBalancerFactory : ILoadBalancerFactory
-    {
-        private readonly IServiceDiscoveryProviderFactory _serviceProviderFactory;
-        public LoadBalancerFactory(IServiceDiscoveryProviderFactory serviceProviderFactory)
-        {
-            _serviceProviderFactory = serviceProviderFactory;
-        }
-
-        public async Task<ILoadBalancer> Get(DownstreamReRoute reRoute, ServiceProviderConfiguration config)
-        {            
-            var serviceProvider = _serviceProviderFactory.Get(config, reRoute);
-
-            switch (reRoute.LoadBalancer)
-            {
-                case "RoundRobin":
-                    return new RoundRobin(async () => await serviceProvider.Get());
-                case "LeastConnection":
-                    return new LeastConnection(async () => await serviceProvider.Get(), reRoute.ServiceName);
-                default:
-                    return new NoLoadBalancer(await serviceProvider.Get());
-            }
-        }
-    }
-}
+using System.Threading.Tasks;
+using Ocelot.Configuration;
+using Ocelot.ServiceDiscovery;
+
+namespace Ocelot.LoadBalancer.LoadBalancers
+{
+    public class LoadBalancerFactory : ILoadBalancerFactory
+    {
+        private readonly IServiceDiscoveryProviderFactory _serviceProviderFactory;
+
+        public LoadBalancerFactory(IServiceDiscoveryProviderFactory serviceProviderFactory)
+        {
+            _serviceProviderFactory = serviceProviderFactory;
+        }
+
+        public async Task<ILoadBalancer> Get(DownstreamReRoute reRoute, ServiceProviderConfiguration config)
+        {            
+            var serviceProvider = _serviceProviderFactory.Get(config, reRoute);
+
+            switch (reRoute.LoadBalancerOptions?.Type)
+            {
+                case nameof(RoundRobin):
+                    return new RoundRobin(async () => await serviceProvider.Get());
+                case nameof(LeastConnection):
+                    return new LeastConnection(async () => await serviceProvider.Get(), reRoute.ServiceName);
+                case nameof(CookieStickySessions):
+                    var loadBalancer = new RoundRobin(async () => await serviceProvider.Get());
+                    return new CookieStickySessions(loadBalancer, reRoute.LoadBalancerOptions.Key, reRoute.LoadBalancerOptions.ExpiryInMs);
+                default:
+                    return new NoLoadBalancer(await serviceProvider.Get());
+            }
+        }
+    }
+}

src/Ocelot/LoadBalancer/LoadBalancers/LoadBalancerHouse.cs

@@ -1,56 +1,56 @@
-using System;
-using System.Collections.Concurrent;
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using Ocelot.Configuration;
-using Ocelot.Responses;
-
-namespace Ocelot.LoadBalancer.LoadBalancers
-{
-    public class LoadBalancerHouse : ILoadBalancerHouse
-    {
-        private readonly ILoadBalancerFactory _factory;
-        private readonly ConcurrentDictionary<string, ILoadBalancer> _loadBalancers;
-
-        public LoadBalancerHouse(ILoadBalancerFactory factory)
-        {
-            _factory = factory;
-            _loadBalancers = new ConcurrentDictionary<string, ILoadBalancer>();
-        }
-
-        public async Task<Response<ILoadBalancer>> Get(DownstreamReRoute reRoute, ServiceProviderConfiguration config)
-        {
-            try
-            {
-                if(_loadBalancers.TryGetValue(reRoute.ReRouteKey, out var loadBalancer))
-                {
-                    loadBalancer = _loadBalancers[reRoute.ReRouteKey];
-
-                    if(reRoute.LoadBalancer != loadBalancer.GetType().Name)
-                    {
-                        loadBalancer = await _factory.Get(reRoute, config);
-                        AddLoadBalancer(reRoute.ReRouteKey, loadBalancer);
-                    }
-
-                    return new OkResponse<ILoadBalancer>(loadBalancer);
-                }
-
-                loadBalancer = await _factory.Get(reRoute, config);
-                AddLoadBalancer(reRoute.ReRouteKey, loadBalancer);
-                return new OkResponse<ILoadBalancer>(loadBalancer);
-            }
-            catch(Exception ex)
-            {
-                return new ErrorResponse<ILoadBalancer>(new List<Ocelot.Errors.Error>()
-                {
-                    new UnableToFindLoadBalancerError($"unabe to find load balancer for {reRoute.ReRouteKey} exception is {ex}")
-                });
-            }
-        }
-
-        private void AddLoadBalancer(string key, ILoadBalancer loadBalancer)
-        {
-            _loadBalancers.AddOrUpdate(key, loadBalancer, (x, y) => loadBalancer);
-        }
-    }
-}
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Ocelot.Configuration;
+using Ocelot.Responses;
+
+namespace Ocelot.LoadBalancer.LoadBalancers
+{
+    public class LoadBalancerHouse : ILoadBalancerHouse
+    {
+        private readonly ILoadBalancerFactory _factory;
+        private readonly ConcurrentDictionary<string, ILoadBalancer> _loadBalancers;
+
+        public LoadBalancerHouse(ILoadBalancerFactory factory)
+        {
+            _factory = factory;
+            _loadBalancers = new ConcurrentDictionary<string, ILoadBalancer>();
+        }
+
+        public async Task<Response<ILoadBalancer>> Get(DownstreamReRoute reRoute, ServiceProviderConfiguration config)
+        {
+            try
+            {
+                if(_loadBalancers.TryGetValue(reRoute.LoadBalancerKey, out var loadBalancer))
+                {
+                    loadBalancer = _loadBalancers[reRoute.LoadBalancerKey];
+
+                    if(reRoute.LoadBalancerOptions.Type != loadBalancer.GetType().Name)
+                    {
+                        loadBalancer = await _factory.Get(reRoute, config);
+                        AddLoadBalancer(reRoute.LoadBalancerKey, loadBalancer);
+                    }
+
+                    return new OkResponse<ILoadBalancer>(loadBalancer);
+                }
+
+                loadBalancer = await _factory.Get(reRoute, config);
+                AddLoadBalancer(reRoute.LoadBalancerKey, loadBalancer);
+                return new OkResponse<ILoadBalancer>(loadBalancer);
+            }
+            catch(Exception ex)
+            {
+                return new ErrorResponse<ILoadBalancer>(new List<Ocelot.Errors.Error>()
+                {
+                    new UnableToFindLoadBalancerError($"unabe to find load balancer for {reRoute.LoadBalancerKey} exception is {ex}")
+                });
+            }
+        }
+
+        private void AddLoadBalancer(string key, ILoadBalancer loadBalancer)
+        {
+            _loadBalancers.AddOrUpdate(key, loadBalancer, (x, y) => loadBalancer);
+        }
+    }
+}

src/Ocelot/LoadBalancer/LoadBalancers/NoLoadBalancer.cs

@@ -1,29 +1,35 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading.Tasks;
-using Ocelot.Responses;
-using Ocelot.Values;
-
-namespace Ocelot.LoadBalancer.LoadBalancers
-{
-    public class NoLoadBalancer : ILoadBalancer
-    {
-        private readonly List<Service> _services;
-
-        public NoLoadBalancer(List<Service> services)
-        {
-            _services = services;
-        }
-
-        public async Task<Response<ServiceHostAndPort>> Lease()
-        {
-            //todo no point spinning a task up here, also first or default could be null..
-            var service = await Task.FromResult(_services.FirstOrDefault());
-            return new OkResponse<ServiceHostAndPort>(service.HostAndPort);
-        }
-
-        public void Release(ServiceHostAndPort hostAndPort)
-        {
-        }
-    }
-}
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Ocelot.Middleware;
+using Ocelot.Responses;
+using Ocelot.Values;
+
+namespace Ocelot.LoadBalancer.LoadBalancers
+{
+    public class NoLoadBalancer : ILoadBalancer
+    {
+        private readonly List<Service> _services;
+
+        public NoLoadBalancer(List<Service> services)
+        {
+            _services = services;
+        }
+
+        public async Task<Response<ServiceHostAndPort>> Lease(DownstreamContext downstreamContext)
+        {
+            //todo no point spinning a task up here, also first or default could be null..
+            if (_services == null || _services.Count == 0)
+            {
+                return new ErrorResponse<ServiceHostAndPort>(new ServicesAreEmptyError("There were no services in NoLoadBalancer"));
+            }
+
+            var service = await Task.FromResult(_services.FirstOrDefault());
+            return new OkResponse<ServiceHostAndPort>(service.HostAndPort);
+        }
+
+        public void Release(ServiceHostAndPort hostAndPort)
+        {
+        }
+    }
+}

src/Ocelot/LoadBalancer/LoadBalancers/RoundRobin.cs

@@ -1,37 +1,38 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using Ocelot.Responses;
-using Ocelot.Values;
-using System;
-
-namespace Ocelot.LoadBalancer.LoadBalancers
-{
-    public class RoundRobin : ILoadBalancer
-    {
-        private readonly Func<Task<List<Service>>> _services;
-
-        private int _last;
-
-        public RoundRobin(Func<Task<List<Service>>> services)
-        {
-            _services = services;
-        }
-
-        public async Task<Response<ServiceHostAndPort>> Lease()
-        {
-            var services = await _services.Invoke();
-            if (_last >= services.Count)
-            {
-                _last = 0;
-            }
-
-            var next = await Task.FromResult(services[_last]);
-            _last++;
-            return new OkResponse<ServiceHostAndPort>(next.HostAndPort);
-        }
-
-        public void Release(ServiceHostAndPort hostAndPort)
-        {
-        }
-    }
-}
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Ocelot.Responses;
+using Ocelot.Values;
+using System;
+using Ocelot.Middleware;
+
+namespace Ocelot.LoadBalancer.LoadBalancers
+{
+    public class RoundRobin : ILoadBalancer
+    {
+        private readonly Func<Task<List<Service>>> _services;
+
+        private int _last;
+
+        public RoundRobin(Func<Task<List<Service>>> services)
+        {
+            _services = services;
+        }
+
+        public async Task<Response<ServiceHostAndPort>> Lease(DownstreamContext downstreamContext)
+        {
+            var services = await _services.Invoke();
+            if (_last >= services.Count)
+            {
+                _last = 0;
+            }
+
+            var next = await Task.FromResult(services[_last]);
+            _last++;
+            return new OkResponse<ServiceHostAndPort>(next.HostAndPort);
+        }
+
+        public void Release(ServiceHostAndPort hostAndPort)
+        {
+        }
+    }
+}

src/Ocelot/LoadBalancer/LoadBalancers/StickySession.cs

@@ -0,0 +1,18 @@
+using System;
+using Ocelot.Values;
+
+namespace Ocelot.LoadBalancer.LoadBalancers
+{
+    public class StickySession
+    {
+        public StickySession(ServiceHostAndPort hostAndPort, DateTime expiry)
+        {
+            HostAndPort = hostAndPort;
+            Expiry = expiry;
+        }
+
+        public ServiceHostAndPort HostAndPort { get; }
+        
+        public DateTime Expiry { get; }
+    }
+}

src/Ocelot/LoadBalancer/Middleware/LoadBalancingMiddleware.cs

@@ -1,63 +1,63 @@
-using System;
-using System.Threading.Tasks;
-using Ocelot.LoadBalancer.LoadBalancers;
-using Ocelot.Logging;
-using Ocelot.Middleware;
-
-namespace Ocelot.LoadBalancer.Middleware
-{
-    public class LoadBalancingMiddleware : OcelotMiddleware
-    {
-        private readonly OcelotRequestDelegate _next;
-        private readonly ILoadBalancerHouse _loadBalancerHouse;
-
-        public LoadBalancingMiddleware(OcelotRequestDelegate next,
-            IOcelotLoggerFactory loggerFactory,
-            ILoadBalancerHouse loadBalancerHouse) 
-                :base(loggerFactory.CreateLogger<LoadBalancingMiddleware>())
-        {
-            _next = next;
-            _loadBalancerHouse = loadBalancerHouse;
-        }
-
-        public async Task Invoke(DownstreamContext context)
-        {
-            var loadBalancer = await _loadBalancerHouse.Get(context.DownstreamReRoute, context.ServiceProviderConfiguration);
-            if(loadBalancer.IsError)
-            {
-                Logger.LogDebug("there was an error retriving the loadbalancer, setting pipeline error");
-                SetPipelineError(context, loadBalancer.Errors);
-                return;
-            }
-
-            var hostAndPort = await loadBalancer.Data.Lease();
-            if(hostAndPort.IsError)
-            {
-                Logger.LogDebug("there was an error leasing the loadbalancer, setting pipeline error");
-                SetPipelineError(context, hostAndPort.Errors);
-                return;
-            }
-
-            context.DownstreamRequest.Host = hostAndPort.Data.DownstreamHost;
-
-            if (hostAndPort.Data.DownstreamPort > 0)
-            {
-                context.DownstreamRequest.Port = hostAndPort.Data.DownstreamPort;
-            }
-
-            try
-            {
-                await _next.Invoke(context);
-            }
-            catch (Exception)
-            {
-                Logger.LogDebug("Exception calling next middleware, exception will be thrown to global handler");
-                throw;
-            }
-            finally
-            {
-                loadBalancer.Data.Release(hostAndPort.Data);
-            }
-        }
-    }
-}
+using System;
+using System.Threading.Tasks;
+using Ocelot.LoadBalancer.LoadBalancers;
+using Ocelot.Logging;
+using Ocelot.Middleware;
+
+namespace Ocelot.LoadBalancer.Middleware
+{
+    public class LoadBalancingMiddleware : OcelotMiddleware
+    {
+        private readonly OcelotRequestDelegate _next;
+        private readonly ILoadBalancerHouse _loadBalancerHouse;
+
+        public LoadBalancingMiddleware(OcelotRequestDelegate next,
+            IOcelotLoggerFactory loggerFactory,
+            ILoadBalancerHouse loadBalancerHouse) 
+                :base(loggerFactory.CreateLogger<LoadBalancingMiddleware>())
+        {
+            _next = next;
+            _loadBalancerHouse = loadBalancerHouse;
+        }
+
+        public async Task Invoke(DownstreamContext context)
+        {
+            var loadBalancer = await _loadBalancerHouse.Get(context.DownstreamReRoute, context.ServiceProviderConfiguration);
+            if(loadBalancer.IsError)
+            {
+                Logger.LogDebug("there was an error retriving the loadbalancer, setting pipeline error");
+                SetPipelineError(context, loadBalancer.Errors);
+                return;
+            }
+
+            var hostAndPort = await loadBalancer.Data.Lease(context);
+            if(hostAndPort.IsError)
+            {
+                Logger.LogDebug("there was an error leasing the loadbalancer, setting pipeline error");
+                SetPipelineError(context, hostAndPort.Errors);
+                return;
+            }
+
+            context.DownstreamRequest.Host = hostAndPort.Data.DownstreamHost;
+
+            if (hostAndPort.Data.DownstreamPort > 0)
+            {
+                context.DownstreamRequest.Port = hostAndPort.Data.DownstreamPort;
+            }
+
+            try
+            {
+                await _next.Invoke(context);
+            }
+            catch (Exception)
+            {
+                Logger.LogDebug("Exception calling next middleware, exception will be thrown to global handler");
+                throw;
+            }
+            finally
+            {
+                loadBalancer.Data.Release(hostAndPort.Data);
+            }
+        }
+    }
+}

src/Ocelot/Requester/HttpClientBuilder.cs

@@ -97,7 +97,11 @@ namespace Ocelot.Requester
 
         private string GetCacheKey(DownstreamContext request)
         {
-            return request.DownstreamRequest.OriginalString;
+            var cacheKey = $"{request.DownstreamRequest.Method}:{request.DownstreamRequest.OriginalString}";
+
+            this._logger.LogDebug($"Cache key for request is {cacheKey}");
+
+            return cacheKey;
         }
     }
 }

src/Ocelot/Requester/QoS/QosProviderHouse.cs

@@ -21,26 +21,26 @@ namespace Ocelot.Requester.QoS
         {
             try
             {
-                if (_qoSProviders.TryGetValue(reRoute.ReRouteKey, out var qosProvider))
+                if (_qoSProviders.TryGetValue(reRoute.QosKey, out var qosProvider))
                 {
                     if (reRoute.IsQos && qosProvider.CircuitBreaker == null)
                     {
                         qosProvider = _qoSProviderFactory.Get(reRoute);
-                        Add(reRoute.ReRouteKey, qosProvider);
+                        Add(reRoute.QosKey, qosProvider);
                     }
 
-                    return new OkResponse<IQoSProvider>(_qoSProviders[reRoute.ReRouteKey]);
+                    return new OkResponse<IQoSProvider>(_qoSProviders[reRoute.QosKey]);
                 }
 
                 qosProvider = _qoSProviderFactory.Get(reRoute);
-                Add(reRoute.ReRouteKey, qosProvider);
+                Add(reRoute.QosKey, qosProvider);
                 return new OkResponse<IQoSProvider>(qosProvider);
             }
             catch (Exception ex)
             {
                 return new ErrorResponse<IQoSProvider>(new List<Ocelot.Errors.Error>()
                 {
-                    new UnableToFindQoSProviderError($"unabe to find qos provider for {reRoute.ReRouteKey}, exception was {ex}")
+                    new UnableToFindQoSProviderError($"unabe to find qos provider for {reRoute.QosKey}, exception was {ex}")
                 });
             }
         }

src/Ocelot/Responder/ErrorsToHttpStatusCodeMapper.cs

@@ -32,6 +32,11 @@ namespace Ocelot.Responder
                 return 404;
             }
 
+            if (errors.Any(e => e.Code == OcelotErrorCode.UnableToCompleteRequestError))
+            {
+                return 500;
+            }
+
             return 404;
         }
     }

test/Ocelot.AcceptanceTests/LoadBalancerTests.cs

@@ -1,163 +1,163 @@
-using System;
-using System.Collections.Generic;
-using System.IO;
-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 LoadBalancerTests : IDisposable
-    {
-        private IWebHost _builderOne;
-        private IWebHost _builderTwo;
-        private readonly Steps _steps;
-        private int _counterOne;
-        private int _counterTwo;
-        private static readonly object _syncLock = new object();
-
-        public LoadBalancerTests()
-        {
-            _steps = new Steps();
-        }
-
-        [Fact]
-        public void should_load_balance_request()
-        {
-            var downstreamServiceOneUrl = "http://localhost:50881";
-            var downstreamServiceTwoUrl = "http://localhost:50892";
-
-            var configuration = new FileConfiguration
-            {
-                ReRoutes = new List<FileReRoute>
-                    {
-                        new FileReRoute
-                        {
-                            DownstreamPathTemplate = "/",
-                            DownstreamScheme = "http",
-                            UpstreamPathTemplate = "/",
-                            UpstreamHttpMethod = new List<string> { "Get" },
-                            LoadBalancer = "LeastConnection",
-                            DownstreamHostAndPorts = new List<FileHostAndPort>
-                            {
-                                new FileHostAndPort
-                                {
-                                    Host = "localhost",
-                                    Port = 50881
-                                },
-                                new FileHostAndPort
-                                {
-                                    Host = "localhost",
-                                    Port = 50892
-                                }
-                            }
-                        }
-                    },
-                    GlobalConfiguration = new FileGlobalConfiguration()
-                    {
-                    }
-            };
-
-            this.Given(x => x.GivenProductServiceOneIsRunning(downstreamServiceOneUrl, 200))
-                .And(x => x.GivenProductServiceTwoIsRunning(downstreamServiceTwoUrl, 200))
-                .And(x => _steps.GivenThereIsAConfiguration(configuration))
-                .And(x => _steps.GivenOcelotIsRunning())
-                .When(x => _steps.WhenIGetUrlOnTheApiGatewayMultipleTimes("/", 50))
-                .Then(x => x.ThenTheTwoServicesShouldHaveBeenCalledTimes(50))
-                .And(x => x.ThenBothServicesCalledRealisticAmountOfTimes(24, 26))
-                .BDDfy();
-        }
-
-        private void ThenBothServicesCalledRealisticAmountOfTimes(int bottom, int top)
-        {
-            _counterOne.ShouldBeInRange(bottom, top);
-            _counterOne.ShouldBeInRange(bottom, top);
-        }
-
-        private void ThenTheTwoServicesShouldHaveBeenCalledTimes(int expected)
-        {
-            var total = _counterOne + _counterTwo;
-            total.ShouldBe(expected);
-        }
-
-        private void GivenProductServiceOneIsRunning(string url, int statusCode)
-        {
-            _builderOne = new WebHostBuilder()
-                .UseUrls(url)
-                .UseKestrel()
-                .UseContentRoot(Directory.GetCurrentDirectory())
-                .UseIISIntegration()
-                .UseUrls(url)
-                .Configure(app =>
-                {
-                    app.Run(async context =>
-                    {
-                        try
-                        {
-                            var response = string.Empty;
-                            lock (_syncLock)
-                            {
-                                _counterOne++;
-                                response = _counterOne.ToString();
-                            }
-                            context.Response.StatusCode = statusCode;
-                            await context.Response.WriteAsync(response);
-                        }
-                        catch (Exception exception)
-                        {
-                            await context.Response.WriteAsync(exception.StackTrace);
-                        }
-                    });
-                })
-                .Build();
-
-            _builderOne.Start();
-        }
-
-        private void GivenProductServiceTwoIsRunning(string url, int statusCode)
-        {
-            _builderTwo = new WebHostBuilder()
-                .UseUrls(url)
-                .UseKestrel()
-                .UseContentRoot(Directory.GetCurrentDirectory())
-                .UseIISIntegration()
-                .UseUrls(url)
-                .Configure(app =>
-                {
-                    app.Run(async context =>
-                    {
-                        try
-                        {
-                            var response = string.Empty;
-                            lock (_syncLock)
-                            {
-                                _counterTwo++;
-                                response = _counterTwo.ToString();
-                            }
-                            
-                            context.Response.StatusCode = statusCode;
-                            await context.Response.WriteAsync(response);
-                        }
-                        catch (System.Exception exception)
-                        {
-                            await context.Response.WriteAsync(exception.StackTrace);
-                        }                   
-                    });
-                })
-                .Build();
-
-            _builderTwo.Start();
-        }
-
-        public void Dispose()
-        {
-            _builderOne?.Dispose();
-            _builderTwo?.Dispose();
-            _steps.Dispose();
-        }
-    }
-}
+using System;
+using System.Collections.Generic;
+using System.IO;
+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 LoadBalancerTests : IDisposable
+    {
+        private IWebHost _builderOne;
+        private IWebHost _builderTwo;
+        private readonly Steps _steps;
+        private int _counterOne;
+        private int _counterTwo;
+        private static readonly object _syncLock = new object();
+
+        public LoadBalancerTests()
+        {
+            _steps = new Steps();
+        }
+
+        [Fact]
+        public void should_load_balance_request()
+        {
+            var downstreamServiceOneUrl = "http://localhost:50881";
+            var downstreamServiceTwoUrl = "http://localhost:50892";
+
+            var configuration = new FileConfiguration
+            {
+                ReRoutes = new List<FileReRoute>
+                    {
+                        new FileReRoute
+                        {
+                            DownstreamPathTemplate = "/",
+                            DownstreamScheme = "http",
+                            UpstreamPathTemplate = "/",
+                            UpstreamHttpMethod = new List<string> { "Get" },
+                            LoadBalancerOptions = new FileLoadBalancerOptions { Type = "LeastConnection" },
+                            DownstreamHostAndPorts = new List<FileHostAndPort>
+                            {
+                                new FileHostAndPort
+                                {
+                                    Host = "localhost",
+                                    Port = 50881
+                                },
+                                new FileHostAndPort
+                                {
+                                    Host = "localhost",
+                                    Port = 50892
+                                }
+                            }
+                        }
+                    },
+                    GlobalConfiguration = new FileGlobalConfiguration()
+                    {
+                    }
+            };
+
+            this.Given(x => x.GivenProductServiceOneIsRunning(downstreamServiceOneUrl, 200))
+                .And(x => x.GivenProductServiceTwoIsRunning(downstreamServiceTwoUrl, 200))
+                .And(x => _steps.GivenThereIsAConfiguration(configuration))
+                .And(x => _steps.GivenOcelotIsRunning())
+                .When(x => _steps.WhenIGetUrlOnTheApiGatewayMultipleTimes("/", 50))
+                .Then(x => x.ThenTheTwoServicesShouldHaveBeenCalledTimes(50))
+                .And(x => x.ThenBothServicesCalledRealisticAmountOfTimes(24, 26))
+                .BDDfy();
+        }
+
+        private void ThenBothServicesCalledRealisticAmountOfTimes(int bottom, int top)
+        {
+            _counterOne.ShouldBeInRange(bottom, top);
+            _counterOne.ShouldBeInRange(bottom, top);
+        }
+
+        private void ThenTheTwoServicesShouldHaveBeenCalledTimes(int expected)
+        {
+            var total = _counterOne + _counterTwo;
+            total.ShouldBe(expected);
+        }
+
+        private void GivenProductServiceOneIsRunning(string url, int statusCode)
+        {
+            _builderOne = new WebHostBuilder()
+                .UseUrls(url)
+                .UseKestrel()
+                .UseContentRoot(Directory.GetCurrentDirectory())
+                .UseIISIntegration()
+                .UseUrls(url)
+                .Configure(app =>
+                {
+                    app.Run(async context =>
+                    {
+                        try
+                        {
+                            var response = string.Empty;
+                            lock (_syncLock)
+                            {
+                                _counterOne++;
+                                response = _counterOne.ToString();
+                            }
+                            context.Response.StatusCode = statusCode;
+                            await context.Response.WriteAsync(response);
+                        }
+                        catch (Exception exception)
+                        {
+                            await context.Response.WriteAsync(exception.StackTrace);
+                        }
+                    });
+                })
+                .Build();
+
+            _builderOne.Start();
+        }
+
+        private void GivenProductServiceTwoIsRunning(string url, int statusCode)
+        {
+            _builderTwo = new WebHostBuilder()
+                .UseUrls(url)
+                .UseKestrel()
+                .UseContentRoot(Directory.GetCurrentDirectory())
+                .UseIISIntegration()
+                .UseUrls(url)
+                .Configure(app =>
+                {
+                    app.Run(async context =>
+                    {
+                        try
+                        {
+                            var response = string.Empty;
+                            lock (_syncLock)
+                            {
+                                _counterTwo++;
+                                response = _counterTwo.ToString();
+                            }
+                            
+                            context.Response.StatusCode = statusCode;
+                            await context.Response.WriteAsync(response);
+                        }
+                        catch (System.Exception exception)
+                        {
+                            await context.Response.WriteAsync(exception.StackTrace);
+                        }                   
+                    });
+                })
+                .Build();
+
+            _builderTwo.Start();
+        }
+
+        public void Dispose()
+        {
+            _builderOne?.Dispose();
+            _builderTwo?.Dispose();
+            _steps.Dispose();
+        }
+    }
+}

test/Ocelot.AcceptanceTests/ServiceDiscoveryTests.cs

@@ -61,7 +61,7 @@ namespace Ocelot.AcceptanceTests
                             UpstreamPathTemplate = "/",
                             UpstreamHttpMethod = new List<string> { "Get" },
                             ServiceName = serviceName,
-                            LoadBalancer = "LeastConnection",
+                            LoadBalancerOptions = new FileLoadBalancerOptions { Type = "LeastConnection" },
                             UseServiceDiscovery = true,
                         }
                     },
@@ -127,7 +127,7 @@ namespace Ocelot.AcceptanceTests
                             UpstreamPathTemplate = "/",
                             UpstreamHttpMethod = new List<string> { "Get" },
                             ServiceName = serviceName,
-                            LoadBalancer = "LeastConnection",
+                            LoadBalancerOptions = new FileLoadBalancerOptions { Type = "LeastConnection" },
                             UseServiceDiscovery = true,
                         }
                     },
@@ -183,7 +183,7 @@ namespace Ocelot.AcceptanceTests
                             UpstreamPathTemplate = "/home",
                             UpstreamHttpMethod = new List<string> { "Get", "Options" },
                             ServiceName = serviceName,
-                            LoadBalancer = "LeastConnection",
+                            LoadBalancerOptions = new FileLoadBalancerOptions { Type = "LeastConnection" },
                             UseServiceDiscovery = true,
                         }
                     },
@@ -239,7 +239,7 @@ namespace Ocelot.AcceptanceTests
                             UpstreamPathTemplate = "/home",
                             UpstreamHttpMethod = new List<string> { "Get", "Options" },
                             ServiceName = serviceName,
-                            LoadBalancer = "LeastConnection",
+                            LoadBalancerOptions = new FileLoadBalancerOptions { Type = "LeastConnection" },
                             UseServiceDiscovery = true,
                         }
                     },
@@ -308,7 +308,7 @@ namespace Ocelot.AcceptanceTests
                             UpstreamPathTemplate = "/",
                             UpstreamHttpMethod = new List<string> { "Get" },
                             ServiceName = serviceName,
-                            LoadBalancer = "LeastConnection",
+                            LoadBalancerOptions = new FileLoadBalancerOptions { Type = "LeastConnection" },
                             UseServiceDiscovery = true,
                         }
                     },

test/Ocelot.AcceptanceTests/SslTests.cs

@@ -92,7 +92,7 @@ namespace Ocelot.AcceptanceTests
                 .And(x => _steps.GivenThereIsAConfiguration(configuration))
                 .And(x => _steps.GivenOcelotIsRunning())
                 .When(x => _steps.WhenIGetUrlOnTheApiGateway("/"))
-                .Then(x => _steps.ThenTheStatusCodeShouldBe(HttpStatusCode.NotFound))
+                .Then(x => _steps.ThenTheStatusCodeShouldBe(HttpStatusCode.InternalServerError))
                 .BDDfy();
         }
 

test/Ocelot.AcceptanceTests/Steps.cs

@@ -30,6 +30,9 @@ using Ocelot.Middleware.Multiplexer;
 
 namespace Ocelot.AcceptanceTests
 {
+    using Microsoft.Net.Http.Headers;
+    using MediaTypeHeaderValue = System.Net.Http.Headers.MediaTypeHeaderValue;
+
     public class Steps : IDisposable
     {
         private TestServer _ocelotServer;
@@ -341,7 +344,7 @@ namespace Ocelot.AcceptanceTests
 
         internal void GivenIAddCookieToMyRequest(string cookie)
         {
-            _ocelotClient.DefaultRequestHeaders.Add("Set-Cookie", cookie);
+            _ocelotClient.DefaultRequestHeaders.Add("Set-Cookie", cookie);
         }
 
         /// <summary>
@@ -671,6 +674,14 @@ namespace Ocelot.AcceptanceTests
             _response = _ocelotClient.GetAsync(url).Result;
         }
 
+        public void WhenIGetUrlOnTheApiGateway(string url, string cookie, string value)
+        {
+            var request = _ocelotServer.CreateRequest(url);
+            request.And(x => { x.Headers.Add("Cookie", new CookieHeaderValue(cookie, value).ToString()); });
+            var response = request.GetAsync().Result;
+            _response = response;
+        }
+
         public void GivenIAddAHeader(string key, string value)
         {
             _ocelotClient.DefaultRequestHeaders.Add(key, value);
@@ -690,6 +701,30 @@ namespace Ocelot.AcceptanceTests
             Task.WaitAll(tasks);
         }
 
+        public async Task WhenIGetUrlOnTheApiGatewayMultipleTimes(string url, int times, string cookie, string value)
+        {
+            var tasks = new Task[times];
+
+            for (int i = 0; i < times; i++)
+            {
+                var urlCopy = url;
+                tasks[i] = GetForServiceDiscoveryTest(urlCopy, cookie, value);
+                Thread.Sleep(_random.Next(40, 60));
+            }
+
+            Task.WaitAll(tasks);
+        }
+
+        private async Task GetForServiceDiscoveryTest(string url, string cookie, string value)
+        {
+            var request = _ocelotServer.CreateRequest(url);
+            request.And(x => { x.Headers.Add("Cookie", new CookieHeaderValue(cookie, value).ToString()); });
+            var response = await request.GetAsync();
+            var content = await response.Content.ReadAsStringAsync();
+            int count = int.Parse(content);
+            count.ShouldBeGreaterThan(0);
+        }
+
         private async Task GetForServiceDiscoveryTest(string url)
         {
             var response = await _ocelotClient.GetAsync(url);

test/Ocelot.AcceptanceTests/StickySessionsTests.cs

@@ -0,0 +1,321 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+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 StickySessionsTests : IDisposable
+    {
+        private IWebHost _builderOne;
+        private IWebHost _builderTwo;
+        private readonly Steps _steps;
+        private int _counterOne;
+        private int _counterTwo;
+        private static readonly object _syncLock = new object();
+
+        public StickySessionsTests()
+        {
+            _steps = new Steps();
+        }
+
+        [Fact]
+        public void should_use_same_downstream_host()
+        {
+            var downstreamPortOne = 51881;
+            var downstreamPortTwo = 51892;
+            var downstreamServiceOneUrl = $"http://localhost:{downstreamPortOne}";
+            var downstreamServiceTwoUrl = $"http://localhost:{downstreamPortTwo}";
+
+            var configuration = new FileConfiguration
+            {
+                ReRoutes = new List<FileReRoute>
+                    {
+                        new FileReRoute
+                        {
+                            DownstreamPathTemplate = "/",
+                            DownstreamScheme = "http",
+                            UpstreamPathTemplate = "/",
+                            UpstreamHttpMethod = new List<string> { "Get" },
+                            LoadBalancerOptions = new FileLoadBalancerOptions
+                            {
+                                Type = "CookieStickySessions",
+                                Key = "sessionid",
+                                Expiry = 300000
+                            },
+                            DownstreamHostAndPorts = new List<FileHostAndPort>
+                            {
+                                new FileHostAndPort
+                                {
+                                    Host = "localhost",
+                                    Port = downstreamPortOne
+                                },
+                                new FileHostAndPort
+                                {
+                                    Host = "localhost",
+                                    Port = downstreamPortTwo
+                                }
+                            }
+                        }
+                    }
+            };
+
+            this.Given(x => x.GivenProductServiceOneIsRunning(downstreamServiceOneUrl, 200))
+                .And(x => x.GivenProductServiceTwoIsRunning(downstreamServiceTwoUrl, 200))
+                .And(x => _steps.GivenThereIsAConfiguration(configuration))
+                .And(x => _steps.GivenOcelotIsRunning())
+                .When(x => _steps.WhenIGetUrlOnTheApiGatewayMultipleTimes("/", 10, "sessionid", "123"))
+                .Then(x => x.ThenTheFirstServiceIsCalled(10))
+                .Then(x => x.ThenTheSecondServiceIsCalled(0))
+                .BDDfy();
+        }
+
+        [Fact]
+        public void should_use_different_downstream_host_for_different_re_route()
+        {
+            var downstreamPortOne = 52881;
+            var downstreamPortTwo = 52892;
+            var downstreamServiceOneUrl = $"http://localhost:{downstreamPortOne}";
+            var downstreamServiceTwoUrl = $"http://localhost:{downstreamPortTwo}";
+
+            var configuration = new FileConfiguration
+            {
+                ReRoutes = new List<FileReRoute>
+                    {
+                        new FileReRoute
+                        {
+                            DownstreamPathTemplate = "/",
+                            DownstreamScheme = "http",
+                            UpstreamPathTemplate = "/",
+                            UpstreamHttpMethod = new List<string> { "Get" },
+                            LoadBalancerOptions = new FileLoadBalancerOptions
+                            {
+                                Type = "CookieStickySessions",
+                                Key = "sessionid",
+                                Expiry = 300000
+                            },
+                            DownstreamHostAndPorts = new List<FileHostAndPort>
+                            {
+                                new FileHostAndPort
+                                {
+                                    Host = "localhost",
+                                    Port = downstreamPortOne
+                                },
+                                new FileHostAndPort
+                                {
+                                    Host = "localhost",
+                                    Port = downstreamPortTwo
+                                }
+                            }
+                        },
+                        new FileReRoute
+                        {
+                            DownstreamPathTemplate = "/",
+                            DownstreamScheme = "http",
+                            UpstreamPathTemplate = "/test",
+                            UpstreamHttpMethod = new List<string> { "Get" },
+                            LoadBalancerOptions = new FileLoadBalancerOptions
+                            {
+                                Type = "CookieStickySessions",
+                                Key = "bestid",
+                                Expiry = 300000
+                            },
+                            DownstreamHostAndPorts = new List<FileHostAndPort>
+                            {
+                                new FileHostAndPort
+                                {
+                                    Host = "localhost",
+                                    Port = downstreamPortTwo
+                                },
+                                new FileHostAndPort
+                                {
+                                    Host = "localhost",
+                                    Port = downstreamPortOne
+                                }
+                            }
+                        }
+                    }
+            };
+
+            this.Given(x => x.GivenProductServiceOneIsRunning(downstreamServiceOneUrl, 200))
+                .And(x => x.GivenProductServiceTwoIsRunning(downstreamServiceTwoUrl, 200))
+                .And(x => _steps.GivenThereIsAConfiguration(configuration))
+                .And(x => _steps.GivenOcelotIsRunning())
+                .When(x => _steps.WhenIGetUrlOnTheApiGateway("/", "sessionid", "123"))
+                .When(x => _steps.WhenIGetUrlOnTheApiGateway("/test", "bestid", "123"))
+                .Then(x => x.ThenTheFirstServiceIsCalled(1))
+                .Then(x => x.ThenTheSecondServiceIsCalled(1))
+                .BDDfy();
+        }
+
+        [Fact]
+        public void should_use_same_downstream_host_for_different_re_route()
+        {
+            var downstreamPortOne = 53881;
+            var downstreamPortTwo = 53892;
+            var downstreamServiceOneUrl = $"http://localhost:{downstreamPortOne}";
+            var downstreamServiceTwoUrl = $"http://localhost:{downstreamPortTwo}";
+
+            var configuration = new FileConfiguration
+            {
+                ReRoutes = new List<FileReRoute>
+                    {
+                        new FileReRoute
+                        {
+                            DownstreamPathTemplate = "/",
+                            DownstreamScheme = "http",
+                            UpstreamPathTemplate = "/",
+                            UpstreamHttpMethod = new List<string> { "Get" },
+                            LoadBalancerOptions = new FileLoadBalancerOptions
+                            {
+                                Type = "CookieStickySessions",
+                                Key = "sessionid",
+                                Expiry = 300000
+                            },
+                            DownstreamHostAndPorts = new List<FileHostAndPort>
+                            {
+                                new FileHostAndPort
+                                {
+                                    Host = "localhost",
+                                    Port = downstreamPortOne
+                                },
+                                new FileHostAndPort
+                                {
+                                    Host = "localhost",
+                                    Port = downstreamPortTwo
+                                }
+                            }
+                        },
+                        new FileReRoute
+                        {
+                            DownstreamPathTemplate = "/",
+                            DownstreamScheme = "http",
+                            UpstreamPathTemplate = "/test",
+                            UpstreamHttpMethod = new List<string> { "Get" },
+                            LoadBalancerOptions = new FileLoadBalancerOptions
+                            {
+                                Type = "CookieStickySessions",
+                                Key = "sessionid",
+                                Expiry = 300000
+                            },
+                            DownstreamHostAndPorts = new List<FileHostAndPort>
+                            {
+                                new FileHostAndPort
+                                {
+                                    Host = "localhost",
+                                    Port = downstreamPortTwo
+                                },
+                                new FileHostAndPort
+                                {
+                                    Host = "localhost",
+                                    Port = downstreamPortOne
+                                }
+                            }
+                        }
+                    }
+            };
+
+            this.Given(x => x.GivenProductServiceOneIsRunning(downstreamServiceOneUrl, 200))
+                .And(x => x.GivenProductServiceTwoIsRunning(downstreamServiceTwoUrl, 200))
+                .And(x => _steps.GivenThereIsAConfiguration(configuration))
+                .And(x => _steps.GivenOcelotIsRunning())
+                .When(x => _steps.WhenIGetUrlOnTheApiGateway("/", "sessionid", "123"))
+                .When(x => _steps.WhenIGetUrlOnTheApiGateway("/test", "sessionid", "123"))
+                .Then(x => x.ThenTheFirstServiceIsCalled(2))
+                .Then(x => x.ThenTheSecondServiceIsCalled(0))
+                .BDDfy();
+        }
+
+        private void ThenTheFirstServiceIsCalled(int expected)
+        {
+            _counterOne.ShouldBe(expected);
+        }
+
+        private void ThenTheSecondServiceIsCalled(int expected)
+        {
+            _counterTwo.ShouldBe(expected);
+        }
+
+        private void GivenProductServiceOneIsRunning(string url, int statusCode)
+        {
+            _builderOne = new WebHostBuilder()
+                .UseUrls(url)
+                .UseKestrel()
+                .UseContentRoot(Directory.GetCurrentDirectory())
+                .UseIISIntegration()
+                .UseUrls(url)
+                .Configure(app =>
+                {
+                    app.Run(async context =>
+                    {
+                        try
+                        {
+                            var response = string.Empty;
+                            lock (_syncLock)
+                            {
+                                _counterOne++;
+                                response = _counterOne.ToString();
+                            }
+                            context.Response.StatusCode = statusCode;
+                            await context.Response.WriteAsync(response);
+                        }
+                        catch (Exception exception)
+                        {
+                            await context.Response.WriteAsync(exception.StackTrace);
+                        }
+                    });
+                })
+                .Build();
+
+            _builderOne.Start();
+        }
+
+        private void GivenProductServiceTwoIsRunning(string url, int statusCode)
+        {
+            _builderTwo = new WebHostBuilder()
+                .UseUrls(url)
+                .UseKestrel()
+                .UseContentRoot(Directory.GetCurrentDirectory())
+                .UseIISIntegration()
+                .UseUrls(url)
+                .Configure(app =>
+                {
+                    app.Run(async context =>
+                    {
+                        try
+                        {
+                            var response = string.Empty;
+                            lock (_syncLock)
+                            {
+                                _counterTwo++;
+                                response = _counterTwo.ToString();
+                            }
+                            
+                            context.Response.StatusCode = statusCode;
+                            await context.Response.WriteAsync(response);
+                        }
+                        catch (System.Exception exception)
+                        {
+                            await context.Response.WriteAsync(exception.StackTrace);
+                        }                   
+                    });
+                })
+                .Build();
+
+            _builderTwo.Start();
+        }
+
+        public void Dispose()
+        {
+            _builderOne?.Dispose();
+            _builderTwo?.Dispose();
+            _steps.Dispose();
+        }
+    }
+}

test/Ocelot.AcceptanceTests/WebSocketTests.cs

@@ -101,7 +101,7 @@ namespace Ocelot.AcceptanceTests
                                 Port = secondDownstreamPort
                             }
                         },
-                        LoadBalancer = "RoundRobin"
+                        LoadBalancerOptions = new FileLoadBalancerOptions { Type = "RoundRobin" }
                     }
                 }
             };
@@ -159,7 +159,7 @@ namespace Ocelot.AcceptanceTests
                         UpstreamPathTemplate = "/",
                         DownstreamPathTemplate = "/ws",
                         DownstreamScheme = "ws",
-                        LoadBalancer = "RoundRobin",
+                        LoadBalancerOptions = new FileLoadBalancerOptions { Type = "RoundRobin" },
                         ServiceName = serviceName,
                         UseServiceDiscovery = true
                     }

test/Ocelot.Benchmarks/AllTheThingsBenchmarks.cs

@@ -76,16 +76,16 @@ namespace Ocelot.Benchmarks
             response.EnsureSuccessStatusCode();
         }
 
-        // * Summary *
-        // BenchmarkDotNet=v0.10.13, OS=macOS 10.12.6 (16G1212) [Darwin 16.7.0]
-        // Intel Core i5-4278U CPU 2.60GHz (Haswell), 1 CPU, 4 logical cores and 2 physical cores
-        // .NET Core SDK=2.1.4
-        //   [Host]     : .NET Core 2.0.6 (CoreCLR 4.6.0.0, CoreFX 4.6.26212.01), 64bit RyuJIT
-        //   DefaultJob : .NET Core 2.0.6 (CoreCLR 4.6.0.0, CoreFX 4.6.26212.01), 64bit RyuJIT
+       //  * Summary*
+       //  BenchmarkDotNet = v0.10.13, OS = macOS 10.12.6 (16G1212) [Darwin 16.7.0]
+       // Intel Core i5-4278U CPU 2.60GHz(Haswell), 1 CPU, 4 logical cores and 2 physical cores
+       //.NET Core SDK = 2.1.4
 
-        //    Method |     Mean |     Error |    StdDev |    StdErr |      Min |       Q1 |   Median |       Q3 |      Max |  Op/s | Scaled |   Gen 0 |  Gen 1 | Allocated |
-        // --------- |---------:|----------:|----------:|----------:|---------:|---------:|---------:|---------:|---------:|------:|-------:|--------:|-------:|----------:|
-        //  Baseline | 2.102 ms | 0.0292 ms | 0.0273 ms | 0.0070 ms | 2.063 ms | 2.080 ms | 2.093 ms | 2.122 ms | 2.152 ms | 475.8 |   1.00 | 31.2500 | 3.9063 |   1.63 KB |
+       //  [Host]     : .NET Core 2.0.6 (CoreCLR 4.6.0.0, CoreFX 4.6.26212.01), 64bit RyuJIT
+       //    DefaultJob : .NET Core 2.0.6 (CoreCLR 4.6.0.0, CoreFX 4.6.26212.01), 64bit RyuJIT
+       //     Method |     Mean |     Error |    StdDev |    StdErr |      Min |       Q1 |   Median |       Q3 |      Max |  Op/s | Scaled |   Gen 0 |  Gen 1 | Allocated |
+       //  --------- |---------:|----------:|----------:|----------:|---------:|---------:|---------:|---------:|---------:|------:|-------:|--------:|-------:|----------:|
+       //  Baseline | 2.102 ms | 0.0292 ms | 0.0273 ms | 0.0070 ms | 2.063 ms | 2.080 ms | 2.093 ms | 2.122 ms | 2.152 ms | 475.8 |   1.00 | 31.2500 | 3.9063 |   1.63 KB |
 
         private void GivenOcelotIsRunning(string url)
         {
@@ -121,7 +121,7 @@ namespace Ocelot.Benchmarks
 
         public void GivenThereIsAConfiguration(FileConfiguration fileConfiguration)
         {
-            var configurationPath = Path.Combine(AppContext.BaseDirectory, "ocelot.json");;
+            var configurationPath = Path.Combine(AppContext.BaseDirectory, "ocelot.json");
 
             var jsonConfiguration = JsonConvert.SerializeObject(fileConfiguration);
 

test/Ocelot.Benchmarks/UrlPathToUrlPathTemplateMatcherBenchmarks.cs

@@ -43,8 +43,6 @@ namespace Ocelot.Benchmarks
         // .NET Core SDK=2.1.4
         //   [Host]     : .NET Core 2.0.6 (CoreCLR 4.6.0.0, CoreFX 4.6.26212.01), 64bit RyuJIT
         //   DefaultJob : .NET Core 2.0.6 (CoreCLR 4.6.0.0, CoreFX 4.6.26212.01), 64bit RyuJIT
-
-
         //      Method |     Mean |     Error |    StdDev |    StdErr |      Min |       Q1 |   Median |       Q3 |      Max |      Op/s |
         // ----------- |---------:|----------:|----------:|----------:|---------:|---------:|---------:|---------:|---------:|----------:|
         //  Benchmark1 | 3.133 us | 0.0492 us | 0.0460 us | 0.0119 us | 3.082 us | 3.100 us | 3.122 us | 3.168 us | 3.233 us | 319,161.9 |

test/Ocelot.UnitTests/Configuration/ConsulFileConfigurationRepositoryTests.cs

@@ -1,137 +1,219 @@
-namespace Ocelot.UnitTests.Configuration
-{
-    using Xunit;
-    using TestStack.BDDfy;
-    using Shouldly;
-    using Ocelot.Configuration.Repository;
-    using Moq;
-    using Ocelot.Infrastructure.Consul;
-    using Ocelot.Logging;
-    using Ocelot.Configuration.File;
-    using Ocelot.Cache;
-    using System;
-    using System.Collections.Generic;
-    using Ocelot.Responses;
-    using System.Threading.Tasks;
-    using Ocelot.Configuration;
-    using Ocelot.Configuration.Builder;
-    using Ocelot.ServiceDiscovery.Configuration;
-    using Consul;
-    using Newtonsoft.Json;
-    using System.Text;
-    using System.Threading;
-    using System.Linq;
-
-    public class ConsulFileConfigurationRepositoryTests
-    {
-        private ConsulFileConfigurationRepository _repo;
-        private Mock<IOcelotCache<FileConfiguration>> _cache;
-        private Mock<IInternalConfigurationRepository> _internalRepo;
-        private Mock<IConsulClientFactory> _factory;
-        private Mock<IOcelotLoggerFactory> _loggerFactory;
-        private Mock<IConsulClient> _client;
-        private Mock<IKVEndpoint> _kvEndpoint;
-        private FileConfiguration _fileConfiguration;
-        private Response _result;
-
-        public ConsulFileConfigurationRepositoryTests()
-        {
-            _cache = new Mock<IOcelotCache<FileConfiguration>>();
-            _internalRepo = new Mock<IInternalConfigurationRepository>();
-            _loggerFactory = new Mock<IOcelotLoggerFactory>();
-
-            _factory = new Mock<IConsulClientFactory>();
-            _client = new Mock<IConsulClient>();
-            _kvEndpoint = new Mock<IKVEndpoint>();
-
-            _client
-                .Setup(x => x.KV)
-                .Returns(_kvEndpoint.Object);
-            _factory
-                .Setup(x => x.Get(It.IsAny<ConsulRegistryConfiguration>()))
-                .Returns(_client.Object);
-
-            _internalRepo
-                .Setup(x => x.Get())
-                .Returns(new OkResponse<IInternalConfiguration>(new InternalConfiguration(new List<ReRoute>(), "", new ServiceProviderConfigurationBuilder().Build(), "")));
-            
-            _repo = new ConsulFileConfigurationRepository(_cache.Object, _internalRepo.Object, _factory.Object, _loggerFactory.Object);
-        }
-
-        [Fact]
-        public void should_set_config()
-        {
-            var config = FakeFileConfiguration();
-
-            this.Given(_ => GivenIHaveAConfiguration(config))
-                .And(_ => GivenWritingToConsulSucceeds())
-                .When(_ => WhenISetTheConfiguration())
-                .Then(_ => ThenTheConfigurationIsStoredAs(config))
-                .BDDfy();
-        }
-
-        private void GivenWritingToConsulSucceeds()
-        {
-            var response = new WriteResult<bool>();
-            response.Response = true;
-
-            _kvEndpoint
-                .Setup(x => x.Put(It.IsAny<KVPair>(), It.IsAny<CancellationToken>())).ReturnsAsync(response);
-        }
-
-        private void ThenTheConfigurationIsStoredAs(FileConfiguration config)
-        {
-            var json = JsonConvert.SerializeObject(config, Formatting.Indented);
-
-            var bytes = Encoding.UTF8.GetBytes(json);
-
-            _kvEndpoint
-                .Verify(x => x.Put(It.Is<KVPair>(k => k.Value.SequenceEqual(bytes)), It.IsAny<CancellationToken>()), Times.Once);
-        }
-
-        private async Task WhenISetTheConfiguration()
-        {
-            _result = await _repo.Set(_fileConfiguration);
-        }
-
-        private void GivenIHaveAConfiguration(FileConfiguration config)
-        {
-            _fileConfiguration = config;
-        }
-        
-        private FileConfiguration FakeFileConfiguration()
-        {
-            var reRoutes = new List<FileReRoute>
-            {
-                new FileReRoute
-                {
-                    DownstreamHostAndPorts = new List<FileHostAndPort>
-                    {
-                        new FileHostAndPort
-                        {
-                            Host = "123.12.12.12",
-                            Port = 80,
-                        }
-                    },
-                    DownstreamScheme = "https",
-                    DownstreamPathTemplate = "/asdfs/test/{test}"
-                }
-            };
-
-            var globalConfiguration = new FileGlobalConfiguration
-            {
-                ServiceDiscoveryProvider = new FileServiceDiscoveryProvider
-                {
-                    Port = 198,
-                    Host = "blah"
-                }
-            };
-
-            return new FileConfiguration
-            {
-                GlobalConfiguration = globalConfiguration,
-                ReRoutes = reRoutes
-            };
-        }
-    }
-}
+namespace Ocelot.UnitTests.Configuration
+{
+    using Xunit;
+    using TestStack.BDDfy;
+    using Shouldly;
+    using Ocelot.Configuration.Repository;
+    using Moq;
+    using Ocelot.Infrastructure.Consul;
+    using Ocelot.Logging;
+    using Ocelot.Configuration.File;
+    using Ocelot.Cache;
+    using System;
+    using System.Collections.Generic;
+    using Ocelot.Responses;
+    using System.Threading.Tasks;
+    using Ocelot.Configuration;
+    using Ocelot.Configuration.Builder;
+    using Ocelot.ServiceDiscovery.Configuration;
+    using Consul;
+    using Newtonsoft.Json;
+    using System.Text;
+    using System.Threading;
+    using System.Linq;
+
+    public class ConsulFileConfigurationRepositoryTests
+    {
+        private ConsulFileConfigurationRepository _repo;
+        private Mock<IOcelotCache<FileConfiguration>> _cache;
+        private Mock<IInternalConfigurationRepository> _internalRepo;
+        private Mock<IConsulClientFactory> _factory;
+        private Mock<IOcelotLoggerFactory> _loggerFactory;
+        private Mock<IConsulClient> _client;
+        private Mock<IKVEndpoint> _kvEndpoint;
+        private FileConfiguration _fileConfiguration;
+        private Response _setResult;
+        private Response<FileConfiguration> _getResult;
+
+        public ConsulFileConfigurationRepositoryTests()
+        {
+            _cache = new Mock<IOcelotCache<FileConfiguration>>();
+            _internalRepo = new Mock<IInternalConfigurationRepository>();
+            _loggerFactory = new Mock<IOcelotLoggerFactory>();
+
+            _factory = new Mock<IConsulClientFactory>();
+            _client = new Mock<IConsulClient>();
+            _kvEndpoint = new Mock<IKVEndpoint>();
+
+            _client
+                .Setup(x => x.KV)
+                .Returns(_kvEndpoint.Object);
+            _factory
+                .Setup(x => x.Get(It.IsAny<ConsulRegistryConfiguration>()))
+                .Returns(_client.Object);
+
+            _internalRepo
+                .Setup(x => x.Get())
+                .Returns(new OkResponse<IInternalConfiguration>(new InternalConfiguration(new List<ReRoute>(), "", new ServiceProviderConfigurationBuilder().Build(), "")));
+            
+            _repo = new ConsulFileConfigurationRepository(_cache.Object, _internalRepo.Object, _factory.Object, _loggerFactory.Object);
+        }
+
+        [Fact]
+        public void should_set_config()
+        {
+            var config = FakeFileConfiguration();
+
+            this.Given(_ => GivenIHaveAConfiguration(config))
+                .And(_ => GivenWritingToConsulSucceeds())
+                .When(_ => WhenISetTheConfiguration())
+                .Then(_ => ThenTheConfigurationIsStoredAs(config))
+                .BDDfy();
+        }
+
+        [Fact]
+        public void should_get_config()
+        {
+            var config = FakeFileConfiguration();
+
+             this.Given(_ => GivenIHaveAConfiguration(config))
+                .And(_ => GivenFetchFromConsulSucceeds())
+                .When(_ => WhenIGetTheConfiguration())
+                .Then(_ => ThenTheConfigurationIs(config))
+                .BDDfy();
+        }
+
+        [Fact]
+        public void should_get_null_config()
+        {
+             this.Given(_ => GivenFetchFromConsulReturnsNull())
+                .When(_ => WhenIGetTheConfiguration())
+                .Then(_ => ThenTheConfigurationIsNull())
+                .BDDfy();
+        }
+
+        [Fact]
+        public void should_get_config_from_cache()
+        {
+            var config = FakeFileConfiguration();
+
+             this.Given(_ => GivenIHaveAConfiguration(config))
+                .And(_ => GivenFetchFromCacheSucceeds())
+                .When(_ => WhenIGetTheConfiguration())
+                .Then(_ => ThenTheConfigurationIs(config))
+                .BDDfy();
+        }
+
+        private void ThenTheConfigurationIsNull()
+        {
+            _getResult.Data.ShouldBeNull();
+        }
+
+        private void ThenTheConfigurationIs(FileConfiguration config)
+        {
+            var expected = JsonConvert.SerializeObject(config, Formatting.Indented);
+            var result = JsonConvert.SerializeObject(_getResult.Data, Formatting.Indented);
+            result.ShouldBe(expected);
+        }
+
+        private async Task WhenIGetTheConfiguration()
+        {
+            _getResult = await _repo.Get();
+        }
+
+        private void GivenWritingToConsulSucceeds()
+        {
+            var response = new WriteResult<bool>();
+            response.Response = true;
+
+            _kvEndpoint
+                .Setup(x => x.Put(It.IsAny<KVPair>(), It.IsAny<CancellationToken>())).ReturnsAsync(response);
+        }
+
+         private void GivenFetchFromCacheSucceeds()
+        {
+            _cache.Setup(x => x.Get(It.IsAny<string>(), It.IsAny<string>())).Returns(_fileConfiguration);
+        }
+
+        private void GivenFetchFromConsulReturnsNull()
+        {
+            QueryResult<KVPair> result = new QueryResult<KVPair>();
+
+            _kvEndpoint
+                .Setup(x => x.Get(It.IsAny<string>(), It.IsAny<CancellationToken>()))
+                .ReturnsAsync(result);
+        }
+
+        private void GivenFetchFromConsulSucceeds()
+        {
+            var json = JsonConvert.SerializeObject(_fileConfiguration, Formatting.Indented);
+
+            var bytes = Encoding.UTF8.GetBytes(json);
+
+            var kvp = new KVPair("OcelotConfiguration");
+            kvp.Value = bytes;
+
+            var query = new QueryResult<KVPair>();
+            query.Response = kvp;
+
+            _kvEndpoint
+                .Setup(x => x.Get(It.IsAny<string>(), It.IsAny<CancellationToken>()))
+                .ReturnsAsync(query);
+        }
+
+        private void ThenTheConfigurationIsStoredAs(FileConfiguration config)
+        {
+            var json = JsonConvert.SerializeObject(config, Formatting.Indented);
+
+            var bytes = Encoding.UTF8.GetBytes(json);
+
+            _kvEndpoint
+                .Verify(x => x.Put(It.Is<KVPair>(k => k.Value.SequenceEqual(bytes)), It.IsAny<CancellationToken>()), Times.Once);
+        }
+
+        private async Task WhenISetTheConfiguration()
+        {
+            _setResult = await _repo.Set(_fileConfiguration);
+        }
+
+        private void GivenIHaveAConfiguration(FileConfiguration config)
+        {
+            _fileConfiguration = config;
+        }
+        
+        private FileConfiguration FakeFileConfiguration()
+        {
+            var reRoutes = new List<FileReRoute>
+            {
+                new FileReRoute
+                {
+                    DownstreamHostAndPorts = new List<FileHostAndPort>
+                    {
+                        new FileHostAndPort
+                        {
+                            Host = "123.12.12.12",
+                            Port = 80,
+                        }
+                    },
+                    DownstreamScheme = "https",
+                    DownstreamPathTemplate = "/asdfs/test/{test}"
+                }
+            };
+
+            var globalConfiguration = new FileGlobalConfiguration
+            {
+                ServiceDiscoveryProvider = new FileServiceDiscoveryProvider
+                {
+                    Port = 198,
+                    Host = "blah"
+                }
+            };
+
+            return new FileConfiguration
+            {
+                GlobalConfiguration = globalConfiguration,
+                ReRoutes = reRoutes
+            };
+        }
+    }
+}

test/Ocelot.UnitTests/LoadBalancer/CookieStickySessionsTests.cs

@@ -0,0 +1,276 @@
+namespace Ocelot.UnitTests.LoadBalancer
+{
+    using System.Threading.Tasks;
+    using Ocelot.LoadBalancer.LoadBalancers;
+    using Ocelot.Responses;
+    using Ocelot.Values;
+    using Shouldly;
+    using Xunit;
+    using Moq;
+    using Microsoft.AspNetCore.Http;
+    using System.Collections.Generic;
+    using System.Collections;
+    using System.Threading;
+    using Ocelot.Middleware;
+    using Ocelot.UnitTests.Responder;
+    using TestStack.BDDfy;
+
+    public class CookieStickySessionsTests
+    {
+        private readonly CookieStickySessions _stickySessions;
+        private readonly Mock<ILoadBalancer> _loadBalancer;
+        private DownstreamContext _downstreamContext;
+        private Response<ServiceHostAndPort> _result;
+        private Response<ServiceHostAndPort> _firstHostAndPort;
+        private Response<ServiceHostAndPort> _secondHostAndPort;
+
+        public CookieStickySessionsTests()
+        {
+            _loadBalancer = new Mock<ILoadBalancer>();
+            const int defaultExpiryInMs = 100;
+            _stickySessions = new CookieStickySessions(_loadBalancer.Object, "sessionid", defaultExpiryInMs);
+            _downstreamContext = new DownstreamContext(new DefaultHttpContext());
+        }
+
+        [Fact]
+        public void should_return_host_and_port()
+        {
+            this.Given(_ => GivenTheLoadBalancerReturns())
+                .When(_ => WhenILease())
+                .Then(_ => ThenTheHostAndPortIsNotNull())
+                .BDDfy();
+        }
+
+        [Fact]
+        public void should_return_same_host_and_port()
+        {
+            this.Given(_ => GivenTheLoadBalancerReturnsSequence())
+                .And(_ => GivenTheDownstreamRequestHasSessionId("321"))
+                .When(_ => WhenILeaseTwiceInARow())
+                .Then(_ => ThenTheFirstAndSecondResponseAreTheSame())
+                .BDDfy();
+        }
+
+        [Fact]
+        public void should_return_different_host_and_port_if_load_balancer_does()
+        {
+            this.Given(_ => GivenTheLoadBalancerReturnsSequence())
+                .When(_ => WhenIMakeTwoRequetsWithDifferentSessionValues())
+                .Then(_ => ThenADifferentHostAndPortIsReturned())
+                .BDDfy();
+        }
+
+        [Fact]
+        public void should_return_error()
+        {
+            this.Given(_ => GivenTheLoadBalancerReturnsError())
+                .When(_ => WhenILease())
+                .Then(_ => ThenAnErrorIsReturned())
+                .BDDfy();
+        }
+
+        [Fact]
+        public void should_expire_sticky_session()
+        {
+            this.Given(_ => GivenTheLoadBalancerReturnsSequence())
+                .When(_ => WhenTheStickySessionExpires())
+                .Then(_ => ThenANewHostAndPortIsReturned())
+                .BDDfy();
+        }
+
+        [Fact]
+        public void should_refresh_sticky_session()
+        {
+            this.Given(_ => GivenTheLoadBalancerReturnsSequence())
+                .When(_ => WhenIMakeRequestsToKeepRefreshingTheSession())
+                .Then(_ => ThenTheSessionIsRefreshed())
+                .BDDfy();
+        }
+
+        [Fact]
+        public void should_dispose()
+        {
+            _stickySessions.Dispose();
+        }
+
+        [Fact]
+        public void should_release()
+        {
+            _stickySessions.Release(new ServiceHostAndPort("", 0));
+        }
+
+        private async Task ThenTheSessionIsRefreshed()
+        {
+            var postExpireHostAndPort = await _stickySessions.Lease(_downstreamContext);
+            postExpireHostAndPort.Data.DownstreamHost.ShouldBe("one");
+            postExpireHostAndPort.Data.DownstreamPort.ShouldBe(80);
+
+            _loadBalancer
+                .Verify(x => x.Lease(It.IsAny<DownstreamContext>()), Times.Once);
+        }
+
+        private async Task WhenIMakeRequestsToKeepRefreshingTheSession()
+        {
+            var context = new DefaultHttpContext();
+            var cookies = new FakeCookies();
+            cookies.AddCookie("sessionid", "321");
+            context.Request.Cookies = cookies;
+            _downstreamContext = new DownstreamContext(context);
+
+            var firstHostAndPort = await _stickySessions.Lease(_downstreamContext);
+            firstHostAndPort.Data.DownstreamHost.ShouldBe("one");
+            firstHostAndPort.Data.DownstreamPort.ShouldBe(80);
+
+            Thread.Sleep(80);
+
+            var secondHostAndPort = await _stickySessions.Lease(_downstreamContext);
+            secondHostAndPort.Data.DownstreamHost.ShouldBe("one");
+            secondHostAndPort.Data.DownstreamPort.ShouldBe(80);
+
+            Thread.Sleep(80);
+        }
+
+        private async Task ThenANewHostAndPortIsReturned()
+        {
+            var postExpireHostAndPort = await _stickySessions.Lease(_downstreamContext);
+            postExpireHostAndPort.Data.DownstreamHost.ShouldBe("two");
+            postExpireHostAndPort.Data.DownstreamPort.ShouldBe(80);
+        }
+
+        private async Task WhenTheStickySessionExpires()
+        {
+            var context = new DefaultHttpContext();
+            var cookies = new FakeCookies();
+            cookies.AddCookie("sessionid", "321");
+            context.Request.Cookies = cookies;
+            _downstreamContext = new DownstreamContext(context);
+
+            var firstHostAndPort = await _stickySessions.Lease(_downstreamContext);
+            var secondHostAndPort = await _stickySessions.Lease(_downstreamContext);
+
+            firstHostAndPort.Data.DownstreamHost.ShouldBe("one");
+            firstHostAndPort.Data.DownstreamPort.ShouldBe(80);
+
+            secondHostAndPort.Data.DownstreamHost.ShouldBe("one");
+            secondHostAndPort.Data.DownstreamPort.ShouldBe(80);
+
+            Thread.Sleep(150);
+        }
+
+        private void ThenAnErrorIsReturned()
+        {
+            _result.IsError.ShouldBeTrue();
+        }
+
+        private void GivenTheLoadBalancerReturnsError()
+        {
+            _loadBalancer
+                .Setup(x => x.Lease(It.IsAny<DownstreamContext>()))
+                .ReturnsAsync(new ErrorResponse<ServiceHostAndPort>(new AnyError()));
+        }
+
+        private void ThenADifferentHostAndPortIsReturned()
+        {
+            _firstHostAndPort.Data.DownstreamHost.ShouldBe("one");
+            _firstHostAndPort.Data.DownstreamPort.ShouldBe(80);
+            _secondHostAndPort.Data.DownstreamHost.ShouldBe("two");
+            _secondHostAndPort.Data.DownstreamPort.ShouldBe(80);
+        }
+
+        private async Task WhenIMakeTwoRequetsWithDifferentSessionValues()
+        {
+            var contextOne = new DefaultHttpContext();
+            var cookiesOne = new FakeCookies();
+            cookiesOne.AddCookie("sessionid", "321");
+            contextOne.Request.Cookies = cookiesOne;
+            var contextTwo = new DefaultHttpContext();
+            var cookiesTwo = new FakeCookies();
+            cookiesTwo.AddCookie("sessionid", "123");
+            contextTwo.Request.Cookies = cookiesTwo;
+            _firstHostAndPort = await _stickySessions.Lease(new DownstreamContext(contextOne));
+            _secondHostAndPort = await _stickySessions.Lease(new DownstreamContext(contextTwo));
+        }
+
+        private void GivenTheLoadBalancerReturnsSequence()
+        {
+            _loadBalancer
+                .SetupSequence(x => x.Lease(It.IsAny<DownstreamContext>()))
+                .ReturnsAsync(new OkResponse<ServiceHostAndPort>(new ServiceHostAndPort("one", 80)))
+                .ReturnsAsync(new OkResponse<ServiceHostAndPort>(new ServiceHostAndPort("two", 80)));
+        }
+
+        private void ThenTheFirstAndSecondResponseAreTheSame()
+        {
+            _firstHostAndPort.Data.DownstreamHost.ShouldBe(_secondHostAndPort.Data.DownstreamHost);
+            _firstHostAndPort.Data.DownstreamPort.ShouldBe(_secondHostAndPort.Data.DownstreamPort);
+        }
+
+        private async Task WhenILeaseTwiceInARow()
+        {
+            _firstHostAndPort = await _stickySessions.Lease(_downstreamContext);
+            _secondHostAndPort = await _stickySessions.Lease(_downstreamContext);
+        }
+
+        private void GivenTheDownstreamRequestHasSessionId(string value)
+        {
+            var context = new DefaultHttpContext();
+            var cookies = new FakeCookies();
+            cookies.AddCookie("sessionid", value);
+            context.Request.Cookies = cookies;
+            _downstreamContext = new DownstreamContext(context);
+        }
+
+        private void GivenTheLoadBalancerReturns()
+        {
+            _loadBalancer
+                .Setup(x => x.Lease(It.IsAny<DownstreamContext>()))
+                .ReturnsAsync(new OkResponse<ServiceHostAndPort>(new ServiceHostAndPort("", 80)));
+        }
+
+        private async Task WhenILease()
+        {
+            _result = await _stickySessions.Lease(_downstreamContext);
+        }
+
+        private void ThenTheHostAndPortIsNotNull()
+        {
+            _result.Data.ShouldNotBeNull();
+        }
+    }
+    
+    class FakeCookies : IRequestCookieCollection
+    {
+        private readonly Dictionary<string, string> _cookies = new Dictionary<string, string>();
+
+        public string this[string key] => _cookies[key];
+
+        public int Count => _cookies.Count;
+
+        public ICollection<string> Keys => _cookies.Keys;
+
+        public void AddCookie(string key, string value)
+        {
+            _cookies[key] = value;
+        }
+
+        public bool ContainsKey(string key)
+        {
+            return _cookies.ContainsKey(key);
+        }
+
+        public IEnumerator<KeyValuePair<string, string>> GetEnumerator()
+        {
+            return _cookies.GetEnumerator();
+        }
+
+        public bool TryGetValue(string key, out string value)
+        {
+            return _cookies.TryGetValue(key, out value);
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return _cookies.GetEnumerator();
+        }
+    }
+}

test/Ocelot.UnitTests/LoadBalancer/LeastConnectionTests.cs

@@ -1,284 +1,288 @@
-using System;
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using Ocelot.LoadBalancer.LoadBalancers;
-using Ocelot.Responses;
-using Ocelot.Values;
-using Shouldly;
-using TestStack.BDDfy;
-using Xunit;
-
-namespace Ocelot.UnitTests.LoadBalancer
-{
-    public class LeastConnectionTests
-    {
-        private ServiceHostAndPort _hostAndPort;
-        private Response<ServiceHostAndPort> _result;
-        private LeastConnection _leastConnection;
-        private List<Service> _services;
-        private Random _random;
-
-        public LeastConnectionTests()
-        {
-            _random = new Random();
-        }
-
-        [Fact]
-        public void should_be_able_to_lease_and_release_concurrently()
-        {
-            var serviceName = "products";
-
-            var availableServices = new List<Service>
-            {
-                new Service(serviceName, new ServiceHostAndPort("127.0.0.1", 80), string.Empty, string.Empty, new string[0]),
-                new Service(serviceName, new ServiceHostAndPort("127.0.0.2", 80), string.Empty, string.Empty, new string[0]),
-            };
-
-            _services = availableServices;
-            _leastConnection = new LeastConnection(() => Task.FromResult(_services), serviceName);
-
-            var tasks = new Task[100];
-           
-            for(var i = 0; i < tasks.Length; i++)
-            {
-                tasks[i] = LeaseDelayAndRelease();
-            }
-
-            Task.WaitAll(tasks);
-        }
-
-        [Fact]
-        public void should_handle_service_returning_to_available()
-        {
-            var serviceName = "products";
-
-            var availableServices = new List<Service>
-            {
-                new Service(serviceName, new ServiceHostAndPort("127.0.0.1", 80), string.Empty, string.Empty, new string[0]),
-                new Service(serviceName, new ServiceHostAndPort("127.0.0.2", 80), string.Empty, string.Empty, new string[0]),
-            };
-
-            _leastConnection = new LeastConnection(() => Task.FromResult(availableServices), serviceName);
-
-            var hostAndPortOne = _leastConnection.Lease().Result;
-            hostAndPortOne.Data.DownstreamHost.ShouldBe("127.0.0.1");
-            var hostAndPortTwo = _leastConnection.Lease().Result;
-            hostAndPortTwo.Data.DownstreamHost.ShouldBe("127.0.0.2");
-            _leastConnection.Release(hostAndPortOne.Data);
-            _leastConnection.Release(hostAndPortTwo.Data);
-
-            availableServices = new List<Service>
-            {
-                new Service(serviceName, new ServiceHostAndPort("127.0.0.1", 80), string.Empty, string.Empty, new string[0]),
-            };
-
-            hostAndPortOne = _leastConnection.Lease().Result;
-            hostAndPortOne.Data.DownstreamHost.ShouldBe("127.0.0.1");
-            hostAndPortTwo = _leastConnection.Lease().Result;
-            hostAndPortTwo.Data.DownstreamHost.ShouldBe("127.0.0.1");
-            _leastConnection.Release(hostAndPortOne.Data);
-            _leastConnection.Release(hostAndPortTwo.Data);
-
-            availableServices = new List<Service>
-            {
-                new Service(serviceName, new ServiceHostAndPort("127.0.0.1", 80), string.Empty, string.Empty, new string[0]),
-                new Service(serviceName, new ServiceHostAndPort("127.0.0.2", 80), string.Empty, string.Empty, new string[0]),
-            };
-
-            hostAndPortOne = _leastConnection.Lease().Result;
-            hostAndPortOne.Data.DownstreamHost.ShouldBe("127.0.0.1");
-            hostAndPortTwo = _leastConnection.Lease().Result;
-            hostAndPortTwo.Data.DownstreamHost.ShouldBe("127.0.0.2");
-            _leastConnection.Release(hostAndPortOne.Data);
-            _leastConnection.Release(hostAndPortTwo.Data);
-        }
-
-        private async Task LeaseDelayAndRelease()
-        {
-            var hostAndPort = await _leastConnection.Lease();
-            await Task.Delay(_random.Next(1, 100));
-            _leastConnection.Release(hostAndPort.Data);
-        }
-
-        [Fact]
-        public void should_get_next_url()
-        {
-            var serviceName = "products";
-
-            var hostAndPort = new ServiceHostAndPort("localhost", 80);
-
-            var availableServices = new List<Service>
-            {
-                new Service(serviceName, hostAndPort, string.Empty, string.Empty, new string[0])
-            };
-
-            this.Given(x => x.GivenAHostAndPort(hostAndPort))
-            .And(x => x.GivenTheLoadBalancerStarts(availableServices, serviceName))
-            .When(x => x.WhenIGetTheNextHostAndPort())
-            .Then(x => x.ThenTheNextHostAndPortIsReturned())
-            .BDDfy();
-        }
-
-        [Fact]
-        public void should_serve_from_service_with_least_connections()
-        {
-            var serviceName = "products";
-
-            var availableServices = new List<Service>
-            {
-                new Service(serviceName, new ServiceHostAndPort("127.0.0.1", 80), string.Empty, string.Empty, new string[0]),
-                new Service(serviceName, new ServiceHostAndPort("127.0.0.2", 80), string.Empty, string.Empty, new string[0]),
-                new Service(serviceName, new ServiceHostAndPort("127.0.0.3", 80), string.Empty, string.Empty, new string[0])
-            };
-
-            _services = availableServices;
-            _leastConnection = new LeastConnection(() => Task.FromResult(_services), serviceName);
-
-            var response = _leastConnection.Lease().Result;
-
-            response.Data.DownstreamHost.ShouldBe(availableServices[0].HostAndPort.DownstreamHost);
-
-            response = _leastConnection.Lease().Result;
-
-            response.Data.DownstreamHost.ShouldBe(availableServices[1].HostAndPort.DownstreamHost);
-
-            response = _leastConnection.Lease().Result;
-
-            response.Data.DownstreamHost.ShouldBe(availableServices[2].HostAndPort.DownstreamHost);
-        }
-
-        [Fact]
-        public void should_build_connections_per_service()
-        {
-             var serviceName = "products";
-
-            var availableServices = new List<Service>
-            {
-                new Service(serviceName, new ServiceHostAndPort("127.0.0.1", 80), string.Empty, string.Empty, new string[0]),
-                new Service(serviceName, new ServiceHostAndPort("127.0.0.2", 80), string.Empty, string.Empty, new string[0]),
-            };
-
-            _services = availableServices;
-            _leastConnection = new LeastConnection(() => Task.FromResult(_services), serviceName);
-
-            var response = _leastConnection.Lease().Result;
-
-            response.Data.DownstreamHost.ShouldBe(availableServices[0].HostAndPort.DownstreamHost);
-
-            response = _leastConnection.Lease().Result;
-
-            response.Data.DownstreamHost.ShouldBe(availableServices[1].HostAndPort.DownstreamHost);
-
-            response = _leastConnection.Lease().Result;
-
-            response.Data.DownstreamHost.ShouldBe(availableServices[0].HostAndPort.DownstreamHost);
-
-            response = _leastConnection.Lease().Result;
-
-            response.Data.DownstreamHost.ShouldBe(availableServices[1].HostAndPort.DownstreamHost);
-        }
-
-        [Fact]
-        public void should_release_connection()
-        {
-             var serviceName = "products";
-
-            var availableServices = new List<Service>
-            {
-                new Service(serviceName, new ServiceHostAndPort("127.0.0.1", 80), string.Empty, string.Empty, new string[0]),
-                new Service(serviceName, new ServiceHostAndPort("127.0.0.2", 80), string.Empty, string.Empty, new string[0]),
-            };
-
-            _services = availableServices;
-            _leastConnection = new LeastConnection(() => Task.FromResult(_services), serviceName);
-
-            var response = _leastConnection.Lease().Result;
-
-            response.Data.DownstreamHost.ShouldBe(availableServices[0].HostAndPort.DownstreamHost);
-
-            response = _leastConnection.Lease().Result;
-
-            response.Data.DownstreamHost.ShouldBe(availableServices[1].HostAndPort.DownstreamHost);
-
-            response = _leastConnection.Lease().Result;
-
-            response.Data.DownstreamHost.ShouldBe(availableServices[0].HostAndPort.DownstreamHost);
-
-            response = _leastConnection.Lease().Result;
-
-            response.Data.DownstreamHost.ShouldBe(availableServices[1].HostAndPort.DownstreamHost);
-
-            //release this so 2 should have 1 connection and we should get 2 back as our next host and port
-            _leastConnection.Release(availableServices[1].HostAndPort);
-
-            response = _leastConnection.Lease().Result;
-
-            response.Data.DownstreamHost.ShouldBe(availableServices[1].HostAndPort.DownstreamHost);
-        }
-
-        [Fact]
-        public void should_return_error_if_services_are_null()
-        {
-            var serviceName = "products";
-
-            var hostAndPort = new ServiceHostAndPort("localhost", 80);
-               this.Given(x => x.GivenAHostAndPort(hostAndPort))
-                .And(x => x.GivenTheLoadBalancerStarts(null, serviceName))
-                .When(x => x.WhenIGetTheNextHostAndPort())
-                .Then(x => x.ThenServiceAreNullErrorIsReturned())
-                .BDDfy();
-        }
-
-        [Fact]
-        public void should_return_error_if_services_are_empty()
-        {
-            var serviceName = "products";
-
-            var hostAndPort = new ServiceHostAndPort("localhost", 80);
-               this.Given(x => x.GivenAHostAndPort(hostAndPort))
-                .And(x => x.GivenTheLoadBalancerStarts(new List<Service>(), serviceName))
-                .When(x => x.WhenIGetTheNextHostAndPort())
-                .Then(x => x.ThenServiceAreEmptyErrorIsReturned())
-                .BDDfy();
-        }
-
-        private void ThenServiceAreNullErrorIsReturned()
-        {
-            _result.IsError.ShouldBeTrue();
-            _result.Errors[0].ShouldBeOfType<ServicesAreNullError>();
-        }
-
-        private void ThenServiceAreEmptyErrorIsReturned()
-        {
-            _result.IsError.ShouldBeTrue();
-            _result.Errors[0].ShouldBeOfType<ServicesAreEmptyError>();
-        }
-
-        private void GivenTheLoadBalancerStarts(List<Service> services, string serviceName)
-        {
-            _services = services;
-            _leastConnection = new LeastConnection(() => Task.FromResult(_services), serviceName);
-        }
-
-        private void WhenTheLoadBalancerStarts(List<Service> services, string serviceName)
-        {
-            GivenTheLoadBalancerStarts(services, serviceName);
-        }
-
-        private void GivenAHostAndPort(ServiceHostAndPort hostAndPort)
-        {
-            _hostAndPort = hostAndPort;
-        }
-
-        private void WhenIGetTheNextHostAndPort()
-        {
-            _result = _leastConnection.Lease().Result;
-        }
-
-        private void ThenTheNextHostAndPortIsReturned()
-        {
-            _result.Data.DownstreamHost.ShouldBe(_hostAndPort.DownstreamHost);
-            _result.Data.DownstreamPort.ShouldBe(_hostAndPort.DownstreamPort);
-        }
-    }
-}
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Http;
+using Ocelot.LoadBalancer.LoadBalancers;
+using Ocelot.Middleware;
+using Ocelot.Responses;
+using Ocelot.Values;
+using Shouldly;
+using TestStack.BDDfy;
+using Xunit;
+
+namespace Ocelot.UnitTests.LoadBalancer
+{
+    public class LeastConnectionTests
+    {
+        private ServiceHostAndPort _hostAndPort;
+        private Response<ServiceHostAndPort> _result;
+        private LeastConnection _leastConnection;
+        private List<Service> _services;
+        private Random _random;
+        private DownstreamContext _context;
+
+        public LeastConnectionTests()
+        {
+            _context = new DownstreamContext(new DefaultHttpContext());
+            _random = new Random();
+        }
+
+        [Fact]
+        public void should_be_able_to_lease_and_release_concurrently()
+        {
+            var serviceName = "products";
+
+            var availableServices = new List<Service>
+            {
+                new Service(serviceName, new ServiceHostAndPort("127.0.0.1", 80), string.Empty, string.Empty, new string[0]),
+                new Service(serviceName, new ServiceHostAndPort("127.0.0.2", 80), string.Empty, string.Empty, new string[0]),
+            };
+
+            _services = availableServices;
+            _leastConnection = new LeastConnection(() => Task.FromResult(_services), serviceName);
+
+            var tasks = new Task[100];
+           
+            for(var i = 0; i < tasks.Length; i++)
+            {
+                tasks[i] = LeaseDelayAndRelease();
+            }
+
+            Task.WaitAll(tasks);
+        }
+
+        [Fact]
+        public void should_handle_service_returning_to_available()
+        {
+            var serviceName = "products";
+
+            var availableServices = new List<Service>
+            {
+                new Service(serviceName, new ServiceHostAndPort("127.0.0.1", 80), string.Empty, string.Empty, new string[0]),
+                new Service(serviceName, new ServiceHostAndPort("127.0.0.2", 80), string.Empty, string.Empty, new string[0]),
+            };
+
+            _leastConnection = new LeastConnection(() => Task.FromResult(availableServices), serviceName);
+
+            var hostAndPortOne = _leastConnection.Lease(_context).Result;
+            hostAndPortOne.Data.DownstreamHost.ShouldBe("127.0.0.1");
+            var hostAndPortTwo = _leastConnection.Lease(_context).Result;
+            hostAndPortTwo.Data.DownstreamHost.ShouldBe("127.0.0.2");
+            _leastConnection.Release(hostAndPortOne.Data);
+            _leastConnection.Release(hostAndPortTwo.Data);
+
+            availableServices = new List<Service>
+            {
+                new Service(serviceName, new ServiceHostAndPort("127.0.0.1", 80), string.Empty, string.Empty, new string[0]),
+            };
+
+            hostAndPortOne = _leastConnection.Lease(_context).Result;
+            hostAndPortOne.Data.DownstreamHost.ShouldBe("127.0.0.1");
+            hostAndPortTwo = _leastConnection.Lease(_context).Result;
+            hostAndPortTwo.Data.DownstreamHost.ShouldBe("127.0.0.1");
+            _leastConnection.Release(hostAndPortOne.Data);
+            _leastConnection.Release(hostAndPortTwo.Data);
+
+            availableServices = new List<Service>
+            {
+                new Service(serviceName, new ServiceHostAndPort("127.0.0.1", 80), string.Empty, string.Empty, new string[0]),
+                new Service(serviceName, new ServiceHostAndPort("127.0.0.2", 80), string.Empty, string.Empty, new string[0]),
+            };
+
+            hostAndPortOne = _leastConnection.Lease(_context).Result;
+            hostAndPortOne.Data.DownstreamHost.ShouldBe("127.0.0.1");
+            hostAndPortTwo = _leastConnection.Lease(_context).Result;
+            hostAndPortTwo.Data.DownstreamHost.ShouldBe("127.0.0.2");
+            _leastConnection.Release(hostAndPortOne.Data);
+            _leastConnection.Release(hostAndPortTwo.Data);
+        }
+
+        private async Task LeaseDelayAndRelease()
+        {
+            var hostAndPort = await _leastConnection.Lease(_context);
+            await Task.Delay(_random.Next(1, 100));
+            _leastConnection.Release(hostAndPort.Data);
+        }
+
+        [Fact]
+        public void should_get_next_url()
+        {
+            var serviceName = "products";
+
+            var hostAndPort = new ServiceHostAndPort("localhost", 80);
+
+            var availableServices = new List<Service>
+            {
+                new Service(serviceName, hostAndPort, string.Empty, string.Empty, new string[0])
+            };
+
+            this.Given(x => x.GivenAHostAndPort(hostAndPort))
+            .And(x => x.GivenTheLoadBalancerStarts(availableServices, serviceName))
+            .When(x => x.WhenIGetTheNextHostAndPort())
+            .Then(x => x.ThenTheNextHostAndPortIsReturned())
+            .BDDfy();
+        }
+
+        [Fact]
+        public void should_serve_from_service_with_least_connections()
+        {
+            var serviceName = "products";
+
+            var availableServices = new List<Service>
+            {
+                new Service(serviceName, new ServiceHostAndPort("127.0.0.1", 80), string.Empty, string.Empty, new string[0]),
+                new Service(serviceName, new ServiceHostAndPort("127.0.0.2", 80), string.Empty, string.Empty, new string[0]),
+                new Service(serviceName, new ServiceHostAndPort("127.0.0.3", 80), string.Empty, string.Empty, new string[0])
+            };
+
+            _services = availableServices;
+            _leastConnection = new LeastConnection(() => Task.FromResult(_services), serviceName);
+
+            var response = _leastConnection.Lease(_context).Result;
+
+            response.Data.DownstreamHost.ShouldBe(availableServices[0].HostAndPort.DownstreamHost);
+
+            response = _leastConnection.Lease(_context).Result;
+
+            response.Data.DownstreamHost.ShouldBe(availableServices[1].HostAndPort.DownstreamHost);
+
+            response = _leastConnection.Lease(_context).Result;
+
+            response.Data.DownstreamHost.ShouldBe(availableServices[2].HostAndPort.DownstreamHost);
+        }
+
+        [Fact]
+        public void should_build_connections_per_service()
+        {
+             var serviceName = "products";
+
+            var availableServices = new List<Service>
+            {
+                new Service(serviceName, new ServiceHostAndPort("127.0.0.1", 80), string.Empty, string.Empty, new string[0]),
+                new Service(serviceName, new ServiceHostAndPort("127.0.0.2", 80), string.Empty, string.Empty, new string[0]),
+            };
+
+            _services = availableServices;
+            _leastConnection = new LeastConnection(() => Task.FromResult(_services), serviceName);
+
+            var response = _leastConnection.Lease(_context).Result;
+
+            response.Data.DownstreamHost.ShouldBe(availableServices[0].HostAndPort.DownstreamHost);
+
+            response = _leastConnection.Lease(_context).Result;
+
+            response.Data.DownstreamHost.ShouldBe(availableServices[1].HostAndPort.DownstreamHost);
+
+            response = _leastConnection.Lease(_context).Result;
+
+            response.Data.DownstreamHost.ShouldBe(availableServices[0].HostAndPort.DownstreamHost);
+
+            response = _leastConnection.Lease(_context).Result;
+
+            response.Data.DownstreamHost.ShouldBe(availableServices[1].HostAndPort.DownstreamHost);
+        }
+
+        [Fact]
+        public void should_release_connection()
+        {
+             var serviceName = "products";
+
+            var availableServices = new List<Service>
+            {
+                new Service(serviceName, new ServiceHostAndPort("127.0.0.1", 80), string.Empty, string.Empty, new string[0]),
+                new Service(serviceName, new ServiceHostAndPort("127.0.0.2", 80), string.Empty, string.Empty, new string[0]),
+            };
+
+            _services = availableServices;
+            _leastConnection = new LeastConnection(() => Task.FromResult(_services), serviceName);
+
+            var response = _leastConnection.Lease(_context).Result;
+
+            response.Data.DownstreamHost.ShouldBe(availableServices[0].HostAndPort.DownstreamHost);
+
+            response = _leastConnection.Lease(_context).Result;
+
+            response.Data.DownstreamHost.ShouldBe(availableServices[1].HostAndPort.DownstreamHost);
+
+            response = _leastConnection.Lease(_context).Result;
+
+            response.Data.DownstreamHost.ShouldBe(availableServices[0].HostAndPort.DownstreamHost);
+
+            response = _leastConnection.Lease(_context).Result;
+
+            response.Data.DownstreamHost.ShouldBe(availableServices[1].HostAndPort.DownstreamHost);
+
+            //release this so 2 should have 1 connection and we should get 2 back as our next host and port
+            _leastConnection.Release(availableServices[1].HostAndPort);
+
+            response = _leastConnection.Lease(_context).Result;
+
+            response.Data.DownstreamHost.ShouldBe(availableServices[1].HostAndPort.DownstreamHost);
+        }
+
+        [Fact]
+        public void should_return_error_if_services_are_null()
+        {
+            var serviceName = "products";
+
+            var hostAndPort = new ServiceHostAndPort("localhost", 80);
+               this.Given(x => x.GivenAHostAndPort(hostAndPort))
+                .And(x => x.GivenTheLoadBalancerStarts(null, serviceName))
+                .When(x => x.WhenIGetTheNextHostAndPort())
+                .Then(x => x.ThenServiceAreNullErrorIsReturned())
+                .BDDfy();
+        }
+
+        [Fact]
+        public void should_return_error_if_services_are_empty()
+        {
+            var serviceName = "products";
+
+            var hostAndPort = new ServiceHostAndPort("localhost", 80);
+               this.Given(x => x.GivenAHostAndPort(hostAndPort))
+                .And(x => x.GivenTheLoadBalancerStarts(new List<Service>(), serviceName))
+                .When(x => x.WhenIGetTheNextHostAndPort())
+                .Then(x => x.ThenServiceAreEmptyErrorIsReturned())
+                .BDDfy();
+        }
+
+        private void ThenServiceAreNullErrorIsReturned()
+        {
+            _result.IsError.ShouldBeTrue();
+            _result.Errors[0].ShouldBeOfType<ServicesAreNullError>();
+        }
+
+        private void ThenServiceAreEmptyErrorIsReturned()
+        {
+            _result.IsError.ShouldBeTrue();
+            _result.Errors[0].ShouldBeOfType<ServicesAreEmptyError>();
+        }
+
+        private void GivenTheLoadBalancerStarts(List<Service> services, string serviceName)
+        {
+            _services = services;
+            _leastConnection = new LeastConnection(() => Task.FromResult(_services), serviceName);
+        }
+
+        private void WhenTheLoadBalancerStarts(List<Service> services, string serviceName)
+        {
+            GivenTheLoadBalancerStarts(services, serviceName);
+        }
+
+        private void GivenAHostAndPort(ServiceHostAndPort hostAndPort)
+        {
+            _hostAndPort = hostAndPort;
+        }
+
+        private void WhenIGetTheNextHostAndPort()
+        {
+            _result = _leastConnection.Lease(_context).Result;
+        }
+
+        private void ThenTheNextHostAndPortIsReturned()
+        {
+            _result.Data.DownstreamHost.ShouldBe(_hostAndPort.DownstreamHost);
+            _result.Data.DownstreamPort.ShouldBe(_hostAndPort.DownstreamPort);
+        }
+    }
+}

test/Ocelot.UnitTests/LoadBalancer/LoadBalancerFactoryTests.cs

@@ -1,126 +1,142 @@
-using Moq;
-using Ocelot.Configuration;
-using Ocelot.Configuration.Builder;
-using Ocelot.LoadBalancer.LoadBalancers;
-using Ocelot.ServiceDiscovery;
-using Shouldly;
-using System.Collections.Generic;
-using Ocelot.ServiceDiscovery.Providers;
-using TestStack.BDDfy;
-using Xunit;
-
-namespace Ocelot.UnitTests.LoadBalancer
-{
-    public class LoadBalancerFactoryTests
-    {
-        private DownstreamReRoute _reRoute;
-        private LoadBalancerFactory _factory;
-        private ILoadBalancer _result;
-        private Mock<IServiceDiscoveryProviderFactory> _serviceProviderFactory;
-        private Mock<IServiceDiscoveryProvider> _serviceProvider;
-        private ServiceProviderConfiguration _serviceProviderConfig;
-
-        public LoadBalancerFactoryTests()
-        {
-            _serviceProviderFactory = new Mock<IServiceDiscoveryProviderFactory>();
-            _serviceProvider = new Mock<IServiceDiscoveryProvider>();
-            _factory = new LoadBalancerFactory(_serviceProviderFactory.Object);
-        }
-
-        [Fact]
-        public void should_return_no_load_balancer()
-        {
-            var reRoute = new DownstreamReRouteBuilder()
-                .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>())
-                .BDDfy();
-        }
-
-        [Fact]
-        public void should_return_round_robin_load_balancer()
-        {
-            var reRoute = new DownstreamReRouteBuilder()
-                .WithLoadBalancer("RoundRobin")
-                .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<RoundRobin>())
-                .BDDfy();
-        }
-
-        [Fact]
-        public void should_return_round_least_connection_balancer()
-        {
-            var reRoute = new DownstreamReRouteBuilder()
-                .WithLoadBalancer("LeastConnection")
-                .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<LeastConnection>())
-                .BDDfy();
-        }
-
-        [Fact]
-        public void should_call_service_provider()
-        {
-            var reRoute = new DownstreamReRouteBuilder()
-                .WithLoadBalancer("RoundRobin")
-                .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.ThenTheServiceProviderIsCalledCorrectly())
-                .BDDfy();
-        }
-
-        private void GivenAServiceProviderConfig(ServiceProviderConfiguration serviceProviderConfig)
-        {
-            _serviceProviderConfig = serviceProviderConfig;
-        }
-
-        private void GivenTheServiceProviderFactoryReturns()
-        {
-            _serviceProviderFactory
-                .Setup(x => x.Get(It.IsAny<ServiceProviderConfiguration>(), It.IsAny<DownstreamReRoute>()))
-                .Returns(_serviceProvider.Object);
-        }
-
-        private void ThenTheServiceProviderIsCalledCorrectly()
-        {
-            _serviceProviderFactory
-                .Verify(x => x.Get(It.IsAny<ServiceProviderConfiguration>(), It.IsAny<DownstreamReRoute>()), Times.Once);
-        }
-
-        private void GivenAReRoute(DownstreamReRoute reRoute)
-        {
-            _reRoute = reRoute;
-        }
-
-        private void WhenIGetTheLoadBalancer()
-        {
-            _result = _factory.Get(_reRoute, _serviceProviderConfig).Result;
-        }
-
-        private void ThenTheLoadBalancerIsReturned<T>()
-        {
-            _result.ShouldBeOfType<T>();
-        }
-    }
-}
+using Moq;
+using Ocelot.Configuration;
+using Ocelot.Configuration.Builder;
+using Ocelot.LoadBalancer.LoadBalancers;
+using Ocelot.ServiceDiscovery;
+using Shouldly;
+using System.Collections.Generic;
+using Ocelot.ServiceDiscovery.Providers;
+using TestStack.BDDfy;
+using Xunit;
+
+namespace Ocelot.UnitTests.LoadBalancer
+{
+    public class LoadBalancerFactoryTests
+    {
+        private DownstreamReRoute _reRoute;
+        private readonly LoadBalancerFactory _factory;
+        private ILoadBalancer _result;
+        private readonly Mock<IServiceDiscoveryProviderFactory> _serviceProviderFactory;
+        private readonly Mock<IServiceDiscoveryProvider> _serviceProvider;
+        private ServiceProviderConfiguration _serviceProviderConfig;
+
+        public LoadBalancerFactoryTests()
+        {
+            _serviceProviderFactory = new Mock<IServiceDiscoveryProviderFactory>();
+            _serviceProvider = new Mock<IServiceDiscoveryProvider>();
+            _factory = new LoadBalancerFactory(_serviceProviderFactory.Object);
+        }
+
+        [Fact]
+        public void should_return_no_load_balancer()
+        {
+            var reRoute = new DownstreamReRouteBuilder()
+                .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>())
+                .BDDfy();
+        }
+
+        [Fact]
+        public void should_return_round_robin_load_balancer()
+        {
+            var reRoute = new DownstreamReRouteBuilder()
+                .WithLoadBalancerOptions(new LoadBalancerOptions("RoundRobin", "", 0))
+                .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<RoundRobin>())
+                .BDDfy();
+        }
+
+        [Fact]
+        public void should_return_round_least_connection_balancer()
+        {
+            var reRoute = new DownstreamReRouteBuilder()
+                .WithLoadBalancerOptions(new LoadBalancerOptions("LeastConnection", "", 0))
+                .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<LeastConnection>())
+                .BDDfy();
+        }
+
+        [Fact]
+        public void should_call_service_provider()
+        {
+            var reRoute = new DownstreamReRouteBuilder()
+                .WithLoadBalancerOptions(new LoadBalancerOptions("RoundRobin", "", 0))
+                .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.ThenTheServiceProviderIsCalledCorrectly())
+                .BDDfy();
+        }
+
+        [Fact]
+        public void should_return_sticky_session()
+        {
+            var reRoute = new DownstreamReRouteBuilder()
+                .WithLoadBalancerOptions(new LoadBalancerOptions("CookieStickySessions", "", 0))
+                .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<CookieStickySessions>())
+                .BDDfy();
+        }
+
+        private void GivenAServiceProviderConfig(ServiceProviderConfiguration serviceProviderConfig)
+        {
+            _serviceProviderConfig = serviceProviderConfig;
+        }
+
+        private void GivenTheServiceProviderFactoryReturns()
+        {
+            _serviceProviderFactory
+                .Setup(x => x.Get(It.IsAny<ServiceProviderConfiguration>(), It.IsAny<DownstreamReRoute>()))
+                .Returns(_serviceProvider.Object);
+        }
+
+        private void ThenTheServiceProviderIsCalledCorrectly()
+        {
+            _serviceProviderFactory
+                .Verify(x => x.Get(It.IsAny<ServiceProviderConfiguration>(), It.IsAny<DownstreamReRoute>()), Times.Once);
+        }
+
+        private void GivenAReRoute(DownstreamReRoute reRoute)
+        {
+            _reRoute = reRoute;
+        }
+
+        private void WhenIGetTheLoadBalancer()
+        {
+            _result = _factory.Get(_reRoute, _serviceProviderConfig).Result;
+        }
+
+        private void ThenTheLoadBalancerIsReturned<T>()
+        {
+            _result.ShouldBeOfType<T>();
+        }
+    }
+}

test/Ocelot.UnitTests/LoadBalancer/LoadBalancerHouseTests.cs

@@ -1,163 +1,182 @@
-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;
-using Shouldly;
-using TestStack.BDDfy;
-using Xunit;
-
-namespace Ocelot.UnitTests.LoadBalancer
-{
-    public class LoadBalancerHouseTests
-    {
-        private DownstreamReRoute _reRoute;
-        private ILoadBalancer _loadBalancer;
-        private readonly LoadBalancerHouse _loadBalancerHouse;
-        private Response<ILoadBalancer> _getResult;
-        private readonly Mock<ILoadBalancerFactory> _factory;
-        private readonly ServiceProviderConfiguration _serviceProviderConfig;
-
-        public LoadBalancerHouseTests()
-        {
-            _factory = new Mock<ILoadBalancerFactory>();
-            _loadBalancerHouse = new LoadBalancerHouse(_factory.Object);
-            _serviceProviderConfig = new ServiceProviderConfiguration("myType","myHost",123, string.Empty);
-        }
-
-        [Fact]
-        public void should_store_load_balancer_on_first_request()
-        {
-            var reRoute = new DownstreamReRouteBuilder().WithReRouteKey("test").Build();
-
-            this.Given(x => x.GivenThereIsALoadBalancer(reRoute, new FakeLoadBalancer()))
-                .Then(x => x.ThenItIsAdded())
-                .BDDfy();
-        }
-
-        [Fact]
-        public void should_not_store_load_balancer_on_second_request()
-        {
-            var reRoute = new DownstreamReRouteBuilder().WithLoadBalancer("FakeLoadBalancer").WithReRouteKey("test").Build();
-
-            this.Given(x => x.GivenThereIsALoadBalancer(reRoute, new FakeLoadBalancer()))
-                .When(x => x.WhenWeGetTheLoadBalancer(reRoute))
-                .Then(x => x.ThenItIsReturned())
-                .BDDfy();
-        }
-
-        [Fact]
-        public void should_store_load_balancers_by_key()
-        {
-            var reRoute = new DownstreamReRouteBuilder().WithLoadBalancer("FakeLoadBalancer").WithReRouteKey("test").Build();
-            var reRouteTwo = new DownstreamReRouteBuilder().WithLoadBalancer("FakeRoundRobinLoadBalancer").WithReRouteKey("testtwo").Build();
-
-            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(reRouteTwo))
-                .Then(x => x.ThenTheLoadBalancerIs<FakeRoundRobinLoadBalancer>())
-                .BDDfy();
-        }
-
-        [Fact]
-        public void should_return_error_if_exception()
-        {
-            var reRoute = new DownstreamReRouteBuilder().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 DownstreamReRouteBuilder().WithLoadBalancer("FakeLoadBalancer").WithReRouteKey("test").Build();
-
-            var reRouteTwo = new DownstreamReRouteBuilder().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<LeastConnection>())
-                .BDDfy();
-        }
-
-        private void WhenIGetTheReRouteWithTheSameKeyButDifferentLoadBalancer(DownstreamReRoute reRoute)
-        {
-            _reRoute = reRoute;
-            _factory.Setup(x => x.Get(_reRoute, _serviceProviderConfig)).ReturnsAsync(new LeastConnection(null, null));
-            _getResult = _loadBalancerHouse.Get(_reRoute, _serviceProviderConfig).Result;
-        }
-
-         private void ThenAnErrorIsReturned()
-        {
-            _getResult.IsError.ShouldBeTrue();
-            _getResult.Errors[0].ShouldBeOfType<UnableToFindLoadBalancerError>();
-        }
-
-        private void ThenTheLoadBalancerIs<T>()
-        {
-            _getResult.Data.ShouldBeOfType<T>();
-        }
-
-        private void ThenItIsAdded()
-        {
-            _getResult.IsError.ShouldBe(false);
-            _getResult.ShouldBeOfType<OkResponse<ILoadBalancer>>();
-            _getResult.Data.ShouldBe(_loadBalancer);
-            _factory.Verify(x => x.Get(_reRoute, _serviceProviderConfig), Times.Once);
-        }
-
-        private void GivenThereIsALoadBalancer(DownstreamReRoute reRoute, ILoadBalancer loadBalancer)
-        {
-            _reRoute = reRoute;
-            _loadBalancer = loadBalancer;
-            _factory.Setup(x => x.Get(_reRoute, _serviceProviderConfig)).ReturnsAsync(loadBalancer);
-            _getResult = _loadBalancerHouse.Get(reRoute, _serviceProviderConfig).Result;
-        }
-
-        private void WhenWeGetTheLoadBalancer(DownstreamReRoute reRoute)
-        {
-            _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
-        {
-            public Task<Response<ServiceHostAndPort>> Lease()
-            {
-                throw new NotImplementedException();
-            }
-
-            public void Release(ServiceHostAndPort hostAndPort)
-            {
-                throw new NotImplementedException();
-            }
-        }
-
-        class FakeRoundRobinLoadBalancer : ILoadBalancer
-        {
-            public Task<Response<ServiceHostAndPort>> Lease()
-            {
-                throw new NotImplementedException();
-            }
-
-            public void Release(ServiceHostAndPort hostAndPort)
-            {
-                throw new NotImplementedException();
-            }
-        }
-    }
-}
+using System;
+using System.Threading.Tasks;
+using Moq;
+using Ocelot.Configuration;
+using Ocelot.Configuration.Builder;
+using Ocelot.LoadBalancer.LoadBalancers;
+using Ocelot.Middleware;
+using Ocelot.Responses;
+using Ocelot.Values;
+using Shouldly;
+using TestStack.BDDfy;
+using Xunit;
+
+namespace Ocelot.UnitTests.LoadBalancer
+{
+    public class LoadBalancerHouseTests
+    {
+        private DownstreamReRoute _reRoute;
+        private ILoadBalancer _loadBalancer;
+        private readonly LoadBalancerHouse _loadBalancerHouse;
+        private Response<ILoadBalancer> _getResult;
+        private readonly Mock<ILoadBalancerFactory> _factory;
+        private readonly ServiceProviderConfiguration _serviceProviderConfig;
+
+        public LoadBalancerHouseTests()
+        {
+            _factory = new Mock<ILoadBalancerFactory>();
+            _loadBalancerHouse = new LoadBalancerHouse(_factory.Object);
+            _serviceProviderConfig = new ServiceProviderConfiguration("myType","myHost",123, string.Empty);
+        }
+
+        [Fact]
+        public void should_store_load_balancer_on_first_request()
+        {
+            var reRoute = new DownstreamReRouteBuilder()
+                .WithReRouteKey("test")
+                .Build();
+
+            this.Given(x => x.GivenThereIsALoadBalancer(reRoute, new FakeLoadBalancer()))
+                .Then(x => x.ThenItIsAdded())
+                .BDDfy();
+        }
+
+        [Fact]
+        public void should_not_store_load_balancer_on_second_request()
+        {
+            var reRoute = new DownstreamReRouteBuilder()
+                .WithLoadBalancerOptions(new LoadBalancerOptions("FakeLoadBalancer", "", 0))
+                .WithReRouteKey("test")
+                .Build();
+
+            this.Given(x => x.GivenThereIsALoadBalancer(reRoute, new FakeLoadBalancer()))
+                .When(x => x.WhenWeGetTheLoadBalancer(reRoute))
+                .Then(x => x.ThenItIsReturned())
+                .BDDfy();
+        }
+
+        [Fact]
+        public void should_store_load_balancers_by_key()
+        {
+            var reRoute = new DownstreamReRouteBuilder()
+                .WithLoadBalancerOptions(new LoadBalancerOptions("FakeLoadBalancer", "", 0))
+                .WithReRouteKey("test")
+                .Build();
+            
+            var reRouteTwo = new DownstreamReRouteBuilder()
+                .WithLoadBalancerOptions(new LoadBalancerOptions("FakeRoundRobinLoadBalancer", "", 0))
+                .WithReRouteKey("testtwo")
+                .Build();
+
+            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(reRouteTwo))
+                .Then(x => x.ThenTheLoadBalancerIs<FakeRoundRobinLoadBalancer>())
+                .BDDfy();
+        }
+
+        [Fact]
+        public void should_return_error_if_exception()
+        {
+            var reRoute = new DownstreamReRouteBuilder().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 DownstreamReRouteBuilder()
+                .WithLoadBalancerOptions(new LoadBalancerOptions("FakeLoadBalancer", "", 0))
+                .WithReRouteKey("test")
+                .Build();
+
+            var reRouteTwo = new DownstreamReRouteBuilder()
+                .WithLoadBalancerOptions(new LoadBalancerOptions("LeastConnection", "", 0))
+                .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<LeastConnection>())
+                .BDDfy();
+        }
+
+        private void WhenIGetTheReRouteWithTheSameKeyButDifferentLoadBalancer(DownstreamReRoute reRoute)
+        {
+            _reRoute = reRoute;
+            _factory.Setup(x => x.Get(_reRoute, _serviceProviderConfig)).ReturnsAsync(new LeastConnection(null, null));
+            _getResult = _loadBalancerHouse.Get(_reRoute, _serviceProviderConfig).Result;
+        }
+
+         private void ThenAnErrorIsReturned()
+        {
+            _getResult.IsError.ShouldBeTrue();
+            _getResult.Errors[0].ShouldBeOfType<UnableToFindLoadBalancerError>();
+        }
+
+        private void ThenTheLoadBalancerIs<T>()
+        {
+            _getResult.Data.ShouldBeOfType<T>();
+        }
+
+        private void ThenItIsAdded()
+        {
+            _getResult.IsError.ShouldBe(false);
+            _getResult.ShouldBeOfType<OkResponse<ILoadBalancer>>();
+            _getResult.Data.ShouldBe(_loadBalancer);
+            _factory.Verify(x => x.Get(_reRoute, _serviceProviderConfig), Times.Once);
+        }
+
+        private void GivenThereIsALoadBalancer(DownstreamReRoute reRoute, ILoadBalancer loadBalancer)
+        {
+            _reRoute = reRoute;
+            _loadBalancer = loadBalancer;
+            _factory.Setup(x => x.Get(_reRoute, _serviceProviderConfig)).ReturnsAsync(loadBalancer);
+            _getResult = _loadBalancerHouse.Get(reRoute, _serviceProviderConfig).Result;
+        }
+
+        private void WhenWeGetTheLoadBalancer(DownstreamReRoute reRoute)
+        {
+            _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
+        {
+            public Task<Response<ServiceHostAndPort>> Lease(DownstreamContext context)
+            {
+                throw new NotImplementedException();
+            }
+
+            public void Release(ServiceHostAndPort hostAndPort)
+            {
+                throw new NotImplementedException();
+            }
+        }
+
+        class FakeRoundRobinLoadBalancer : ILoadBalancer
+        {
+            public Task<Response<ServiceHostAndPort>> Lease(DownstreamContext context)
+            {
+                throw new NotImplementedException();
+            }
+
+            public void Release(ServiceHostAndPort hostAndPort)
+            {
+                throw new NotImplementedException();
+            }
+        }
+    }
+}

test/Ocelot.UnitTests/LoadBalancer/LoadBalancerMiddlewareTests.cs

@@ -1,193 +1,193 @@
-using Ocelot.Middleware;
-
-namespace Ocelot.UnitTests.LoadBalancer
-{
-    using System.Collections.Generic;
-    using System.Net.Http;
-    using System.Threading.Tasks;
-    using Microsoft.AspNetCore.Http;
-    using Moq;
-    using Ocelot.Configuration;
-    using Ocelot.Configuration.Builder;
-    using Ocelot.Errors;
-    using Ocelot.LoadBalancer.LoadBalancers;
-    using Ocelot.LoadBalancer.Middleware;
-    using Ocelot.Logging;
-    using Ocelot.Request.Middleware;
-    using Ocelot.Responses;
-    using Ocelot.Values;
-    using Shouldly;
-    using TestStack.BDDfy;
-    using Xunit;
-
-    public class LoadBalancerMiddlewareTests
-    {
-        private readonly Mock<ILoadBalancerHouse> _loadBalancerHouse;
-        private readonly Mock<ILoadBalancer> _loadBalancer;
-        private ServiceHostAndPort _hostAndPort;
-        private ErrorResponse<ILoadBalancer> _getLoadBalancerHouseError;
-        private ErrorResponse<ServiceHostAndPort> _getHostAndPortError;
-        private HttpRequestMessage _downstreamRequest;
-        private ServiceProviderConfiguration _config;
-        private Mock<IOcelotLoggerFactory> _loggerFactory;
-        private Mock<IOcelotLogger> _logger;
-        private LoadBalancingMiddleware _middleware;
-        private DownstreamContext _downstreamContext;
-        private OcelotRequestDelegate _next;
-
-        public LoadBalancerMiddlewareTests()
-        {
-            _loadBalancerHouse = new Mock<ILoadBalancerHouse>();
-            _loadBalancer = new Mock<ILoadBalancer>();
-            _loadBalancerHouse = new Mock<ILoadBalancerHouse>();
-            _downstreamRequest = new HttpRequestMessage(HttpMethod.Get, "http://test.com/");
-            _downstreamContext = new DownstreamContext(new DefaultHttpContext());
-            _loggerFactory = new Mock<IOcelotLoggerFactory>();
-            _logger = new Mock<IOcelotLogger>();
-            _loggerFactory.Setup(x => x.CreateLogger<LoadBalancingMiddleware>()).Returns(_logger.Object);
-            _next = context => Task.CompletedTask;
-            _downstreamContext.DownstreamRequest = new DownstreamRequest(_downstreamRequest);
-        }
-
-        [Fact]
-        public void should_call_scoped_data_repository_correctly()
-        {
-            var downstreamRoute = new DownstreamReRouteBuilder()
-                    .WithUpstreamHttpMethod(new List<string> { "Get" })
-                    .Build();
-
-            var serviceProviderConfig = new ServiceProviderConfigurationBuilder()
-                .Build();
-
-            this.Given(x => x.GivenTheDownStreamUrlIs("http://my.url/abc?q=123"))
-                .And(x => GivenTheConfigurationIs(serviceProviderConfig))
-                .And(x => x.GivenTheDownStreamRouteIs(downstreamRoute, new List<Ocelot.DownstreamRouteFinder.UrlMatcher.PlaceholderNameAndValue>()))
-                .And(x => x.GivenTheLoadBalancerHouseReturns())
-                .And(x => x.GivenTheLoadBalancerReturns())
-                .When(x => x.WhenICallTheMiddleware())
-                .Then(x => x.ThenTheDownstreamUrlIsReplacedWith("http://127.0.0.1:80/abc?q=123"))
-                .BDDfy();
-        }
-
-        [Fact]
-        public void should_set_pipeline_error_if_cannot_get_load_balancer()
-        {         
-            var downstreamRoute = new DownstreamReRouteBuilder()
-                    .WithUpstreamHttpMethod(new List<string> { "Get" })
-                    .Build();
-
-            var serviceProviderConfig = new ServiceProviderConfigurationBuilder()
-                .Build();
-
-            this.Given(x => x.GivenTheDownStreamUrlIs("http://my.url/abc?q=123"))
-                .And(x => GivenTheConfigurationIs(serviceProviderConfig))
-                .And(x => x.GivenTheDownStreamRouteIs(downstreamRoute, new List<Ocelot.DownstreamRouteFinder.UrlMatcher.PlaceholderNameAndValue>()))
-                .And(x => x.GivenTheLoadBalancerHouseReturnsAnError())
-                .When(x => x.WhenICallTheMiddleware())
-                .Then(x => x.ThenAnErrorStatingLoadBalancerCouldNotBeFoundIsSetOnPipeline())
-                .BDDfy();
-        }
-
-        [Fact]
-        public void should_set_pipeline_error_if_cannot_get_least()
-        {
-            var downstreamRoute = new DownstreamReRouteBuilder()
-                    .WithUpstreamHttpMethod(new List<string> { "Get" })
-                    .Build();
-                
-             var serviceProviderConfig = new ServiceProviderConfigurationBuilder()
-                .Build();
-
-            this.Given(x => x.GivenTheDownStreamUrlIs("http://my.url/abc?q=123"))
-                .And(x => GivenTheConfigurationIs(serviceProviderConfig))
-                .And(x => x.GivenTheDownStreamRouteIs(downstreamRoute, new List<Ocelot.DownstreamRouteFinder.UrlMatcher.PlaceholderNameAndValue>()))
-                .And(x => x.GivenTheLoadBalancerHouseReturns())
-                .And(x => x.GivenTheLoadBalancerReturnsAnError())
-                .When(x => x.WhenICallTheMiddleware())
-                .Then(x => x.ThenAnErrorStatingHostAndPortCouldNotBeFoundIsSetOnPipeline())
-                .BDDfy();
-        }
-
-        private void WhenICallTheMiddleware()
-        {
-            _middleware = new LoadBalancingMiddleware(_next, _loggerFactory.Object, _loadBalancerHouse.Object);
-            _middleware.Invoke(_downstreamContext).GetAwaiter().GetResult();
-        }
-
-        private void GivenTheConfigurationIs(ServiceProviderConfiguration config)
-        {
-            _config = config;
-            _downstreamContext.ServiceProviderConfiguration = config;
-        }
-
-        private void GivenTheDownStreamUrlIs(string downstreamUrl)
-        {
-            _downstreamRequest.RequestUri = new System.Uri(downstreamUrl);
-            _downstreamContext.DownstreamRequest = new DownstreamRequest(_downstreamRequest);
-        }
-
-        private void GivenTheLoadBalancerReturnsAnError()
-        {
-            _getHostAndPortError = new ErrorResponse<ServiceHostAndPort>(new List<Error>() { new ServicesAreNullError($"services were null for bah") });
-             _loadBalancer
-                .Setup(x => x.Lease())
-                .ReturnsAsync(_getHostAndPortError);
-        }
-
-        private void GivenTheLoadBalancerReturns()
-        {
-            _hostAndPort = new ServiceHostAndPort("127.0.0.1", 80);
-            _loadBalancer
-                .Setup(x => x.Lease())
-                .ReturnsAsync(new OkResponse<ServiceHostAndPort>(_hostAndPort));
-        }
-
-        private void GivenTheDownStreamRouteIs(DownstreamReRoute downstreamRoute, List<Ocelot.DownstreamRouteFinder.UrlMatcher.PlaceholderNameAndValue> placeholder)
-        {
-            _downstreamContext.TemplatePlaceholderNameAndValues = placeholder;
-            _downstreamContext.DownstreamReRoute = downstreamRoute;
-        }
-
-        private void GivenTheLoadBalancerHouseReturns()
-        {
-            _loadBalancerHouse
-                .Setup(x => x.Get(It.IsAny<DownstreamReRoute>(), It.IsAny<ServiceProviderConfiguration>()))
-                .ReturnsAsync(new OkResponse<ILoadBalancer>(_loadBalancer.Object));
-        }
-
-        private void GivenTheLoadBalancerHouseReturnsAnError()
-        {
-            _getLoadBalancerHouseError = new ErrorResponse<ILoadBalancer>(new List<Ocelot.Errors.Error>()
-            {
-                new UnableToFindLoadBalancerError($"unabe to find load balancer for bah")
-            });
-
-            _loadBalancerHouse
-                .Setup(x => x.Get(It.IsAny<DownstreamReRoute>(), It.IsAny<ServiceProviderConfiguration>()))
-                .ReturnsAsync(_getLoadBalancerHouseError);
-        }
-
-        private void ThenAnErrorStatingLoadBalancerCouldNotBeFoundIsSetOnPipeline()
-        {
-            _downstreamContext.IsError.ShouldBeTrue();
-            _downstreamContext.Errors.ShouldBe(_getLoadBalancerHouseError.Errors);
-        }
-
-        private void ThenAnErrorSayingReleaseFailedIsSetOnThePipeline()
-        {
-            _downstreamContext.IsError.ShouldBeTrue();
-            _downstreamContext.Errors.ShouldBe(It.IsAny<List<Error>>());
-        }
-
-        private void ThenAnErrorStatingHostAndPortCouldNotBeFoundIsSetOnPipeline()
-        {
-            _downstreamContext.IsError.ShouldBeTrue();
-            _downstreamContext.Errors.ShouldBe(_getHostAndPortError.Errors);
-        }
-
-        private void ThenTheDownstreamUrlIsReplacedWith(string expectedUri)
-        {
-            _downstreamContext.DownstreamRequest.ToHttpRequestMessage().RequestUri.OriginalString.ShouldBe(expectedUri);
-        }
-    }
-}
+using Ocelot.Middleware;
+
+namespace Ocelot.UnitTests.LoadBalancer
+{
+    using System.Collections.Generic;
+    using System.Net.Http;
+    using System.Threading.Tasks;
+    using Microsoft.AspNetCore.Http;
+    using Moq;
+    using Ocelot.Configuration;
+    using Ocelot.Configuration.Builder;
+    using Ocelot.Errors;
+    using Ocelot.LoadBalancer.LoadBalancers;
+    using Ocelot.LoadBalancer.Middleware;
+    using Ocelot.Logging;
+    using Ocelot.Request.Middleware;
+    using Ocelot.Responses;
+    using Ocelot.Values;
+    using Shouldly;
+    using TestStack.BDDfy;
+    using Xunit;
+
+    public class LoadBalancerMiddlewareTests
+    {
+        private readonly Mock<ILoadBalancerHouse> _loadBalancerHouse;
+        private readonly Mock<ILoadBalancer> _loadBalancer;
+        private ServiceHostAndPort _hostAndPort;
+        private ErrorResponse<ILoadBalancer> _getLoadBalancerHouseError;
+        private ErrorResponse<ServiceHostAndPort> _getHostAndPortError;
+        private HttpRequestMessage _downstreamRequest;
+        private ServiceProviderConfiguration _config;
+        private Mock<IOcelotLoggerFactory> _loggerFactory;
+        private Mock<IOcelotLogger> _logger;
+        private LoadBalancingMiddleware _middleware;
+        private DownstreamContext _downstreamContext;
+        private OcelotRequestDelegate _next;
+
+        public LoadBalancerMiddlewareTests()
+        {
+            _loadBalancerHouse = new Mock<ILoadBalancerHouse>();
+            _loadBalancer = new Mock<ILoadBalancer>();
+            _loadBalancerHouse = new Mock<ILoadBalancerHouse>();
+            _downstreamRequest = new HttpRequestMessage(HttpMethod.Get, "http://test.com/");
+            _downstreamContext = new DownstreamContext(new DefaultHttpContext());
+            _loggerFactory = new Mock<IOcelotLoggerFactory>();
+            _logger = new Mock<IOcelotLogger>();
+            _loggerFactory.Setup(x => x.CreateLogger<LoadBalancingMiddleware>()).Returns(_logger.Object);
+            _next = context => Task.CompletedTask;
+            _downstreamContext.DownstreamRequest = new DownstreamRequest(_downstreamRequest);
+        }
+
+        [Fact]
+        public void should_call_scoped_data_repository_correctly()
+        {
+            var downstreamRoute = new DownstreamReRouteBuilder()
+                    .WithUpstreamHttpMethod(new List<string> { "Get" })
+                    .Build();
+
+            var serviceProviderConfig = new ServiceProviderConfigurationBuilder()
+                .Build();
+
+            this.Given(x => x.GivenTheDownStreamUrlIs("http://my.url/abc?q=123"))
+                .And(x => GivenTheConfigurationIs(serviceProviderConfig))
+                .And(x => x.GivenTheDownStreamRouteIs(downstreamRoute, new List<Ocelot.DownstreamRouteFinder.UrlMatcher.PlaceholderNameAndValue>()))
+                .And(x => x.GivenTheLoadBalancerHouseReturns())
+                .And(x => x.GivenTheLoadBalancerReturns())
+                .When(x => x.WhenICallTheMiddleware())
+                .Then(x => x.ThenTheDownstreamUrlIsReplacedWith("http://127.0.0.1:80/abc?q=123"))
+                .BDDfy();
+        }
+
+        [Fact]
+        public void should_set_pipeline_error_if_cannot_get_load_balancer()
+        {         
+            var downstreamRoute = new DownstreamReRouteBuilder()
+                    .WithUpstreamHttpMethod(new List<string> { "Get" })
+                    .Build();
+
+            var serviceProviderConfig = new ServiceProviderConfigurationBuilder()
+                .Build();
+
+            this.Given(x => x.GivenTheDownStreamUrlIs("http://my.url/abc?q=123"))
+                .And(x => GivenTheConfigurationIs(serviceProviderConfig))
+                .And(x => x.GivenTheDownStreamRouteIs(downstreamRoute, new List<Ocelot.DownstreamRouteFinder.UrlMatcher.PlaceholderNameAndValue>()))
+                .And(x => x.GivenTheLoadBalancerHouseReturnsAnError())
+                .When(x => x.WhenICallTheMiddleware())
+                .Then(x => x.ThenAnErrorStatingLoadBalancerCouldNotBeFoundIsSetOnPipeline())
+                .BDDfy();
+        }
+
+        [Fact]
+        public void should_set_pipeline_error_if_cannot_get_least()
+        {
+            var downstreamRoute = new DownstreamReRouteBuilder()
+                    .WithUpstreamHttpMethod(new List<string> { "Get" })
+                    .Build();
+                
+             var serviceProviderConfig = new ServiceProviderConfigurationBuilder()
+                .Build();
+
+            this.Given(x => x.GivenTheDownStreamUrlIs("http://my.url/abc?q=123"))
+                .And(x => GivenTheConfigurationIs(serviceProviderConfig))
+                .And(x => x.GivenTheDownStreamRouteIs(downstreamRoute, new List<Ocelot.DownstreamRouteFinder.UrlMatcher.PlaceholderNameAndValue>()))
+                .And(x => x.GivenTheLoadBalancerHouseReturns())
+                .And(x => x.GivenTheLoadBalancerReturnsAnError())
+                .When(x => x.WhenICallTheMiddleware())
+                .Then(x => x.ThenAnErrorStatingHostAndPortCouldNotBeFoundIsSetOnPipeline())
+                .BDDfy();
+        }
+
+        private void WhenICallTheMiddleware()
+        {
+            _middleware = new LoadBalancingMiddleware(_next, _loggerFactory.Object, _loadBalancerHouse.Object);
+            _middleware.Invoke(_downstreamContext).GetAwaiter().GetResult();
+        }
+
+        private void GivenTheConfigurationIs(ServiceProviderConfiguration config)
+        {
+            _config = config;
+            _downstreamContext.ServiceProviderConfiguration = config;
+        }
+
+        private void GivenTheDownStreamUrlIs(string downstreamUrl)
+        {
+            _downstreamRequest.RequestUri = new System.Uri(downstreamUrl);
+            _downstreamContext.DownstreamRequest = new DownstreamRequest(_downstreamRequest);
+        }
+
+        private void GivenTheLoadBalancerReturnsAnError()
+        {
+            _getHostAndPortError = new ErrorResponse<ServiceHostAndPort>(new List<Error>() { new ServicesAreNullError($"services were null for bah") });
+             _loadBalancer
+                .Setup(x => x.Lease(It.IsAny<DownstreamContext>()))
+                .ReturnsAsync(_getHostAndPortError);
+        }
+
+        private void GivenTheLoadBalancerReturns()
+        {
+            _hostAndPort = new ServiceHostAndPort("127.0.0.1", 80);
+            _loadBalancer
+                .Setup(x => x.Lease(It.IsAny<DownstreamContext>()))
+                .ReturnsAsync(new OkResponse<ServiceHostAndPort>(_hostAndPort));
+        }
+
+        private void GivenTheDownStreamRouteIs(DownstreamReRoute downstreamRoute, List<Ocelot.DownstreamRouteFinder.UrlMatcher.PlaceholderNameAndValue> placeholder)
+        {
+            _downstreamContext.TemplatePlaceholderNameAndValues = placeholder;
+            _downstreamContext.DownstreamReRoute = downstreamRoute;
+        }
+
+        private void GivenTheLoadBalancerHouseReturns()
+        {
+            _loadBalancerHouse
+                .Setup(x => x.Get(It.IsAny<DownstreamReRoute>(), It.IsAny<ServiceProviderConfiguration>()))
+                .ReturnsAsync(new OkResponse<ILoadBalancer>(_loadBalancer.Object));
+        }
+
+        private void GivenTheLoadBalancerHouseReturnsAnError()
+        {
+            _getLoadBalancerHouseError = new ErrorResponse<ILoadBalancer>(new List<Ocelot.Errors.Error>()
+            {
+                new UnableToFindLoadBalancerError($"unabe to find load balancer for bah")
+            });
+
+            _loadBalancerHouse
+                .Setup(x => x.Get(It.IsAny<DownstreamReRoute>(), It.IsAny<ServiceProviderConfiguration>()))
+                .ReturnsAsync(_getLoadBalancerHouseError);
+        }
+
+        private void ThenAnErrorStatingLoadBalancerCouldNotBeFoundIsSetOnPipeline()
+        {
+            _downstreamContext.IsError.ShouldBeTrue();
+            _downstreamContext.Errors.ShouldBe(_getLoadBalancerHouseError.Errors);
+        }
+
+        private void ThenAnErrorSayingReleaseFailedIsSetOnThePipeline()
+        {
+            _downstreamContext.IsError.ShouldBeTrue();
+            _downstreamContext.Errors.ShouldBe(It.IsAny<List<Error>>());
+        }
+
+        private void ThenAnErrorStatingHostAndPortCouldNotBeFoundIsSetOnPipeline()
+        {
+            _downstreamContext.IsError.ShouldBeTrue();
+            _downstreamContext.Errors.ShouldBe(_getHostAndPortError.Errors);
+        }
+
+        private void ThenTheDownstreamUrlIsReplacedWith(string expectedUri)
+        {
+            _downstreamContext.DownstreamRequest.ToHttpRequestMessage().RequestUri.OriginalString.ShouldBe(expectedUri);
+        }
+    }
+}

test/Ocelot.UnitTests/LoadBalancer/NoLoadBalancerTests.cs

@@ -1,48 +1,77 @@
-using System.Collections.Generic;
-using Ocelot.LoadBalancer.LoadBalancers;
-using Ocelot.Responses;
-using Ocelot.Values;
-using Shouldly;
-using TestStack.BDDfy;
-using Xunit;
-
-namespace Ocelot.UnitTests.LoadBalancer
-{
-    public class NoLoadBalancerTests
-    {
-        private List<Service> _services;
-        private NoLoadBalancer _loadBalancer;
-        private Response<ServiceHostAndPort> _result;
-
-        [Fact]
-        public void should_return_host_and_port()
-        {
-            var hostAndPort = new ServiceHostAndPort("127.0.0.1", 80);
-
-            var services = new List<Service>
-            {
-                new Service("product", hostAndPort, string.Empty, string.Empty, new string[0])
-            };
-            this.Given(x => x.GivenServices(services))
-                .When(x => x.WhenIGetTheNextHostAndPort())
-                .Then(x => x.ThenTheHostAndPortIs(hostAndPort))
-                .BDDfy();
-        }
-
-        private void GivenServices(List<Service> services)
-        {
-            _services = services;
-        }
-
-        private void WhenIGetTheNextHostAndPort()
-        {
-            _loadBalancer = new NoLoadBalancer(_services);
-            _result = _loadBalancer.Lease().Result;
-        }
-
-        private void ThenTheHostAndPortIs(ServiceHostAndPort expected)
-        {
-            _result.Data.ShouldBe(expected);
-        }
-    }
-}
+using System.Collections.Generic;
+using Microsoft.AspNetCore.Http;
+using Ocelot.LoadBalancer.LoadBalancers;
+using Ocelot.Middleware;
+using Ocelot.Responses;
+using Ocelot.Values;
+using Shouldly;
+using TestStack.BDDfy;
+using Xunit;
+
+namespace Ocelot.UnitTests.LoadBalancer
+{
+    public class NoLoadBalancerTests
+    {
+        private List<Service> _services;
+        private NoLoadBalancer _loadBalancer;
+        private Response<ServiceHostAndPort> _result;
+
+        [Fact]
+        public void should_return_host_and_port()
+        {
+            var hostAndPort = new ServiceHostAndPort("127.0.0.1", 80);
+
+            var services = new List<Service>
+            {
+                new Service("product", hostAndPort, string.Empty, string.Empty, new string[0])
+            };
+            this.Given(x => x.GivenServices(services))
+                .When(x => x.WhenIGetTheNextHostAndPort())
+                .Then(x => x.ThenTheHostAndPortIs(hostAndPort))
+                .BDDfy();
+        }
+
+        [Fact]
+        public void should_return_error_if_no_services()
+        {
+            var services = new List<Service>();
+
+            this.Given(x => x.GivenServices(services))
+                .When(x => x.WhenIGetTheNextHostAndPort())
+                .Then(x => x.ThenThereIsAnError())
+                .BDDfy();
+        }
+
+        [Fact]
+        public void should_return_error_if_null_services()
+        {
+            List<Service> services = null;
+
+            this.Given(x => x.GivenServices(services))
+                .When(x => x.WhenIGetTheNextHostAndPort())
+                .Then(x => x.ThenThereIsAnError())
+                .BDDfy();
+        }
+
+        private void ThenThereIsAnError()
+        {
+            _result.IsError.ShouldBeTrue();
+        }
+
+        private void GivenServices(List<Service> services)
+        {
+            _services = services;
+        }
+
+        private void WhenIGetTheNextHostAndPort()
+        {
+            _loadBalancer = new NoLoadBalancer(_services);
+            _result = _loadBalancer.Lease(new DownstreamContext(new DefaultHttpContext())).Result;
+        }
+
+        private void ThenTheHostAndPortIs(ServiceHostAndPort expected)
+        {
+            _result.Data.ShouldBe(expected);
+        }
+    }
+}

test/Ocelot.UnitTests/LoadBalancer/RoundRobinTests.cs

@@ -1,69 +1,74 @@
-using System.Collections.Generic;
-using System.Diagnostics;
-using Ocelot.LoadBalancer.LoadBalancers;
-using Ocelot.Responses;
-using Ocelot.Values;
-using Shouldly;
-using TestStack.BDDfy;
-using Xunit;
-using System.Threading.Tasks;
-
-namespace Ocelot.UnitTests.LoadBalancer
-{
-    public class RoundRobinTests
-    {
-        private readonly RoundRobin _roundRobin;
-        private readonly List<Service> _services;
-        private Response<ServiceHostAndPort> _hostAndPort;
-
-        public RoundRobinTests()
-        {
-            _services = new List<Service>
-            {
-                new Service("product", new ServiceHostAndPort("127.0.0.1", 5000), string.Empty, string.Empty, new string[0]),
-                new Service("product", new ServiceHostAndPort("127.0.0.1", 5001), string.Empty, string.Empty, new string[0]),
-                new Service("product", new ServiceHostAndPort("127.0.0.1", 5001), string.Empty, string.Empty, new string[0])
-            };
-
-            _roundRobin = new RoundRobin(() => Task.FromResult(_services));
-        }
-
-        [Fact]
-        public void should_get_next_address()
-        {
-            this.Given(x => x.GivenIGetTheNextAddress())
-                .Then(x => x.ThenTheNextAddressIndexIs(0))
-                .Given(x => x.GivenIGetTheNextAddress())
-                .Then(x => x.ThenTheNextAddressIndexIs(1))
-                .Given(x => x.GivenIGetTheNextAddress())
-                .Then(x => x.ThenTheNextAddressIndexIs(2))
-                .BDDfy();
-        }
-
-        [Fact]
-        public void should_go_back_to_first_address_after_finished_last()
-        {
-            var stopWatch = Stopwatch.StartNew();
-
-            while (stopWatch.ElapsedMilliseconds < 1000)
-            {
-                var address = _roundRobin.Lease().Result;
-                address.Data.ShouldBe(_services[0].HostAndPort);
-                address = _roundRobin.Lease().Result;
-                address.Data.ShouldBe(_services[1].HostAndPort);
-                address = _roundRobin.Lease().Result;
-                address.Data.ShouldBe(_services[2].HostAndPort);
-            }
-        }
-
-        private void GivenIGetTheNextAddress()
-        {
-            _hostAndPort = _roundRobin.Lease().Result;
-        }
-
-        private void ThenTheNextAddressIndexIs(int index)
-        {
-            _hostAndPort.Data.ShouldBe(_services[index].HostAndPort);
-        }
-    }
-}
+using System.Collections.Generic;
+using System.Diagnostics;
+using Ocelot.LoadBalancer.LoadBalancers;
+using Ocelot.Responses;
+using Ocelot.Values;
+using Shouldly;
+using TestStack.BDDfy;
+using Xunit;
+using System.Threading.Tasks;
+using Ocelot.Middleware;
+using Microsoft.AspNetCore.Http;
+
+namespace Ocelot.UnitTests.LoadBalancer
+{
+    public class RoundRobinTests
+    {
+        private readonly RoundRobin _roundRobin;
+        private readonly List<Service> _services;
+        private Response<ServiceHostAndPort> _hostAndPort;
+        private DownstreamContext _context;
+
+        public RoundRobinTests()
+        {
+            _context = new DownstreamContext(new DefaultHttpContext());
+
+            _services = new List<Service>
+            {
+                new Service("product", new ServiceHostAndPort("127.0.0.1", 5000), string.Empty, string.Empty, new string[0]),
+                new Service("product", new ServiceHostAndPort("127.0.0.1", 5001), string.Empty, string.Empty, new string[0]),
+                new Service("product", new ServiceHostAndPort("127.0.0.1", 5001), string.Empty, string.Empty, new string[0])
+            };
+
+            _roundRobin = new RoundRobin(() => Task.FromResult(_services));
+        }
+
+        [Fact]
+        public void should_get_next_address()
+        {
+            this.Given(x => x.GivenIGetTheNextAddress())
+                .Then(x => x.ThenTheNextAddressIndexIs(0))
+                .Given(x => x.GivenIGetTheNextAddress())
+                .Then(x => x.ThenTheNextAddressIndexIs(1))
+                .Given(x => x.GivenIGetTheNextAddress())
+                .Then(x => x.ThenTheNextAddressIndexIs(2))
+                .BDDfy();
+        }
+
+        [Fact]
+        public void should_go_back_to_first_address_after_finished_last()
+        {
+            var stopWatch = Stopwatch.StartNew();
+
+            while (stopWatch.ElapsedMilliseconds < 1000)
+            {
+                var address = _roundRobin.Lease(_context).Result;
+                address.Data.ShouldBe(_services[0].HostAndPort);
+                address = _roundRobin.Lease(_context).Result;
+                address.Data.ShouldBe(_services[1].HostAndPort);
+                address = _roundRobin.Lease(_context).Result;
+                address.Data.ShouldBe(_services[2].HostAndPort);
+            }
+        }
+
+        private void GivenIGetTheNextAddress()
+        {
+            _hostAndPort = _roundRobin.Lease(_context).Result;
+        }
+
+        private void ThenTheNextAddressIndexIs(int index)
+        {
+            _hostAndPort.Data.ShouldBe(_services[index].HostAndPort);
+        }
+    }
+}

test/Ocelot.UnitTests/Requester/HttpClientBuilderTests.cs

@@ -130,6 +130,38 @@ namespace Ocelot.UnitTests.Requester
                 .BDDfy();
         }
 
+        [Theory]
+        [InlineData("GET")]
+        [InlineData("POST")]
+        [InlineData("PUT")]
+        [InlineData("DELETE")]
+        [InlineData("PATCH")]
+        public void should_add_verb_to_cache_key(string verb)
+        {
+            var client = "http://localhost:5012";
+
+            HttpMethod method = new HttpMethod(verb);
+
+            var reRoute = new DownstreamReRouteBuilder()
+                .WithIsQos(false)
+                .WithHttpHandlerOptions(new HttpHandlerOptions(false, false, false))
+                .WithReRouteKey("")
+                .WithQosOptions(new QoSOptionsBuilder().Build())
+                .Build();
+
+            this.Given(_ => GivenADownstreamService())
+                .And(_ => GivenARequestWithAUrlAndMethod(reRoute, client, method))
+                .And(_ => GivenTheFactoryReturnsNothing())
+                .And(_ => WhenIBuild())
+                .And(_ => GivenCacheIsCalledWithExpectedKey($"{method.ToString()}:{client}"))
+                .BDDfy();
+        }
+
+        private void GivenCacheIsCalledWithExpectedKey(string expectedKey)
+        {
+            this._cacheHandlers.Verify(x => x.Get(It.Is<string>(p => p.Equals(expectedKey, StringComparison.OrdinalIgnoreCase))), Times.Once);
+        }
+
         private void ThenTheDangerousAcceptAnyServerCertificateValidatorWarningIsLogged()
         {
             _logger.Verify(x => x.LogWarning($"You have ignored all SSL warnings by using DangerousAcceptAnyServerCertificateValidator for this DownstreamReRoute, UpstreamPathTemplate: {_context.DownstreamReRoute.UpstreamPathTemplate}, DownstreamPathTemplate: {_context.DownstreamReRoute.DownstreamPathTemplate}"), Times.Once);
@@ -197,11 +229,16 @@ namespace Ocelot.UnitTests.Requester
         }
 
         private void GivenARequest(DownstreamReRoute downstream)
+        {
+            GivenARequestWithAUrlAndMethod(downstream, "http://localhost:5003", HttpMethod.Get);
+        }
+
+        private void GivenARequestWithAUrlAndMethod(DownstreamReRoute downstream, string url, HttpMethod method)
         {
             var context = new DownstreamContext(new DefaultHttpContext())
             {
                 DownstreamReRoute = downstream,
-                DownstreamRequest = new DownstreamRequest(new HttpRequestMessage() { RequestUri = new Uri("http://localhost:5003") }),
+                DownstreamRequest = new DownstreamRequest(new HttpRequestMessage() { RequestUri = new Uri(url), Method = method }),
             };
 
             _context = context;

test/Ocelot.UnitTests/Requester/QosProviderHouseTests.cs

@@ -26,7 +26,7 @@ namespace Ocelot.UnitTests.Requester
         [Fact]
         public void should_store_qos_provider_on_first_request()
         {
-            var reRoute = new DownstreamReRouteBuilder().WithReRouteKey("test").Build();
+            var reRoute = new DownstreamReRouteBuilder().WithQosKey("test").Build();
 
             this.Given(x => x.GivenThereIsAQoSProvider(reRoute, new FakeQoSProvider()))
                 .Then(x => x.ThenItIsAdded())
@@ -36,7 +36,7 @@ namespace Ocelot.UnitTests.Requester
         [Fact]
         public void should_not_store_qos_provider_on_first_request()
         {
-            var reRoute = new DownstreamReRouteBuilder().WithReRouteKey("test").Build();
+            var reRoute = new DownstreamReRouteBuilder().WithQosKey("test").Build();
 
             this.Given(x => x.GivenThereIsAQoSProvider(reRoute, new FakeQoSProvider()))
                 .When(x => x.WhenWeGetTheQoSProvider(reRoute))
@@ -47,8 +47,8 @@ namespace Ocelot.UnitTests.Requester
         [Fact]
         public void should_store_qos_providers_by_key()
         {
-            var reRoute = new DownstreamReRouteBuilder().WithReRouteKey("test").Build();
-            var reRouteTwo = new DownstreamReRouteBuilder().WithReRouteKey("testTwo").Build();
+            var reRoute = new DownstreamReRouteBuilder().WithQosKey("test").Build();
+            var reRouteTwo = new DownstreamReRouteBuilder().WithQosKey("testTwo").Build();
 
             this.Given(x => x.GivenThereIsAQoSProvider(reRoute, new FakeQoSProvider()))
                 .And(x => x.GivenThereIsAQoSProvider(reRouteTwo, new FakePollyQoSProvider()))
@@ -72,9 +72,9 @@ namespace Ocelot.UnitTests.Requester
         [Fact]
         public void should_get_new_qos_provider_if_reroute_qos_provider_has_changed()
         {
-            var reRoute = new DownstreamReRouteBuilder().WithReRouteKey("test").Build();
+            var reRoute = new DownstreamReRouteBuilder().WithQosKey("test").Build();
 
-            var reRouteTwo = new DownstreamReRouteBuilder().WithReRouteKey("test").WithIsQos(true).Build();
+            var reRouteTwo = new DownstreamReRouteBuilder().WithQosKey("test").WithIsQos(true).Build();
 
             this.Given(x => x.GivenThereIsAQoSProvider(reRoute, new FakeQoSProvider()))
                 .When(x => x.WhenWeGetTheQoSProvider(reRoute))

test/Ocelot.UnitTests/Responder/ErrorsToHttpStatusCodeMapperTests.cs

@@ -45,6 +45,13 @@ namespace Ocelot.UnitTests.Responder
             ShouldMapErrorToStatusCode(errorCode, HttpStatusCode.ServiceUnavailable);
         }
 
+        [Theory]
+        [InlineData(OcelotErrorCode.UnableToCompleteRequestError)]
+        public void should_return_internal_server_error(OcelotErrorCode errorCode)
+        {
+            ShouldMapErrorToStatusCode(errorCode, HttpStatusCode.InternalServerError);
+        }
+
         [Theory]
         [InlineData(OcelotErrorCode.CannotAddDataError)]
         [InlineData(OcelotErrorCode.CannotFindDataError)]
@@ -60,7 +67,6 @@ namespace Ocelot.UnitTests.Responder
         [InlineData(OcelotErrorCode.RateLimitOptionsError)]
         [InlineData(OcelotErrorCode.ServicesAreEmptyError)]
         [InlineData(OcelotErrorCode.ServicesAreNullError)]
-        [InlineData(OcelotErrorCode.UnableToCompleteRequestError)]
         [InlineData(OcelotErrorCode.UnableToCreateAuthenticationHandlerError)]
         [InlineData(OcelotErrorCode.UnableToFindDownstreamRouteError)]
         [InlineData(OcelotErrorCode.UnableToFindLoadBalancerError)]