Rename all ReRoute to Route to move closer to YARP +semver: breaking

test/Ocelot.UnitTests/LoadBalancer/CookieStickySessionsCreatorTests.cs

@@ -1,74 +1,74 @@
-namespace Ocelot.UnitTests.LoadBalancer
-{
-    using Moq;
-    using Ocelot.Configuration;
-    using Ocelot.Configuration.Builder;
-    using Ocelot.LoadBalancer.LoadBalancers;
-    using Ocelot.ServiceDiscovery.Providers;
-    using Ocelot.Responses;
-    using Shouldly;
-    using TestStack.BDDfy;
-    using Xunit;
-
-    public class CookieStickySessionsCreatorTests
-    {
-        private readonly CookieStickySessionsCreator _creator;
-        private readonly Mock<IServiceDiscoveryProvider> _serviceProvider;
-        private DownstreamReRoute _reRoute;
-        private Response<ILoadBalancer> _loadBalancer;
-        private string _typeName;
-
-        public CookieStickySessionsCreatorTests()
-        {
-            _creator = new CookieStickySessionsCreator();
-            _serviceProvider = new Mock<IServiceDiscoveryProvider>();
-        }
-        
-        [Fact]
-        public void should_return_instance_of_expected_load_balancer_type()
-        {
-            var reRoute = new DownstreamReRouteBuilder()
-                .WithLoadBalancerOptions(new LoadBalancerOptions("myType", "myKey", 1000))
-                .Build();
-
-            this.Given(x => x.GivenAReRoute(reRoute))
-                .When(x => x.WhenIGetTheLoadBalancer())
-                .Then(x => x.ThenTheLoadBalancerIsReturned<CookieStickySessions>())
-                .BDDfy();
-        }
-                
-        [Fact]
-        public void should_return_expected_name()
-        {
-            this.When(x => x.WhenIGetTheLoadBalancerTypeName())
-                .Then(x => x.ThenTheLoadBalancerTypeIs("CookieStickySessions"))
-                .BDDfy();
-        }
-
-        private void GivenAReRoute(DownstreamReRoute reRoute)
-        {
-            _reRoute = reRoute;
-        }
-
-        private void WhenIGetTheLoadBalancer()
-        {
-            _loadBalancer = _creator.Create(_reRoute, _serviceProvider.Object);
-        }
-        
-        private void WhenIGetTheLoadBalancerTypeName()
-        {
-            _typeName = _creator.Type;
-        }
-
-        private void ThenTheLoadBalancerIsReturned<T>()
-            where T : ILoadBalancer
-        {
-            _loadBalancer.Data.ShouldBeOfType<T>();
-        }
-
-        private void ThenTheLoadBalancerTypeIs(string type)
-        {
-            _typeName.ShouldBe(type);
-        }
-    }
-}
+namespace Ocelot.UnitTests.LoadBalancer
+{
+    using Moq;
+    using Ocelot.Configuration;
+    using Ocelot.Configuration.Builder;
+    using Ocelot.LoadBalancer.LoadBalancers;
+    using Ocelot.ServiceDiscovery.Providers;
+    using Ocelot.Responses;
+    using Shouldly;
+    using TestStack.BDDfy;
+    using Xunit;
+
+    public class CookieStickySessionsCreatorTests
+    {
+        private readonly CookieStickySessionsCreator _creator;
+        private readonly Mock<IServiceDiscoveryProvider> _serviceProvider;
+        private DownstreamRoute _route;
+        private Response<ILoadBalancer> _loadBalancer;
+        private string _typeName;
+
+        public CookieStickySessionsCreatorTests()
+        {
+            _creator = new CookieStickySessionsCreator();
+            _serviceProvider = new Mock<IServiceDiscoveryProvider>();
+        }
+        
+        [Fact]
+        public void should_return_instance_of_expected_load_balancer_type()
+        {
+            var route = new DownstreamRouteBuilder()
+                .WithLoadBalancerOptions(new LoadBalancerOptions("myType", "myKey", 1000))
+                .Build();
+
+            this.Given(x => x.GivenARoute(route))
+                .When(x => x.WhenIGetTheLoadBalancer())
+                .Then(x => x.ThenTheLoadBalancerIsReturned<CookieStickySessions>())
+                .BDDfy();
+        }
+                
+        [Fact]
+        public void should_return_expected_name()
+        {
+            this.When(x => x.WhenIGetTheLoadBalancerTypeName())
+                .Then(x => x.ThenTheLoadBalancerTypeIs("CookieStickySessions"))
+                .BDDfy();
+        }
+
+        private void GivenARoute(DownstreamRoute route)
+        {
+            _route = route;
+        }
+
+        private void WhenIGetTheLoadBalancer()
+        {
+            _loadBalancer = _creator.Create(_route, _serviceProvider.Object);
+        }
+        
+        private void WhenIGetTheLoadBalancerTypeName()
+        {
+            _typeName = _creator.Type;
+        }
+
+        private void ThenTheLoadBalancerIsReturned<T>()
+            where T : ILoadBalancer
+        {
+            _loadBalancer.Data.ShouldBeOfType<T>();
+        }
+
+        private void ThenTheLoadBalancerTypeIs(string type)
+        {
+            _typeName.ShouldBe(type);
+        }
+    }
+}

test/Ocelot.UnitTests/LoadBalancer/DelegateInvokingLoadBalancerCreatorTests.cs

