updated file options

src/Ocelot/Configuration/Builder/ReRouteOptionsBuilder.cs

@@ -0,0 +1,46 @@
+namespace Ocelot.Configuration.Builder
+{
+    public class ReRouteOptionsBuilder
+    {
+        private bool _isAuthenticated;
+        private bool _isAuthorised;
+        private bool _isCached;
+        private bool _isQoS;
+        private bool _enableRateLimiting;
+
+        public ReRouteOptionsBuilder WithIsCached(bool isCached)
+        {
+            _isCached = isCached;
+            return this;
+        }
+
+        public ReRouteOptionsBuilder WithIsAuthenticated(bool isAuthenticated)
+        {
+            _isAuthenticated = isAuthenticated;
+            return this;
+        }
+
+        public ReRouteOptionsBuilder WithIsAuthorised(bool isAuthorised)
+        {
+            _isAuthorised = isAuthorised;
+            return this;
+        }
+
+        public ReRouteOptionsBuilder WithIsQos(bool isQoS)
+        {
+            _isQoS = isQoS;
+            return this;
+        }
+
+        public ReRouteOptionsBuilder WithRateLimiting(bool enableRateLimiting)
+        {
+            _enableRateLimiting = enableRateLimiting;
+            return this;
+        }
+
+        public ReRouteOptions Build()
+        {
+            return new ReRouteOptions(_isAuthenticated, _isAuthorised, _isCached, _isQoS, _enableRateLimiting);
+        }
+    }
+}

src/Ocelot/Configuration/Creator/FileOcelotConfigurationCreator.cs

@@ -33,6 +33,7 @@ namespace Ocelot.Configuration.Creator
         private IRequestIdKeyCreator _requestIdKeyCreator;
         private IServiceProviderConfigurationCreator _serviceProviderConfigCreator;
         private IQoSOptionsCreator _qosOptionsCreator;
+        private IReRouteOptionsCreator _fileReRouteOptionsCreator;
 
         public FileOcelotConfigurationCreator(
             IOptions<FileConfiguration> options, 
@@ -47,7 +48,8 @@ namespace Ocelot.Configuration.Creator
             IUpstreamTemplatePatternCreator upstreamTemplatePatternCreator,
             IRequestIdKeyCreator requestIdKeyCreator,
             IServiceProviderConfigurationCreator serviceProviderConfigCreator,
-            IQoSOptionsCreator qosOptionsCreator
+            IQoSOptionsCreator qosOptionsCreator,
+            IReRouteOptionsCreator fileReRouteOptionsCreator
             )
         {
             _requestIdKeyCreator = requestIdKeyCreator;
@@ -63,6 +65,7 @@ namespace Ocelot.Configuration.Creator
             _claimsToThingCreator = claimsToThingCreator;
             _serviceProviderConfigCreator = serviceProviderConfigCreator;
             _qosOptionsCreator = qosOptionsCreator;
+            _fileReRouteOptionsCreator = fileReRouteOptionsCreator;
         }
 
         public async Task<Response<IOcelotConfiguration>> Create()
