Feature/steeltoe (#324)

* #262 - Integrated Steeltoe Service Discovery with Ocelot for review.

* messing around

* seems to be working with eureka

* acceptance test passing with external lib references

* #262 support for netflix eureka service discovery thanks to pivotal

* #262 fixed warnings

test/Ocelot.UnitTests/Middleware/OcelotPipelineExtensionsTests.cs

@@ -1,20 +1,15 @@
-using System.Threading.Tasks;
-using Microsoft.AspNetCore.Http;
-using Microsoft.Extensions.Configuration;
-using Microsoft.Extensions.DependencyInjection;
-using Moq;
-using Ocelot.Configuration;
-using Ocelot.Configuration.Builder;
-using Ocelot.DependencyInjection;
-using Ocelot.Middleware;
-using Ocelot.Middleware.Multiplexer;
-using Ocelot.Middleware.Pipeline;
-using Shouldly;
-using TestStack.BDDfy;
-using Xunit;
-
 namespace Ocelot.UnitTests.Middleware
 {
+    using Microsoft.Extensions.Configuration;
+    using Microsoft.Extensions.DependencyInjection;
+    using Ocelot.DependencyInjection;
+    using Ocelot.Middleware;
+    using Ocelot.Middleware.Pipeline;
+    using Pivotal.Discovery.Client;
+    using Shouldly;
+    using TestStack.BDDfy;
+    using Xunit;
+
     public class OcelotPipelineExtensionsTests
     {
         private OcelotPipelineBuilder _builder;
@@ -45,9 +40,10 @@ namespace Ocelot.UnitTests.Middleware
             var root = test.Build();
             var services = new ServiceCollection();
             services.AddSingleton<IConfiguration>(root);
+            services.AddDiscoveryClient(new DiscoveryOptions {ClientType = DiscoveryClientType.EUREKA});
             services.AddOcelot();
             var provider = services.BuildServiceProvider();
             _builder = new OcelotPipelineBuilder(provider);
         }
     }
-}
+}

test/Ocelot.UnitTests/ServiceDiscovery/EurekaServiceDiscoveryProviderTests.cs

@@ -0,0 +1,117 @@
+namespace Ocelot.UnitTests.ServiceDiscovery
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Threading.Tasks;
+    using Moq;
+    using Ocelot.ServiceDiscovery.Providers;
+    using Pivotal.Discovery.Client;
+    using Shouldly;
+    using TestStack.BDDfy;
+    using Values;
+    using Xunit;
+
+    public class EurekaServiceDiscoveryProviderTests
+    {
+        private readonly EurekaServiceDiscoveryProvider _provider;
+        private readonly Mock<IDiscoveryClient> _client;
+        private readonly string _serviceId;
+        private List<IServiceInstance> _instances;
+        private List<Service> _result;
+
+        public EurekaServiceDiscoveryProviderTests()
+        {
+            _serviceId = "Laura";
+            _client = new Mock<IDiscoveryClient>();
+            _provider = new EurekaServiceDiscoveryProvider(_serviceId, _client.Object);
+        }
+
+        [Fact]
+        public void should_return_empty_services()
+        {
+            this.When(_ => WhenIGet())
+                .Then(_ => ThenTheCountIs(0))
+                .BDDfy();
+        }
+
+        [Fact]
+        public void should_return_service_from_client()
+        {
+            var instances = new List<IServiceInstance>
+            {
+                new EurekaService(_serviceId, "somehost", 801, false, new Uri("http://somehost:801"), new Dictionary<string, string>())
+            };
+
+            this.Given(_ => GivenThe(instances))
+                .When(_ => WhenIGet())
+                .Then(_ => ThenTheCountIs(1))
+                .And(_ => ThenTheClientIsCalledCorrectly())
+                .And(_ => ThenTheServiceIsMapped())
+                .BDDfy();
+        }
+
+        [Fact]
+        public void should_return_services_from_client()
+        {
+            var instances = new List<IServiceInstance>
+            {
+                new EurekaService(_serviceId, "somehost", 801, false, new Uri("http://somehost:801"), new Dictionary<string, string>()),
+                new EurekaService(_serviceId, "somehost", 801, false, new Uri("http://somehost:801"), new Dictionary<string, string>())
+            };
+
+            this.Given(_ => GivenThe(instances))
+                .When(_ => WhenIGet())
+                .Then(_ => ThenTheCountIs(2))
+                .And(_ => ThenTheClientIsCalledCorrectly())
+                .BDDfy();
+        }
+
+        private void ThenTheServiceIsMapped()
+        {
+            _result[0].HostAndPort.DownstreamHost.ShouldBe("somehost");
+            _result[0].HostAndPort.DownstreamPort.ShouldBe(801);
+            _result[0].Name.ShouldBe(_serviceId);
+        }
+
+        private void ThenTheCountIs(int expected)
+        {
+            _result.Count.ShouldBe(expected);
+        }
+
+        private void ThenTheClientIsCalledCorrectly()
+        {
+            _client.Verify(x => x.GetInstances(_serviceId), Times.Once);
+        }
+
+        private async Task WhenIGet()
+        {
+            _result = await _provider.Get();
+        }
+
+        private void GivenThe(List<IServiceInstance> instances)
+        {
+            _instances = instances;
+            _client.Setup(x => x.GetInstances(It.IsAny<string>())).Returns(instances);
+        }
+    }
+
+    public class EurekaService : IServiceInstance
+    {
+        public EurekaService(string serviceId, string host, int port, bool isSecure, Uri uri, IDictionary<string, string> metadata)
+        {
+            ServiceId = serviceId;
+            Host = host;
+            Port = port;
+            IsSecure = isSecure;
+            Uri = uri;
+            Metadata = metadata;
+        }
+
+        public string ServiceId { get; }
+        public string Host { get; }
+        public int Port { get; }
+        public bool IsSecure { get; }
+        public Uri Uri { get; }
+        public IDictionary<string, string> Metadata { get; }
+    }
+}