@@ -19,16 +19,16 @@ namespace Ocelot.UnitTests.LoadBalancer
     public class DelegateInvokingLoadBalancerCreatorTests
     {
         private DelegateInvokingLoadBalancerCreator<FakeLoadBalancer> _creator;
-        private Func<DownstreamReRoute, IServiceDiscoveryProvider, ILoadBalancer> _creatorFunc;
+        private Func<DownstreamRoute, IServiceDiscoveryProvider, ILoadBalancer> _creatorFunc;
         private readonly Mock<IServiceDiscoveryProvider> _serviceProvider;
-        private DownstreamReRoute _reRoute;
+        private DownstreamRoute _route;
         private Response<ILoadBalancer> _loadBalancer;
         private string _typeName;
 
         public DelegateInvokingLoadBalancerCreatorTests()
         {
-            _creatorFunc = (reRoute, serviceDiscoveryProvider) =>
-                new FakeLoadBalancer(reRoute, serviceDiscoveryProvider);
+            _creatorFunc = (route, serviceDiscoveryProvider) =>
+                new FakeLoadBalancer(route, serviceDiscoveryProvider);
             _creator = new DelegateInvokingLoadBalancerCreator<FakeLoadBalancer>(_creatorFunc);
             _serviceProvider = new Mock<IServiceDiscoveryProvider>();
         }
@@ -44,10 +44,10 @@ namespace Ocelot.UnitTests.LoadBalancer
         [Fact]
         public void should_return_result_of_specified_creator_func()
         {
-            var reRoute = new DownstreamReRouteBuilder()
+            var route = new DownstreamRouteBuilder()
                 .Build();
 
-            this.Given(x => x.GivenAReRoute(reRoute))
+            this.Given(x => x.GivenARoute(route))
                 .When(x => x.WhenIGetTheLoadBalancer())
                 .Then(x => x.ThenTheLoadBalancerIsReturned<FakeLoadBalancer>())
                 .BDDfy();
@@ -56,10 +56,10 @@ namespace Ocelot.UnitTests.LoadBalancer
         [Fact]
         public void should_return_error()
         {
-            var reRoute = new DownstreamReRouteBuilder()
+            var route = new DownstreamRouteBuilder()
                 .Build();
 
-            this.Given(x => x.GivenAReRoute(reRoute))
+            this.Given(x => x.GivenARoute(route))
                 .And(x => x.GivenTheCreatorFuncThrows())
                 .When(x => x.WhenIGetTheLoadBalancer())
                 .Then(x => x.ThenAnErrorIsReturned())
@@ -68,7 +68,7 @@ namespace Ocelot.UnitTests.LoadBalancer
 
         private void GivenTheCreatorFuncThrows()
         {
-            _creatorFunc = (reRoute, serviceDiscoveryProvider) => throw new Exception();
+            _creatorFunc = (route, serviceDiscoveryProvider) => throw new Exception();
 
             _creator = new DelegateInvokingLoadBalancerCreator<FakeLoadBalancer>(_creatorFunc);
         }
@@ -78,14 +78,14 @@ namespace Ocelot.UnitTests.LoadBalancer
             _loadBalancer.IsError.ShouldBeTrue();
         }
 
-        private void GivenAReRoute(DownstreamReRoute reRoute)
+        private void GivenARoute(DownstreamRoute route)
         {
-            _reRoute = reRoute;
+            _route = route;
         }
 
         private void WhenIGetTheLoadBalancer()
         {
-            _loadBalancer = _creator.Create(_reRoute, _serviceProvider.Object);
+            _loadBalancer = _creator.Create(_route, _serviceProvider.Object);
         }
 
         private void WhenIGetTheLoadBalancerTypeName()
@@ -106,13 +106,13 @@ namespace Ocelot.UnitTests.LoadBalancer
 
         private class FakeLoadBalancer : ILoadBalancer
         {
-            public FakeLoadBalancer(DownstreamReRoute reRoute, IServiceDiscoveryProvider serviceDiscoveryProvider)
+            public FakeLoadBalancer(DownstreamRoute downstreamRoute, IServiceDiscoveryProvider serviceDiscoveryProvider)
             {
-                ReRoute = reRoute;
+                DownstreamRoute = downstreamRoute;
                 ServiceDiscoveryProvider = serviceDiscoveryProvider;
             }
 
-            public DownstreamReRoute ReRoute { get; }
+            public DownstreamRoute DownstreamRoute { get; }
             public IServiceDiscoveryProvider ServiceDiscoveryProvider { get; }
 
             public Task<Response<ServiceHostAndPort>> Lease(HttpContext httpContext)

test/Ocelot.UnitTests/LoadBalancer/LeastConnectionCreatorTests.cs

@@ -1,74 +1,74 @@
-namespace Ocelot.UnitTests.LoadBalancer
-{
-    using Moq;
-    using Ocelot.Configuration;
-    using Ocelot.Configuration.Builder;
-    using Ocelot.LoadBalancer.LoadBalancers;
-    using Ocelot.Responses;
-    using Ocelot.ServiceDiscovery.Providers;
-    using Shouldly;
-    using TestStack.BDDfy;
-    using Xunit;
-
-    public class LeastConnectionCreatorTests
-    {
-        private readonly LeastConnectionCreator _creator;
-        private readonly Mock<IServiceDiscoveryProvider> _serviceProvider;
-        private DownstreamReRoute _reRoute;
-        private Response<ILoadBalancer> _loadBalancer;
-        private string _typeName;
-
-        public LeastConnectionCreatorTests()
-        {
-            _creator = new LeastConnectionCreator();
-            _serviceProvider = new Mock<IServiceDiscoveryProvider>();
-        }
-        
-        [Fact]
-        public void should_return_instance_of_expected_load_balancer_type()
-        {
-            var reRoute = new DownstreamReRouteBuilder()
-                .WithServiceName("myService")
-                .Build();
-
-            this.Given(x => x.GivenAReRoute(reRoute))
-                .When(x => x.WhenIGetTheLoadBalancer())
-                .Then(x => x.ThenTheLoadBalancerIsReturned<LeastConnection>())
-                .BDDfy();
-        }
-                
-        [Fact]
-        public void should_return_expected_name()
-        {
-            this.When(x => x.WhenIGetTheLoadBalancerTypeName())
-                .Then(x => x.ThenTheLoadBalancerTypeIs("LeastConnection"))
-                .BDDfy();
-        }
-
-        private void GivenAReRoute(DownstreamReRoute reRoute)
-        {
-            _reRoute = reRoute;
-        }
-
-        private void WhenIGetTheLoadBalancer()
-        {
-            _loadBalancer = _creator.Create(_reRoute, _serviceProvider.Object);
-        }
-        
-        private void WhenIGetTheLoadBalancerTypeName()
-        {
-            _typeName = _creator.Type;
-        }
-
-        private void ThenTheLoadBalancerIsReturned<T>()
-            where T : ILoadBalancer
-        {
-            _loadBalancer.Data.ShouldBeOfType<T>();
-        }
-
-        private void ThenTheLoadBalancerTypeIs(string type)
-        {
-            _typeName.ShouldBe(type);
-        }
-    }
-}
+namespace Ocelot.UnitTests.LoadBalancer
+{
+    using Moq;
+    using Ocelot.Configuration;
+    using Ocelot.Configuration.Builder;
+    using Ocelot.LoadBalancer.LoadBalancers;
+    using Ocelot.Responses;
+    using Ocelot.ServiceDiscovery.Providers;
+    using Shouldly;
+    using TestStack.BDDfy;
+    using Xunit;
+
+    public class LeastConnectionCreatorTests
+    {
+        private readonly LeastConnectionCreator _creator;
+        private readonly Mock<IServiceDiscoveryProvider> _serviceProvider;
+        private DownstreamRoute _route;
+        private Response<ILoadBalancer> _loadBalancer;
+        private string _typeName;
+
+        public LeastConnectionCreatorTests()
+        {
+            _creator = new LeastConnectionCreator();
+            _serviceProvider = new Mock<IServiceDiscoveryProvider>();
+        }
+        
+        [Fact]
+        public void should_return_instance_of_expected_load_balancer_type()
+        {
+            var route = new DownstreamRouteBuilder()
+                .WithServiceName("myService")
+                .Build();
+
+            this.Given(x => x.GivenARoute(route))
+                .When(x => x.WhenIGetTheLoadBalancer())
+                .Then(x => x.ThenTheLoadBalancerIsReturned<LeastConnection>())
+                .BDDfy();
+        }
+                
+        [Fact]
+        public void should_return_expected_name()
+        {
+            this.When(x => x.WhenIGetTheLoadBalancerTypeName())
+                .Then(x => x.ThenTheLoadBalancerTypeIs("LeastConnection"))
+                .BDDfy();
+        }
+
+        private void GivenARoute(DownstreamRoute route)
+        {
+            _route = route;
+        }
+
+        private void WhenIGetTheLoadBalancer()
+        {
+            _loadBalancer = _creator.Create(_route, _serviceProvider.Object);
+        }
+        
+        private void WhenIGetTheLoadBalancerTypeName()
+        {
+            _typeName = _creator.Type;
+        }
+
+        private void ThenTheLoadBalancerIsReturned<T>()
+            where T : ILoadBalancer
+        {
+            _loadBalancer.Data.ShouldBeOfType<T>();
+        }
+
+        private void ThenTheLoadBalancerTypeIs(string type)
+        {
+            _typeName.ShouldBe(type);
+        }
+    }
+}

test/Ocelot.UnitTests/LoadBalancer/LoadBalancerFactoryTests.cs

@@ -21,7 +21,7 @@ namespace Ocelot.UnitTests.LoadBalancer
 
     public class LoadBalancerFactoryTests
     {
-        private DownstreamReRoute _reRoute;
+        private DownstreamRoute _route;
         private readonly LoadBalancerFactory _factory;
         private Response<ILoadBalancer> _result;
         private readonly Mock<IServiceDiscoveryProviderFactory> _serviceProviderFactory;
@@ -46,11 +46,11 @@ namespace Ocelot.UnitTests.LoadBalancer
         [Fact]
         public void should_return_no_load_balancer_by_default()
         {
-            var reRoute = new DownstreamReRouteBuilder()
+            var route = new DownstreamRouteBuilder()
                 .WithUpstreamHttpMethod(new List<string> { "Get" })
                 .Build();
 
-            this.Given(x => x.GivenAReRoute(reRoute))
+            this.Given(x => x.GivenARoute(route))
                 .And(x => GivenAServiceProviderConfig(new ServiceProviderConfigurationBuilder().Build()))
                 .And(x => x.GivenTheServiceProviderFactoryReturns())
                 .When(x => x.WhenIGetTheLoadBalancer())
@@ -61,12 +61,12 @@ namespace Ocelot.UnitTests.LoadBalancer
         [Fact]
         public void should_return_matching_load_balancer()
         {
-            var reRoute = new DownstreamReRouteBuilder()
+            var route = new DownstreamRouteBuilder()
                 .WithLoadBalancerOptions(new LoadBalancerOptions("FakeLoadBalancerTwo", "", 0))
                 .WithUpstreamHttpMethod(new List<string> { "Get" })
                 .Build();
 
-            this.Given(x => x.GivenAReRoute(reRoute))
+            this.Given(x => x.GivenARoute(route))
                 .And(x => GivenAServiceProviderConfig(new ServiceProviderConfigurationBuilder().Build()))
                 .And(x => x.GivenTheServiceProviderFactoryReturns())
                 .When(x => x.WhenIGetTheLoadBalancer())
@@ -77,12 +77,12 @@ namespace Ocelot.UnitTests.LoadBalancer
         [Fact]
         public void should_return_error_response_if_cannot_find_load_balancer_creator()
         {
-            var reRoute = new DownstreamReRouteBuilder()
+            var route = new DownstreamRouteBuilder()
                 .WithLoadBalancerOptions(new LoadBalancerOptions("DoesntExistLoadBalancer", "", 0))
                 .WithUpstreamHttpMethod(new List<string> { "Get" })
                 .Build();
 
-            this.Given(x => x.GivenAReRoute(reRoute))
+            this.Given(x => x.GivenARoute(route))
                 .And(x => GivenAServiceProviderConfig(new ServiceProviderConfigurationBuilder().Build()))
                 .And(x => x.GivenTheServiceProviderFactoryReturns())
                 .When(x => x.WhenIGetTheLoadBalancer())
@@ -94,12 +94,12 @@ namespace Ocelot.UnitTests.LoadBalancer
         [Fact]
         public void should_return_error_response_if_creator_errors()
         {
-            var reRoute = new DownstreamReRouteBuilder()
+            var route = new DownstreamRouteBuilder()
                 .WithLoadBalancerOptions(new LoadBalancerOptions("BrokenLoadBalancer", "", 0))
                 .WithUpstreamHttpMethod(new List<string> { "Get" })
                 .Build();
 
-            this.Given(x => x.GivenAReRoute(reRoute))
+            this.Given(x => x.GivenARoute(route))
                 .And(x => GivenAServiceProviderConfig(new ServiceProviderConfigurationBuilder().Build()))
                 .And(x => x.GivenTheServiceProviderFactoryReturns())
                 .When(x => x.WhenIGetTheLoadBalancer())
@@ -110,12 +110,12 @@ namespace Ocelot.UnitTests.LoadBalancer
         [Fact]
         public void should_call_service_provider()
         {
-            var reRoute = new DownstreamReRouteBuilder()
+            var route = new DownstreamRouteBuilder()
                 .WithLoadBalancerOptions(new LoadBalancerOptions("FakeLoadBalancerOne", "", 0))
                 .WithUpstreamHttpMethod(new List<string> { "Get" })
                 .Build();
 
-            this.Given(x => x.GivenAReRoute(reRoute))
+            this.Given(x => x.GivenARoute(route))
                 .And(x => GivenAServiceProviderConfig(new ServiceProviderConfigurationBuilder().Build()))
                 .And(x => x.GivenTheServiceProviderFactoryReturns())
                 .When(x => x.WhenIGetTheLoadBalancer())
@@ -126,12 +126,12 @@ namespace Ocelot.UnitTests.LoadBalancer
         [Fact]
         public void should_return_error_response_when_call_to_service_provider_fails()
         {
-            var reRoute = new DownstreamReRouteBuilder()
+            var route = new DownstreamRouteBuilder()
                 .WithLoadBalancerOptions(new LoadBalancerOptions("FakeLoadBalancerOne", "", 0))
                 .WithUpstreamHttpMethod(new List<string> { "Get" })
                 .Build();
 
-            this.Given(x => x.GivenAReRoute(reRoute))
+            this.Given(x => x.GivenARoute(route))
                 .And(x => GivenAServiceProviderConfig(new ServiceProviderConfigurationBuilder().Build()))
                 .And(x => x.GivenTheServiceProviderFactoryFails())
                 .When(x => x.WhenIGetTheLoadBalancer())
@@ -147,31 +147,31 @@ namespace Ocelot.UnitTests.LoadBalancer
         private void GivenTheServiceProviderFactoryReturns()
         {
             _serviceProviderFactory
-                .Setup(x => x.Get(It.IsAny<ServiceProviderConfiguration>(), It.IsAny<DownstreamReRoute>()))
+                .Setup(x => x.Get(It.IsAny<ServiceProviderConfiguration>(), It.IsAny<DownstreamRoute>()))
                 .Returns(new OkResponse<IServiceDiscoveryProvider>(_serviceProvider.Object));
         }
 
         private void GivenTheServiceProviderFactoryFails()
         {
             _serviceProviderFactory
-                .Setup(x => x.Get(It.IsAny<ServiceProviderConfiguration>(), It.IsAny<DownstreamReRoute>()))
+                .Setup(x => x.Get(It.IsAny<ServiceProviderConfiguration>(), It.IsAny<DownstreamRoute>()))
                 .Returns(new ErrorResponse<IServiceDiscoveryProvider>(new CannotFindDataError("For tests")));
         }
 
         private void ThenTheServiceProviderIsCalledCorrectly()
         {
             _serviceProviderFactory
-                .Verify(x => x.Get(It.IsAny<ServiceProviderConfiguration>(), It.IsAny<DownstreamReRoute>()), Times.Once);
+                .Verify(x => x.Get(It.IsAny<ServiceProviderConfiguration>(), It.IsAny<DownstreamRoute>()), Times.Once);
         }
 
-        private void GivenAReRoute(DownstreamReRoute reRoute)
+        private void GivenARoute(DownstreamRoute route)
         {
-            _reRoute = reRoute;
+            _route = route;
         }
 
         private void WhenIGetTheLoadBalancer()
         {
-            _result = _factory.Get(_reRoute, _serviceProviderConfig);
+            _result = _factory.Get(_route, _serviceProviderConfig);
         }
 
         private void ThenTheLoadBalancerIsReturned<T>()
@@ -203,7 +203,7 @@ namespace Ocelot.UnitTests.LoadBalancer
                 Type = type;
             }
 
-            public Response<ILoadBalancer> Create(DownstreamReRoute reRoute, IServiceDiscoveryProvider serviceProvider)
+            public Response<ILoadBalancer> Create(DownstreamRoute route, IServiceDiscoveryProvider serviceProvider)
             {
                 return new OkResponse<ILoadBalancer>(new T());
             }
@@ -219,7 +219,7 @@ namespace Ocelot.UnitTests.LoadBalancer
                 Type = typeof(T).Name;
             }
 
-            public Response<ILoadBalancer> Create(DownstreamReRoute reRoute, IServiceDiscoveryProvider serviceProvider)
+            public Response<ILoadBalancer> Create(DownstreamRoute route, IServiceDiscoveryProvider serviceProvider)
             {
                 return new ErrorResponse<ILoadBalancer>(new ErrorInvokingLoadBalancerCreator(new Exception()));
             }

test/Ocelot.UnitTests/LoadBalancer/LoadBalancerHouseTests.cs

@@ -17,7 +17,7 @@ namespace Ocelot.UnitTests.LoadBalancer
 
     public class LoadBalancerHouseTests
     {
-        private DownstreamReRoute _reRoute;
+        private DownstreamRoute _route;
         private ILoadBalancer _loadBalancer;
         private readonly LoadBalancerHouse _loadBalancerHouse;
         private Response<ILoadBalancer> _getResult;
@@ -34,11 +34,11 @@ namespace Ocelot.UnitTests.LoadBalancer
         [Fact]
         public void should_store_load_balancer_on_first_request()
         {
-            var reRoute = new DownstreamReRouteBuilder()
+            var route = new DownstreamRouteBuilder()
                 .WithLoadBalancerKey("test")
                 .Build();
 
-            this.Given(x => x.GivenThereIsALoadBalancer(reRoute, new FakeLoadBalancer()))
+            this.Given(x => x.GivenThereIsALoadBalancer(route, new FakeLoadBalancer()))
                 .Then(x => x.ThenItIsAdded())
                 .BDDfy();
         }
@@ -46,13 +46,13 @@ namespace Ocelot.UnitTests.LoadBalancer
         [Fact]
         public void should_not_store_load_balancer_on_second_request()
         {
-            var reRoute = new DownstreamReRouteBuilder()
+            var route = new DownstreamRouteBuilder()
                 .WithLoadBalancerOptions(new LoadBalancerOptions("FakeLoadBalancer", "", 0))
                 .WithLoadBalancerKey("test")
                 .Build();
 
-            this.Given(x => x.GivenThereIsALoadBalancer(reRoute, new FakeLoadBalancer()))
-                .When(x => x.WhenWeGetTheLoadBalancer(reRoute))
+            this.Given(x => x.GivenThereIsALoadBalancer(route, new FakeLoadBalancer()))
+                .When(x => x.WhenWeGetTheLoadBalancer(route))
                 .Then(x => x.ThenItIsReturned())
                 .BDDfy();
         }
@@ -60,21 +60,21 @@ namespace Ocelot.UnitTests.LoadBalancer
         [Fact]
         public void should_store_load_balancers_by_key()
         {
-            var reRoute = new DownstreamReRouteBuilder()
+            var route = new DownstreamRouteBuilder()
                 .WithLoadBalancerOptions(new LoadBalancerOptions("FakeLoadBalancer", "", 0))
                 .WithLoadBalancerKey("test")
                 .Build();
 
-            var reRouteTwo = new DownstreamReRouteBuilder()
+            var routeTwo = new DownstreamRouteBuilder()
                 .WithLoadBalancerOptions(new LoadBalancerOptions("FakeRoundRobinLoadBalancer", "", 0))
                 .WithLoadBalancerKey("testtwo")
                 .Build();
 
-            this.Given(x => x.GivenThereIsALoadBalancer(reRoute, new FakeLoadBalancer()))
-                .And(x => x.GivenThereIsALoadBalancer(reRouteTwo, new FakeRoundRobinLoadBalancer()))
-                .When(x => x.WhenWeGetTheLoadBalancer(reRoute))
+            this.Given(x => x.GivenThereIsALoadBalancer(route, new FakeLoadBalancer()))
+                .And(x => x.GivenThereIsALoadBalancer(routeTwo, new FakeRoundRobinLoadBalancer()))
+                .When(x => x.WhenWeGetTheLoadBalancer(route))
                 .Then(x => x.ThenTheLoadBalancerIs<FakeLoadBalancer>())
-                .When(x => x.WhenWeGetTheLoadBalancer(reRouteTwo))
+                .When(x => x.WhenWeGetTheLoadBalancer(routeTwo))
                 .Then(x => x.ThenTheLoadBalancerIs<FakeRoundRobinLoadBalancer>())
                 .BDDfy();
         }
@@ -82,39 +82,39 @@ namespace Ocelot.UnitTests.LoadBalancer
         [Fact]
         public void should_return_error_if_exception()
         {
-            var reRoute = new DownstreamReRouteBuilder().Build();
+            var route = new DownstreamRouteBuilder().Build();
 
-            this.When(x => x.WhenWeGetTheLoadBalancer(reRoute))
+            this.When(x => x.WhenWeGetTheLoadBalancer(route))
             .Then(x => x.ThenAnErrorIsReturned())
             .BDDfy();
         }
 
         [Fact]
-        public void should_get_new_load_balancer_if_reroute_load_balancer_has_changed()
+        public void should_get_new_load_balancer_if_route_load_balancer_has_changed()
         {
-            var reRoute = new DownstreamReRouteBuilder()
+            var route = new DownstreamRouteBuilder()
                 .WithLoadBalancerOptions(new LoadBalancerOptions("FakeLoadBalancer", "", 0))
                 .WithLoadBalancerKey("test")
                 .Build();
 
-            var reRouteTwo = new DownstreamReRouteBuilder()
+            var routeTwo = new DownstreamRouteBuilder()
                 .WithLoadBalancerOptions(new LoadBalancerOptions("LeastConnection", "", 0))
                 .WithLoadBalancerKey("test")
                 .Build();
 
-            this.Given(x => x.GivenThereIsALoadBalancer(reRoute, new FakeLoadBalancer()))
-                .When(x => x.WhenWeGetTheLoadBalancer(reRoute))
+            this.Given(x => x.GivenThereIsALoadBalancer(route, new FakeLoadBalancer()))
+                .When(x => x.WhenWeGetTheLoadBalancer(route))
                 .Then(x => x.ThenTheLoadBalancerIs<FakeLoadBalancer>())
-                .When(x => x.WhenIGetTheReRouteWithTheSameKeyButDifferentLoadBalancer(reRouteTwo))
+                .When(x => x.WhenIGetTheRouteWithTheSameKeyButDifferentLoadBalancer(routeTwo))
                 .Then(x => x.ThenTheLoadBalancerIs<LeastConnection>())
                 .BDDfy();
         }
 
-        private void WhenIGetTheReRouteWithTheSameKeyButDifferentLoadBalancer(DownstreamReRoute reRoute)
+        private void WhenIGetTheRouteWithTheSameKeyButDifferentLoadBalancer(DownstreamRoute route)
         {
-            _reRoute = reRoute;
-            _factory.Setup(x => x.Get(_reRoute, _serviceProviderConfig)).Returns(new OkResponse<ILoadBalancer>(new LeastConnection(null, null)));
-            _getResult = _loadBalancerHouse.Get(_reRoute, _serviceProviderConfig);
+            _route = route;
+            _factory.Setup(x => x.Get(_route, _serviceProviderConfig)).Returns(new OkResponse<ILoadBalancer>(new LeastConnection(null, null)));
+            _getResult = _loadBalancerHouse.Get(_route, _serviceProviderConfig);
         }
 
         private void ThenAnErrorIsReturned()
@@ -133,26 +133,26 @@ namespace Ocelot.UnitTests.LoadBalancer
             _getResult.IsError.ShouldBe(false);
             _getResult.ShouldBeOfType<OkResponse<ILoadBalancer>>();
             _getResult.Data.ShouldBe(_loadBalancer);
-            _factory.Verify(x => x.Get(_reRoute, _serviceProviderConfig), Times.Once);
+            _factory.Verify(x => x.Get(_route, _serviceProviderConfig), Times.Once);
         }
 
-        private void GivenThereIsALoadBalancer(DownstreamReRoute reRoute, ILoadBalancer loadBalancer)
+        private void GivenThereIsALoadBalancer(DownstreamRoute route, ILoadBalancer loadBalancer)
         {
-            _reRoute = reRoute;
+            _route = route;
             _loadBalancer = loadBalancer;
-            _factory.Setup(x => x.Get(_reRoute, _serviceProviderConfig)).Returns(new OkResponse<ILoadBalancer>(loadBalancer));
-            _getResult = _loadBalancerHouse.Get(reRoute, _serviceProviderConfig);
+            _factory.Setup(x => x.Get(_route, _serviceProviderConfig)).Returns(new OkResponse<ILoadBalancer>(loadBalancer));
+            _getResult = _loadBalancerHouse.Get(route, _serviceProviderConfig);
         }
 
-        private void WhenWeGetTheLoadBalancer(DownstreamReRoute reRoute)
+        private void WhenWeGetTheLoadBalancer(DownstreamRoute route)
         {
-            _getResult = _loadBalancerHouse.Get(reRoute, _serviceProviderConfig);
+            _getResult = _loadBalancerHouse.Get(route, _serviceProviderConfig);
         }
 
         private void ThenItIsReturned()
         {
             _getResult.Data.ShouldBe(_loadBalancer);
-            _factory.Verify(x => x.Get(_reRoute, _serviceProviderConfig), Times.Once);
+            _factory.Verify(x => x.Get(_route, _serviceProviderConfig), Times.Once);
         }
 
         private class FakeLoadBalancer : ILoadBalancer

test/Ocelot.UnitTests/LoadBalancer/LoadBalancerMiddlewareTests.cs

@@ -56,7 +56,7 @@ namespace Ocelot.UnitTests.LoadBalancer
         [Fact]
         public void should_call_scoped_data_repository_correctly()
         {
-            var downstreamRoute = new DownstreamReRouteBuilder()
+            var downstreamRoute = new DownstreamRouteBuilder()
                     .WithUpstreamHttpMethod(new List<string> { "Get" })
                     .Build();
 
@@ -76,7 +76,7 @@ namespace Ocelot.UnitTests.LoadBalancer
         [Fact]
         public void should_set_pipeline_error_if_cannot_get_load_balancer()
         {
-            var downstreamRoute = new DownstreamReRouteBuilder()
+            var downstreamRoute = new DownstreamRouteBuilder()
                     .WithUpstreamHttpMethod(new List<string> { "Get" })
                     .Build();
 
@@ -95,7 +95,7 @@ namespace Ocelot.UnitTests.LoadBalancer
         [Fact]
         public void should_set_pipeline_error_if_cannot_get_least()
         {
-            var downstreamRoute = new DownstreamReRouteBuilder()
+            var downstreamRoute = new DownstreamRouteBuilder()
                     .WithUpstreamHttpMethod(new List<string> { "Get" })
                     .Build();
 
@@ -115,7 +115,7 @@ namespace Ocelot.UnitTests.LoadBalancer
         [Fact]
         public void should_set_scheme()
         {
-            var downstreamRoute = new DownstreamReRouteBuilder()
+            var downstreamRoute = new DownstreamRouteBuilder()
                 .WithUpstreamHttpMethod(new List<string> { "Get" })
                 .Build();
 
@@ -174,16 +174,16 @@ namespace Ocelot.UnitTests.LoadBalancer
                 .ReturnsAsync(new OkResponse<ServiceHostAndPort>(_hostAndPort));
         }
 
-        private void GivenTheDownStreamRouteIs(DownstreamReRoute downstreamRoute, List<Ocelot.DownstreamRouteFinder.UrlMatcher.PlaceholderNameAndValue> placeholder)
+        private void GivenTheDownStreamRouteIs(DownstreamRoute downstreamRoute, List<Ocelot.DownstreamRouteFinder.UrlMatcher.PlaceholderNameAndValue> placeholder)
         {
             _httpContext.Items.UpsertTemplatePlaceholderNameAndValues(placeholder);
-            _httpContext.Items.UpsertDownstreamReRoute(downstreamRoute);
+            _httpContext.Items.UpsertDownstreamRoute(downstreamRoute);
         }
 
         private void GivenTheLoadBalancerHouseReturns()
         {
             _loadBalancerHouse
-                .Setup(x => x.Get(It.IsAny<DownstreamReRoute>(), It.IsAny<ServiceProviderConfiguration>()))
+                .Setup(x => x.Get(It.IsAny<DownstreamRoute>(), It.IsAny<ServiceProviderConfiguration>()))
                 .Returns(new OkResponse<ILoadBalancer>(_loadBalancer.Object));
         }
 
@@ -195,7 +195,7 @@ namespace Ocelot.UnitTests.LoadBalancer
             });
 
             _loadBalancerHouse
-                .Setup(x => x.Get(It.IsAny<DownstreamReRoute>(), It.IsAny<ServiceProviderConfiguration>()))
+                .Setup(x => x.Get(It.IsAny<DownstreamRoute>(), It.IsAny<ServiceProviderConfiguration>()))
                 .Returns(_getLoadBalancerHouseError);
         }
 

test/Ocelot.UnitTests/LoadBalancer/NoLoadBalancerCreatorTests.cs

@@ -1,73 +1,73 @@
-namespace Ocelot.UnitTests.LoadBalancer
-{
-    using Moq;
-    using Ocelot.Configuration;
-    using Ocelot.Configuration.Builder;
-    using Ocelot.LoadBalancer.LoadBalancers;
-    using Ocelot.Responses;
-    using Ocelot.ServiceDiscovery.Providers;
-    using Shouldly;
-    using TestStack.BDDfy;
-    using Xunit;
-
-    public class NoLoadBalancerCreatorTests
-    {
-        private readonly NoLoadBalancerCreator _creator;
-        private readonly Mock<IServiceDiscoveryProvider> _serviceProvider;
-        private DownstreamReRoute _reRoute;
-        private Response<ILoadBalancer> _loadBalancer;
-        private string _typeName;
-
-        public NoLoadBalancerCreatorTests()
-        {
-            _creator = new NoLoadBalancerCreator();
-            _serviceProvider = new Mock<IServiceDiscoveryProvider>();
-        }
-        
-        [Fact]
-        public void should_return_instance_of_expected_load_balancer_type()
-        {
-            var reRoute = new DownstreamReRouteBuilder()
-                .Build();
-
-            this.Given(x => x.GivenAReRoute(reRoute))
-                .When(x => x.WhenIGetTheLoadBalancer())
-                .Then(x => x.ThenTheLoadBalancerIsReturned<NoLoadBalancer>())
-                .BDDfy();
-        }
-                
-        [Fact]
-        public void should_return_expected_name()
-        {
-            this.When(x => x.WhenIGetTheLoadBalancerTypeName())
-                .Then(x => x.ThenTheLoadBalancerTypeIs("NoLoadBalancer"))
-                .BDDfy();
-        }
-
-        private void GivenAReRoute(DownstreamReRoute reRoute)
-        {
-            _reRoute = reRoute;
-        }
-
-        private void WhenIGetTheLoadBalancer()
-        {
-            _loadBalancer = _creator.Create(_reRoute, _serviceProvider.Object);
-        }
-        
-        private void WhenIGetTheLoadBalancerTypeName()
-        {
-            _typeName = _creator.Type;
-        }
-
-        private void ThenTheLoadBalancerIsReturned<T>()
-            where T : ILoadBalancer
-        {
-            _loadBalancer.Data.ShouldBeOfType<T>();
-        }
-
-        private void ThenTheLoadBalancerTypeIs(string type)
-        {
-            _typeName.ShouldBe(type);
-        }
-    }
-}
+namespace Ocelot.UnitTests.LoadBalancer
+{
+    using Moq;
+    using Ocelot.Configuration;
+    using Ocelot.Configuration.Builder;
+    using Ocelot.LoadBalancer.LoadBalancers;
+    using Ocelot.Responses;
+    using Ocelot.ServiceDiscovery.Providers;
+    using Shouldly;
+    using TestStack.BDDfy;
+    using Xunit;
+
+    public class NoLoadBalancerCreatorTests
+    {
+        private readonly NoLoadBalancerCreator _creator;
+        private readonly Mock<IServiceDiscoveryProvider> _serviceProvider;
+        private DownstreamRoute _route;
+        private Response<ILoadBalancer> _loadBalancer;
+        private string _typeName;
+
+        public NoLoadBalancerCreatorTests()
+        {
+            _creator = new NoLoadBalancerCreator();
+            _serviceProvider = new Mock<IServiceDiscoveryProvider>();
+        }
+        
+        [Fact]
+        public void should_return_instance_of_expected_load_balancer_type()
+        {
+            var route = new DownstreamRouteBuilder()
+                .Build();
+
+            this.Given(x => x.GivenARoute(route))
+                .When(x => x.WhenIGetTheLoadBalancer())
+                .Then(x => x.ThenTheLoadBalancerIsReturned<NoLoadBalancer>())
+                .BDDfy();
+        }
+                
+        [Fact]
+        public void should_return_expected_name()
+        {
+            this.When(x => x.WhenIGetTheLoadBalancerTypeName())
+                .Then(x => x.ThenTheLoadBalancerTypeIs("NoLoadBalancer"))
+                .BDDfy();
+        }
+
+        private void GivenARoute(DownstreamRoute route)
+        {
+            _route = route;
+        }
+
+        private void WhenIGetTheLoadBalancer()
+        {
+            _loadBalancer = _creator.Create(_route, _serviceProvider.Object);
+        }
+        
+        private void WhenIGetTheLoadBalancerTypeName()
+        {
+            _typeName = _creator.Type;
+        }
+
+        private void ThenTheLoadBalancerIsReturned<T>()
+            where T : ILoadBalancer
+        {
+            _loadBalancer.Data.ShouldBeOfType<T>();
+        }
+
+        private void ThenTheLoadBalancerTypeIs(string type)
+        {
+            _typeName.ShouldBe(type);
+        }
+    }
+}

test/Ocelot.UnitTests/LoadBalancer/RoundRobinCreatorTests.cs

@@ -1,73 +1,73 @@
-namespace Ocelot.UnitTests.LoadBalancer
-{
-    using Moq;
-    using Ocelot.Configuration;
-    using Ocelot.Configuration.Builder;
-    using Ocelot.LoadBalancer.LoadBalancers;
-    using Ocelot.Responses;
-    using Ocelot.ServiceDiscovery.Providers;
-    using Shouldly;
-    using TestStack.BDDfy;
-    using Xunit;
-
-    public class RoundRobinCreatorTests
-    {
-        private readonly RoundRobinCreator _creator;
-        private readonly Mock<IServiceDiscoveryProvider> _serviceProvider;
-        private DownstreamReRoute _reRoute;
-        private Response<ILoadBalancer> _loadBalancer;
-        private string _typeName;
-
-        public RoundRobinCreatorTests()
-        {
-            _creator = new RoundRobinCreator();
-            _serviceProvider = new Mock<IServiceDiscoveryProvider>();
-        }
-        
-        [Fact]
-        public void should_return_instance_of_expected_load_balancer_type()
-        {
-            var reRoute = new DownstreamReRouteBuilder()
-                .Build();
-
-            this.Given(x => x.GivenAReRoute(reRoute))
-                .When(x => x.WhenIGetTheLoadBalancer())
-                .Then(x => x.ThenTheLoadBalancerIsReturned<RoundRobin>())
-                .BDDfy();
-        }
-                
-        [Fact]
-        public void should_return_expected_name()
-        {
-            this.When(x => x.WhenIGetTheLoadBalancerTypeName())
-                .Then(x => x.ThenTheLoadBalancerTypeIs("RoundRobin"))
-                .BDDfy();
-        }
-
-        private void GivenAReRoute(DownstreamReRoute reRoute)
-        {
-            _reRoute = reRoute;
-        }
-
-        private void WhenIGetTheLoadBalancer()
-        {
-            _loadBalancer = _creator.Create(_reRoute, _serviceProvider.Object);
-        }
-        
-        private void WhenIGetTheLoadBalancerTypeName()
-        {
-            _typeName = _creator.Type;
-        }
-
-        private void ThenTheLoadBalancerIsReturned<T>()
-            where T : ILoadBalancer
-        {
-            _loadBalancer.Data.ShouldBeOfType<T>();
-        }
-
-        private void ThenTheLoadBalancerTypeIs(string type)
-        {
-            _typeName.ShouldBe(type);
-        }
-    }
-}
+namespace Ocelot.UnitTests.LoadBalancer
+{
+    using Moq;
+    using Ocelot.Configuration;
+    using Ocelot.Configuration.Builder;
+    using Ocelot.LoadBalancer.LoadBalancers;
+    using Ocelot.Responses;
+    using Ocelot.ServiceDiscovery.Providers;
+    using Shouldly;
+    using TestStack.BDDfy;
+    using Xunit;
+
+    public class RoundRobinCreatorTests
+    {
+        private readonly RoundRobinCreator _creator;
+        private readonly Mock<IServiceDiscoveryProvider> _serviceProvider;
+        private DownstreamRoute _route;
+        private Response<ILoadBalancer> _loadBalancer;
+        private string _typeName;
+
+        public RoundRobinCreatorTests()
+        {
+            _creator = new RoundRobinCreator();
+            _serviceProvider = new Mock<IServiceDiscoveryProvider>();
+        }
+        
+        [Fact]
+        public void should_return_instance_of_expected_load_balancer_type()
+        {
+            var route = new DownstreamRouteBuilder()
+                .Build();
+
+            this.Given(x => x.GivenARoute(route))
+                .When(x => x.WhenIGetTheLoadBalancer())
+                .Then(x => x.ThenTheLoadBalancerIsReturned<RoundRobin>())
+                .BDDfy();
+        }
+                
+        [Fact]
+        public void should_return_expected_name()
+        {
+            this.When(x => x.WhenIGetTheLoadBalancerTypeName())
+                .Then(x => x.ThenTheLoadBalancerTypeIs("RoundRobin"))
+                .BDDfy();
+        }
+
+        private void GivenARoute(DownstreamRoute route)
+        {
+            _route = route;
+        }
+
+        private void WhenIGetTheLoadBalancer()
+        {
+            _loadBalancer = _creator.Create(_route, _serviceProvider.Object);
+        }
+        
+        private void WhenIGetTheLoadBalancerTypeName()
+        {
+            _typeName = _creator.Type;
+        }
+
+        private void ThenTheLoadBalancerIsReturned<T>()
+            where T : ILoadBalancer
+        {
+            _loadBalancer.Data.ShouldBeOfType<T>();
+        }
+
+        private void ThenTheLoadBalancerTypeIs(string type)
+        {
+            _typeName.ShouldBe(type);
+        }
+    }
+}