pulling out service config cretor

src/Ocelot/Configuration/Builder/ReRouteBuilder.cs

@@ -25,7 +25,7 @@ namespace Ocelot.Configuration.Builder
         private string _downstreamHost;
         private int _downstreamPort;
         private string _loadBalancer;
-        private ServiceProviderConfiguraion _serviceProviderConfiguraion;
+        private ServiceProviderConfiguration _serviceProviderConfiguraion;
         private bool _useQos;
         private QoSOptions _qosOptions;
         public bool _enableRateLimiting;
@@ -150,7 +150,7 @@ namespace Ocelot.Configuration.Builder
             return this;
         }
 
-        public ReRouteBuilder WithServiceProviderConfiguraion(ServiceProviderConfiguraion serviceProviderConfiguraion)
+        public ReRouteBuilder WithServiceProviderConfiguraion(ServiceProviderConfiguration serviceProviderConfiguraion)
         {
             _serviceProviderConfiguraion = serviceProviderConfiguraion;
             return this;

src/Ocelot/Configuration/Builder/ServiceProviderConfiguraionBuilder.cs

@@ -53,9 +53,9 @@ namespace Ocelot.Configuration.Builder
         }
 
         
-        public ServiceProviderConfiguraion Build()
+        public ServiceProviderConfiguration Build()
         {
-            return new ServiceProviderConfiguraion(_serviceName, _downstreamHost, _downstreamPort, _userServiceDiscovery,
+            return new ServiceProviderConfiguration(_serviceName, _downstreamHost, _downstreamPort, _userServiceDiscovery,
             _serviceDiscoveryProvider, _serviceDiscoveryProviderHost,_serviceDiscoveryProviderPort);
         }
     }

src/Ocelot/Configuration/Creator/FileOcelotConfigurationCreator.cs

@@ -32,6 +32,7 @@ namespace Ocelot.Configuration.Creator
         private readonly IAuthenticationOptionsCreator _authOptionsCreator;
         private IUpstreamTemplatePatternCreator _upstreamTemplatePatternCreator;
         private IRequestIdKeyCreator _requestIdKeyCreator;
+        private IServiceProviderConfigurationCreator _serviceProviderConfigCreator;
 
         public FileOcelotConfigurationCreator(
             IOptions<FileConfiguration> options, 
@@ -44,7 +45,8 @@ namespace Ocelot.Configuration.Creator
             IClaimsToThingCreator claimsToThingCreator,
             IAuthenticationOptionsCreator authOptionsCreator,
             IUpstreamTemplatePatternCreator upstreamTemplatePatternCreator,
-            IRequestIdKeyCreator requestIdKeyCreator)
+            IRequestIdKeyCreator requestIdKeyCreator,
+            IServiceProviderConfigurationCreator serviceProviderConfigCreator)
         {
             _requestIdKeyCreator = requestIdKeyCreator;
             _upstreamTemplatePatternCreator = upstreamTemplatePatternCreator;
@@ -57,6 +59,7 @@ namespace Ocelot.Configuration.Creator
             _configurationValidator = configurationValidator;
             _logger = logger;
             _claimsToThingCreator = claimsToThingCreator;
+            _serviceProviderConfigCreator = serviceProviderConfigCreator;
         }
 
         public async Task<Response<IOcelotConfiguration>> Create()
@@ -110,13 +113,13 @@ namespace Ocelot.Configuration.Creator
 
             var requestIdKey = _requestIdKeyCreator.Create(fileReRoute, globalConfiguration);
 
-            var reRouteKey = BuildReRouteKey(fileReRoute);
+            var reRouteKey = CreateReRouteKey(fileReRoute);
 
             var upstreamTemplatePattern = _upstreamTemplatePatternCreator.Create(fileReRoute);
 
             var isQos = IsQoS(fileReRoute);
 