@@ -108,11 +111,7 @@ namespace Ocelot.Configuration.Creator
 
         private async Task<ReRoute> SetUpReRoute(FileReRoute fileReRoute, FileGlobalConfiguration globalConfiguration)
         {
-            var isAuthenticated = IsAuthenticated(fileReRoute);
+            var fileReRouteOptions = _fileReRouteOptionsCreator.Create(fileReRoute);
-
-            var isAuthorised = IsAuthorised(fileReRoute);
-
-            var isCached = IsCached(fileReRoute);
 
             var requestIdKey = _requestIdKeyCreator.Create(fileReRoute, globalConfiguration);
 
@@ -120,8 +119,6 @@ namespace Ocelot.Configuration.Creator
 
             var upstreamTemplatePattern = _upstreamTemplatePatternCreator.Create(fileReRoute);
 
-            var isQos = IsQoS(fileReRoute);
-
             var serviceProviderConfiguration = _serviceProviderConfigCreator.Create(fileReRoute, globalConfiguration);
 
             var authOptionsForRoute = _authOptionsCreator.Create(fileReRoute);
@@ -134,24 +131,22 @@ namespace Ocelot.Configuration.Creator
 
             var qosOptions = _qosOptionsCreator.Create(fileReRoute);
 
-            var enableRateLimiting = IsEnableRateLimiting(fileReRoute);
+            var rateLimitOption = BuildRateLimitOptions(fileReRoute, globalConfiguration, fileReRouteOptions.EnableRateLimiting);
-
-            var rateLimitOption = BuildRateLimitOptions(fileReRoute, globalConfiguration, enableRateLimiting);
 
             var reRoute = new ReRouteBuilder()
                 .WithDownstreamPathTemplate(fileReRoute.DownstreamPathTemplate)
                 .WithUpstreamPathTemplate(fileReRoute.UpstreamPathTemplate)
                 .WithUpstreamHttpMethod(fileReRoute.UpstreamHttpMethod)
                 .WithUpstreamTemplatePattern(upstreamTemplatePattern)
-                .WithIsAuthenticated(isAuthenticated)
+                .WithIsAuthenticated(fileReRouteOptions.IsAuthenticated)
                 .WithAuthenticationOptions(authOptionsForRoute)
                 .WithClaimsToHeaders(claimsToHeaders)
                 .WithClaimsToClaims(claimsToClaims)
                 .WithRouteClaimsRequirement(fileReRoute.RouteClaimsRequirement)
-                .WithIsAuthorised(isAuthorised)
+                .WithIsAuthorised(fileReRouteOptions.IsAuthorised)
                 .WithClaimsToQueries(claimsToQueries)
                 .WithRequestIdKey(requestIdKey)
-                .WithIsCached(isCached)
+                .WithIsCached(fileReRouteOptions.IsCached)
                 .WithCacheOptions(new CacheOptions(fileReRoute.FileCacheOptions.TtlSeconds))
                 .WithDownstreamScheme(fileReRoute.DownstreamScheme)
                 .WithLoadBalancer(fileReRoute.LoadBalancer)
@@ -159,9 +154,9 @@ namespace Ocelot.Configuration.Creator
                 .WithDownstreamPort(fileReRoute.DownstreamPort)
                 .WithLoadBalancerKey(reRouteKey)
                 .WithServiceProviderConfiguraion(serviceProviderConfiguration)
-                .WithIsQos(isQos)
+                .WithIsQos(fileReRouteOptions.IsQos)
                 .WithQosOptions(qosOptions)
-                .WithEnableRateLimiting(enableRateLimiting)
+                .WithEnableRateLimiting(fileReRouteOptions.EnableRateLimiting)
                 .WithRateLimitOptions(rateLimitOption)
                 .Build();
 
@@ -185,31 +180,6 @@ namespace Ocelot.Configuration.Creator
             return rateLimitOption;
         }
 
-        private static bool IsEnableRateLimiting(FileReRoute fileReRoute)
-        {
-            return (fileReRoute.RateLimitOptions != null && fileReRoute.RateLimitOptions.EnableRateLimiting) ? true : false;
-        }
-
-        private bool IsQoS(FileReRoute fileReRoute)
-        {
-            return fileReRoute.QoSOptions?.ExceptionsAllowedBeforeBreaking > 0 && fileReRoute.QoSOptions?.TimeoutValue > 0;
-        }
-
-        private bool IsAuthenticated(FileReRoute fileReRoute)
-        {
-            return !string.IsNullOrEmpty(fileReRoute.AuthenticationOptions?.Provider);
-        }
-      
-        private bool IsAuthorised(FileReRoute fileReRoute)
-        {
-            return fileReRoute.RouteClaimsRequirement?.Count > 0;
-        }
-
-        private bool IsCached(FileReRoute fileReRoute)
-        {
-            return fileReRoute.FileCacheOptions.TtlSeconds > 0;
-        }
-
         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
@@ -228,10 +198,5 @@ namespace Ocelot.Configuration.Creator
             var loadBalancer = _qoSProviderFactory.Get(reRoute);
             _qosProviderHouse.Add(reRoute.ReRouteKey, loadBalancer);
         }
-
-        private bool IsPlaceHolder(string upstreamTemplate, int i)
-        {
-            return upstreamTemplate[i] == '{';
-        }
     }
 }

