Add ConfigAwarePlaceholders class (#997)

* Add ConfigAwarePlaceholders class

This allows placeholder values to be sourced from IConfiguration in
addition to set values.

* Rework how IPlaceholders is decorated in container

test/Ocelot.UnitTests/DependencyInjection/OcelotBuilderTests.cs

@@ -14,6 +14,7 @@ namespace Ocelot.UnitTests.DependencyInjection
     using System.Collections.Generic;
     using System.Linq;
     using System.Net.Http;
+    using Ocelot.Infrastructure;
     using TestStack.BDDfy;
     using Xunit;
     using static Ocelot.UnitTests.Middleware.UserDefinedResponseAggregatorTests;
@@ -136,6 +137,16 @@ namespace Ocelot.UnitTests.DependencyInjection
                 .BDDfy();
         }
 
+        [Fact]
+        public void should_replace_iplaceholder()
+        {
+            this.Given(x => x.WhenISetUpOcelotServices())
+                .When(x => AddConfigPlaceholders())
+                .Then(x => ThenAnExceptionIsntThrown())
+                .And(x => ThenTheIPlaceholderInstanceIsReplaced())
+                .BDDfy();
+        }
+
         private void AddSingletonDefinedAggregator<T>()
             where T : class, IDefinedAggregator
         {
@@ -148,6 +159,11 @@ namespace Ocelot.UnitTests.DependencyInjection
             _ocelotBuilder.AddTransientDefinedAggregator<T>();
         }
 
+        private void AddConfigPlaceholders()
+        {
+            _ocelotBuilder.AddConfigPlaceholders();
+        }
+
         private void ThenTheSpecificHandlersAreTransient()
         {
             var handlers = _serviceProvider.GetServices<DelegatingHandler>().ToList();
@@ -235,6 +251,13 @@ namespace Ocelot.UnitTests.DependencyInjection
             _ocelotBuilder.ShouldBeOfType<OcelotBuilder>();
         }
 
+        private void ThenTheIPlaceholderInstanceIsReplaced()
+        {
+            _serviceProvider = _services.BuildServiceProvider();
+            var placeholders = _serviceProvider.GetService<IPlaceholders>();
+            placeholders.ShouldBeOfType<ConfigAwarePlaceholders>();
+        }
+
         private void WhenISetUpOcelotServices()
         {
             try

test/Ocelot.UnitTests/Infrastructure/ConfigAwarePlaceholdersTests.cs

@@ -0,0 +1,78 @@
+namespace Ocelot.UnitTests.Infrastructure
+{
+    using System;
+    using Moq;
+    using Ocelot.Infrastructure;
+    using Responses;
+    using Shouldly;
+    using Microsoft.Extensions.Configuration;
+    using Xunit;
+
+    public class ConfigAwarePlaceholdersTests
+    {
+        private readonly IPlaceholders _placeholders;
+        private readonly Mock<IPlaceholders> _basePlaceholders;
+
+        public ConfigAwarePlaceholdersTests()
+        {
+            var configurationBuilder = new ConfigurationBuilder();
+            configurationBuilder.AddJsonFile("appsettings.json");
+            var configuration = configurationBuilder.Build();
+
+            _basePlaceholders = new Mock<IPlaceholders>();
+            _placeholders = new ConfigAwarePlaceholders(configuration, _basePlaceholders.Object);
+        }
+
+        [Fact]
+        public void should_return_value_from_underlying_placeholders()
+        {
+            var baseUrl = "http://www.bbc.co.uk";
+            const string key = "{BaseUrl}";
+            
+            _basePlaceholders.Setup(x => x.Get(key)).Returns(new OkResponse<string>(baseUrl));
+            var result = _placeholders.Get(key);
+            result.Data.ShouldBe(baseUrl);
+        }
+
+        [Fact]
+        public void should_return_value_from_config_with_same_name_as_placeholder_if_underlying_placeholder_not_found()
+        {
+            const string expected = "http://foo-bar.co.uk";
+            var baseUrl = "http://www.bbc.co.uk";
+            const string key = "{BaseUrl}";
+            
+            _basePlaceholders.Setup(x => x.Get(key)).Returns(new ErrorResponse<string>(new FakeError()));
+            var result = _placeholders.Get(key);
+            result.Data.ShouldBe(expected);
+        }
+
+        [Theory]
+        [InlineData("{TestConfig}")]
+        [InlineData("{TestConfigNested:Child}")]
+        public void should_return_value_from_config(string key)
+        {
+            const string expected = "foo";
+            
+            _basePlaceholders.Setup(x => x.Get(key)).Returns(new ErrorResponse<string>(new FakeError()));
+            var result = _placeholders.Get(key);
+            result.Data.ShouldBe(expected);
+        }
+
+        [Fact]
+        public void should_call_underyling_when_added()
+        {
+            const string key = "{Test}";
+            Func<Response<string>> func = () => new OkResponse<string>("test)");
+            _placeholders.Add(key, func);
+            _basePlaceholders.Verify(p => p.Add(key, func), Times.Once);
+        }
+
+        [Fact]
+        public void should_call_underyling_when_removed()
+        {
+            const string key = "{Test}";
+            _placeholders.Remove(key);
+            _basePlaceholders.Verify(p => p.Remove(key), Times.Once);
+        }
+    }
+}

test/Ocelot.UnitTests/appsettings.json

@@ -20,5 +20,10 @@
       "port": 5000,
       "hostName": "localhost"
     }
+  },
+  "BaseUrl": "http://foo-bar.co.uk",
+  "TestConfig": "foo",
+  "TestConfigNested":{
+    "Child": "foo"
   }
 }