#298 initial hacking around better aggregation (#310)

* #298 initial hacking around better aggregation

* #298 bit more hacking around

* #298 abstraction over httpresponsemessage

* #298 tidying up

* #298 docs

* #298 missed this

test/Ocelot.AcceptanceTests/AggregateTests.cs

@@ -1,11 +1,17 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using System.Net;
+using System.Net.Http;
+using System.Net.Http.Headers;
+using System.Threading.Tasks;
 using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
 using Microsoft.AspNetCore.Http;
 using Ocelot.Configuration.File;
+using Ocelot.Middleware;
+using Ocelot.Middleware.Multiplexer;
 using Shouldly;
 using TestStack.BDDfy;
 using Xunit;
@@ -15,6 +21,7 @@ namespace Ocelot.AcceptanceTests
     public class AggregateTests : IDisposable
     {
         private IWebHost _serviceOneBuilder;
+        private IWebHost _serviceTwoBuilder;
         private readonly Steps _steps;
         private string _downstreamPathOne;
         private string _downstreamPathTwo;
@@ -24,6 +31,75 @@ namespace Ocelot.AcceptanceTests
             _steps = new Steps();
         }
 
+        [Fact]
+        public void should_return_response_200_with_simple_url_user_defined_aggregate()
+        {
+            var configuration = new FileConfiguration
+            {
+                ReRoutes = new List<FileReRoute>
+                    {
+                        new FileReRoute
+                        {
+                            DownstreamPathTemplate = "/",
+                            DownstreamScheme = "http",
+                            DownstreamHostAndPorts = new List<FileHostAndPort>
+                            {
+                                new FileHostAndPort
+                                {
+                                    Host = "localhost",
+                                    Port = 51885,
+                                }
+                            },
+                            UpstreamPathTemplate = "/laura",
+                            UpstreamHttpMethod = new List<string> { "Get" },
+                            Key = "Laura"
+                        },
+                        new FileReRoute
+                        {
+                            DownstreamPathTemplate = "/",
+                            DownstreamScheme = "http",
+                            DownstreamHostAndPorts = new List<FileHostAndPort>
+                            {
+                                new FileHostAndPort
+                                {
+                                    Host = "localhost",
+                                    Port = 51886,
+                                }
+                            },
+                            UpstreamPathTemplate = "/tom",
+                            UpstreamHttpMethod = new List<string> { "Get" },
+                            Key = "Tom"
+                        }
+                    },
+                    Aggregates = new List<FileAggregateReRoute>
+                    {
+                        new FileAggregateReRoute
+                        {
+                            UpstreamPathTemplate = "/",
+                            UpstreamHost = "localhost",
+                            ReRouteKeys = new List<string> 
+                            {
+                                "Tom",
+                                "Laura"
+                            },
+                            Aggregator = "FakeDefinedAggregator"
+                        }
+                    }
+            };
+
+            var expected = "Bye from Laura, Bye from Tom";
+
+            this.Given(x => x.GivenServiceOneIsRunning("http://localhost:51885", "/", 200, "{Hello from Laura}"))
+                .Given(x => x.GivenServiceTwoIsRunning("http://localhost:51886", "/", 200, "{Hello from Tom}"))
+                .And(x => _steps.GivenThereIsAConfiguration(configuration))
+                .And(x => _steps.GivenOcelotIsRunningWithSpecficAggregatorsRegisteredInDi<FakeDefinedAggregator, FakeDepdendency>())
+                .When(x => _steps.WhenIGetUrlOnTheApiGateway("/"))
+                .Then(x => _steps.ThenTheStatusCodeShouldBe(HttpStatusCode.OK))
+                .And(x => _steps.ThenTheResponseBodyShouldBe(expected))
+                .And(x => ThenTheDownstreamUrlPathShouldBe("/", "/"))
+                .BDDfy();
+        }
+
         [Fact]
         public void should_return_response_200_with_simple_url()
         {
@@ -325,7 +401,7 @@ namespace Ocelot.AcceptanceTests
 
         private void GivenServiceTwoIsRunning(string baseUrl, string basePath, int statusCode, string responseBody)
         {
-            _serviceOneBuilder = new WebHostBuilder()
+            _serviceTwoBuilder = new WebHostBuilder()
                 .UseUrls(baseUrl)
                 .UseKestrel()
                 .UseContentRoot(Directory.GetCurrentDirectory())
@@ -351,7 +427,7 @@ namespace Ocelot.AcceptanceTests
                 })
                 .Build();
 
-            _serviceOneBuilder.Start();
+            _serviceTwoBuilder.Start();
         }
 
         internal void ThenTheDownstreamUrlPathShouldBe(string expectedDownstreamPathOne, string expectedDownstreamPath)
@@ -363,7 +439,33 @@ namespace Ocelot.AcceptanceTests
         public void Dispose()
         {
             _serviceOneBuilder?.Dispose();
+            _serviceTwoBuilder?.Dispose();
             _steps.Dispose();
         }
     }
+
+    public class FakeDepdendency
+    {
+    }
+
+    public class FakeDefinedAggregator : IDefinedAggregator
+    {
+        private readonly FakeDepdendency _dep;
+
+        public FakeDefinedAggregator(FakeDepdendency dep)
+        {
+            _dep = dep;
+        }
+
+        public async Task<DownstreamResponse> Aggregate(List<DownstreamResponse> responses)
+        {
+            var one = await responses[0].Content.ReadAsStringAsync();
+            var two = await responses[1].Content.ReadAsStringAsync();
+
+            var merge = $"{one}, {two}";
+            merge = merge.Replace("Hello", "Bye").Replace("{", "").Replace("}", "");
+            var headers = responses.SelectMany(x => x.Headers).ToList();
+            return new DownstreamResponse(new StringContent(merge), HttpStatusCode.OK, headers);
+        }
+    }
 }