src/Ocelot/Configuration/Creator/IReRouteOptionsCreator.cs

@@ -0,0 +1,9 @@
+using Ocelot.Configuration.File;
+
+namespace Ocelot.Configuration.Creator
+{
+    public interface IReRouteOptionsCreator
+    {
+        ReRouteOptions Create(FileReRoute fileReRoute);
+    }
+}

src/Ocelot/Configuration/Creator/ReRouteOptionsCreator.cs

@@ -0,0 +1,52 @@
+using Ocelot.Configuration.Builder;
+using Ocelot.Configuration.File;
+
+namespace Ocelot.Configuration.Creator
+{
+    public class ReRouteOptionsCreator : IReRouteOptionsCreator
+    {
+        public ReRouteOptions Create(FileReRoute fileReRoute)
+        {
+            var isAuthenticated = IsAuthenticated(fileReRoute);
+            var isAuthorised = IsAuthorised(fileReRoute);
+            var isCached = IsCached(fileReRoute);
+            var isQos = IsQoS(fileReRoute);
+            var enableRateLimiting = IsEnableRateLimiting(fileReRoute);
+
+            var options = new ReRouteOptionsBuilder()
+                .WithIsAuthenticated(isAuthenticated)
+                .WithIsAuthorised(isAuthorised)
+                .WithIsCached(isCached)
+                .WithIsQos(isQos)
+                .WithRateLimiting(enableRateLimiting)
+                .Build();
+            
+            return options;
+        }
+
+        private static bool IsEnableRateLimiting(FileReRoute fileReRoute)
+        {
+            return (fileReRoute.RateLimitOptions != null && fileReRoute.RateLimitOptions.EnableRateLimiting) ? true : false;
+        }
+
+        private bool IsQoS(FileReRoute fileReRoute)
+        {
+            return fileReRoute.QoSOptions?.ExceptionsAllowedBeforeBreaking > 0 && fileReRoute.QoSOptions?.TimeoutValue > 0;
+        }
+
+        private bool IsAuthenticated(FileReRoute fileReRoute)
+        {
+            return !string.IsNullOrEmpty(fileReRoute.AuthenticationOptions?.Provider);
+        }
+
+        private bool IsAuthorised(FileReRoute fileReRoute)
+        {
+            return fileReRoute.RouteClaimsRequirement?.Count > 0;
+        }
+
+        private bool IsCached(FileReRoute fileReRoute)
+        {
+            return fileReRoute.FileCacheOptions.TtlSeconds > 0;
+        }
+    }
+}

src/Ocelot/Configuration/ReRouteOptions.cs

@@ -0,0 +1,20 @@
+namespace Ocelot.Configuration
+{
+    public class ReRouteOptions
+    {
+        public ReRouteOptions(bool isAuthenticated, bool isAuthorised, bool isCached, bool isQos, bool isEnableRateLimiting)
+        {
+            IsAuthenticated = isAuthenticated;
+            IsAuthorised = isAuthorised;
+            IsCached = isCached;
+            IsQos = isQos;
+            EnableRateLimiting = isEnableRateLimiting;
+
+        }
+        public bool IsAuthenticated { get; private set; }
+        public bool IsAuthorised { get; private set; }
+        public bool IsCached { get; private set; }
+        public bool IsQos { get; private set; }
+        public bool EnableRateLimiting { get; private set; }
+    }
+}

src/Ocelot/DependencyInjection/ServiceCollectionExtensions.cs

@@ -66,6 +66,7 @@ namespace Ocelot.DependencyInjection
             services.AddSingleton<IRequestIdKeyCreator, RequestIdKeyCreator>();
             services.AddSingleton<IServiceProviderConfigurationCreator,ServiceProviderConfigurationCreator>();
             services.AddSingleton<IQoSOptionsCreator, QoSOptionsCreator>();
+            services.AddSingleton<IReRouteOptionsCreator, ReRouteOptionsCreator>();
 
             var identityServerConfiguration = IdentityServerConfigurationCreator.GetIdentityServerConfiguration();
             

test/Ocelot.UnitTests/Configuration/FileConfigurationCreatorTests.cs

