Feature/store configuraton json idented (#328)

* messing around with benchmark.net.seems Ocelot adds about 2ms to a request..lets make this less? :)

* #326 store json indented so it looks nice :P

test/Ocelot.UnitTests/Configuration/ConsulFileConfigurationRepositoryTests.cs

@@ -0,0 +1,137 @@
+namespace Ocelot.UnitTests.Configuration
+{
+    using Xunit;
+    using TestStack.BDDfy;
+    using Shouldly;
+    using Ocelot.Configuration.Repository;
+    using Moq;
+    using Ocelot.Infrastructure.Consul;
+    using Ocelot.Logging;
+    using Ocelot.Configuration.File;
+    using Ocelot.Cache;
+    using System;
+    using System.Collections.Generic;
+    using Ocelot.Responses;
+    using System.Threading.Tasks;
+    using Ocelot.Configuration;
+    using Ocelot.Configuration.Builder;
+    using Ocelot.ServiceDiscovery.Configuration;
+    using Consul;
+    using Newtonsoft.Json;
+    using System.Text;
+    using System.Threading;
+    using System.Linq;
+
+    public class ConsulFileConfigurationRepositoryTests
+    {
+        private ConsulFileConfigurationRepository _repo;
+        private Mock<IOcelotCache<FileConfiguration>> _cache;
+        private Mock<IInternalConfigurationRepository> _internalRepo;
+        private Mock<IConsulClientFactory> _factory;
+        private Mock<IOcelotLoggerFactory> _loggerFactory;
+        private Mock<IConsulClient> _client;
+        private Mock<IKVEndpoint> _kvEndpoint;
+        private FileConfiguration _fileConfiguration;
+        private Response _result;
+
+        public ConsulFileConfigurationRepositoryTests()
+        {
+            _cache = new Mock<IOcelotCache<FileConfiguration>>();
+            _internalRepo = new Mock<IInternalConfigurationRepository>();
+            _loggerFactory = new Mock<IOcelotLoggerFactory>();
+
+            _factory = new Mock<IConsulClientFactory>();
+            _client = new Mock<IConsulClient>();
+            _kvEndpoint = new Mock<IKVEndpoint>();
+
+            _client
+                .Setup(x => x.KV)
+                .Returns(_kvEndpoint.Object);
+            _factory
+                .Setup(x => x.Get(It.IsAny<ConsulRegistryConfiguration>()))
+                .Returns(_client.Object);
+
+            _internalRepo
+                .Setup(x => x.Get())
+                .Returns(new OkResponse<IInternalConfiguration>(new InternalConfiguration(new List<ReRoute>(), "", new ServiceProviderConfigurationBuilder().Build(), "")));
+            
+            _repo = new ConsulFileConfigurationRepository(_cache.Object, _internalRepo.Object, _factory.Object, _loggerFactory.Object);
+        }
+
+        [Fact]
+        public void should_set_config()
+        {
+            var config = FakeFileConfiguration();
+
+            this.Given(_ => GivenIHaveAConfiguration(config))
+                .And(_ => GivenWritingToConsulSucceeds())
+                .When(_ => WhenISetTheConfiguration())
+                .Then(_ => ThenTheConfigurationIsStoredAs(config))
+                .BDDfy();
+        }
+
+        private void GivenWritingToConsulSucceeds()
+        {
+            var response = new WriteResult<bool>();
+            response.Response = true;
+
+            _kvEndpoint
+                .Setup(x => x.Put(It.IsAny<KVPair>(), It.IsAny<CancellationToken>())).ReturnsAsync(response);
+        }
+
+        private void ThenTheConfigurationIsStoredAs(FileConfiguration config)
+        {
+            var json = JsonConvert.SerializeObject(config, Formatting.Indented);
+
+            var bytes = Encoding.UTF8.GetBytes(json);
+
+            _kvEndpoint
+                .Verify(x => x.Put(It.Is<KVPair>(k => k.Value.SequenceEqual(bytes)), It.IsAny<CancellationToken>()), Times.Once);
+        }
+
+        private async Task WhenISetTheConfiguration()
+        {
+            _result = await _repo.Set(_fileConfiguration);
+        }
+
+        private void GivenIHaveAConfiguration(FileConfiguration config)
+        {
+            _fileConfiguration = config;
+        }
+        
+        private FileConfiguration FakeFileConfiguration()
+        {
+            var reRoutes = new List<FileReRoute>
+            {
+                new FileReRoute
+                {
+                    DownstreamHostAndPorts = new List<FileHostAndPort>
+                    {
+                        new FileHostAndPort
+                        {
+                            Host = "123.12.12.12",
+                            Port = 80,
+                        }
+                    },
+                    DownstreamScheme = "https",
+                    DownstreamPathTemplate = "/asdfs/test/{test}"
+                }
+            };
+
+            var globalConfiguration = new FileGlobalConfiguration
+            {
+                ServiceDiscoveryProvider = new FileServiceDiscoveryProvider
+                {
+                    Port = 198,
+                    Host = "blah"
+                }
+            };
+
+            return new FileConfiguration
+            {
+                GlobalConfiguration = globalConfiguration,
+                ReRoutes = reRoutes
+            };
+        }
+    }
+}

test/Ocelot.UnitTests/Configuration/DiskFileConfigurationRepositoryTests.cs

