Merge pull request #33 from eealeivan/cancellation-tokens

Add cancellation tokens to all IMixpanelClient methods.

Author: eealeivan

src/Mixpanel/Mixpanel.Tests/Mixpanel.Tests.csproj

@@ -9,6 +9,7 @@
   <ItemGroup>
     <PackageReference Include="Bogus" Version="34.0.2" />
     <PackageReference Include="FluentAssertions" Version="6.7.0" />
+    <PackageReference Include="Microsoft.TestPlatform.TestHost" Version="17.2.0" />
     <PackageReference Include="Newtonsoft.Json" Version="13.0.1" />
     <PackageReference Include="NUnit" Version="3.13.3" />
     <PackageReference Include="NUnit3TestAdapter" Version="4.2.1" />

src/Mixpanel/Mixpanel.Tests/MixpanelClient/HttpMockMixpanelConfig.cs

@@ -8,38 +8,57 @@
 
 namespace Mixpanel.Tests.MixpanelClient
 {
-    public class HttpMockMixpanelConfig
+    public class HttpMockMixpanelConfig<TMessage> where TMessage : class
     {
         public MixpanelConfig Instance { get; }
-        public List<(string Endpoint, JObject Message)> Messages { get; }
+        public List<(string Endpoint, TMessage Message)> Messages { get; }
+        public bool RequestCancelled { get; private set; }
 
-        public HttpMockMixpanelConfig(MixpanelConfig config)
+        public HttpMockMixpanelConfig(MixpanelConfig config = null)
         {
             Instance = config ?? new MixpanelConfig();
-            Messages = new List<(string Endpoint, JObject Message)>();
+            Messages = new List<(string Endpoint, TMessage Message)>();
 
             if (Instance.AsyncHttpPostFn != null)
             {
                 throw new Exception("AsyncHttpPostFn is expected to be null.");
             }
 
-            Instance.AsyncHttpPostFn = (endpoint, data) =>
+            Instance.AsyncHttpPostFn = async (endpoint, data, cancellationToken) =>
             {
+                if (cancellationToken.CanBeCanceled)
+                {
+                    cancellationToken.WaitHandle.WaitOne(TimeSpan.FromSeconds(1));
+                }
+
+                RequestCancelled = cancellationToken.IsCancellationRequested;
+                cancellationToken.ThrowIfCancellationRequested();
+
                 Messages.Add((endpoint, ParseMessageData(data)));
-                return Task.FromResult(true);
+                return await Task.FromResult(true);
             };
         }
 
-        private JObject ParseMessageData(string data)
+        private TMessage ParseMessageData(string data)
         {
             // Can't use JObject.Parse because it's not possible to disable DateTime parsing
             using (var stringReader = new StringReader(GetJsonFromData(data)))
             {
                 using (JsonReader jsonReader = new JsonTextReader(stringReader))
                 {
                     jsonReader.DateParseHandling = DateParseHandling.None;
-                    JObject msg = JObject.Load(jsonReader);
-                    return msg;
+
+                    if (typeof(TMessage) == typeof(JObject))
+                    {
+                        return JObject.Load(jsonReader) as TMessage;
+                    }
+
+                    if (typeof(TMessage) == typeof(JArray))
+                    {
+                        return JArray.Load(jsonReader) as TMessage;
+                    }
+
+                    throw new NotSupportedException($"{typeof(TMessage)} is not supported.");
                 }
             }
         }

src/Mixpanel/Mixpanel.Tests/MixpanelClient/MixpanelClientHttpTests.cs

@@ -37,10 +37,13 @@ public void SetUp()
                 () => client.PeopleUnsetAsync(DistinctId, StringPropertyArray),
                 () => client.PeopleDeleteAsync(DistinctId),
                 () => client.PeopleTrackChargeAsync(DistinctId, DecimalPropertyValue),
-                () => client.SendAsync(new MixpanelMessage
+                () => client.SendAsync(new[]
                 {
-                    Kind = MessageKind.PeopleSet,
-                    Data = DictionaryWithStringProperty
+                    new MixpanelMessage
+                    {
+                        Kind = MessageKind.PeopleSet,
+                        Data = DictionaryWithStringProperty
+                    }
                 })
             };
         }
@@ -49,7 +52,7 @@ private MixpanelConfig GetConfig()
         {
             return new MixpanelConfig
             {
-                AsyncHttpPostFn = (endpoint, data) =>
+                AsyncHttpPostFn = (endpoint, data, cancellationToken) =>
                 {
                     urls.Add(endpoint);
                     return Task.FromResult(true);

src/Mixpanel/Mixpanel.Tests/MixpanelClient/MixpanelClientSendJsonTests.cs

@@ -1,50 +1,69 @@
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
+using Bogus;
+using FluentAssertions;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using NUnit.Framework;
 
 namespace Mixpanel.Tests.MixpanelClient
 {
     [TestFixture]
-    public class MixpanelClientSendJsonTests : MixpanelClientTestsBase
+    public class MixpanelClientSendJsonTests
     {
         [Test]
-        public async Task When_SendAsync_Then_CorrectDataSent()
+        public async Task SendAsync_TrackMessage_CorrectDataSent()
         {
-            bool result = await Client.SendJsonAsync(MixpanelMessageEndpoint.Track, CreateJsonMessage());
+            // Arrange
+            var httpMockMixpanelConfig = new HttpMockMixpanelConfig<JObject>();
+            var client = new Mixpanel.MixpanelClient(httpMockMixpanelConfig.Instance);
+            var message = CreateJsonMessage();
 
-            Assert.That(result, Is.True);
-            Assert.That(HttpPostEntries.Single().Endpoint, Is.EqualTo(TrackUrl));
-            CheckSendJsonMessage();
+            // Act
+            var result = await client.SendJsonAsync(MixpanelMessageEndpoint.Track, message);
+
+            // Assert
+            result.Should().BeTrue();
+            var (endpoint, sentMessage) = httpMockMixpanelConfig.Messages.Single();
+            endpoint.Should().Be("https://api.mixpanel.com/track");
+            sentMessage.ToString(Formatting.None).Should().Be(message);
+        }
+
+        [Test]
+        public void SendAsync_CancellationRequested_RequestCancelled()
+        {
+            // Arrange
+            var httpMockMixpanelConfig = new HttpMockMixpanelConfig<JObject>();
+            var cancellationTokenSource = new CancellationTokenSource();
+            var client = new Mixpanel.MixpanelClient(httpMockMixpanelConfig.Instance);
+            var jsonMessage = CreateJsonMessage();
+
+            // Act
+            var task = Task.Factory.StartNew(
+                async () => await client.SendJsonAsync(
+                    MixpanelMessageEndpoint.Track, jsonMessage, cancellationTokenSource.Token));
+            cancellationTokenSource.Cancel();
+            task.Wait();
+
+            // Assert
+            httpMockMixpanelConfig.RequestCancelled.Should().BeTrue();
         }
 
         private string CreateJsonMessage()
         {
+            var randomizer = new Randomizer();
             var message = new
             {
-                @event = Event,
+                @event = randomizer.Words(),
                 properties = new
                 {
-                    token = Token,
-                    distinct_id = DistinctId,
-                    StringProperty = StringPropertyValue
+                    token = randomizer.AlphaNumeric(30),
+                    distinct_id = randomizer.AlphaNumeric(10)
                 }
             };
-            string messageJson = JsonConvert.SerializeObject(message);
-            return messageJson;
-        }
 
-        private void CheckSendJsonMessage()
-        {
-            var msg = ParseMessageData(HttpPostEntries.Single().Data);
-            Assert.That(msg.Count, Is.EqualTo(2));
-            Assert.That(msg["event"].Value<string>(), Is.EqualTo(Event));
-            var props = (JObject)msg["properties"];
-            Assert.That(props.Count, Is.EqualTo(3));
-            Assert.That(props["token"].Value<string>(), Is.EqualTo(Token));
-            Assert.That(props["distinct_id"].Value<string>(), Is.EqualTo(DistinctId));
-            Assert.That(props[StringPropertyName].Value<string>(), Is.EqualTo(StringPropertyValue));
+            return JsonConvert.SerializeObject(message);
         }
     }
 }