@@ -36,6 +36,7 @@ namespace Ocelot.UnitTests.Configuration
         private Mock<IRequestIdKeyCreator> _requestIdKeyCreator;
         private Mock<IServiceProviderConfigurationCreator> _serviceProviderConfigCreator;
         private Mock<IQoSOptionsCreator> _qosOptionsCreator;
+        private Mock<IReRouteOptionsCreator> _fileReRouteOptionsCreator;
 
         public FileConfigurationCreatorTests()
         {
@@ -54,13 +55,14 @@ namespace Ocelot.UnitTests.Configuration
             _requestIdKeyCreator = new Mock<IRequestIdKeyCreator>();
             _serviceProviderConfigCreator = new Mock<IServiceProviderConfigurationCreator>();
             _qosOptionsCreator = new Mock<IQoSOptionsCreator>();
+            _fileReRouteOptionsCreator = new Mock<IReRouteOptionsCreator>();
 
             _ocelotConfigurationCreator = new FileOcelotConfigurationCreator( 
                 _fileConfig.Object, _validator.Object, _logger.Object,
                 _loadBalancerFactory.Object, _loadBalancerHouse.Object, 
                 _qosProviderFactory.Object, _qosProviderHouse.Object, _claimsToThingCreator.Object,
                 _authOptionsCreator.Object, _upstreamTemplatePatternCreator.Object, _requestIdKeyCreator.Object,
-                _serviceProviderConfigCreator.Object, _qosOptionsCreator.Object);
+                _serviceProviderConfigCreator.Object, _qosOptionsCreator.Object, _fileReRouteOptionsCreator.Object);
         }
 
         [Fact]
@@ -72,6 +74,10 @@ namespace Ocelot.UnitTests.Configuration
                 .WithTimeoutValue(1)
                 .Build();
 
+            var serviceOptions = new ReRouteOptionsBuilder()
+                .WithIsQos(true)
+                .Build();
+
              this.Given(x => x.GivenTheConfigIs(new FileConfiguration
             {
                 ReRoutes = new List<FileReRoute>
@@ -92,16 +98,22 @@ namespace Ocelot.UnitTests.Configuration
                 },
             }))
                 .And(x => x.GivenTheConfigIsValid())
+                .And(x => x.GivenTheFollowingOptionsAreReturned(serviceOptions))
                 .And(x => x.GivenTheQosProviderFactoryReturns())
                 .And(x => x.GivenTheQosOptionsCreatorReturns(expected))
                 .When(x => x.WhenICreateTheConfig())
                 .Then(x => x.ThenTheQosOptionsAre(expected))
+                .And(x => x.TheQosProviderFactoryIsCalledCorrectly())
+                .And(x => x.ThenTheQosProviderHouseIsCalledCorrectly())
                 .BDDfy();
         }
 
         [Fact]
         public void should_create_load_balancer()
         {
+            var reRouteOptions = new ReRouteOptionsBuilder()
+                .Build();
+
             this.Given(x => x.GivenTheConfigIs(new FileConfiguration
                             {
                                 ReRoutes = new List<FileReRoute>
@@ -116,6 +128,7 @@ namespace Ocelot.UnitTests.Configuration
                                 },
                             }))
                                 .And(x => x.GivenTheConfigIsValid())
+                                .And(x => x.GivenTheFollowingOptionsAreReturned(reRouteOptions))
                                 .And(x => x.GivenTheLoadBalancerFactoryReturns())
                                 .When(x => x.WhenICreateTheConfig())
                                 .Then(x => x.TheLoadBalancerFactoryIsCalledCorrectly())
@@ -123,69 +136,46 @@ namespace Ocelot.UnitTests.Configuration
                     .BDDfy();
         }
 
