merged develop and stolen binarymash dont publish unstable build script code

test/Ocelot.AcceptanceTests/ClientRateLimitTests.cs

@@ -0,0 +1,165 @@
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.Http;
+using Ocelot.Configuration.File;
+using Shouldly;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Net.Http;
+using System.Threading.Tasks;
+using TestStack.BDDfy;
+using Xunit;
+
+namespace Ocelot.AcceptanceTests
+{
+    public class ClientRateLimitTests : IDisposable
+    {
+        private IWebHost _builder;
+        private readonly Steps _steps;
+         private int _counterOne;
+
+
+        public ClientRateLimitTests()
+        {
+            _steps = new Steps();
+        }
+
+
+        public void Dispose()
+        {
+            _builder?.Dispose();
+            _steps.Dispose();
+        }
+
+        [Fact]
+        public void should_call_withratelimiting()
+        {
+            var configuration = new FileConfiguration
+            {
+                ReRoutes = new List<FileReRoute>
+                    {
+                        new FileReRoute
+                        {
+                            DownstreamPathTemplate = "/api/ClientRateLimit",
+                            DownstreamPort = 51879,
+                            DownstreamScheme = "http",
+                            DownstreamHost = "localhost",
+                            UpstreamPathTemplate = "/api/ClientRateLimit",
+                            UpstreamHttpMethod = "Get",
+                            RequestIdKey = _steps.RequestIdKey,
+                             
+                            RateLimitOptions =    new FileRateLimitRule()
+                            {
+                                EnableRateLimiting = true,
+                                ClientWhitelist = new List<string>(),
+                                Limit = 3,
+                                Period = "1s",
+                                PeriodTimespan = 1000
+                            }
+                        }
+                },
+                GlobalConfiguration = new FileGlobalConfiguration()
+                {
+                    RateLimitOptions = new FileRateLimitOptions()
+                    {
+                        ClientIdHeader = "ClientId",
+                        DisableRateLimitHeaders = false,
+                        QuotaExceededMessage = "",
+                        RateLimitCounterPrefix = "",
+                         HttpStatusCode = 428
+
+                    },
+                     RequestIdKey ="oceclientrequest"
+                }
+            };
+
+            this.Given(x => x.GivenThereIsAServiceRunningOn("http://localhost:51879/api/ClientRateLimit"))
+                .And(x => _steps.GivenThereIsAConfiguration(configuration))
+                .And(x => _steps.GivenOcelotIsRunning())
+                .When(x => _steps.WhenIGetUrlOnTheApiGatewayMultipleTimesForRateLimit("/api/ClientRateLimit",1))
+                .Then(x => _steps.ThenTheStatusCodeShouldBe(200))
+                .When(x => _steps.WhenIGetUrlOnTheApiGatewayMultipleTimesForRateLimit("/api/ClientRateLimit", 2))
+                .Then(x => _steps.ThenTheStatusCodeShouldBe(200))
+                .When(x => _steps.WhenIGetUrlOnTheApiGatewayMultipleTimesForRateLimit("/api/ClientRateLimit",1))
+                .Then(x => _steps.ThenTheStatusCodeShouldBe(428))
+                .BDDfy();
+        }
+
+
+        [Fact]
+        public void should_call_middleware_withWhitelistClient()
+        {
+            var configuration = new FileConfiguration
+            {
+                ReRoutes = new List<FileReRoute>
+                    {
+                        new FileReRoute
+                        {
+                            DownstreamPathTemplate = "/api/ClientRateLimit",
+                            DownstreamPort = 51879,
+                            DownstreamScheme = "http",
+                            DownstreamHost = "localhost",
+                            UpstreamPathTemplate = "/api/ClientRateLimit",
+                            UpstreamHttpMethod = "Get",
+                            RequestIdKey = _steps.RequestIdKey,
+
+                            RateLimitOptions =    new FileRateLimitRule()
+                            {
+                                EnableRateLimiting = true,
+                                ClientWhitelist = new List<string>() { "ocelotclient1"},
+                                Limit = 3,
+                                Period = "1s",
+                                PeriodTimespan = 100
+                            }
+                        }
+                },
+                GlobalConfiguration = new FileGlobalConfiguration()
+                {
+                    RateLimitOptions = new FileRateLimitOptions()
+                    {
+                        ClientIdHeader = "ClientId",
+                        DisableRateLimitHeaders = false,
+                        QuotaExceededMessage = "",
+                        RateLimitCounterPrefix = ""
+                    },
+                    RequestIdKey = "oceclientrequest"
+                }
+            };
+
+            this.Given(x => x.GivenThereIsAServiceRunningOn("http://localhost:51879/api/ClientRateLimit"))
+                .And(x => _steps.GivenThereIsAConfiguration(configuration))
+                .And(x => _steps.GivenOcelotIsRunning())
+                .When(x => _steps.WhenIGetUrlOnTheApiGatewayMultipleTimesForRateLimit("/api/ClientRateLimit", 4))
+                .Then(x => _steps.ThenTheStatusCodeShouldBe(200))
+                .BDDfy();
+        }
+
+
+        private void GivenThereIsAServiceRunningOn(string url)
+        {
+            _builder = new WebHostBuilder()
+                .UseUrls(url)
+                .UseKestrel()
+                .UseContentRoot(Directory.GetCurrentDirectory())
+                .UseIISIntegration()
+                .UseUrls(url)
+                .Configure(app =>
+                {
+                    app.Run(context =>
+                    {
+                        _counterOne++;
+                        context.Response.StatusCode = 200;
+                        context.Response.WriteAsync(_counterOne.ToString());
+                        return Task.CompletedTask;
+                    });
+                })
+                .Build();
+
+            _builder.Start();
+        }
+
+  
+    }
+}

test/Ocelot.AcceptanceTests/Steps.cs

@@ -238,6 +238,17 @@ namespace Ocelot.AcceptanceTests
             count.ShouldBeGreaterThan(0);
         }
 
+        public void WhenIGetUrlOnTheApiGatewayMultipleTimesForRateLimit(string url, int times)
+        {
+            for (int i = 0; i < times; i++)
+            {
+                var clientId = "ocelotclient1";
+                var request = new HttpRequestMessage(new HttpMethod("GET"), url);
+                request.Headers.Add("ClientId", clientId);
+                _response = _ocelotClient.SendAsync(request).Result;
+            }
+        } 
+
         public void WhenIGetUrlOnTheApiGateway(string url, string requestId)
         {
             _ocelotClient.DefaultRequestHeaders.TryAddWithoutValidation(RequestIdKey, requestId);
@@ -265,6 +276,13 @@ namespace Ocelot.AcceptanceTests
             _response.StatusCode.ShouldBe(expectedHttpStatusCode);
         }
 
