Feature/fix #463 (#506)

* #463 save both files

* #463 made it so we dont save to disk on startup unless using admin api

test/Ocelot.AcceptanceTests/StartupTests.cs

@@ -0,0 +1,100 @@
+namespace Ocelot.AcceptanceTests
+{
+    using System;
+    using System.Collections.Generic;
+    using System.IO;
+    using System.Net;
+    using System.Threading.Tasks;
+    using Configuration.Repository;
+    using Microsoft.AspNetCore.Http;
+    using Ocelot.Configuration.File;
+    using Responses;
+    using TestStack.BDDfy;
+    using Xunit;
+
+    public class StartupTests : IDisposable
+    {
+        private readonly Steps _steps;
+        private readonly ServiceHandler _serviceHandler;
+        private string _downstreamPath;
+
+        public StartupTests()
+        {
+            _serviceHandler = new ServiceHandler();
+            _steps = new Steps();
+        }
+
+        [Fact]
+        public void should_not_try_and_write_to_disk_on_startup_when_not_using_admin_api()
+        {
+            var configuration = new FileConfiguration
+            {
+                ReRoutes = new List<FileReRoute>
+                {
+                    new FileReRoute
+                    {
+                        DownstreamPathTemplate = "/",
+                        DownstreamScheme = "http",
+                        DownstreamHostAndPorts = new List<FileHostAndPort>
+                        {
+                            new FileHostAndPort
+                            {
+                                Host = "localhost",
+                                Port = 52179,
+                            }
+                        },
+                        UpstreamPathTemplate = "/",
+                        UpstreamHttpMethod = new List<string> { "Get" },
+                    }
+                }
+            };
+
+            var fakeRepo = new FakeFileConfigurationRepository();
+
+            this.Given(x => x.GivenThereIsAServiceRunningOn("http://localhost:52179", "/", 200, "Hello from Laura"))
+                .And(x => _steps.GivenThereIsAConfiguration(configuration))
+                .And(x => _steps.GivenOcelotIsRunningWithBlowingUpDiskRepo(fakeRepo))
+                .When(x => _steps.WhenIGetUrlOnTheApiGateway("/"))
+                .Then(x => _steps.ThenTheStatusCodeShouldBe(HttpStatusCode.OK))
+                .BDDfy();
+        }
+
+        private void GivenThereIsAServiceRunningOn(string baseUrl, string basePath, int statusCode, string responseBody)
+        {
+            _serviceHandler.GivenThereIsAServiceRunningOn(baseUrl, basePath, async context =>
+            {
+                _downstreamPath = !string.IsNullOrEmpty(context.Request.PathBase.Value) ? context.Request.PathBase.Value : context.Request.Path.Value;
+
+                if (_downstreamPath != basePath)
+                {
+                    context.Response.StatusCode = statusCode;
+                    await context.Response.WriteAsync("downstream path didnt match base path");
+                }
+                else
+                {
+                    context.Response.StatusCode = statusCode;
+                    await context.Response.WriteAsync(responseBody);
+                }
+            });
+        }
+
+        public void Dispose()
+        {
+            _serviceHandler?.Dispose();
+            _steps.Dispose();
+        }
+
+        class FakeFileConfigurationRepository : IFileConfigurationRepository
+        {
+            public Task<Response<FileConfiguration>> Get()
+            {
+                throw new NotImplementedException();
+            }
+
+            public Task<Response> Set(FileConfiguration fileConfiguration)
+            {
+                throw new NotImplementedException();
+            }
+        }
+    }
+}

test/Ocelot.AcceptanceTests/Steps.cs

@@ -31,6 +31,7 @@ using static Ocelot.Infrastructure.Wait;
 
 namespace Ocelot.AcceptanceTests
 {
+    using Configuration.Repository;
     using Microsoft.Net.Http.Headers;
     using MediaTypeHeaderValue = System.Net.Http.Headers.MediaTypeHeaderValue;
 
@@ -928,5 +929,35 @@ namespace Ocelot.AcceptanceTests
             var content = await response.Content.ReadAsStringAsync();
             content.ShouldBe(expectedBody);
         }
+
+        public void GivenOcelotIsRunningWithBlowingUpDiskRepo(IFileConfigurationRepository fake)
+        {
+            _webHostBuilder = new WebHostBuilder();
+
+            _webHostBuilder
+                .ConfigureAppConfiguration((hostingContext, config) =>
+                {
+                    config.SetBasePath(hostingContext.HostingEnvironment.ContentRootPath);
+                    var env = hostingContext.HostingEnvironment;
+                    config.AddJsonFile("appsettings.json", optional: true, reloadOnChange: false)
+                        .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true, reloadOnChange: false);
+                    config.AddJsonFile("ocelot.json", false, false);
+                    config.AddEnvironmentVariables();
+                })
+                .ConfigureServices(s =>
+                {
+                    s.AddSingleton<IFileConfigurationRepository>(fake);
+                    s.AddOcelot();
+                })
+                .Configure(app =>
+                {
+                    app.UseOcelot().Wait();
+                });
+
+            _ocelotServer = new TestServer(_webHostBuilder);
+
+            _ocelotClient = _ocelotServer.CreateClient();
+
+        }
     }
 }