-        [Fact]
-        public void should_create_qos_provider()
-        {
-            this.Given(x => x.GivenTheConfigIs(new FileConfiguration
-            {
-                ReRoutes = new List<FileReRoute>
-                {
-                    new FileReRoute
-                    {
-                        DownstreamHost = "127.0.0.1",
-                        UpstreamPathTemplate = "/api/products/{productId}",
-                        DownstreamPathTemplate = "/products/{productId}",
-                        UpstreamHttpMethod = "Get",
-                        QoSOptions = new FileQoSOptions
-                        {
-                            TimeoutValue = 1,
-                            DurationOfBreak = 1,
-                            ExceptionsAllowedBeforeBreaking = 1
-                        }
-                    }
-                },
-            }))
-                .And(x => x.GivenTheConfigIsValid())
-                .And(x => x.GivenTheQosProviderFactoryReturns())
-                .When(x => x.WhenICreateTheConfig())
-                .Then(x => x.TheQosProviderFactoryIsCalledCorrectly())
-                .And(x => x.ThenTheQosProviderHouseIsCalledCorrectly())
-                .BDDfy();
-        }
-
         [Fact]
         public void should_use_downstream_host()
         {
-                this.Given(x => x.GivenTheConfigIs(new FileConfiguration
+            var reRouteOptions = new ReRouteOptionsBuilder()
+                .Build();
+
+            this.Given(x => x.GivenTheConfigIs(new FileConfiguration
+                        {
+                            ReRoutes = new List<FileReRoute>
                             {
-                                ReRoutes = new List<FileReRoute>
+                                new FileReRoute
                                 {
-                                    new FileReRoute
+                                    DownstreamHost = "127.0.0.1",
-                                    {
+                                    UpstreamPathTemplate = "/api/products/{productId}",
-                                        DownstreamHost = "127.0.0.1",
+                                    DownstreamPathTemplate = "/products/{productId}",
-                                        UpstreamPathTemplate = "/api/products/{productId}",
+                                    UpstreamHttpMethod = "Get",
-                                        DownstreamPathTemplate = "/products/{productId}",
+                                }
-                                        UpstreamHttpMethod = "Get",
+                            },
-                                    }
+                        }))
-                                },
+                            .And(x => x.GivenTheConfigIsValid())
+                            .And(x => x.GivenTheFollowingOptionsAreReturned(reRouteOptions))
+                            .When(x => x.WhenICreateTheConfig())
+                            .Then(x => x.ThenTheReRoutesAre(new List<ReRoute>
+                            {
+                                new ReRouteBuilder()
+                                    .WithDownstreamHost("127.0.0.1")
+                                    .WithDownstreamPathTemplate("/products/{productId}")
+                                    .WithUpstreamPathTemplate("/api/products/{productId}")
+                                    .WithUpstreamHttpMethod("Get")
+                                    .Build()
                             }))
-                                .And(x => x.GivenTheConfigIsValid())
+                .BDDfy();
-                                .When(x => x.WhenICreateTheConfig())
-                                .Then(x => x.ThenTheReRoutesAre(new List<ReRoute>
-                                {
-                                    new ReRouteBuilder()
-                                        .WithDownstreamHost("127.0.0.1")
-                                        .WithDownstreamPathTemplate("/products/{productId}")
-                                        .WithUpstreamPathTemplate("/api/products/{productId}")
-                                        .WithUpstreamHttpMethod("Get")
-                                        .Build()
-                                }))
-                    .BDDfy();
         }
 
         [Fact]
         public void should_use_downstream_scheme()
         {
+            var reRouteOptions = new ReRouteOptionsBuilder()
+                .Build();
+
             this.Given(x => x.GivenTheConfigIs(new FileConfiguration
                                         {
                                             ReRoutes = new List<FileReRoute>
@@ -200,6 +190,7 @@ namespace Ocelot.UnitTests.Configuration
                                             },
                                         }))
                                             .And(x => x.GivenTheConfigIsValid())
+                                            .And(x => x.GivenTheFollowingOptionsAreReturned(reRouteOptions))
                                             .When(x => x.WhenICreateTheConfig())
                                             .Then(x => x.ThenTheReRoutesAre(new List<ReRoute>
                                             {
@@ -216,6 +207,9 @@ namespace Ocelot.UnitTests.Configuration
         [Fact]
         public void should_use_service_discovery_for_downstream_service_host()
         {
+            var reRouteOptions = new ReRouteOptionsBuilder()
+                .Build();
+
             this.Given(x => x.GivenTheConfigIs(new FileConfiguration
                         {
                             ReRoutes = new List<FileReRoute>
@@ -239,6 +233,7 @@ namespace Ocelot.UnitTests.Configuration
                             }
                         }))
                             .And(x => x.GivenTheConfigIsValid())
+                            .And(x => x.GivenTheFollowingOptionsAreReturned(reRouteOptions))
                             .When(x => x.WhenICreateTheConfig())
                             .Then(x => x.ThenTheReRoutesAre(new List<ReRoute>
                             {
@@ -260,6 +255,9 @@ namespace Ocelot.UnitTests.Configuration
          [Fact]
         public void should_not_use_service_discovery_for_downstream_host_url_when_no_service_name()
         {
+            var reRouteOptions = new ReRouteOptionsBuilder()
+                .Build();
+                
             this.Given(x => x.GivenTheConfigIs(new FileConfiguration
                         {
                             ReRoutes = new List<FileReRoute>
@@ -274,6 +272,7 @@ namespace Ocelot.UnitTests.Configuration
                             }
                         }))
                             .And(x => x.GivenTheConfigIsValid())
+                            .And(x => x.GivenTheFollowingOptionsAreReturned(reRouteOptions))
                             .When(x => x.WhenICreateTheConfig())
                             .Then(x => x.ThenTheReRoutesAre(new List<ReRoute>
                             {
@@ -292,6 +291,9 @@ namespace Ocelot.UnitTests.Configuration
         [Fact]
         public void should_call_template_pattern_creator_correctly()
         {
+             var reRouteOptions = new ReRouteOptionsBuilder()
+                .Build();
+                
             this.Given(x => x.GivenTheConfigIs(new FileConfiguration
             {
                 ReRoutes = new List<FileReRoute>
@@ -306,6 +308,7 @@ namespace Ocelot.UnitTests.Configuration
                 }
             }))
                 .And(x => x.GivenTheConfigIsValid())
+                .And(x => x.GivenTheFollowingOptionsAreReturned(reRouteOptions))
                 .And(x => x.GivenTheUpstreamTemplatePatternCreatorReturns("(?i)/api/products/.*/$"))
                 .When(x => x.WhenICreateTheConfig())
                 .Then(x => x.ThenTheReRoutesAre(new List<ReRoute>
@@ -323,6 +326,9 @@ namespace Ocelot.UnitTests.Configuration
         [Fact]
         public void should_call_request_id_creator()
         {
+            var reRouteOptions = new ReRouteOptionsBuilder()
+                .Build();
+
             this.Given(x => x.GivenTheConfigIs(new FileConfiguration
             {
                 ReRoutes = new List<FileReRoute>
@@ -341,6 +347,7 @@ namespace Ocelot.UnitTests.Configuration
                 }
             }))
                 .And(x => x.GivenTheConfigIsValid())    
+                .And(x => x.GivenTheFollowingOptionsAreReturned(reRouteOptions))
                 .And(x => x.GivenTheRequestIdCreatorReturns("blahhhh"))
                 .When(x => x.WhenICreateTheConfig())
                 .Then(x => x.ThenTheReRoutesAre(new List<ReRoute>
@@ -359,6 +366,10 @@ namespace Ocelot.UnitTests.Configuration
         [Fact]
         public void should_create_with_headers_to_extract()
         {
+            var reRouteOptions = new ReRouteOptionsBuilder()
+                .WithIsAuthenticated(true)
+                .Build();
+
             var authenticationOptions = new AuthenticationOptionsBuilder()
                     .WithProvider("IdentityServer")
                     .WithProviderRootUrl("http://localhost:51888")
@@ -410,6 +421,7 @@ namespace Ocelot.UnitTests.Configuration
             }))
                 .And(x => x.GivenTheConfigIsValid())
                 .And(x => x.GivenTheAuthOptionsCreatorReturns(authenticationOptions))
+                .And(x => x.GivenTheFollowingOptionsAreReturned(reRouteOptions))
                 .And(x => x.GivenTheClaimsToThingCreatorReturns(new List<ClaimToThing>{new ClaimToThing("CustomerId", "CustomerId", "", 0)}))
                 .And(x => x.GivenTheLoadBalancerFactoryReturns())
                 .When(x => x.WhenICreateTheConfig())
@@ -424,6 +436,10 @@ namespace Ocelot.UnitTests.Configuration
         [Fact]
         public void should_create_with_authentication_properties()
         {
+            var reRouteOptions = new ReRouteOptionsBuilder()
+                .WithIsAuthenticated(true)
+                .Build();
+
              var authenticationOptions = new AuthenticationOptionsBuilder()
                     .WithProvider("IdentityServer")
                     .WithProviderRootUrl("http://localhost:51888")
@@ -466,6 +482,7 @@ namespace Ocelot.UnitTests.Configuration
                 }
             }))
                 .And(x => x.GivenTheConfigIsValid())
+                .And(x => x.GivenTheFollowingOptionsAreReturned(reRouteOptions))
                 .And(x => x.GivenTheAuthOptionsCreatorReturns(authenticationOptions))
                 .And(x => x.GivenTheLoadBalancerFactoryReturns())
                 .When(x => x.WhenICreateTheConfig())
@@ -475,6 +492,14 @@ namespace Ocelot.UnitTests.Configuration
                 .BDDfy();
         }
 
+        private void GivenTheFollowingOptionsAreReturned(ReRouteOptions fileReRouteOptions)
+        {
+            _fileReRouteOptionsCreator
+                .Setup(x => x.Create(It.IsAny<FileReRoute>()))
+                .Returns(fileReRouteOptions);
+        }
+
+
         private void GivenTheConfigIsValid()
         {
             _validator

test/Ocelot.UnitTests/Configuration/ReRouteOptionsCreatorTests.cs

@@ -0,0 +1,84 @@
+using System.Collections.Generic;
+using Ocelot.Configuration;
+using Ocelot.Configuration.Builder;
+using Ocelot.Configuration.Creator;
+using Ocelot.Configuration.File;
+using Shouldly;
+using TestStack.BDDfy;
+using Xunit;
+
+namespace Ocelot.UnitTests.Configuration
+{
+    public class ReRouteOptionsCreatorTests
+    {
+        private ReRouteOptionsCreator _creator;
+        private FileReRoute _reRoute;
+        private ReRouteOptions _result;
+
+        public ReRouteOptionsCreatorTests()
+        {
+            _creator = new ReRouteOptionsCreator();
+        }
+        
+        [Fact]
+        public void should_create_re_route_options()
+        {
+            var reRoute = new FileReRoute
+            {
+                RateLimitOptions = new FileRateLimitRule
+                {
+                    EnableRateLimiting = true
+                },
+                QoSOptions = new FileQoSOptions
+                {
+                    ExceptionsAllowedBeforeBreaking = 1,
+                    TimeoutValue = 1
+                },
+                AuthenticationOptions = new FileAuthenticationOptions
+                {
+                    Provider = "IdentityServer"
+                },
+                RouteClaimsRequirement = new Dictionary<string, string>()
+                {
+                    {"",""}
+                },
+                FileCacheOptions = new FileCacheOptions
+                {
+                    TtlSeconds = 1
+                }
+            };
+
+            var expected = new ReRouteOptionsBuilder()
+                .WithIsAuthenticated(true)
+                .WithIsAuthorised(true)
+                .WithIsCached(true)
+                .WithIsQos(true)
+                .WithRateLimiting(true)
+                .Build();
+
+            this.Given(x => x.GivenTheFollowing(reRoute))
+                .When(x => x.WhenICreate())
+                .Then(x => x.ThenTheFollowingIsReturned(expected))
+                .BDDfy();
+        }
+
+        private void GivenTheFollowing(FileReRoute reRoute)
+        {
+            _reRoute = reRoute;
+        }
+
+        private void WhenICreate()
+        {
+            _result = _creator.Create(_reRoute);
+        }
+
+        private void ThenTheFollowingIsReturned(ReRouteOptions expected)
+        {
+            _result.IsAuthenticated.ShouldBe(expected.IsAuthenticated);
+            _result.IsAuthorised.ShouldBe(expected.IsAuthorised);
+            _result.IsQos.ShouldBe(expected.IsQos);
+            _result.IsCached.ShouldBe(expected.IsCached);
+            _result.EnableRateLimiting.ShouldBe(expected.EnableRateLimiting);
+        }
+    }
+}