+
+        public void ThenTheStatusCodeShouldBe(int expectedHttpStatusCode)
+        {
+            var responseStatusCode = (int)_response.StatusCode;
+            responseStatusCode.ShouldBe(expectedHttpStatusCode);
+        }
+
         public void Dispose()
         {
             _ocelotClient?.Dispose();

test/Ocelot.AcceptanceTests/Steps.cs.orig

@@ -0,0 +1,305 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Threading;
+using System.Threading.Tasks;
+using CacheManager.Core;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.TestHost;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Newtonsoft.Json;
+using Ocelot.Configuration.File;
+using Ocelot.DependencyInjection;
+using Ocelot.ManualTest;
+using Ocelot.Middleware;
+using Shouldly;
+using ConfigurationBuilder = Microsoft.Extensions.Configuration.ConfigurationBuilder;
+
+namespace Ocelot.AcceptanceTests
+{
+    public class Steps : IDisposable
+    {
+        private TestServer _ocelotServer;
+        private HttpClient _ocelotClient;
+        private HttpResponseMessage _response;
+        private HttpContent _postContent;
+        private BearerToken _token;
+        public HttpClient OcelotClient => _ocelotClient;
+        public string RequestIdKey = "OcRequestId";
+        private readonly Random _random;
+        private IWebHostBuilder _webHostBuilder;
+
+        public Steps()
+        {
+            _random = new Random();
+        }
+
+        public void GivenThereIsAConfiguration(FileConfiguration fileConfiguration)
+        {
+            var configurationPath = TestConfiguration.ConfigurationPath;
+
+            var jsonConfiguration = JsonConvert.SerializeObject(fileConfiguration);
+
+            if (File.Exists(configurationPath))
+            {
+                File.Delete(configurationPath);
+            }
+
+            File.WriteAllText(configurationPath, jsonConfiguration);
+        }
+
+        public void GivenThereIsAConfiguration(FileConfiguration fileConfiguration, string configurationPath)
+        {
+            var jsonConfiguration = JsonConvert.SerializeObject(fileConfiguration);
+
+            if (File.Exists(configurationPath))
+            {
+                File.Delete(configurationPath);
+            }
+
+            File.WriteAllText(configurationPath, jsonConfiguration);
+        }
+
+        /// <summary>
+        /// This is annoying cos it should be in the constructor but we need to set up the file before calling startup so its a step.
+        /// </summary>
+        public void GivenOcelotIsRunning()
+        {
+             _webHostBuilder = new WebHostBuilder();
+            
+            _webHostBuilder.ConfigureServices(s => 
+            {
+                s.AddSingleton(_webHostBuilder);
+            });
+
+            _ocelotServer = new TestServer(_webHostBuilder
+                .UseStartup<Startup>());
+
+            _ocelotClient = _ocelotServer.CreateClient();
+        }
+
+        internal void ThenTheResponseShouldBe(FileConfiguration expected)
+        {
+            var response = JsonConvert.DeserializeObject<FileConfiguration>(_response.Content.ReadAsStringAsync().Result);
+            
+            response.GlobalConfiguration.AdministrationPath.ShouldBe(expected.GlobalConfiguration.AdministrationPath);
+            response.GlobalConfiguration.RequestIdKey.ShouldBe(expected.GlobalConfiguration.RequestIdKey);
+            response.GlobalConfiguration.ServiceDiscoveryProvider.Host.ShouldBe(expected.GlobalConfiguration.ServiceDiscoveryProvider.Host);
+            response.GlobalConfiguration.ServiceDiscoveryProvider.Port.ShouldBe(expected.GlobalConfiguration.ServiceDiscoveryProvider.Port);
+            response.GlobalConfiguration.ServiceDiscoveryProvider.Provider.ShouldBe(expected.GlobalConfiguration.ServiceDiscoveryProvider.Provider);
+
+            for(var i = 0; i < response.ReRoutes.Count; i++)
+            {
+                response.ReRoutes[i].DownstreamHost.ShouldBe(expected.ReRoutes[i].DownstreamHost);
+                response.ReRoutes[i].DownstreamPathTemplate.ShouldBe(expected.ReRoutes[i].DownstreamPathTemplate);
+                response.ReRoutes[i].DownstreamPort.ShouldBe(expected.ReRoutes[i].DownstreamPort);
+                response.ReRoutes[i].DownstreamScheme.ShouldBe(expected.ReRoutes[i].DownstreamScheme);
+                response.ReRoutes[i].UpstreamPathTemplate.ShouldBe(expected.ReRoutes[i].UpstreamPathTemplate);
+                response.ReRoutes[i].UpstreamHttpMethod.ShouldBe(expected.ReRoutes[i].UpstreamHttpMethod);
+            }
+        }
+
+        /// <summary>
+        /// This is annoying cos it should be in the constructor but we need to set up the file before calling startup so its a step.
+        /// </summary>
+        public void GivenOcelotIsRunning(OcelotMiddlewareConfiguration ocelotMiddlewareConfig)
+        {
+            var builder = new ConfigurationBuilder()
+                .SetBasePath(Directory.GetCurrentDirectory())
+                .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
+                .AddJsonFile("configuration.json")
+                .AddEnvironmentVariables();
+
+            var configuration = builder.Build();
+
+            _webHostBuilder = new WebHostBuilder();
+            
+            _webHostBuilder.ConfigureServices(s => 
+            {
+                s.AddSingleton(_webHostBuilder);
+            });
+
+            _ocelotServer = new TestServer(_webHostBuilder
+                .UseConfiguration(configuration)
+                .ConfigureServices(s =>
+                {
+                    Action<ConfigurationBuilderCachePart> settings = (x) =>
+                    {
+                        x.WithMicrosoftLogging(log =>
+                        {
+                            log.AddConsole(LogLevel.Debug);
+                        })
+                        .WithDictionaryHandle();
+                    };
+<<<<<<< HEAD
+                    
+=======
+>>>>>>> develop
+                    s.AddOcelotOutputCaching(settings);
+                    s.AddOcelot(configuration);
+                })
+                .ConfigureLogging(l =>
+                {
+                    l.AddConsole(configuration.GetSection("Logging"));
+                    l.AddDebug();
+                })
+                .Configure(a =>
+                {
+                    a.UseOcelot(ocelotMiddlewareConfig).Wait();
+                }));
+
+            _ocelotClient = _ocelotServer.CreateClient();
+        }
+
+        public void GivenIHaveAddedATokenToMyRequest()
+        {
+            _ocelotClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", _token.AccessToken);
+        }
+
+        public void GivenIHaveAToken(string url)
+        {
+            var tokenUrl = $"{url}/connect/token";
+            var formData = new List<KeyValuePair<string, string>>
+            {
+                new KeyValuePair<string, string>("client_id", "client"),
+                new KeyValuePair<string, string>("client_secret", "secret"),
+                new KeyValuePair<string, string>("scope", "api"),
+                new KeyValuePair<string, string>("username", "test"),
+                new KeyValuePair<string, string>("password", "test"),
+                new KeyValuePair<string, string>("grant_type", "password")
+            };
+            var content = new FormUrlEncodedContent(formData);
+
+            using (var httpClient = new HttpClient())
+            {
+                var response = httpClient.PostAsync(tokenUrl, content).Result;
+                var responseContent = response.Content.ReadAsStringAsync().Result;
+                response.EnsureSuccessStatusCode();
+                _token = JsonConvert.DeserializeObject<BearerToken>(responseContent);
+            }
+        }
+
+        public void GivenIHaveAnOcelotToken(string adminPath)
+        {
+            var tokenUrl = $"{adminPath}/connect/token";
+            var formData = new List<KeyValuePair<string, string>>
+            {
+                new KeyValuePair<string, string>("client_id", "admin"),
+                new KeyValuePair<string, string>("client_secret", "secret"),
+                new KeyValuePair<string, string>("scope", "admin"),
+                new KeyValuePair<string, string>("username", "admin"),
+                new KeyValuePair<string, string>("password", "admin"),
+                new KeyValuePair<string, string>("grant_type", "password")
+            };
+            var content = new FormUrlEncodedContent(formData);
+
+            var response = _ocelotClient.PostAsync(tokenUrl, content).Result;
+            var responseContent = response.Content.ReadAsStringAsync().Result;
+            response.EnsureSuccessStatusCode();
+            _token = JsonConvert.DeserializeObject<BearerToken>(responseContent);
+        }
+
+        public void VerifyIdentiryServerStarted(string url)
+        {
+            using (var httpClient = new HttpClient())
+            {
+                var response = httpClient.GetAsync($"{url}/.well-known/openid-configuration").Result;
+                response.EnsureSuccessStatusCode();
+            }
+        }
+
+        public void WhenIGetUrlOnTheApiGateway(string url)
+        {
+            _response = _ocelotClient.GetAsync(url).Result;
+        }
+
+        public void WhenIGetUrlOnTheApiGatewayMultipleTimes(string url, int times)
+        {
+            var tasks = new Task[times];
+            
+            for (int i = 0; i < times; i++)
+            {
+                var urlCopy = url;
+                tasks[i] = GetForServiceDiscoveryTest(urlCopy);
+                Thread.Sleep(_random.Next(40,60));
+            }
+
+            Task.WaitAll(tasks);
+        }
+
+        private async Task GetForServiceDiscoveryTest(string url)
+        {
+            var response = await _ocelotClient.GetAsync(url);
+            var content = await response.Content.ReadAsStringAsync();
+            int count = int.Parse(content);
+            count.ShouldBeGreaterThan(0);
+        }
+
+        public void WhenIGetUrlOnTheApiGatewayMultipleTimesForRateLimit(string url, int times)
+        {
+            for (int i = 0; i < times; i++)
+            {
+                var clientId = "ocelotclient1";
+                var request = new HttpRequestMessage(new HttpMethod("GET"), url);
+                request.Headers.Add("ClientId", clientId);
+                _response = _ocelotClient.SendAsync(request).Result;
+            }
+        } 
+
+        public void WhenIGetUrlOnTheApiGateway(string url, string requestId)
+        {
+            _ocelotClient.DefaultRequestHeaders.TryAddWithoutValidation(RequestIdKey, requestId);
+
+            _response = _ocelotClient.GetAsync(url).Result;
+        }
+
+        public void WhenIPostUrlOnTheApiGateway(string url)
+        {
+            _response = _ocelotClient.PostAsync(url, _postContent).Result;
+        }
+
+        public void GivenThePostHasContent(string postcontent)
+        {
+            _postContent = new StringContent(postcontent);
+        }
+
+        public void ThenTheResponseBodyShouldBe(string expectedBody)
+        {
+            _response.Content.ReadAsStringAsync().Result.ShouldBe(expectedBody);
+        }
+
+        public void ThenTheStatusCodeShouldBe(HttpStatusCode expectedHttpStatusCode)
+        {
+            _response.StatusCode.ShouldBe(expectedHttpStatusCode);
+        }
+
+
+        public void ThenTheStatusCodeShouldBe(int expectedHttpStatusCode)
+        {
+            var responseStatusCode = (int)_response.StatusCode;
+            responseStatusCode.ShouldBe(expectedHttpStatusCode);
+        }
+
+        public void Dispose()
+        {
+            _ocelotClient?.Dispose();
+            _ocelotServer?.Dispose();
+        }
+
+        public void ThenTheRequestIdIsReturned()
+        {
+            _response.Headers.GetValues(RequestIdKey).First().ShouldNotBeNullOrEmpty();
+        }
+
+        public void ThenTheRequestIdIsReturned(string expected)
+        {
+            _response.Headers.GetValues(RequestIdKey).First().ShouldBe(expected);
+        }
+    }
+}

test/Ocelot.AcceptanceTests/TestConfiguration.cs

@@ -1,9 +1,10 @@
 using System;
+using System.IO;
 
 namespace Ocelot.AcceptanceTests
 {
     public static class TestConfiguration
     {
-        public static string ConfigurationPath => $"{AppContext.BaseDirectory}/configuration.json";
+        public static string ConfigurationPath => Path.Combine(AppContext.BaseDirectory, "configuration.json");
     }
 }

test/Ocelot.AcceptanceTests/TestConfiguration.cs.orig

@@ -0,0 +1,17 @@
+using System;
+<<<<<<< HEAD
+=======
+using System.IO;
+>>>>>>> develop
+
+namespace Ocelot.AcceptanceTests
+{
+    public static class TestConfiguration
+    {
+<<<<<<< HEAD
+        public static string ConfigurationPath => $"{AppContext.BaseDirectory}/configuration.json";
+=======
+        public static string ConfigurationPath => Path.Combine(AppContext.BaseDirectory, "configuration.json");
+>>>>>>> develop
+    }
+}

test/Ocelot.AcceptanceTests/configuration.json

@@ -0,0 +1 @@
+{"ReRoutes":[{"DownstreamPathTemplate":"41879/","UpstreamPathTemplate":"/","UpstreamHttpMethod":"Get","AuthenticationOptions":{"Provider":null,"ProviderRootUrl":null,"ScopeName":null,"RequireHttps":false,"AdditionalScopes":[],"ScopeSecret":null},"AddHeadersToRequest":{},"AddClaimsToRequest":{},"RouteClaimsRequirement":{},"AddQueriesToRequest":{},"RequestIdKey":null,"FileCacheOptions":{"TtlSeconds":0},"ReRouteIsCaseSensitive":false,"ServiceName":null,"DownstreamScheme":"http","DownstreamHost":"localhost","DownstreamPort":41879,"QoSOptions":{"ExceptionsAllowedBeforeBreaking":0,"DurationOfBreak":0,"TimeoutValue":0},"LoadBalancer":null,"RateLimitOptions":{"ClientWhitelist":[],"EnableRateLimiting":false,"Period":null,"PeriodTimespan":0.0,"Limit":0}}],"GlobalConfiguration":{"RequestIdKey":null,"ServiceDiscoveryProvider":{"Provider":null,"Host":null,"Port":0},"AdministrationPath":null,"RateLimitOptions":{"ClientIdHeader":"ClientId","QuotaExceededMessage":null,"RateLimitCounterPrefix":"ocelot","DisableRateLimitHeaders":false,"HttpStatusCode":429}}}

test/Ocelot.AcceptanceTests/project.json

@@ -23,23 +23,25 @@
     "Microsoft.AspNetCore.Http": "1.1.0",
     "Microsoft.DotNet.InternalAbstractions": "1.0.0",
     "Ocelot": "0.0.0-dev",
-    "xunit": "2.2.0-beta2-build3300",
     "dotnet-test-xunit": "2.2.0-preview2-build1029",
     "Ocelot.ManualTest": "0.0.0-dev",
     "Microsoft.AspNetCore.TestHost": "1.1.0",
     "IdentityServer4": "1.0.1",
     "Microsoft.AspNetCore.Mvc": "1.1.0",
     "Microsoft.AspNetCore.Server.Kestrel": "1.1.0",
+    "Microsoft.AspNetCore.Server.Kestrel.Https": "1.1.0",
     "Microsoft.NETCore.App": "1.1.0",
     "Shouldly": "2.8.2",
     "TestStack.BDDfy": "4.3.2",
-    "Consul": "0.7.2.1"
+    "Consul": "0.7.2.1",
+    "Microsoft.Extensions.Caching.Memory": "1.1.0",
+    "xunit": "2.2.0-rc1-build3507"
   },
   "runtimes": {
-    "win10-x64": {},
-    "osx.10.11-x64": {},
-    "osx.10.12-x64": {},
-    "win7-x64": {}
+    "osx.10.11-x64":{},
+    "osx.10.12-x64":{},
+    "win7-x64": {},
+    "win10-x64": {}
   },
   "frameworks": {
     "netcoreapp1.1": {

test/Ocelot.AcceptanceTests/project.json.orig

@@ -0,0 +1,59 @@
+{
+  "version": "0.0.0-dev",
+
+  "buildOptions": {
+    "copyToOutput": {
+      "include": [
+        "configuration.json"
+      ]
+    }
+  },
+
+  "testRunner": "xunit",
+
+  "dependencies": {
+    "Microsoft.AspNetCore.Server.IISIntegration": "1.1.0",
+    "Microsoft.Extensions.Configuration.EnvironmentVariables": "1.1.0",
+    "Microsoft.Extensions.Configuration.FileExtensions": "1.1.0",
+    "Microsoft.Extensions.Configuration.Json": "1.1.0",
+    "Microsoft.Extensions.Logging": "1.1.0",
+    "Microsoft.Extensions.Logging.Console": "1.1.0",
+    "Microsoft.Extensions.Logging.Debug": "1.1.0",
+    "Microsoft.Extensions.Options.ConfigurationExtensions": "1.1.0",
+    "Microsoft.AspNetCore.Http": "1.1.0",
+    "Microsoft.DotNet.InternalAbstractions": "1.0.0",
+    "Ocelot": "0.0.0-dev",
+    "dotnet-test-xunit": "2.2.0-preview2-build1029",
+    "Ocelot.ManualTest": "0.0.0-dev",
+    "Microsoft.AspNetCore.TestHost": "1.1.0",
+    "IdentityServer4": "1.0.1",
+    "Microsoft.AspNetCore.Mvc": "1.1.0",
+    "Microsoft.AspNetCore.Server.Kestrel": "1.1.0",
+    "Microsoft.AspNetCore.Server.Kestrel.Https": "1.1.0",
+    "Microsoft.NETCore.App": "1.1.0",
+    "Shouldly": "2.8.2",
+    "TestStack.BDDfy": "4.3.2",
+    "Consul": "0.7.2.1",
+    "Microsoft.Extensions.Caching.Memory": "1.1.0",
+    "xunit": "2.2.0-rc1-build3507"
+  },
+  "runtimes": {
+<<<<<<< HEAD
+    "win10-x64": {},
+    "osx.10.11-x64": {},
+    "osx.10.12-x64": {},
+    "win7-x64": {}
+=======
+    "osx.10.11-x64":{},
+    "osx.10.12-x64":{},
+    "win7-x64": {},
+    "win10-x64": {}
+>>>>>>> develop
+  },
+  "frameworks": {
+    "netcoreapp1.1": {
+      "imports": [
+      ]
+    }
+  }
+}

test/Ocelot.Benchmarks/project.json

@@ -9,10 +9,10 @@
     "BenchmarkDotNet": "0.10.2"
   },
   "runtimes": {
-    "win10-x64": {},
     "osx.10.11-x64":{},
-    "osx.10.12-x64": {},
-    "win7-x64": {}
+    "osx.10.12-x64":{},
+    "win7-x64": {},
+    "win10-x64": {}
   },
   "frameworks": {
     "netcoreapp1.1": {

test/Ocelot.Benchmarks/project.json.orig

@@ -0,0 +1,28 @@
+{
+  "version": "0.0.0-dev",
+  "buildOptions": {
+    "emitEntryPoint": true
+  },
+
+  "dependencies": {
+    "Ocelot": "0.0.0-dev",
+    "BenchmarkDotNet": "0.10.2"
+  },
+  "runtimes": {
+    "osx.10.11-x64":{},
+<<<<<<< HEAD
+    "osx.10.12-x64": {},
+    "win7-x64": {}
+=======
+    "osx.10.12-x64":{},
+    "win7-x64": {},
+    "win10-x64": {}
+>>>>>>> develop
+  },
+  "frameworks": {
+    "netcoreapp1.1": {
+      "imports": [
+      ]
+    }
+  }
+}

test/Ocelot.IntegrationTests/configuration.json

@@ -1 +1 @@
-{"ReRoutes":[],"GlobalConfiguration":{"RequestIdKey":null,"ServiceDiscoveryProvider":{"Provider":null,"Host":null,"Port":0},"AdministrationPath":"/administration"}}
+{"ReRoutes":[],"GlobalConfiguration":{"RequestIdKey":null,"ServiceDiscoveryProvider":{"Provider":null,"Host":null,"Port":0},"AdministrationPath":"/administration","RateLimitOptions":{"ClientIdHeader":"ClientId","QuotaExceededMessage":null,"RateLimitCounterPrefix":"ocelot","DisableRateLimitHeaders":false,"HttpStatusCode":429}}}

test/Ocelot.ManualTest/Startup.cs

@@ -37,7 +37,6 @@ namespace Ocelot.ManualTest
                 })
                 .WithDictionaryHandle();
             };
