added lame test for service config creator

src/Ocelot/Configuration/Builder/ServiceProviderConfigurationBuilder.cs

@@ -1,6 +1,6 @@
 namespace Ocelot.Configuration.Builder
 {
-    public class ServiceProviderConfiguraionBuilder
+    public class ServiceProviderConfigurationBuilder
     {
         private string _serviceName;
         private string _downstreamHost;
@@ -10,43 +10,43 @@ namespace Ocelot.Configuration.Builder
         private string _serviceDiscoveryProviderHost;
         private int _serviceDiscoveryProviderPort;
 
-        public ServiceProviderConfiguraionBuilder WithServiceName(string serviceName)
+        public ServiceProviderConfigurationBuilder WithServiceName(string serviceName)
         {
             _serviceName = serviceName;
             return this;
         }
 
-        public ServiceProviderConfiguraionBuilder WithDownstreamHost(string downstreamHost)
+        public ServiceProviderConfigurationBuilder WithDownstreamHost(string downstreamHost)
         {
             _downstreamHost = downstreamHost;
             return this;
         }
 
-        public ServiceProviderConfiguraionBuilder WithDownstreamPort(int downstreamPort)
+        public ServiceProviderConfigurationBuilder WithDownstreamPort(int downstreamPort)
         {
             _downstreamPort = downstreamPort;
             return this;
         }
 
-        public ServiceProviderConfiguraionBuilder WithUseServiceDiscovery(bool userServiceDiscovery)
+        public ServiceProviderConfigurationBuilder WithUseServiceDiscovery(bool userServiceDiscovery)
         {
             _userServiceDiscovery = userServiceDiscovery;
             return this;
         }
 
-        public ServiceProviderConfiguraionBuilder WithServiceDiscoveryProvider(string serviceDiscoveryProvider)
+        public ServiceProviderConfigurationBuilder WithServiceDiscoveryProvider(string serviceDiscoveryProvider)
         {
             _serviceDiscoveryProvider = serviceDiscoveryProvider;
             return this;
         }
 
-        public ServiceProviderConfiguraionBuilder WithServiceDiscoveryProviderHost(string serviceDiscoveryProviderHost)
+        public ServiceProviderConfigurationBuilder WithServiceDiscoveryProviderHost(string serviceDiscoveryProviderHost)
         {
             _serviceDiscoveryProviderHost = serviceDiscoveryProviderHost;
             return this;
         }
 
-        public ServiceProviderConfiguraionBuilder WithServiceDiscoveryProviderPort(int serviceDiscoveryProviderPort)
+        public ServiceProviderConfigurationBuilder WithServiceDiscoveryProviderPort(int serviceDiscoveryProviderPort)
         {
             _serviceDiscoveryProviderPort = serviceDiscoveryProviderPort;
             return this;

src/Ocelot/Configuration/Creator/ServiceProviderConfigurationCreator.cs

@@ -12,7 +12,7 @@ namespace Ocelot.Configuration.Creator
 
             var serviceProviderPort = globalConfiguration?.ServiceDiscoveryProvider?.Port ?? 0;
 
-            return new ServiceProviderConfiguraionBuilder()
+            return new ServiceProviderConfigurationBuilder()
                     .WithServiceName(fileReRoute.ServiceName)
                     .WithDownstreamHost(fileReRoute.DownstreamHost)
                     .WithDownstreamPort(fileReRoute.DownstreamPort)

test/Ocelot.UnitTests/Configuration/FileConfigurationCreatorTests.cs

@@ -209,7 +209,7 @@ namespace Ocelot.UnitTests.Configuration
                                     .WithDownstreamPathTemplate("/products/{productId}")
                                     .WithUpstreamPathTemplate("/api/products/{productId}")
                                     .WithUpstreamHttpMethod("Get")
-                                    .WithServiceProviderConfiguraion(new ServiceProviderConfiguraionBuilder()
+                                    .WithServiceProviderConfiguraion(new ServiceProviderConfigurationBuilder()
                                         .WithUseServiceDiscovery(true)
                                         .WithServiceDiscoveryProvider("consul")
                                         .WithServiceDiscoveryProviderHost("127.0.0.1")
@@ -244,7 +244,7 @@ namespace Ocelot.UnitTests.Configuration
                                     .WithDownstreamPathTemplate("/products/{productId}")
                                     .WithUpstreamPathTemplate("/api/products/{productId}")
                                     .WithUpstreamHttpMethod("Get")
-                                    .WithServiceProviderConfiguraion(new ServiceProviderConfiguraionBuilder()
+                                    .WithServiceProviderConfiguraion(new ServiceProviderConfigurationBuilder()
                                         .WithUseServiceDiscovery(false)
                                         .Build())
                                     .Build()

test/Ocelot.UnitTests/Configuration/ServiceProviderCreatorTests.cs

@@ -0,0 +1,76 @@
+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 ServiceProviderCreatorTests
+    {
+        private ServiceProviderConfigurationCreator _creator;
+        private FileReRoute _reRoute;
+        private FileGlobalConfiguration _globalConfig;
+        private ServiceProviderConfiguration _result;
+
+        public ServiceProviderCreatorTests()
+        {
+            _creator = new ServiceProviderConfigurationCreator();
+        }
+
+        [Fact]
+        public void should_create_service_provider_config()
+        {
+            var reRoute = new FileReRoute();
+            
+            var globalConfig = new FileGlobalConfiguration
+            {
+                ServiceDiscoveryProvider = new FileServiceDiscoveryProvider
+                {
+                    Provider = "consul",
+                    Host = "127.0.0.1",
+                    Port = 1234
+                }
+            };
+
+            var expected = new ServiceProviderConfigurationBuilder()
+                .WithServiceDiscoveryProvider("consul")
+                .WithServiceDiscoveryProviderHost("127.0.0.1")
+                .WithServiceDiscoveryProviderPort(1234)
+                .Build();
+
+            this.Given(x => x.GivenTheFollowingReRoute(reRoute))
+                .And(x => x.GivenTheFollowingGlobalConfig(globalConfig))
+                .When(x => x.WhenICreate())
+                .Then(x => x.ThenTheConfigIs(expected))
+                .BDDfy();
+        }
+
+        private void GivenTheFollowingReRoute(FileReRoute fileReRoute)
+        {
+            _reRoute = fileReRoute;
+        }
+
+        private void GivenTheFollowingGlobalConfig(FileGlobalConfiguration fileGlobalConfig)
+        {
+            _globalConfig = fileGlobalConfig;
+        }
+
+        private void WhenICreate()
+        {
+            _result = _creator.Create(_reRoute, _globalConfig);
+        }
+
+        private void ThenTheConfigIs(ServiceProviderConfiguration expected)
+        {
+            _result.DownstreamHost.ShouldBe(expected.DownstreamHost);
+            _result.DownstreamPort.ShouldBe(expected.DownstreamPort);
+            _result.ServiceDiscoveryProvider.ShouldBe(expected.ServiceDiscoveryProvider);
+            _result.ServiceName.ShouldBe(expected.ServiceName);
+            _result.ServiceProviderHost.ShouldBe(expected.ServiceProviderHost);
+            _result.ServiceProviderPort.ShouldBe(expected.ServiceProviderPort);
+        }
+    }
+}

test/Ocelot.UnitTests/LoadBalancer/LoadBalancerFactoryTests.cs

@@ -28,7 +28,7 @@ namespace Ocelot.UnitTests.LoadBalancer
         public void should_return_no_load_balancer()
         {
             var reRoute = new ReRouteBuilder()
-                .WithServiceProviderConfiguraion(new ServiceProviderConfiguraionBuilder().Build())
+                .WithServiceProviderConfiguraion(new ServiceProviderConfigurationBuilder().Build())
                 .WithUpstreamHttpMethod("Get")
                 .Build();
 
@@ -45,7 +45,7 @@ namespace Ocelot.UnitTests.LoadBalancer
              var reRoute = new ReRouteBuilder()
                 .WithLoadBalancer("RoundRobin")
                 .WithUpstreamHttpMethod("Get")
-                .WithServiceProviderConfiguraion(new ServiceProviderConfiguraionBuilder().Build())
+                .WithServiceProviderConfiguraion(new ServiceProviderConfigurationBuilder().Build())
                 .Build();
 
             this.Given(x => x.GivenAReRoute(reRoute))
@@ -61,7 +61,7 @@ namespace Ocelot.UnitTests.LoadBalancer
              var reRoute = new ReRouteBuilder()
                 .WithLoadBalancer("LeastConnection")
                 .WithUpstreamHttpMethod("Get")
-                .WithServiceProviderConfiguraion(new ServiceProviderConfiguraionBuilder().Build())
+                .WithServiceProviderConfiguraion(new ServiceProviderConfigurationBuilder().Build())
                 .Build();
 
             this.Given(x => x.GivenAReRoute(reRoute))
@@ -77,7 +77,7 @@ namespace Ocelot.UnitTests.LoadBalancer
             var reRoute = new ReRouteBuilder()
                 .WithLoadBalancer("RoundRobin")
                 .WithUpstreamHttpMethod("Get")
-                .WithServiceProviderConfiguraion(new ServiceProviderConfiguraionBuilder().Build())
+                .WithServiceProviderConfiguraion(new ServiceProviderConfigurationBuilder().Build())
                 .Build();
 
             this.Given(x => x.GivenAReRoute(reRoute))

test/Ocelot.UnitTests/ServiceDiscovery/ServiceProviderFactoryTests.cs

@@ -21,7 +21,7 @@ namespace Ocelot.UnitTests.ServiceDiscovery
         [Fact]
         public void should_return_no_service_provider()
         {
-            var serviceConfig = new ServiceProviderConfiguraionBuilder()
+            var serviceConfig = new ServiceProviderConfigurationBuilder()
                 .WithDownstreamHost("127.0.0.1")
                 .WithDownstreamPort(80)
                 .WithUseServiceDiscovery(false)
@@ -36,7 +36,7 @@ namespace Ocelot.UnitTests.ServiceDiscovery
         [Fact]
         public void should_return_consul_service_provider()
         {
-            var serviceConfig = new ServiceProviderConfiguraionBuilder()
+            var serviceConfig = new ServiceProviderConfigurationBuilder()
                 .WithServiceName("product")
                 .WithUseServiceDiscovery(true)
                 .WithServiceDiscoveryProvider("Consul")