Refactor HttpClient usage

Keen.NET.Test/DelegatingHandlerMock.cs

@@ -0,0 +1,29 @@
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+
+
+namespace Keen.Net.Test
+{
+    /// <summary>
+    /// Wraps an <see cref="IHttpMessageHandler"/> and allows for using it as a DelegatingHandler.
+    /// If the IHttpMessageHandler doesn't already have a default action set, we'll have it call
+    /// our own base SendAsync() which will forward the request down the handler chain.
+    /// </summary>
+    internal class DelegatingHandlerMock : DelegatingHandler
+    {
+        private readonly IHttpMessageHandler _handler;
+
+        internal DelegatingHandlerMock(IHttpMessageHandler handler)
+        {
+            _handler = handler;
+            _handler.DefaultAsync = (_handler.DefaultAsync ?? base.SendAsync);
+        }
+
+        protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request,
+                                                               CancellationToken cancellationToken)
+        {
+            return _handler.SendAsync(request, cancellationToken);
+        }
+    }
+}

Keen.NET.Test/EventCollectionMock.cs

@@ -1,7 +1,8 @@
-using System;
-using System.Threading.Tasks;
-using Keen.Core;
+using Keen.Core;
 using Newtonsoft.Json.Linq;
+using System;
+using System.Threading.Tasks;
+
 
 namespace Keen.Net.Test
 {

Keen.NET.Test/FuncHandler.cs

@@ -0,0 +1,64 @@
+using System;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+
+
+namespace Keen.Net.Test
+{
+    /// <summary>
+    /// An <see cref="IHttpMessageHandler"/> that has pre/post/default message handlers functors,
+    /// as well as a Func<> that produces the actual HttpResponseMessage. These can all be set by
+    /// test code and will be called if available. There are defaults in place that essentially do
+    /// nothing, but client code should make sure DefaultAsync gets set, either by a wrapper or
+    /// explicitly.
+    /// </summary>
+    internal class FuncHandler : IHttpMessageHandler
+    {
+        internal Action<HttpRequestMessage, CancellationToken> PreProcess = (request, ct) => { };
+
+        internal Func<HttpRequestMessage,
+                      CancellationToken,
+                      Task<HttpResponseMessage>> ProduceResultAsync =
+                          (request, ct) => Task.FromResult<HttpResponseMessage>(null);
+
+        internal Func<HttpRequestMessage,
+                      HttpResponseMessage,
+                      HttpResponseMessage> PostProcess = (request, response) => response;
+
+        internal bool DeferToDefault { get; set; } = true;
+
+        public Func<HttpRequestMessage,
+                    CancellationToken,
+                    Task<HttpResponseMessage>> DefaultAsync { get; set; }
+
+
+        public async Task<HttpResponseMessage> SendAsync(
+            HttpRequestMessage request,
+            CancellationToken cancellationToken)
+        {
+            PreProcess(request, cancellationToken);
+            HttpResponseMessage response =
+                await ProduceResultAsync(request, cancellationToken).ConfigureAwait(false);
+
+            // Pass it along down the line if we didn't create a result already.
+            if (null == response)
+            {
+                if (DeferToDefault)
+                {
+                    response = await DefaultAsync(request, cancellationToken).ConfigureAwait(false);
+                }
+                else
+                {
+                    // Create a dummy successful response so HttpClient doesn't just throw always.
+                    response = await HttpTests.CreateJsonStringResponseAsync(new { dummy = "" })
+                        .ConfigureAwait(false);
+                }
+            }
+
+            PostProcess(request, response);
+
+            return response;
+        }
+    }
+}

Keen.NET.Test/FunnelTest.cs

@@ -1,11 +1,12 @@
-using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
-using Keen.Core;
+using Keen.Core;
 using Keen.Core.Query;
 using Moq;
 using NUnit.Framework;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
 
 namespace Keen.Net.Test
 {
@@ -52,6 +53,7 @@ public override void Setup()
         public async Task Funnel_Simple_Success()
         {
             var client = new KeenClient(SettingsEnv);
+            var timeframe = QueryRelativeTimeframe.ThisHour();
 
             IEnumerable<FunnelStep> funnelsteps = new List<FunnelStep>
             {
@@ -83,22 +85,21 @@ public async Task Funnel_Simple_Success()
                 Result = new[] { 3, 2 }
             };
 
-
             Mock<IQueries> queryMock = null;
             if (UseMocks)
             {
                 queryMock = new Mock<IQueries>();
                 queryMock.Setup(m => m.Funnel(
                         It.Is<IEnumerable<FunnelStep>>(f => f.Equals(funnelsteps)),
-                        It.Is<QueryTimeframe>(t => t == null),
+                        It.Is<QueryTimeframe>(t => t == timeframe),
                         It.Is<string>(t => t == "")
                       ))
                   .Returns(Task.FromResult(expected));
 
                 client.Queries = queryMock.Object;
             }
 
-            var reply = (await client.QueryFunnelAsync(funnelsteps));
+            var reply = (await client.QueryFunnelAsync(funnelsteps, timeframe));
             Assert.NotNull(reply);
             Assert.NotNull(reply.Result);
             Assert.NotNull(reply.Steps);
@@ -112,6 +113,7 @@ public async Task Funnel_Simple_Success()
         public async Task Funnel_Inverted_Success()
         {
             var client = new KeenClient(SettingsEnv);
+            var timeframe = QueryRelativeTimeframe.ThisHour();
 
             IEnumerable<FunnelStep> funnelsteps = new List<FunnelStep>
             {
@@ -144,22 +146,21 @@ public async Task Funnel_Inverted_Success()
                 Result = new [] { 3, 1 }
             };
 
-
             Mock<IQueries> queryMock = null;
             if (UseMocks)
             {
                 queryMock = new Mock<IQueries>();
                 queryMock.Setup(m => m.Funnel(
                         It.Is<IEnumerable<FunnelStep>>(f => f.Equals(funnelsteps)),
-                        It.Is<QueryTimeframe>(t => t == null),
+                        It.Is<QueryTimeframe>(t => t == timeframe),
                         It.Is<string>(t => t == "")
                       ))
                   .Returns(Task.FromResult(expected));
 
                 client.Queries = queryMock.Object;
             }
 
-            var reply = (await client.QueryFunnelAsync(funnelsteps));
+            var reply = (await client.QueryFunnelAsync(funnelsteps, timeframe));
             Assert.NotNull(reply);
             Assert.NotNull(reply.Result);
             Assert.True(reply.Result.SequenceEqual(expected.Result));
@@ -174,6 +175,7 @@ public async Task Funnel_Inverted_Success()
         public async Task Funnel_Optional_Success()
         {
             var client = new KeenClient(SettingsEnv);
+            var timeframe = QueryRelativeTimeframe.ThisHour();
 
             IEnumerable<FunnelStep> funnelsteps = new []
             {
@@ -215,22 +217,21 @@ public async Task Funnel_Optional_Success()
                 Result = new [] { 3, 2, 1 }
             };
 
-
             Mock<IQueries> queryMock = null;
             if (UseMocks)
             {
                 queryMock = new Mock<IQueries>();
                 queryMock.Setup(m => m.Funnel(
                         It.Is<IEnumerable<FunnelStep>>(f => f.Equals(funnelsteps)),
-                        It.Is<QueryTimeframe>(t => t == null),
+                        It.Is<QueryTimeframe>(t => t == timeframe),
                         It.Is<string>(t => t == "")
                       ))
                   .Returns(Task.FromResult(expected));
 
                 client.Queries = queryMock.Object;
             }
 
-            var reply = (await client.QueryFunnelAsync(funnelsteps));
+            var reply = (await client.QueryFunnelAsync(funnelsteps, timeframe));
             Assert.NotNull(reply);
             Assert.NotNull(reply.Result);
             Assert.True(reply.Result.SequenceEqual(expected.Result));
@@ -245,6 +246,7 @@ public async Task Funnel_Optional_Success()
         public async Task Funnel_ValidFilter_Success()
         {
             var client = new KeenClient(SettingsEnv);
+            var timeframe = QueryRelativeTimeframe.ThisHour();
             var filters = new List<QueryFilter> { new QueryFilter("id", QueryFilter.FilterOperator.GreaterThanOrEqual(), 0) };
 
             IEnumerable<FunnelStep> funnelsteps = new []
@@ -279,22 +281,21 @@ public async Task Funnel_ValidFilter_Success()
                 Result = new [] { 3, 2 }
             };
 
-
             Mock<IQueries> queryMock = null;
             if (UseMocks)
             {
                 queryMock = new Mock<IQueries>();
                 queryMock.Setup(m => m.Funnel(
                         It.Is<IEnumerable<FunnelStep>>(f => f.Equals(funnelsteps)),
-                        It.Is<QueryTimeframe>(t => t == null),
+                        It.Is<QueryTimeframe>(t => t == timeframe),
                         It.Is<string>(t => t == "")
                       ))
                   .Returns(Task.FromResult(expected));
 
                 client.Queries = queryMock.Object;
             }
 
-            var reply = (await client.QueryFunnelAsync(funnelsteps));
+            var reply = (await client.QueryFunnelAsync(funnelsteps, timeframe));
             Assert.NotNull(reply);
             Assert.NotNull(reply.Result);
             Assert.True(reply.Result.SequenceEqual(expected.Result));
@@ -309,20 +310,21 @@ public async Task Funnel_ValidFilter_Success()
         public async Task Funnel_ValidTimeframe_Success()
         {
             var client = new KeenClient(SettingsEnv);
-            var timeframe = QueryRelativeTimeframe.PreviousHour();
+            var timeframe = QueryRelativeTimeframe.ThisHour();
 
             IEnumerable<FunnelStep> funnelsteps = new []
             {
                 new FunnelStep
                 {
-                    EventCollection = FunnelColA, 
+                    EventCollection = FunnelColA,
                     ActorProperty = "id",
-                    Timeframe = timeframe,
+                    Timeframe = timeframe, // Issue #50 : These are ignored.
                 },
                 new FunnelStep
                 {
-                    EventCollection = FunnelColB, 
-                    ActorProperty = "id"
+                    EventCollection = FunnelColB,
+                    ActorProperty = "id",
+                    Timeframe = timeframe,
                 },
             };
 
@@ -332,32 +334,31 @@ public async Task Funnel_ValidTimeframe_Success()
                 {
                     new FunnelResultStep
                     {
-                        EventCollection = FunnelColA, 
+                        EventCollection = FunnelColA,
                     },
                     new FunnelResultStep
                     {
-                        EventCollection = FunnelColB, 
+                        EventCollection = FunnelColB,
                     },
                 },
                 Result = new [] { 3, 2 }
             };
 
-
             Mock<IQueries> queryMock = null;
             if (UseMocks)
             {
                 queryMock = new Mock<IQueries>();
                 queryMock.Setup(m => m.Funnel(
                         It.Is<IEnumerable<FunnelStep>>(f => f.Equals(funnelsteps)),
-                        It.Is<QueryTimeframe>(t => t == null),
+                        It.Is<QueryTimeframe>(t => t == timeframe),
                         It.Is<string>(t => t == "")
                       ))
                   .Returns(Task.FromResult(expected));
 
                 client.Queries = queryMock.Object;
             }
 
-            var reply = (await client.QueryFunnelAsync(funnelsteps));
+            var reply = (await client.QueryFunnelAsync(funnelsteps, timeframe));
             Assert.NotNull(reply);
             Assert.NotNull(reply.Result);
             Assert.True(reply.Result.SequenceEqual(expected.Result));
@@ -372,6 +373,7 @@ public async Task Funnel_ValidTimeframe_Success()
         public async Task Funnel_WithActors_Success()
         {
             var client = new KeenClient(SettingsEnv);
+            var timeframe = QueryRelativeTimeframe.ThisHour();
 
             IEnumerable<FunnelStep> funnelsteps = new []
             {
@@ -413,15 +415,15 @@ public async Task Funnel_WithActors_Success()
                 queryMock = new Mock<IQueries>();
                 queryMock.Setup(m => m.Funnel(
                         It.Is<IEnumerable<FunnelStep>>(f => f.Equals(funnelsteps)),
-                        It.Is<QueryTimeframe>(t => t == null),
+                        It.Is<QueryTimeframe>(t => t == timeframe),
                         It.Is<string>(t => t == "")
                       ))
                   .Returns(Task.FromResult(expected));
 
                 client.Queries = queryMock.Object;
             }
 
-            var reply = (await client.QueryFunnelAsync(funnelsteps));
+            var reply = (await client.QueryFunnelAsync(funnelsteps, timeframe));
             Assert.NotNull(reply);
             Assert.NotNull(reply.Actors);
             Assert.AreEqual(reply.Actors.Count(), 2);

Keen.NET.Test/HttpClientHandlerMock.cs

@@ -0,0 +1,31 @@
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+
+
+namespace Keen.Net.Test
+{
+    /// <summary>
+    /// Wraps an <see cref="IHttpMessageHandler"/> and allows for using it as an HttpClientHandler.
+    /// If the IHttpMessageHandler doesn't already have a default action set, we'll have it call
+    /// our own base SendAsync() which will forward the request to the actual HttpClientHandler
+    /// implementation, with all the configuration and proxies and such, which may actually go out
+    /// over the network.
+    /// </summary>
+    internal class HttpClientHandlerMock : HttpClientHandler
+    {
+        internal readonly IHttpMessageHandler _handler;
+
+        internal HttpClientHandlerMock(IHttpMessageHandler handler)
+        {
+            _handler = handler;
+            _handler.DefaultAsync = (_handler.DefaultAsync ?? base.SendAsync);
+        }
+
+        protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request,
+                                                               CancellationToken cancellationToken)
+        {
+            return _handler.SendAsync(request, cancellationToken);
+        }
+    }
+}