-
             services.AddOcelotOutputCaching(settings);
             services.AddOcelot(Configuration);
         }

test/Ocelot.ManualTest/configuration.json

@@ -47,9 +47,9 @@
     },
     {
       "DownstreamPathTemplate": "/posts",
-      "DownstreamScheme": "http",
+      "DownstreamScheme": "https",
       "DownstreamHost": "jsonplaceholder.typicode.com",
-      "DownstreamPort": 80,
+      "DownstreamPort": 443,
       "UpstreamPathTemplate": "/posts",
       "UpstreamHttpMethod": "Get",
       "QoSOptions": {

test/Ocelot.ManualTest/configuration.json.orig

@@ -0,0 +1,310 @@
+{
+  "ReRoutes": [
+    {
+      "DownstreamPathTemplate": "/",
+      "DownstreamScheme": "http",
+      "DownstreamHost": "localhost",
+      "DownstreamPort": 52876,
+      "UpstreamPathTemplate": "/identityserverexample",
+      "UpstreamHttpMethod": "Get",
+      "QoSOptions": {
+        "ExceptionsAllowedBeforeBreaking": 3,
+        "DurationOfBreak": 10,
+        "TimeoutValue": 5000
+      },
+      "AuthenticationOptions": {
+        "Provider": "IdentityServer",
+        "ProviderRootUrl": "http://localhost:52888",
+        "ScopeName": "api",
+        "AdditionalScopes": [
+          "openid",
+          "offline_access"
+        ],
+        "ScopeSecret": "secret"
+      },
+      "AddHeadersToRequest": {
+        "CustomerId": "Claims[CustomerId] > value",
+        "LocationId": "Claims[LocationId] > value",
+        "UserType": "Claims[sub] > value[0] > |",
+        "UserId": "Claims[sub] > value[1] > |"
+      },
+      "AddClaimsToRequest": {
+        "CustomerId": "Claims[CustomerId] > value",
+        "LocationId": "Claims[LocationId] > value",
+        "UserType": "Claims[sub] > value[0] > |",
+        "UserId": "Claims[sub] > value[1] > |"
+      },
+      "AddQueriesToRequest": {
+        "CustomerId": "Claims[CustomerId] > value",
+        "LocationId": "Claims[LocationId] > value",
+        "UserType": "Claims[sub] > value[0] > |",
+        "UserId": "Claims[sub] > value[1] > |"
+      },
+      "RouteClaimsRequirement": {
+        "UserType": "registered"
+      },
+      "RequestIdKey": "OcRequestId"
+    },
+    {
+      "DownstreamPathTemplate": "/posts",
+      "DownstreamScheme": "https",
+      "DownstreamHost": "jsonplaceholder.typicode.com",
+<<<<<<< HEAD
+      "DownstreamPort": 80,
+=======
+      "DownstreamPort": 443,
+>>>>>>> develop
+      "UpstreamPathTemplate": "/posts",
+      "UpstreamHttpMethod": "Get",
+      "QoSOptions": {
+        "ExceptionsAllowedBeforeBreaking": 3,
+        "DurationOfBreak": 10,
+        "TimeoutValue": 5000
+      }
+    },
+    {
+      "DownstreamPathTemplate": "/posts/{postId}",
+      "DownstreamScheme": "http",
+      "DownstreamHost": "jsonplaceholder.typicode.com",
+      "DownstreamPort": 80,
+      "UpstreamPathTemplate": "/posts/{postId}",
+      "UpstreamHttpMethod": "Get",
+      "QoSOptions": {
+        "ExceptionsAllowedBeforeBreaking": 3,
+        "DurationOfBreak": 10,
+        "TimeoutValue": 5000
+      }
+    },
+    {
+      "DownstreamPathTemplate": "/posts/{postId}/comments",
+      "DownstreamScheme": "http",
+      "DownstreamHost": "jsonplaceholder.typicode.com",
+      "DownstreamPort": 80,
+      "UpstreamPathTemplate": "/posts/{postId}/comments",
+      "UpstreamHttpMethod": "Get",
+      "QoSOptions": {
+        "ExceptionsAllowedBeforeBreaking": 3,
+        "DurationOfBreak": 10,
+        "TimeoutValue": 5000
+      }
+    },
+    {
+      "DownstreamPathTemplate": "/comments",
+      "DownstreamScheme": "http",
+      "DownstreamHost": "jsonplaceholder.typicode.com",
+      "DownstreamPort": 80,
+      "UpstreamPathTemplate": "/comments",
+      "UpstreamHttpMethod": "Get",
+      "QoSOptions": {
+        "ExceptionsAllowedBeforeBreaking": 3,
+        "DurationOfBreak": 10,
+        "TimeoutValue": 5000
+      }
+    },
+    {
+      "DownstreamPathTemplate": "/posts",
+      "DownstreamScheme": "http",
+      "DownstreamHost": "jsonplaceholder.typicode.com",
+      "DownstreamPort": 80,
+      "UpstreamPathTemplate": "/posts",
+      "UpstreamHttpMethod": "Post",
+      "QoSOptions": {
+        "ExceptionsAllowedBeforeBreaking": 3,
+        "DurationOfBreak": 10,
+        "TimeoutValue": 5000
+      }
+    },
+    {
+      "DownstreamPathTemplate": "/posts/{postId}",
+      "DownstreamScheme": "http",
+      "DownstreamHost": "jsonplaceholder.typicode.com",
+      "DownstreamPort": 80,
+      "UpstreamPathTemplate": "/posts/{postId}",
+      "UpstreamHttpMethod": "Put",
+      "QoSOptions": {
+        "ExceptionsAllowedBeforeBreaking": 3,
+        "DurationOfBreak": 10,
+        "TimeoutValue": 5000
+      }
+    },
+    {
+      "DownstreamPathTemplate": "/posts/{postId}",
+      "DownstreamScheme": "http",
+      "DownstreamHost": "jsonplaceholder.typicode.com",
+      "DownstreamPort": 80,
+      "UpstreamPathTemplate": "/posts/{postId}",
+      "UpstreamHttpMethod": "Patch",
+      "QoSOptions": {
+        "ExceptionsAllowedBeforeBreaking": 3,
+        "DurationOfBreak": 10,
+        "TimeoutValue": 5000
+      }
+    },
+    {
+      "DownstreamPathTemplate": "/posts/{postId}",
+      "DownstreamScheme": "http",
+      "DownstreamHost": "jsonplaceholder.typicode.com",
+      "DownstreamPort": 80,
+      "UpstreamPathTemplate": "/posts/{postId}",
+      "UpstreamHttpMethod": "Delete",
+      "QoSOptions": {
+        "ExceptionsAllowedBeforeBreaking": 3,
+        "DurationOfBreak": 10,
+        "TimeoutValue": 5000
+      }
+    },
+    {
+      "DownstreamPathTemplate": "/api/products",
+      "DownstreamScheme": "http",
+      "DownstreamHost": "jsonplaceholder.typicode.com",
+      "DownstreamPort": 80,
+      "UpstreamPathTemplate": "/products",
+      "UpstreamHttpMethod": "Get",
+      "QoSOptions": {
+        "ExceptionsAllowedBeforeBreaking": 3,
+        "DurationOfBreak": 10,
+        "TimeoutValue": 5000
+      },
+      "FileCacheOptions": { "TtlSeconds": 15 }
+    },
+    {
+      "DownstreamPathTemplate": "/api/products/{productId}",
+      "DownstreamScheme": "http",
+      "DownstreamHost": "jsonplaceholder.typicode.com",
+      "DownstreamPort": 80,
+      "UpstreamPathTemplate": "/products/{productId}",
+      "UpstreamHttpMethod": "Get",
+      "FileCacheOptions": { "TtlSeconds": 15 }
+    },
+    {
+      "DownstreamPathTemplate": "/api/products",
+      "DownstreamScheme": "http",
+      "DownstreamHost": "products20161126090340.azurewebsites.net",
+      "DownstreamPort": 80,
+      "UpstreamPathTemplate": "/products",
+      "UpstreamHttpMethod": "Post",
+      "QoSOptions": {
+        "ExceptionsAllowedBeforeBreaking": 3,
+        "DurationOfBreak": 10,
+        "TimeoutValue": 5000
+      }
+    },
+    {
+      "DownstreamPathTemplate": "/api/products/{productId}",
+      "DownstreamScheme": "http",
+      "DownstreamHost": "products20161126090340.azurewebsites.net",
+      "DownstreamPort": 80,
+      "UpstreamPathTemplate": "/products/{productId}",
+      "UpstreamHttpMethod": "Put",
+      "QoSOptions": {
+        "ExceptionsAllowedBeforeBreaking": 3,
+        "DurationOfBreak": 10,
+        "TimeoutValue": 5000
+      },
+      "FileCacheOptions": { "TtlSeconds": 15 }
+    },
+    {
+      "DownstreamPathTemplate": "/api/products/{productId}",
+      "DownstreamScheme": "http",
+      "DownstreamHost": "products20161126090340.azurewebsites.net",
+      "DownstreamPort": 80,
+      "UpstreamPathTemplate": "/products/{productId}",
+      "UpstreamHttpMethod": "Delete",
+      "QoSOptions": {
+        "ExceptionsAllowedBeforeBreaking": 3,
+        "DurationOfBreak": 10,
+        "TimeoutValue": 5000
+      },
+      "FileCacheOptions": { "TtlSeconds": 15 }
+    },
+    {
+      "DownstreamPathTemplate": "/api/customers",
+      "DownstreamScheme": "http",
+      "DownstreamHost": "customers20161126090811.azurewebsites.net",
+      "DownstreamPort": 80,
+      "UpstreamPathTemplate": "/customers",
+      "UpstreamHttpMethod": "Get",
+      "QoSOptions": {
+        "ExceptionsAllowedBeforeBreaking": 3,
+        "DurationOfBreak": 10,
+        "TimeoutValue": 5000
+      },
+      "FileCacheOptions": { "TtlSeconds": 15 }
+    },
+    {
+      "DownstreamPathTemplate": "/api/customers/{customerId}",
+      "DownstreamScheme": "http",
+      "DownstreamHost": "customers20161126090811.azurewebsites.net",
+      "DownstreamPort": 80,
+      "UpstreamPathTemplate": "/customers/{customerId}",
+      "UpstreamHttpMethod": "Get",
+      "QoSOptions": {
+        "ExceptionsAllowedBeforeBreaking": 3,
+        "DurationOfBreak": 10,
+        "TimeoutValue": 5000
+      },
+      "FileCacheOptions": { "TtlSeconds": 15 }
+    },
+    {
+      "DownstreamPathTemplate": "/api/customers",
+      "DownstreamScheme": "http",
+      "DownstreamHost": "customers20161126090811.azurewebsites.net",
+      "DownstreamPort": 80,
+      "UpstreamPathTemplate": "/customers",
+      "UpstreamHttpMethod": "Post",
+      "QoSOptions": {
+        "ExceptionsAllowedBeforeBreaking": 3,
+        "DurationOfBreak": 10,
+        "TimeoutValue": 5000
+      },
+      "FileCacheOptions": { "TtlSeconds": 15 }
+    },
+    {
+      "DownstreamPathTemplate": "/api/customers/{customerId}",
+      "DownstreamScheme": "http",
+      "DownstreamHost": "customers20161126090811.azurewebsites.net",
+      "DownstreamPort": 80,
+      "UpstreamPathTemplate": "/customers/{customerId}",
+      "UpstreamHttpMethod": "Put",
+      "QoSOptions": {
+        "ExceptionsAllowedBeforeBreaking": 3,
+        "DurationOfBreak": 10,
+        "TimeoutValue": 5000
+      },
+      "FileCacheOptions": { "TtlSeconds": 15 }
+    },
+    {
+      "DownstreamPathTemplate": "/api/customers/{customerId}",
+      "DownstreamScheme": "http",
+      "DownstreamHost": "customers20161126090811.azurewebsites.net",
+      "DownstreamPort": 80,
+      "UpstreamPathTemplate": "/customers/{customerId}",
+      "UpstreamHttpMethod": "Delete",
+      "QoSOptions": {
+        "ExceptionsAllowedBeforeBreaking": 3,
+        "DurationOfBreak": 10,
+        "TimeoutValue": 5000
+      },
+      "FileCacheOptions": { "TtlSeconds": 15 }
+    },
+    {
+      "DownstreamPathTemplate": "/posts",
+      "DownstreamScheme": "http",
+      "DownstreamHost": "jsonplaceholder.typicode.com",
+      "DownstreamPort": 80,
+      "UpstreamPathTemplate": "/posts/",
+      "UpstreamHttpMethod": "Get",
+      "QoSOptions": {
+        "ExceptionsAllowedBeforeBreaking": 3,
+        "DurationOfBreak": 10,
+        "TimeoutValue": 5000
+      },
+      "FileCacheOptions": { "TtlSeconds": 15 }
+    }
+  ],
+
+  "GlobalConfiguration": {
+    "RequestIdKey": "OcRequestId",
+    "AdministrationPath": "/admin"
+  }
+}

test/Ocelot.ManualTest/project.json

@@ -22,10 +22,10 @@
     "Microsoft.AspNetCore.Server.IISIntegration.Tools": "1.0.0-preview2-final"
   },
   "runtimes": {
-    "win10-x64": {},
     "osx.10.11-x64":{},
-    "osx.10.12-x64": {},
-    "win7-x64": {}
+    "osx.10.12-x64":{},
+    "win7-x64": {},
+    "win10-x64": {}
   },
   "frameworks": {
     "netcoreapp1.1": {

test/Ocelot.ManualTest/project.json.orig

@@ -0,0 +1,72 @@
+{
+  "version": "0.0.0-dev",
+
+  "dependencies": {
+    "Microsoft.AspNetCore.Http": "1.1.0",
+    "Microsoft.Extensions.Configuration.EnvironmentVariables": "1.1.0",
+    "Microsoft.Extensions.Configuration.FileExtensions": "1.1.0",
+    "Microsoft.Extensions.Configuration.Json": "1.1.0",
+    "Microsoft.Extensions.Logging": "1.1.0",
+    "Microsoft.Extensions.Logging.Console": "1.1.0",
+    "Microsoft.Extensions.Logging.Debug": "1.1.0",
+    "Microsoft.Extensions.Options.ConfigurationExtensions": "1.1.0",
+    "Ocelot": "0.0.0-dev",
+    "Microsoft.AspNetCore.Server.Kestrel": "1.1.0",
+    "Microsoft.NETCore.App": "1.1.0",
+    "Consul": "0.7.2.1",
+    "Polly": "5.0.3",
+      "Microsoft.AspNetCore.Cryptography.KeyDerivation": "1.1.0"
+  },
+
+  "tools": {
+    "Microsoft.AspNetCore.Server.IISIntegration.Tools": "1.0.0-preview2-final"
+  },
+  "runtimes": {
+    "osx.10.11-x64":{},
+<<<<<<< HEAD
+    "osx.10.12-x64": {},
+    "win7-x64": {}
+=======
+    "osx.10.12-x64":{},
+    "win7-x64": {},
+    "win10-x64": {}
+>>>>>>> develop
+  },
+  "frameworks": {
+    "netcoreapp1.1": {
+      "imports": [
+      ]
+    }
+  },
+
+  "buildOptions": {
+    "emitEntryPoint": true,
+    "preserveCompilationContext": true,
+    "copyToOutput": {
+      "include": [
+        "configuration.json"
+      ]
+    }
+  },
+
+  "runtimeOptions": {
+    "configProperties": {
+      "System.GC.Server": true
+    }
+  },
+
+  "publishOptions": {
+    "include": [
+      "wwwroot",
+      "Views",
+      "Areas/**/Views",
+      "appsettings.json",
+      "web.config",
+      "configuration.json"
+    ]
+  },
+
+  "scripts": {
+    "postpublish": [ "dotnet publish-iis --publish-folder %publish:OutputPath% --framework %publish:FullTargetFramework%" ]
+  }
+}

test/Ocelot.UnitTests/RateLimit/ClientRateLimitMiddlewareTests.cs

@@ -0,0 +1,149 @@
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.TestHost;
+using Microsoft.AspNetCore.Http;
+using Moq;
+using Ocelot.Infrastructure.RequestData;
+using Ocelot.RateLimit;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Threading.Tasks;
+using Microsoft.Extensions.DependencyInjection;
+using Ocelot.Logging;
+using System.IO;
+using Ocelot.RateLimit.Middleware;
+using Ocelot.DownstreamRouteFinder;
+using Ocelot.Responses;
+using Xunit;
+using TestStack.BDDfy;
+using Ocelot.Configuration.Builder;
+using Shouldly;
+using Ocelot.Configuration;
+
+namespace Ocelot.UnitTests.RateLimit
+{
+    public class ClientRateLimitMiddlewareTests
+    {
+        private readonly Mock<IRequestScopedDataRepository> _scopedRepository;
+        private readonly string _url;
+        private readonly TestServer _server;
+        private readonly HttpClient _client;
+        private OkResponse<DownstreamRoute> _downstreamRoute;
+        private int responseStatusCode;
+
+        public ClientRateLimitMiddlewareTests()
+        {
+            _url = "http://localhost:51879/api/ClientRateLimit";
+            _scopedRepository = new Mock<IRequestScopedDataRepository>();
+             var builder = new WebHostBuilder()
+              .ConfigureServices(x =>
+              {
+                  x.AddSingleton<IOcelotLoggerFactory, AspDotNetLoggerFactory>();
+                  x.AddLogging();
+                  x.AddMemoryCache();
+                  x.AddSingleton<IRateLimitCounterHandler, MemoryCacheRateLimitCounterHandler>();
+                  x.AddSingleton(_scopedRepository.Object);
+              })
+              .UseUrls(_url)
+              .UseKestrel()
+              .UseContentRoot(Directory.GetCurrentDirectory())
+              .UseIISIntegration()
+              .UseUrls(_url)
+              .Configure(app =>
+              {
+                  app.UseRateLimiting();
+                  app.Run(async context =>
+                  {
+                      context.Response.StatusCode = 200;
+                      await context.Response.WriteAsync("This is ratelimit test");
+                  });
+              });
+
+            _server = new TestServer(builder);
+            _client = _server.CreateClient();
+        }
+
+
+        [Fact]
+        public void should_call_middleware_and_ratelimiting()
+        {
+            var downstreamRoute = new DownstreamRoute(new List<Ocelot.DownstreamRouteFinder.UrlMatcher.UrlPathPlaceholderNameAndValue>(),
+                 new ReRouteBuilder().WithEnableRateLimiting(true).WithRateLimitOptions(
+                     new Ocelot.Configuration.RateLimitOptions(true, "ClientId", new List<string>(), false, "", "", new Ocelot.Configuration.RateLimitRule("1s", TimeSpan.FromSeconds(100), 3), 429))
+                     .WithUpstreamHttpMethod("Get")
+                     .Build());
+
+            this.Given(x => x.GivenTheDownStreamRouteIs(downstreamRoute))
+                .When(x => x.WhenICallTheMiddlewareMultipleTime(2))
+                .Then(x => x.ThenresponseStatusCodeIs200())
+                .When(x => x.WhenICallTheMiddlewareMultipleTime(2))
+                .Then(x => x.ThenresponseStatusCodeIs429())
+                .BDDfy();
+        }
+
+        [Fact]
+        public void should_call_middleware_withWhitelistClient()
+        {
+            var downstreamRoute = new DownstreamRoute(new List<Ocelot.DownstreamRouteFinder.UrlMatcher.UrlPathPlaceholderNameAndValue>(),
+                 new ReRouteBuilder().WithEnableRateLimiting(true).WithRateLimitOptions(
+                     new Ocelot.Configuration.RateLimitOptions(true, "ClientId", new List<string>() { "ocelotclient2" }, false, "", "", new  RateLimitRule( "1s", TimeSpan.FromSeconds(100),3),429))
+                     .WithUpstreamHttpMethod("Get")
+                     .Build());
+
+            this.Given(x => x.GivenTheDownStreamRouteIs(downstreamRoute))
+                .When(x => x.WhenICallTheMiddlewareWithWhiteClient())
+                .Then(x => x.ThenresponseStatusCodeIs200())
+                .BDDfy();
+        }
+
+
+        private void GivenTheDownStreamRouteIs(DownstreamRoute downstreamRoute)
+        {
+            _downstreamRoute = new OkResponse<DownstreamRoute>(downstreamRoute);
+            _scopedRepository
+                .Setup(x => x.Get<DownstreamRoute>(It.IsAny<string>()))
+                .Returns(_downstreamRoute);
+        }
+
+        private void WhenICallTheMiddlewareMultipleTime(int times)
+        {
+            var clientId = "ocelotclient1";
+            // Act    
+            for (int i = 0; i < times; i++)
+            {
+                var request = new HttpRequestMessage(new HttpMethod("GET"), _url);
+                request.Headers.Add("ClientId", clientId);
+
+                var response = _client.SendAsync(request);
+                responseStatusCode = (int)response.Result.StatusCode;
+            }
+
+        }
+
+        private void WhenICallTheMiddlewareWithWhiteClient()
+        {
+            var clientId = "ocelotclient2";
+            // Act    
+            for (int i = 0; i < 10; i++)
+            {
+                var request = new HttpRequestMessage(new HttpMethod("GET"), _url);
+                request.Headers.Add("ClientId", clientId);
+
+                var response = _client.SendAsync(request);
+                responseStatusCode = (int)response.Result.StatusCode;
+            }
+         }      
+
+        private void ThenresponseStatusCodeIs429()
+        {
+            responseStatusCode.ShouldBe(429);
+        }
+
+        private void ThenresponseStatusCodeIs200()
+        {
+            responseStatusCode.ShouldBe(200);
+        }
+    }
+}

test/Ocelot.UnitTests/project.json

@@ -3,35 +3,35 @@
 
   "testRunner": "xunit",
 
-  "dependencies": {
-    "Microsoft.AspNetCore.Server.IISIntegration": "1.1.0",
-    "Microsoft.Extensions.Configuration.EnvironmentVariables": "1.1.0",
-    "Microsoft.Extensions.Configuration.FileExtensions": "1.1.0",
-    "Microsoft.Extensions.Configuration.Json": "1.1.0",
-    "Microsoft.Extensions.Logging": "1.1.0",
-    "Microsoft.Extensions.Logging.Console": "1.1.0",
-    "Microsoft.Extensions.Logging.Debug": "1.1.0",
-    "Microsoft.Extensions.Options.ConfigurationExtensions": "1.1.0",
-    "Microsoft.AspNetCore.Http": "1.1.0",
-    "Ocelot": "0.0.0-dev",
-    "xunit": "2.2.0-beta2-build3300",
-    "dotnet-test-xunit": "2.2.0-preview2-build1029",
-    "Moq": "4.6.38-alpha",
-    "Microsoft.AspNetCore.TestHost": "1.1.0",
-    "Microsoft.AspNetCore.Mvc": "1.1.0",
-    "Microsoft.AspNetCore.Server.Kestrel": "1.1.0",
-    "Microsoft.NETCore.App": "1.1.0",
-    "Shouldly": "2.8.2",
-    "TestStack.BDDfy": "4.3.2",
-    "Microsoft.AspNetCore.Authentication.OAuth": "1.1.0",
-    "Microsoft.DotNet.InternalAbstractions": "1.0.0",
-    "Microsoft.AspNetCore.Cryptography.KeyDerivation": "1.1.0"
-  },
+    "dependencies": {
+        "dotnet-test-xunit": "2.2.0-preview2-build1029",
+        "Microsoft.AspNetCore.Authentication.OAuth": "1.1.0",
+        "Microsoft.AspNetCore.Cryptography.KeyDerivation": "1.1.0",
+        "Microsoft.AspNetCore.Http": "1.1.0",
+        "Microsoft.AspNetCore.Mvc": "1.1.0",
+        "Microsoft.AspNetCore.Server.IISIntegration": "1.1.0",
+        "Microsoft.AspNetCore.Server.Kestrel": "1.1.0",
+        "Microsoft.AspNetCore.TestHost": "1.1.0",
+        "Microsoft.DotNet.InternalAbstractions": "1.0.0",
+        "Microsoft.Extensions.Configuration.EnvironmentVariables": "1.1.0",
+        "Microsoft.Extensions.Configuration.FileExtensions": "1.1.0",
+        "Microsoft.Extensions.Configuration.Json": "1.1.0",
+        "Microsoft.Extensions.Logging": "1.1.0",
+        "Microsoft.Extensions.Logging.Console": "1.1.0",
+        "Microsoft.Extensions.Logging.Debug": "1.1.0",
+        "Microsoft.Extensions.Options.ConfigurationExtensions": "1.1.0",
+        "Microsoft.NETCore.App": "1.1.0",
+        "Moq": "4.6.38-alpha",
+        "Ocelot": "0.0.0-dev",
+        "Shouldly": "2.8.2",
+        "TestStack.BDDfy": "4.3.2",
+        "xunit": "2.2.0-rc1-build3507"
+    },
   "runtimes": {
-    "win10-x64": {},
     "osx.10.11-x64":{},
-    "osx.10.12-x64": {},
-    "win7-x64": {}
+    "osx.10.12-x64":{},
+    "win7-x64": {},
+    "win10-x64": {}
   },
   "frameworks": {
     "netcoreapp1.1": {

test/Ocelot.UnitTests/project.json.orig

@@ -0,0 +1,50 @@
+{
+  "version": "0.0.0-dev",
+
+  "testRunner": "xunit",
+
+  "dependencies": {
+    "Microsoft.AspNetCore.Server.IISIntegration": "1.1.0",
+    "Microsoft.Extensions.Configuration.EnvironmentVariables": "1.1.0",
+    "Microsoft.Extensions.Configuration.FileExtensions": "1.1.0",
+    "Microsoft.Extensions.Configuration.Json": "1.1.0",
+    "Microsoft.Extensions.Logging": "1.1.0",
+    "Microsoft.Extensions.Logging.Console": "1.1.0",
+    "Microsoft.Extensions.Logging.Debug": "1.1.0",
+    "Microsoft.Extensions.Options.ConfigurationExtensions": "1.1.0",
+    "Microsoft.AspNetCore.Http": "1.1.0",
+    "Ocelot": "0.0.0-dev",
+    "dotnet-test-xunit": "2.2.0-preview2-build1029",
+    "Moq": "4.6.38-alpha",
+    "Microsoft.AspNetCore.TestHost": "1.1.0",
+    "Microsoft.AspNetCore.Mvc": "1.1.0",
+    "Microsoft.AspNetCore.Server.Kestrel": "1.1.0",
+    "Microsoft.NETCore.App": "1.1.0",
+    "Shouldly": "2.8.2",
+    "TestStack.BDDfy": "4.3.2",
+    "Microsoft.AspNetCore.Authentication.OAuth": "1.1.0",
+    "Microsoft.DotNet.InternalAbstractions": "1.0.0",
+<<<<<<< HEAD
+    "Microsoft.AspNetCore.Cryptography.KeyDerivation": "1.1.0"
+=======
+    "xunit": "2.2.0-rc1-build3507"
+>>>>>>> develop
+  },
+  "runtimes": {
+    "osx.10.11-x64":{},
+<<<<<<< HEAD
+    "osx.10.12-x64": {},
+    "win7-x64": {}
+=======
+    "osx.10.12-x64":{},
+    "win7-x64": {},
+    "win10-x64": {}
+>>>>>>> develop
+  },
+  "frameworks": {
+    "netcoreapp1.1": {
+      "imports": [
+      ]
+    }
+  }
+}