-            var serviceProviderConfiguration = BuildServiceProviderConfiguration(fileReRoute, globalConfiguration);
+            var serviceProviderConfiguration = _serviceProviderConfigCreator.Create(fileReRoute, globalConfiguration);
 
             var authOptionsForRoute = _authOptionsCreator.Create(fileReRoute);
 
@@ -213,7 +216,7 @@ namespace Ocelot.Configuration.Creator
             return fileReRoute.FileCacheOptions.TtlSeconds > 0;
         }
 
-        private string BuildReRouteKey(FileReRoute fileReRoute)
+        private string CreateReRouteKey(FileReRoute fileReRoute)
         {
             //note - not sure if this is the correct key, but this is probably the only unique key i can think of given my poor brain
             var loadBalancerKey = $"{fileReRoute.UpstreamPathTemplate}{fileReRoute.UpstreamHttpMethod}";
@@ -232,24 +235,6 @@ namespace Ocelot.Configuration.Creator
             _qosProviderHouse.Add(reRoute.ReRouteKey, loadBalancer);
         }
 
-        private ServiceProviderConfiguraion BuildServiceProviderConfiguration(FileReRoute fileReRoute, FileGlobalConfiguration globalConfiguration)
-        {
-            var useServiceDiscovery = !string.IsNullOrEmpty(fileReRoute.ServiceName)
-                && !string.IsNullOrEmpty(globalConfiguration?.ServiceDiscoveryProvider?.Provider);
-
-            var serviceProviderPort = globalConfiguration?.ServiceDiscoveryProvider?.Port ?? 0;
-
-            return new ServiceProviderConfiguraionBuilder()
-                    .WithServiceName(fileReRoute.ServiceName)
-                    .WithDownstreamHost(fileReRoute.DownstreamHost)
-                    .WithDownstreamPort(fileReRoute.DownstreamPort)
-                    .WithUseServiceDiscovery(useServiceDiscovery)
-                    .WithServiceDiscoveryProvider(globalConfiguration?.ServiceDiscoveryProvider?.Provider)
-                    .WithServiceDiscoveryProviderHost(globalConfiguration?.ServiceDiscoveryProvider?.Host)
-                    .WithServiceDiscoveryProviderPort(serviceProviderPort)
-                    .Build();
-        }
-
         private bool IsPlaceHolder(string upstreamTemplate, int i)
         {
             return upstreamTemplate[i] == '{';

src/Ocelot/Configuration/Creator/IServiceProviderConfigurationCreator.cs

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

src/Ocelot/Configuration/Creator/ServiceProviderConfigurationCreator.cs

@@ -0,0 +1,26 @@
+using Ocelot.Configuration.Builder;
+using Ocelot.Configuration.File;
+
+namespace Ocelot.Configuration.Creator
+{
+    public class ServiceProviderConfigurationCreator : IServiceProviderConfigurationCreator
+    {
+        public ServiceProviderConfiguration Create(FileReRoute fileReRoute, FileGlobalConfiguration globalConfiguration)
+        {
+            var useServiceDiscovery = !string.IsNullOrEmpty(fileReRoute.ServiceName)
+                && !string.IsNullOrEmpty(globalConfiguration?.ServiceDiscoveryProvider?.Provider);
+
+            var serviceProviderPort = globalConfiguration?.ServiceDiscoveryProvider?.Port ?? 0;
+
+            return new ServiceProviderConfiguraionBuilder()
+                    .WithServiceName(fileReRoute.ServiceName)
+                    .WithDownstreamHost(fileReRoute.DownstreamHost)
+                    .WithDownstreamPort(fileReRoute.DownstreamPort)
+                    .WithUseServiceDiscovery(useServiceDiscovery)
+                    .WithServiceDiscoveryProvider(globalConfiguration?.ServiceDiscoveryProvider?.Provider)
+                    .WithServiceDiscoveryProviderHost(globalConfiguration?.ServiceDiscoveryProvider?.Host)
+                    .WithServiceDiscoveryProviderPort(serviceProviderPort)
+                    .Build();
+        }
+    }
+}

src/Ocelot/Configuration/ReRoute.cs

@@ -25,7 +25,7 @@ namespace Ocelot.Configuration
             string downstreamHost, 
             int downstreamPort, 
             string reRouteKey, 
-            ServiceProviderConfiguraion serviceProviderConfiguraion,
+            ServiceProviderConfiguration serviceProviderConfiguraion,
             bool isQos,
             QoSOptions qos,
             bool enableRateLimit,
@@ -81,7 +81,7 @@ namespace Ocelot.Configuration
         public string LoadBalancer {get;private set;}
         public string DownstreamHost { get; private set; }
         public int DownstreamPort { get; private set; }
-        public ServiceProviderConfiguraion ServiceProviderConfiguraion { get; private set; }
+        public ServiceProviderConfiguration ServiceProviderConfiguraion { get; private set; }
         public bool EnableEndpointRateLimiting { get; private set; }
         public RateLimitOptions RateLimitOptions { get; private set; }
     }