test/Ocelot.UnitTests/ServiceDiscovery/ServiceProviderFactoryTests.cs

@@ -13,6 +13,8 @@ using Xunit;
 
 namespace Ocelot.UnitTests.ServiceDiscovery
 {
+    using Pivotal.Discovery.Client;
+
     public class ServiceProviderFactoryTests
     {
         private ServiceProviderConfiguration _serviceConfig;
@@ -20,13 +22,13 @@ namespace Ocelot.UnitTests.ServiceDiscovery
         private readonly ServiceDiscoveryProviderFactory _factory;
         private DownstreamReRoute _reRoute;
         private Mock<IOcelotLoggerFactory> _loggerFactory;
-        private IConsulClientFactory _clientFactory;
+        private Mock<IDiscoveryClient> _discoveryClient;
 
         public ServiceProviderFactoryTests()
         {
             _loggerFactory = new Mock<IOcelotLoggerFactory>();
-            _clientFactory = new ConsulClientFactory();
-            _factory = new ServiceDiscoveryProviderFactory(_loggerFactory.Object, _clientFactory);
+            _discoveryClient = new Mock<IDiscoveryClient>();
+            _factory = new ServiceDiscoveryProviderFactory(_loggerFactory.Object, new ConsulClientFactory(), _discoveryClient.Object);
         }
         
         [Fact]
@@ -99,6 +101,24 @@ namespace Ocelot.UnitTests.ServiceDiscovery
                 .BDDfy();
         }
 
+        [Fact]
+        public void should_return_eureka_provider()
+        {
+            var reRoute = new DownstreamReRouteBuilder()
+                .WithServiceName("product")
+                .WithUseServiceDiscovery(true)
+                .Build();
+
+            var serviceConfig = new ServiceProviderConfigurationBuilder()
+                .WithType("Eureka")
+                .Build();
+
+            this.Given(x => x.GivenTheReRoute(serviceConfig, reRoute))
+                .When(x => x.WhenIGetTheServiceProvider())
+                .Then(x => x.ThenTheServiceProviderIs<EurekaServiceDiscoveryProvider>())
+                .BDDfy();
+        }
+
         private void ThenTheFollowingServicesAreReturned(List<DownstreamHostAndPort> downstreamAddresses)
         {
             var result = (ConfigurationServiceProvider)_result;