@@ -1,21 +1,22 @@
-using System;
-using System.Collections.Generic;
-using Moq;
-using Ocelot.Configuration.File;
-using Shouldly;
-using TestStack.BDDfy;
-using Xunit;
-using Newtonsoft.Json;
-using System.IO;
-using Microsoft.AspNetCore.Hosting;
-using Ocelot.Configuration.Repository;
-
 namespace Ocelot.UnitTests.Configuration
 {
-    public class FileConfigurationRepositoryTests
+    using System;
+    using System.Collections.Generic;
+    using Moq;
+    using Ocelot.Configuration.File;
+    using Shouldly;
+    using TestStack.BDDfy;
+    using Xunit;
+    using Newtonsoft.Json;
+    using System.IO;
+    using Microsoft.AspNetCore.Hosting;
+    using Ocelot.Configuration.Repository;
+
+    public class DiskFileConfigurationRepositoryTests
     {
         private readonly Mock<IHostingEnvironment> _hostingEnvironment = new Mock<IHostingEnvironment>();
         private IFileConfigurationRepository _repo;
+        private string _configurationPath;
         private FileConfiguration _result;
         private FileConfiguration _fileConfiguration;
 
@@ -24,7 +25,7 @@ namespace Ocelot.UnitTests.Configuration
         // tests but whatever...
         private string _environmentName = "DEV.DEV";
 
-        public FileConfigurationRepositoryTests()
+        public DiskFileConfigurationRepositoryTests()
         {
             _hostingEnvironment.Setup(he => he.EnvironmentName).Returns(_environmentName);
             _repo = new DiskFileConfigurationRepository(_hostingEnvironment.Object);
@@ -35,9 +36,9 @@ namespace Ocelot.UnitTests.Configuration
         {
             var config = FakeFileConfigurationForGet();
 
-            this.Given(x => x.GivenTheConfigurationIs(config))
-                .When(x => x.WhenIGetTheReRoutes())
-                .Then(x => x.ThenTheFollowingIsReturned(config))
+            this.Given(_ => GivenTheConfigurationIs(config))
+                .When(_ => WhenIGetTheReRoutes())
+                .Then(_ => ThenTheFollowingIsReturned(config))
                 .BDDfy();
         }
 
@@ -46,10 +47,10 @@ namespace Ocelot.UnitTests.Configuration
         {
             var config = FakeFileConfigurationForGet();
 
-            this.Given(x => x.GivenTheEnvironmentNameIsUnavailable())
-                .And(x => x.GivenTheConfigurationIs(config))
-                .When(x => x.WhenIGetTheReRoutes())
-                .Then(x => x.ThenTheFollowingIsReturned(config))
+            this.Given(_ => GivenTheEnvironmentNameIsUnavailable())
+                .And(_ => GivenTheConfigurationIs(config))
+                .When(_ => WhenIGetTheReRoutes())
+                .Then(_ => ThenTheFollowingIsReturned(config))
                 .BDDfy();
         }
 
@@ -58,9 +59,10 @@ namespace Ocelot.UnitTests.Configuration
         {
             var config = FakeFileConfigurationForSet();
 
-            this.Given(x => GivenIHaveAConfiguration(config))
-                .When(x => WhenISetTheConfiguration())
-                .Then(x => ThenTheConfigurationIsStoredAs(config))
+            this.Given(_ => GivenIHaveAConfiguration(config))
+                .When(_ => WhenISetTheConfiguration())
+                .Then(_ => ThenTheConfigurationIsStoredAs(config))
+                .And(_ => ThenTheConfigurationJsonIsIndented(config))
                 .BDDfy();
         }
 
@@ -68,10 +70,12 @@ namespace Ocelot.UnitTests.Configuration
         public void should_set_file_configuration_if_environment_name_is_unavailable()
         {
             var config = FakeFileConfigurationForSet();
-            this.Given(x => GivenIHaveAConfiguration(config))
-                .And(x => GivenTheEnvironmentNameIsUnavailable())
-                .When(x => WhenISetTheConfiguration())
-                .Then(x => ThenTheConfigurationIsStoredAs(config))
+
+            this.Given(_ => GivenIHaveAConfiguration(config))
+                .And(_ => GivenTheEnvironmentNameIsUnavailable())
+                .When(_ => WhenISetTheConfiguration())
+                .Then(_ => ThenTheConfigurationIsStoredAs(config))
+                .And(_ => ThenTheConfigurationJsonIsIndented(config))
                 .BDDfy();
         }
 
@@ -117,16 +121,25 @@ namespace Ocelot.UnitTests.Configuration
 
         private void GivenTheConfigurationIs(FileConfiguration fileConfiguration)
         {
-            var configurationPath = $"{AppContext.BaseDirectory}/ocelot{(string.IsNullOrEmpty(_environmentName) ? string.Empty : ".")}{_environmentName}.json";
+            _configurationPath = $"{AppContext.BaseDirectory}/ocelot{(string.IsNullOrEmpty(_environmentName) ? string.Empty : ".")}{_environmentName}.json";
 
-            var jsonConfiguration = JsonConvert.SerializeObject(fileConfiguration);
+            var jsonConfiguration = JsonConvert.SerializeObject(fileConfiguration, Formatting.Indented);
 
-            if (File.Exists(configurationPath))
+            if (File.Exists(_configurationPath))
             {
-                File.Delete(configurationPath);
+                File.Delete(_configurationPath);
             }
 
-            File.WriteAllText(configurationPath, jsonConfiguration);
+            File.WriteAllText(_configurationPath, jsonConfiguration);
+        }
+
+        private void ThenTheConfigurationJsonIsIndented(FileConfiguration expecteds)
+        {
+            var path = !string.IsNullOrEmpty(_configurationPath) ? _configurationPath : _configurationPath = $"{AppContext.BaseDirectory}/ocelot{(string.IsNullOrEmpty(_environmentName) ? string.Empty : ".")}{_environmentName}.json";
+            
+            var resultText = File.ReadAllText(_configurationPath);
+            var expectedText = JsonConvert.SerializeObject(expecteds, Formatting.Indented);
+            resultText.ShouldBe(expectedText);
         }
 
         private void WhenIGetTheReRoutes()