src/Ocelot/Configuration/ServiceProviderConfiguraion.cs

@@ -1,8 +1,8 @@
 namespace Ocelot.Configuration
 {
-    public class ServiceProviderConfiguraion
+    public class ServiceProviderConfiguration
     {
-        public ServiceProviderConfiguraion(string serviceName, string downstreamHost,
+        public ServiceProviderConfiguration(string serviceName, string downstreamHost,
             int downstreamPort, bool useServiceDiscovery, string serviceDiscoveryProvider, string serviceProviderHost, int serviceProviderPort)
         {
             ServiceName = serviceName;

src/Ocelot/DependencyInjection/ServiceCollectionExtensions.cs

@@ -64,6 +64,7 @@ namespace Ocelot.DependencyInjection
             services.AddSingleton<IAuthenticationOptionsCreator, AuthenticationOptionsCreator>();
             services.AddSingleton<IUpstreamTemplatePatternCreator, UpstreamTemplatePatternCreator>();
             services.AddSingleton<IRequestIdKeyCreator, RequestIdKeyCreator>();
+            services.AddSingleton<IServiceProviderConfigurationCreator,ServiceProviderConfigurationCreator>();
 
             var identityServerConfiguration = IdentityServerConfigurationCreator.GetIdentityServerConfiguration();
             

src/Ocelot/ServiceDiscovery/IServiceDiscoveryProviderFactory.cs

@@ -5,6 +5,6 @@ namespace Ocelot.ServiceDiscovery
 {
     public interface IServiceDiscoveryProviderFactory
     {
-        IServiceDiscoveryProvider Get(ServiceProviderConfiguraion serviceConfig);
+        IServiceDiscoveryProvider Get(ServiceProviderConfiguration serviceConfig);
     }
 }

src/Ocelot/ServiceDiscovery/ServiceDiscoveryProviderFactory.cs

@@ -6,7 +6,7 @@ namespace Ocelot.ServiceDiscovery
 {
     public class ServiceDiscoveryProviderFactory : IServiceDiscoveryProviderFactory
     {
-        public  IServiceDiscoveryProvider Get(ServiceProviderConfiguraion serviceConfig)
+        public  IServiceDiscoveryProvider Get(ServiceProviderConfiguration serviceConfig)
         {
             if (serviceConfig.UseServiceDiscovery)
             {

test/Ocelot.UnitTests/Configuration/FileConfigurationCreatorTests.cs

@@ -35,6 +35,7 @@ namespace Ocelot.UnitTests.Configuration
         private Mock<IAuthenticationOptionsCreator> _authOptionsCreator;
         private Mock<IUpstreamTemplatePatternCreator> _upstreamTemplatePatternCreator;
         private Mock<IRequestIdKeyCreator> _requestIdKeyCreator;
+        private Mock<IServiceProviderConfigurationCreator> _serviceProviderConfigCreator;
 
         public FileConfigurationCreatorTests()
         {
@@ -51,12 +52,14 @@ namespace Ocelot.UnitTests.Configuration
             _authOptionsCreator = new Mock<IAuthenticationOptionsCreator>();
             _upstreamTemplatePatternCreator = new Mock<IUpstreamTemplatePatternCreator>();
             _requestIdKeyCreator = new Mock<IRequestIdKeyCreator>();
+            _serviceProviderConfigCreator = new Mock<IServiceProviderConfigurationCreator>();
 
             _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);
+                _authOptionsCreator.Object, _upstreamTemplatePatternCreator.Object, _requestIdKeyCreator.Object,
+                _serviceProviderConfigCreator.Object);
         }
 
         [Fact]
@@ -470,9 +473,25 @@ namespace Ocelot.UnitTests.Configuration
                 result.ClaimsToHeaders.Count.ShouldBe(expected.ClaimsToHeaders.Count);
                 result.ClaimsToQueries.Count.ShouldBe(expected.ClaimsToQueries.Count);
                 result.RequestIdKey.ShouldBe(expected.RequestIdKey);
+            
             }
         }
 
+        private void ThenTheServiceConfigurationIs(ServiceProviderConfiguration expected)
+        {
+            for (int i = 0; i < _config.Data.ReRoutes.Count; i++)
+            {
+                var result = _config.Data.ReRoutes[i];
+                result.ServiceProviderConfiguraion.DownstreamHost.ShouldBe(expected.DownstreamHost);
+                result.ServiceProviderConfiguraion.DownstreamPort.ShouldBe(expected.DownstreamPort);
+                result.ServiceProviderConfiguraion.ServiceDiscoveryProvider.ShouldBe(expected.ServiceDiscoveryProvider);
+                result.ServiceProviderConfiguraion.ServiceName.ShouldBe(expected.ServiceName);
+                result.ServiceProviderConfiguraion.ServiceProviderHost.ShouldBe(expected.ServiceProviderHost);
+                result.ServiceProviderConfiguraion.ServiceProviderPort.ShouldBe(expected.ServiceProviderPort);
+            }
+        }
+
+
         private void ThenTheAuthenticationOptionsAre(List<ReRoute> expectedReRoutes)
         {
             for (int i = 0; i < _config.Data.ReRoutes.Count; i++)

test/Ocelot.UnitTests/LoadBalancer/LoadBalancerFactoryTests.cs

@@ -90,14 +90,14 @@ namespace Ocelot.UnitTests.LoadBalancer
         private void GivenTheServiceProviderFactoryReturns()
         {
             _serviceProviderFactory
-                .Setup(x => x.Get(It.IsAny<ServiceProviderConfiguraion>()))
+                .Setup(x => x.Get(It.IsAny<ServiceProviderConfiguration>()))
                 .Returns(_serviceProvider.Object);
         }
 
         private void ThenTheServiceProviderIsCalledCorrectly()
         {
             _serviceProviderFactory
-                .Verify(x => x.Get(It.IsAny<ServiceProviderConfiguraion>()), Times.Once);
+                .Verify(x => x.Get(It.IsAny<ServiceProviderConfiguration>()), Times.Once);
         }
 
         private void GivenAReRoute(ReRoute reRoute)

test/Ocelot.UnitTests/ServiceDiscovery/ServiceProviderFactoryTests.cs

@@ -9,7 +9,7 @@ namespace Ocelot.UnitTests.ServiceDiscovery
 {
     public class ServiceProviderFactoryTests
     {
-        private ServiceProviderConfiguraion _serviceConfig;
+        private ServiceProviderConfiguration _serviceConfig;
         private IServiceDiscoveryProvider _result;
         private readonly ServiceDiscoveryProviderFactory _factory;
 
@@ -48,7 +48,7 @@ namespace Ocelot.UnitTests.ServiceDiscovery
                 .BDDfy();
         }
 
-        private void GivenTheReRoute(ServiceProviderConfiguraion serviceConfig)
+        private void GivenTheReRoute(ServiceProviderConfiguration serviceConfig)
         {
             _serviceConfig = serviceConfig;
         }