Enables cancellation on async InjectLatency monkey.

GitVersionConfig.yaml

@@ -1 +1 @@
-next-version: 0.1.0
+next-version: 0.2.0

README.md

@@ -183,4 +183,4 @@ Simmy was [the brainchild of](https://github.com/App-vNext/Polly/issues/499) [@m
 ### Samples
 * [Dylan Reisenberger](http://www.thepollyproject.org/author/dylan/) presents an [intentionally simple example](https://github.com/Polly-Contrib/Polly.Contrib.SimmyDemo_WebApi) .NET Core WebAPI app demonstrating how we can set up Simmy chaos policies for certain environments and without changing any existing configuration code injecting faults or chaos by modifying external configuration.
 
-* [Geovanny Alzate Sandoval](https://github.com/vany0114) made a [microservices based sample application](https://github.com/vany0114/chaos-injection-using-simmy) to demonstrate how chaos engineering works with Simmy using chaos policies in a distributed system and how we can inject even a custom behavior given our needs or infrastructure, this time injecting custom behavior to generate chaos in our Service Fabric Cluster.
+* [Geovanny Alzate Sandoval](https://github.com/vany0114) made a [microservices based sample application](https://github.com/vany0114/chaos-injection-using-simmy) to demonstrate how chaos engineering works with Simmy using chaos policies in a distributed system and how we can inject even a custom behavior given our needs or infrastructure, this time injecting custom behavior to generate chaos in our Service Fabric Cluster.

src/Polly.Contrib.Simmy.Specs/Latency/InjectLatencyAsyncSpecs.cs

@@ -1,8 +1,10 @@
 using System;
+using System.Diagnostics;
 using System.Threading;
 using System.Threading.Tasks;
 using FluentAssertions;
 using Polly.Contrib.Simmy.Utilities;
+using Polly.Timeout;
 using Polly.Utilities;
 using Xunit;
 
@@ -75,7 +77,7 @@ public async Task InjectLatency_Context_Free_Should_Not_Introduce_Delay_If_Injec
             var delay = TimeSpan.FromMilliseconds(500);
             var policy = MonkeyPolicy.InjectLatencyAsync(delay, 0.3, () => true);
             var executed = false;
-            
+
             Func<Task> actionAsync = () => { executed = true; return TaskHelper.EmptyTask; };
             await policy.ExecuteAsync(actionAsync);
 
@@ -170,7 +172,7 @@ public async Task InjectLatency_With_Context_With_InjectionRate_Lambda_Should_In
             {
                 if (ctx["InjectionRate"] != null)
                 {
-                    return await Task.FromResult((double) ctx["InjectionRate"]);
+                    return await Task.FromResult((double)ctx["InjectionRate"]);
                 }
 
                 return await Task.FromResult(0);
@@ -203,7 +205,7 @@ public async Task InjectLatency_With_Context_With_InjectionRate_Lambda_Should_No
             {
                 if (ctx["InjectionRate"] != null)
                 {
-                    return await Task.FromResult((double) ctx["InjectionRate"]);
+                    return await Task.FromResult((double)ctx["InjectionRate"]);
                 }
 
                 return await Task.FromResult(0);
@@ -247,7 +249,7 @@ public async Task InjectLatency_With_Context_With_Latency_Lambda_Should_Introduc
             {
                 if (ctx["InjectionRate"] != null)
                 {
-                    return await Task.FromResult((double) ctx["InjectionRate"]);
+                    return await Task.FromResult((double)ctx["InjectionRate"]);
                 }
 
                 return await Task.FromResult(0);
@@ -291,7 +293,7 @@ public async Task InjectLatency_With_Context_With_Latency_Lambda_Should_Not_Intr
             {
                 if (ctx["InjectionRate"] != null)
                 {
-                    return await Task.FromResult((double) ctx["InjectionRate"]);
+                    return await Task.FromResult((double)ctx["InjectionRate"]);
                 }
 
                 return await Task.FromResult(0);
@@ -335,7 +337,7 @@ public async Task InjectLatency_With_Context_With_Latency_Lambda_Should_Not_Intr
             {
                 if (ctx["InjectionRate"] != null)
                 {
-                    return await Task.FromResult((double) ctx["InjectionRate"]);
+                    return await Task.FromResult((double)ctx["InjectionRate"]);
                 }
 
                 return await Task.FromResult(0);
@@ -557,6 +559,68 @@ public void InjectLatency_With_Context_Should_not_execute_user_delegate_if_user_
             _totalTimeSlept.Should().Be(0);
         }
 
+        [Theory]
+        [InlineData(TimeoutStrategy.Optimistic)]
+        [InlineData(TimeoutStrategy.Pessimistic)]
+        public void InjectLatency_With_Context_Should_not_inject_the_whole_latency_if_user_cancelationtoken_is_signaled_from_timeout(TimeoutStrategy timeoutStrategy)
+        {
+            SystemClock.Reset();
+            var timeout = TimeSpan.FromSeconds(5);
+            var delay = TimeSpan.FromSeconds(10);
+            var context = new Context();
+            context["ShouldInjectLatency"] = true;
+            context["Enabled"] = true;
+            context["InjectionRate"] = 0.6;
+
+            Boolean executed = false;
+            Stopwatch watch = new Stopwatch();
+
+            using (CancellationTokenSource cts = new CancellationTokenSource())
+            {
+                Func<Context, CancellationToken, Task<bool>> enabled = async (ctx, ct) =>
+                {
+                    return await Task.FromResult((bool)ctx["Enabled"]);
+                };
+
+                Func<Context, CancellationToken, Task<double>> injectionRate = async (ctx, ct) =>
+                {
+                    if (ctx["InjectionRate"] != null)
+                    {
+                        return await Task.FromResult((double)ctx["InjectionRate"]);
+                    }
+
+                    return await Task.FromResult(0);
+                };
+
+                Func<Context, CancellationToken, Task<TimeSpan>> latencyProvider = async (ctx, ct) =>
+                {
+                    if ((bool)ctx["ShouldInjectLatency"])
+                    {
+                        return await Task.FromResult(delay);
+                    }
+
+                    return await Task.FromResult(TimeSpan.FromMilliseconds(0));
+                };
+
+                Func<Context, CancellationToken, Task> actionAsync = (_, ct) =>
+                {
+                    executed = true;
+                    return TaskHelper.EmptyTask;
+                };
+
+                var policy = Policy.TimeoutAsync(timeout, timeoutStrategy)
+                    .WrapAsync(MonkeyPolicy.InjectLatencyAsync(latencyProvider, injectionRate, enabled));
+
+                watch.Start();
+                policy.Awaiting(async x => { await x.ExecuteAsync(actionAsync, context, cts.Token); })
+                    .ShouldThrow<TimeoutRejectedException>();
+                watch.Stop();
+            }
+
+            executed.Should().BeFalse();
+            watch.Elapsed.Should().BeCloseTo(timeout, ((int)TimeSpan.FromSeconds(3).TotalMilliseconds));
+        }
+
         #endregion
     }
 }

src/Polly.Contrib.Simmy.Specs/Latency/InjectLatencySpecs.cs

@@ -1,7 +1,9 @@
 using System;
+using System.Diagnostics;
 using System.Threading;
 using FluentAssertions;
 using Polly.Contrib.Simmy.Utilities;
+using Polly.Timeout;
 using Polly.Utilities;
 using Xunit;
 
@@ -536,6 +538,62 @@ public void InjectLatency_With_Context_Should_not_execute_user_delegate_if_user_
             _totalTimeSlept.Should().Be(0);
         }
 
+        [Theory]
+        [InlineData(TimeoutStrategy.Optimistic)]
+        [InlineData(TimeoutStrategy.Pessimistic)]
+        public void InjectLatency_With_Context_Should_not_inject_the_whole_latency_if_user_cancelationtoken_is_signaled_from_timeout(TimeoutStrategy timeoutStrategy)
+        {
+            SystemClock.Reset();
+            var timeout = TimeSpan.FromSeconds(5);
+            var delay = TimeSpan.FromSeconds(10);
+            var context = new Context();
+            context["ShouldInjectLatency"] = true;
+            context["Enabled"] = true;
+            context["InjectionRate"] = 0.6;
+
+            Boolean executed = false;
+            Stopwatch watch = new Stopwatch();
+
+            using (CancellationTokenSource cts = new CancellationTokenSource())
+            {
+                Func<Context, CancellationToken, bool> enabled = (ctx, ct) =>
+                {
+                    return (bool)ctx["Enabled"];
+                };
+
+                Func<Context, CancellationToken, double> injectionRate = (ctx, ct) =>
+                {
+                    if (ctx["InjectionRate"] != null)
+                    {
+                        return (double)ctx["InjectionRate"];
+                    }
+
+                    return 0;
+                };
+
+                Func<Context, CancellationToken, TimeSpan> latencyProvider = (ctx, ct) =>
+                {
+                    if ((bool)ctx["ShouldInjectLatency"])
+                    {
+                        return delay;
+                    }
+
+                    return TimeSpan.FromMilliseconds(0);
+                };
+
+                var policy = Policy.Timeout(timeout, timeoutStrategy)
+                    .Wrap(MonkeyPolicy.InjectLatency(latencyProvider, injectionRate, enabled));
+
+                watch.Start();
+                policy.Invoking(x => { x.Execute((ctx, ct) => { executed = true; }, context, cts.Token); })
+                    .ShouldThrow<TimeoutRejectedException>();
+                watch.Stop();
+            }
+
+            executed.Should().BeFalse();
+            watch.Elapsed.Should().BeCloseTo(timeout, ((int)TimeSpan.FromSeconds(3).TotalMilliseconds));
+        }
+
         #endregion
     }
 }

src/Polly.Contrib.Simmy.Specs/Latency/InjectLatencyTResultAsyncSpecs .cs

@@ -1,10 +1,12 @@
 using System;
+using System.Diagnostics;
 using System.Threading;
 using System.Threading.Tasks;
 using FluentAssertions;
 using Polly.Utilities;
 using Polly.Contrib.Simmy.Specs.Helpers;
 using Polly.Contrib.Simmy.Utilities;
+using Polly.Timeout;
 using Xunit;
 
 namespace Polly.Contrib.Simmy.Specs.Latency
@@ -178,7 +180,7 @@ public async Task InjectLatency_With_Context_With_InjectionRate_Lambda_Should_In
             {
                 if (ctx["InjectionRate"] != null)
                 {
-                    return await Task.FromResult((double) ctx["InjectionRate"]);
+                    return await Task.FromResult((double)ctx["InjectionRate"]);
                 }
 
                 return await Task.FromResult(0);
@@ -212,7 +214,7 @@ public async Task InjectLatency_With_Context_With_InjectionRate_Lambda_Should_No
             {
                 if (ctx["InjectionRate"] != null)
                 {
-                    return await Task.FromResult((double) ctx["InjectionRate"]);
+                    return await Task.FromResult((double)ctx["InjectionRate"]);
                 }
 
                 return await Task.FromResult(0);
@@ -257,7 +259,7 @@ public async Task InjectLatency_With_Context_With_Latency_Lambda_Should_Introduc
             {
                 if (ctx["InjectionRate"] != null)
                 {
-                    return await Task.FromResult((double) ctx["InjectionRate"]);
+                    return await Task.FromResult((double)ctx["InjectionRate"]);
                 }
 
                 return await Task.FromResult(0);
@@ -302,7 +304,7 @@ public async Task InjectLatency_With_Context_With_Latency_Lambda_Should_Not_Intr
             {
                 if (ctx["InjectionRate"] != null)
                 {
-                    return await Task.FromResult((double) ctx["InjectionRate"]);
+                    return await Task.FromResult((double)ctx["InjectionRate"]);
                 }
 
                 return await Task.FromResult(0);
@@ -347,7 +349,7 @@ public async Task InjectLatency_With_Context_With_Latency_Lambda_Should_Not_Intr
             {
                 if (ctx["InjectionRate"] != null)
                 {
-                    return await Task.FromResult((double) ctx["InjectionRate"]);
+                    return await Task.FromResult((double)ctx["InjectionRate"]);
                 }
 
                 return await Task.FromResult(0);
@@ -570,6 +572,69 @@ public void InjectLatency_With_Context_Should_not_execute_user_delegate_if_user_
             _totalTimeSlept.Should().Be(0);
         }
 
+        [Theory]
+        [InlineData(TimeoutStrategy.Optimistic)]
+        [InlineData(TimeoutStrategy.Pessimistic)]
+        public void InjectLatency_With_Context_Should_not_inject_the_whole_latency_if_user_cancelationtoken_is_signaled_from_timeout(TimeoutStrategy timeoutStrategy)
+        {
+            SystemClock.Reset();
+            var timeout = TimeSpan.FromSeconds(5);
+            var delay = TimeSpan.FromSeconds(10);
+            var context = new Context();
+            context["ShouldInjectLatency"] = true;
+            context["Enabled"] = true;
+            context["InjectionRate"] = 0.6;
+
+            Boolean executed = false;
+            Stopwatch watch = new Stopwatch();
+
+            using (CancellationTokenSource cts = new CancellationTokenSource())
+            {
+                Func<Context, CancellationToken, Task<bool>> enabled = async (ctx, ct) =>
+                {
+                    return await Task.FromResult((bool)ctx["Enabled"]);
+                };
+
+                Func<Context, CancellationToken, Task<double>> injectionRate = async (ctx, ct) =>
+                {
+                    if (ctx["InjectionRate"] != null)
+                    {
+                        return await Task.FromResult((double)ctx["InjectionRate"]);
+                    }
+
+                    return await Task.FromResult(0);
+                };
+
+                Func<Context, CancellationToken, Task<TimeSpan>> latencyProvider = async (ctx, ct) =>
+                {
+                    if ((bool)ctx["ShouldInjectLatency"])
+                    {
+                        return await Task.FromResult(delay);
+                    }
+
+                    return await Task.FromResult(TimeSpan.FromMilliseconds(0));
+                };
+
+                Func<Context, CancellationToken, Task<ResultPrimitive>> actionAsync = (_, ct) =>
+                {
+                    executed = true;
+                    return Task.FromResult(ResultPrimitive.Good);
+                };
+
+                var policy = Policy.TimeoutAsync(timeout, timeoutStrategy)
+                    .WrapAsync(MonkeyPolicy.InjectLatencyAsync<ResultPrimitive>(latencyProvider, injectionRate, enabled));
+
+                watch.Start();
+                policy.Awaiting(async x => { await x.ExecuteAsync(actionAsync, context, cts.Token); })
+                    .ShouldThrow<TimeoutRejectedException>();
+
+                watch.Stop();
+            }
+
+            executed.Should().BeFalse();
+            watch.Elapsed.Should().BeCloseTo(timeout, ((int)TimeSpan.FromSeconds(3).TotalMilliseconds));
+        }
+
         #endregion
     }
 }