Implement BeforeInject callback

iCodeSometime · iCodeSometime · commit a7b5090198af · 2022-01-20T02:21:20.000-06:00
Closes Polly-Contrib#65
diff --git a/src/Polly.Contrib.Simmy.Specs/Behavior/InjectBehaviourAsyncWithOptionsSpecs.cs b/src/Polly.Contrib.Simmy.Specs/Behavior/InjectBehaviourAsyncWithOptionsSpecs.cs
@@ -109,6 +109,59 @@ public void Should_inject_behaviour_before_executing_user_delegate()
             injectedBehaviourExecuted.Should().BeTrue();
         }
 
+        #region BeforeInject
+        [Fact]
+        public async Task Should_call_before_inject_callback_before_injecting_behavior()
+        {
+            var beforeInjectExecuted = false;
+            var injectedBehaviourExecuted = false;
+
+            var policy = MonkeyPolicy.InjectBehaviourAsync(with =>
+                with.Behaviour(async () =>
+                {
+                    beforeInjectExecuted.Should().BeTrue();
+                    injectedBehaviourExecuted = true;
+                })
+                .BeforeInject(async (context, cancellation) =>
+                {
+                    injectedBehaviourExecuted.Should().BeFalse();
+                    beforeInjectExecuted = true;
+                })
+                .InjectionRate(0.6)
+                .Enabled()
+            );
+
+            await policy.ExecuteAsync(() => Task.CompletedTask);
+
+            beforeInjectExecuted.Should().BeTrue();
+            injectedBehaviourExecuted.Should().BeTrue();
+        }
+
+        public async Task Should_not_call_before_inject_callback_if_not_injecting()
+        {
+            var beforeInjectExecuted = false;
+            var behaviorExecuted = false;
+
+            var policy = MonkeyPolicy.InjectBehaviourAsync(with =>
+                with.Behaviour(async () =>
+                {
+                    behaviorExecuted = true;
+                })
+                .BeforeInject(async (context, cancellation) =>
+                {
+                    beforeInjectExecuted = true;
+                })
+                .InjectionRate(0.4)
+                .Enabled()
+            );
+
+            await policy.ExecuteAsync(() => Task.CompletedTask);
+
+            beforeInjectExecuted.Should().BeFalse();
+            behaviorExecuted.Should().BeFalse();
+        }
+        #endregion
+
         #region invalid threshold on configuration and execution time
 
         [Fact]
diff --git a/src/Polly.Contrib.Simmy.Specs/Behavior/InjectBehaviourWithOptionsSpecs.cs b/src/Polly.Contrib.Simmy.Specs/Behavior/InjectBehaviourWithOptionsSpecs.cs
@@ -91,6 +91,59 @@ public void Should_inject_behaviour_before_executing_user_delegate()
             injectedBehaviourExecuted.Should().BeTrue();
         }
 
+        #region BeforeInject
+        [Fact]
+        public void Should_call_before_inject_callback_before_injecting_behavior()
+        {
+            var beforeInjectExecuted = false;
+            var injectedBehaviourExecuted = false;
+
+            var policy = MonkeyPolicy.InjectBehaviour(with =>
+                with.Behaviour(() =>
+                {
+                    beforeInjectExecuted.Should().BeTrue();
+                    injectedBehaviourExecuted = true;
+                })
+                .BeforeInject((context, cancellation) =>
+                {
+                    injectedBehaviourExecuted.Should().BeFalse();
+                    beforeInjectExecuted = true;
+                })
+                .InjectionRate(0.6)
+                .Enabled()
+            );
+
+            policy.Execute(() => { });
+
+            beforeInjectExecuted.Should().BeTrue();
+            injectedBehaviourExecuted.Should().BeTrue();
+        }
+
+        public void Should_not_call_before_inject_callback_if_not_injecting()
+        {
+            var beforeInjectExecuted = false;
+            var behaviorExecuted = false;
+
+            var policy = MonkeyPolicy.InjectBehaviour(with =>
+                with.Behaviour(() =>
+                {
+                    behaviorExecuted = true;
+                })
+                .BeforeInject((context, cancellation) =>
+                {
+                    beforeInjectExecuted = true;
+                })
+                .InjectionRate(0.4)
+                .Enabled()
+            );
+
+            policy.Execute(() => { });
+
+            beforeInjectExecuted.Should().BeFalse();
+            behaviorExecuted.Should().BeFalse();
+        }
+        #endregion
+
         #region invalid threshold on configuration and execution time
 
         [Fact]
diff --git a/src/Polly.Contrib.Simmy/AsyncMonkeyEngine.cs b/src/Polly.Contrib.Simmy/AsyncMonkeyEngine.cs
@@ -41,10 +41,15 @@ internal static async Task<TResult> InjectBehaviourImplementationAsync<TResult>(
             Func<Context, CancellationToken, Task> injectedBehaviour,
             Func<Context, CancellationToken, Task<Double>> injectionRate,
             Func<Context, CancellationToken, Task<bool>> enabled,
+            Func<Context, CancellationToken, Task> beforeInjectCallback,
             bool continueOnCapturedContext)
         {
             if (await ShouldInjectAsync(context, cancellationToken, injectionRate, enabled, continueOnCapturedContext).ConfigureAwait(continueOnCapturedContext))
             {
+                if (beforeInjectCallback != null)
+                {
+                    await beforeInjectCallback(context, cancellationToken);
+                }
                 await injectedBehaviour(context, cancellationToken).ConfigureAwait(continueOnCapturedContext);
             }
 
@@ -60,6 +65,7 @@ internal static async Task<TResult> InjectExceptionImplementationAsync<TResult>(
             Func<Context, CancellationToken, Task<Exception>> injectedException,
             Func<Context, CancellationToken, Task<Double>> injectionRate,
             Func<Context, CancellationToken, Task<bool>> enabled,
+            Func<Context, CancellationToken, Task> beforeInjectCallback,
             bool continueOnCapturedContext)
         {
             if (await ShouldInjectAsync(context, cancellationToken, injectionRate, enabled, continueOnCapturedContext).ConfigureAwait(continueOnCapturedContext))
@@ -71,6 +77,10 @@ internal static async Task<TResult> InjectExceptionImplementationAsync<TResult>(
 
                 if (exception != null)
                 {
+                    if (beforeInjectCallback != null)
+                    {
+                        await beforeInjectCallback(context, cancellationToken);
+                    }
                     throw exception;
                 }
             }
@@ -85,10 +95,15 @@ internal static async Task<TResult> InjectResultImplementationAsync<TResult>(
             Func<Context, CancellationToken, Task<TResult>> injectedResult,
             Func<Context, CancellationToken, Task<Double>> injectionRate,
             Func<Context, CancellationToken, Task<bool>> enabled,
+            Func<Context, CancellationToken, Task> beforeInjectCallback,
             bool continueOnCapturedContext)
         {
             if (await ShouldInjectAsync(context, cancellationToken, injectionRate, enabled, continueOnCapturedContext).ConfigureAwait(continueOnCapturedContext))
             {
+                if (beforeInjectCallback != null)
+                {
+                    await beforeInjectCallback(context, cancellationToken);
+                }
                 return await injectedResult(context, cancellationToken).ConfigureAwait(continueOnCapturedContext);
             }
 
diff --git a/src/Polly.Contrib.Simmy/Behavior/AsyncInjectBehaviourPolicy.cs b/src/Polly.Contrib.Simmy/Behavior/AsyncInjectBehaviourPolicy.cs
@@ -10,6 +10,7 @@ namespace Polly.Contrib.Simmy.Behavior
     public class AsyncInjectBehaviourPolicy : AsyncMonkeyPolicy
     {
         private readonly Func<Context, CancellationToken, Task> _behaviour;
+        private readonly Func<Context, CancellationToken, Task> _beforeInjectCallback;
 
         [Obsolete]
         internal AsyncInjectBehaviourPolicy(Func<Context, CancellationToken, Task> behaviour, Func<Context, CancellationToken, Task<Double>> injectionRate, Func<Context, CancellationToken, Task<bool>> enabled)
@@ -22,6 +23,7 @@ internal AsyncInjectBehaviourPolicy(InjectBehaviourAsyncOptions options)
             : base(options.InjectionRate, options.Enabled)
         {
             _behaviour = options.BehaviourInternal ?? throw new ArgumentNullException(nameof(options.BehaviourInternal));
+            _beforeInjectCallback = options.BeforeInjectCallback;
         }
 
         /// <inheritdoc/>
@@ -35,6 +37,7 @@ protected override Task<TResult> ImplementationAsync<TResult>(Func<Context, Canc
                 _behaviour,
                 InjectionRate,
                 Enabled,
+                _beforeInjectCallback,
                 continueOnCapturedContext);
         }
     }
@@ -46,6 +49,7 @@ protected override Task<TResult> ImplementationAsync<TResult>(Func<Context, Canc
     public class AsyncInjectBehaviourPolicy<TResult> : AsyncMonkeyPolicy<TResult>
     {
         private readonly Func<Context, CancellationToken, Task> _behaviour;
+        private readonly Func<Context, CancellationToken, Task> _beforeInjectCallback;
 
         [Obsolete]
         internal AsyncInjectBehaviourPolicy(Func<Context, CancellationToken, Task> behaviour, Func<Context, CancellationToken, Task<Double>> injectionRate, Func<Context, CancellationToken, Task<bool>> enabled)
@@ -58,6 +62,7 @@ internal AsyncInjectBehaviourPolicy(InjectBehaviourAsyncOptions options)
             : base(options.InjectionRate, options.Enabled)
         {
             _behaviour = options.BehaviourInternal ?? throw new ArgumentNullException(nameof(options.BehaviourInternal));
+            _beforeInjectCallback = options.BeforeInjectCallback;
         }
 
         /// <inheritdoc/>
@@ -70,6 +75,7 @@ protected override Task<TResult> ImplementationAsync(Func<Context, CancellationT
                 _behaviour,
                 InjectionRate,
                 Enabled,
+                _beforeInjectCallback,
                 continueOnCapturedContext);
         }
     }
diff --git a/src/Polly.Contrib.Simmy/Behavior/InjectBehaviourPolicy.cs b/src/Polly.Contrib.Simmy/Behavior/InjectBehaviourPolicy.cs
@@ -9,6 +9,7 @@ namespace Polly.Contrib.Simmy.Behavior
     public class InjectBehaviourPolicy : Simmy.MonkeyPolicy
     {
         private readonly Action<Context, CancellationToken> _behaviour;
+        private readonly Action<Context, CancellationToken> _beforeInjectCallback;
 
         [Obsolete]
         internal InjectBehaviourPolicy(Action<Context, CancellationToken> behaviour, Func<Context, CancellationToken, double> injectionRate, Func<Context, CancellationToken, bool> enabled) 
@@ -21,6 +22,7 @@ internal InjectBehaviourPolicy(InjectBehaviourOptions options)
             : base(options.InjectionRate, options.Enabled)
         {
             _behaviour = options.BehaviourInternal ?? throw new ArgumentNullException(nameof(options.BehaviourInternal));
+            _beforeInjectCallback = options.BeforeInjectCallback;
         }
 
         /// <inheritdoc/>
@@ -32,7 +34,8 @@ protected override TResult Implementation<TResult>(Func<Context, CancellationTok
                 cancellationToken,
                 (ctx, ct) => _behaviour(ctx, ct),
                 InjectionRate,
-                Enabled);
+                Enabled,
+                _beforeInjectCallback);
         }
     }
     /// <summary>
@@ -42,6 +45,7 @@ protected override TResult Implementation<TResult>(Func<Context, CancellationTok
     public class InjectBehaviourPolicy<TResult> : MonkeyPolicy<TResult>
     {
         private readonly Action<Context, CancellationToken> _behaviour;
+        private readonly Action<Context, CancellationToken> _beforeInjectCallback;
 
         [Obsolete]
         internal InjectBehaviourPolicy(Action<Context, CancellationToken> behaviour, Func<Context, CancellationToken, double> injectionRate, Func<Context, CancellationToken, bool> enabled)
@@ -54,6 +58,7 @@ internal InjectBehaviourPolicy(InjectBehaviourOptions options)
             : base(options.InjectionRate, options.Enabled)
         {
             _behaviour = options.BehaviourInternal ?? throw new ArgumentNullException(nameof(options.BehaviourInternal));
+            _beforeInjectCallback = options.BeforeInjectCallback;
         }
 
         /// <inheritdoc/>
@@ -65,7 +70,8 @@ protected override TResult Implementation(Func<Context, CancellationToken, TResu
                 cancellationToken,
                 (ctx, ct) => _behaviour(ctx, ct),
                 InjectionRate,
-                Enabled);
+                Enabled,
+                _beforeInjectCallback);
         }
     }
 }
diff --git a/src/Polly.Contrib.Simmy/InjectOptionsAsyncBase.cs b/src/Polly.Contrib.Simmy/InjectOptionsAsyncBase.cs
@@ -18,5 +18,10 @@ public abstract class InjectOptionsAsyncBase
         /// Lambda to check if this policy is enabled in current context
         /// </summary>
         internal Func<Context, CancellationToken, Task<bool>> Enabled { get; set; }
+
+        /// <summary>
+        /// Lambda to call immediately before injecting
+        /// </summary>
+        internal virtual Func<Context, CancellationToken, Task> BeforeInjectCallback { get; set; }
     }
 }
diff --git a/src/Polly.Contrib.Simmy/InjectOptionsAsyncBaseExtensions.cs b/src/Polly.Contrib.Simmy/InjectOptionsAsyncBaseExtensions.cs
@@ -60,5 +60,17 @@ public static InjectOptionsAsyncBase InjectionRate(this InjectOptionsAsyncBase o
             options.InjectionRate = injectionRateProvider;
             return options;
         }
+
+        /// <summary>
+        /// Configure a callback to be run immediately before injecting chaos.
+        /// </summary>
+        /// <param name="options">The configuration object.</param>
+        /// <param name="beforeInjectCallback">A delegate to be run immediately before injecting chaos.</param>
+        /// <returns></returns>
+        public static InjectOptionsAsyncBase BeforeInject(this InjectOptionsAsyncBase options, Func<Context, CancellationToken, Task> beforeInjectCallback)
+        {
+            options.BeforeInjectCallback = beforeInjectCallback;
+            return options;
+        }
     }
 }
diff --git a/src/Polly.Contrib.Simmy/InjectOptionsBase.cs b/src/Polly.Contrib.Simmy/InjectOptionsBase.cs
@@ -17,5 +17,10 @@ public abstract class InjectOptionsBase
         /// Lambda to check if this policy is enabled in current context
         /// </summary>
         internal Func<Context, CancellationToken, bool> Enabled { get; set; }
+
+        /// <summary>
+        /// Lambda to call immediately before injecting
+        /// </summary>
+        internal Action<Context, CancellationToken> BeforeInjectCallback { get; set; }
     }
 }
diff --git a/src/Polly.Contrib.Simmy/InjectOptionsBaseExtensions.cs b/src/Polly.Contrib.Simmy/InjectOptionsBaseExtensions.cs
@@ -59,5 +59,17 @@ public static InjectOptionsBase InjectionRate(this InjectOptionsBase options, Fu
             options.InjectionRate = injectionRateProvider;
             return options;
         }
+
+        /// <summary>
+        /// Configure a callback to be run immediately before injecting chaos.
+        /// </summary>
+        /// <param name="options">The configuration object.</param>
+        /// <param name="beforeInjectCallback">A delegate to be run immediately before injecting chaos.</param>
+        /// <returns></returns>
+        public static InjectOptionsBase BeforeInject(this InjectOptionsBase options, Action<Context, CancellationToken> beforeInjectCallback)
+        {
+            options.BeforeInjectCallback = beforeInjectCallback;
+            return options;
+        }
     }
 }
diff --git a/src/Polly.Contrib.Simmy/Latency/AsyncInjectLatencyPolicy.cs b/src/Polly.Contrib.Simmy/Latency/AsyncInjectLatencyPolicy.cs
@@ -11,6 +11,7 @@ namespace Polly.Contrib.Simmy.Latency
     public class AsyncInjectLatencyPolicy : AsyncMonkeyPolicy
     {
         private readonly Func<Context, CancellationToken, Task<TimeSpan>> _latencyProvider;
+        private readonly Func<Context, CancellationToken, Task> _beforeInjectCallback;
 
         [Obsolete]
         internal AsyncInjectLatencyPolicy(
@@ -26,6 +27,7 @@ internal AsyncInjectLatencyPolicy(InjectLatencyAsyncOptions options)
             : base(options.InjectionRate, options.Enabled)
         {
             _latencyProvider = options.LatencyInternal ?? throw new ArgumentNullException(nameof(options.LatencyInternal));
+            _beforeInjectCallback = options.BeforeInjectCallback;
         }
 
         /// <inheritdoc/>
@@ -52,6 +54,7 @@ await SystemClock.SleepAsync(
                 },
                 InjectionRate,
                 Enabled,
+                _beforeInjectCallback,
                 continueOnCapturedContext);
         }
     }
@@ -62,6 +65,7 @@ await SystemClock.SleepAsync(
     public class AsyncInjectLatencyPolicy<TResult> : AsyncMonkeyPolicy<TResult>
     {
         private readonly Func<Context, CancellationToken, Task<TimeSpan>> _latencyProvider;
+        private readonly Func<Context, CancellationToken, Task> _beforeInjectCallback;
 
         [Obsolete]
         internal AsyncInjectLatencyPolicy(
@@ -77,6 +81,7 @@ internal AsyncInjectLatencyPolicy(InjectLatencyAsyncOptions options)
             : base(options.InjectionRate, options.Enabled)
         {
             _latencyProvider = options.LatencyInternal ?? throw new ArgumentNullException(nameof(options.LatencyInternal));
+            _beforeInjectCallback = options.BeforeInjectCallback;
         }
 
         /// <inheritdoc/>
@@ -103,6 +108,7 @@ await SystemClock.SleepAsync(
                 },
                 InjectionRate,
                 Enabled,
+                _beforeInjectCallback,
                 continueOnCapturedContext);
         }
     }
diff --git a/src/Polly.Contrib.Simmy/Latency/InjectLatencyPolicy.cs b/src/Polly.Contrib.Simmy/Latency/InjectLatencyPolicy.cs
diff --git a/src/Polly.Contrib.Simmy/MonkeyEngine.cs b/src/Polly.Contrib.Simmy/MonkeyEngine.cs
diff --git a/src/Polly.Contrib.Simmy/Outcomes/AsyncInjectOutcomePolicy.cs b/src/Polly.Contrib.Simmy/Outcomes/AsyncInjectOutcomePolicy.cs
diff --git a/src/Polly.Contrib.Simmy/Outcomes/InjectOutcomePolicy.cs b/src/Polly.Contrib.Simmy/Outcomes/InjectOutcomePolicy.cs

Original file line number	Diff line number	Diff line change
`@@ -41,10 +41,15 @@ internal static async Task<TResult> InjectBehaviourImplementationAsync<TResult>(`
`41`	`41`	`Func<Context, CancellationToken, Task> injectedBehaviour,`
`42`	`42`	`Func<Context, CancellationToken, Task<Double>> injectionRate,`
`43`	`43`	`Func<Context, CancellationToken, Task<bool>> enabled,`
	`44`	`+ Func<Context, CancellationToken, Task> beforeInjectCallback,`
`44`	`45`	`bool continueOnCapturedContext)`
`45`	`46`	`{`
`46`	`47`	`if (await ShouldInjectAsync(context, cancellationToken, injectionRate, enabled, continueOnCapturedContext).ConfigureAwait(continueOnCapturedContext))`
`47`	`48`	`{`
	`49`	`+ if (beforeInjectCallback != null)`
	`50`	`+ {`
	`51`	`+ await beforeInjectCallback(context, cancellationToken);`
	`52`	`+ }`
`48`	`53`	`await injectedBehaviour(context, cancellationToken).ConfigureAwait(continueOnCapturedContext);`
`49`	`54`	`}`
`50`	`55`
`@@ -60,6 +65,7 @@ internal static async Task<TResult> InjectExceptionImplementationAsync<TResult>(`
`60`	`65`	`Func<Context, CancellationToken, Task<Exception>> injectedException,`
`61`	`66`	`Func<Context, CancellationToken, Task<Double>> injectionRate,`
`62`	`67`	`Func<Context, CancellationToken, Task<bool>> enabled,`
	`68`	`+ Func<Context, CancellationToken, Task> beforeInjectCallback,`
`63`	`69`	`bool continueOnCapturedContext)`
`64`	`70`	`{`
`65`	`71`	`if (await ShouldInjectAsync(context, cancellationToken, injectionRate, enabled, continueOnCapturedContext).ConfigureAwait(continueOnCapturedContext))`
`@@ -71,6 +77,10 @@ internal static async Task<TResult> InjectExceptionImplementationAsync<TResult>(`
`71`	`77`
`72`	`78`	`if (exception != null)`
`73`	`79`	`{`
	`80`	`+ if (beforeInjectCallback != null)`
	`81`	`+ {`
	`82`	`+ await beforeInjectCallback(context, cancellationToken);`
	`83`	`+ }`
`74`	`84`	`throw exception;`
`75`	`85`	`}`
`76`	`86`	`}`
`@@ -85,10 +95,15 @@ internal static async Task<TResult> InjectResultImplementationAsync<TResult>(`
`85`	`95`	`Func<Context, CancellationToken, Task<TResult>> injectedResult,`
`86`	`96`	`Func<Context, CancellationToken, Task<Double>> injectionRate,`
`87`	`97`	`Func<Context, CancellationToken, Task<bool>> enabled,`
	`98`	`+ Func<Context, CancellationToken, Task> beforeInjectCallback,`
`88`	`99`	`bool continueOnCapturedContext)`
`89`	`100`	`{`
`90`	`101`	`if (await ShouldInjectAsync(context, cancellationToken, injectionRate, enabled, continueOnCapturedContext).ConfigureAwait(continueOnCapturedContext))`
`91`	`102`	`{`
	`103`	`+ if (beforeInjectCallback != null)`
	`104`	`+ {`
	`105`	`+ await beforeInjectCallback(context, cancellationToken);`
	`106`	`+ }`
`92`	`107`	`return await injectedResult(context, cancellationToken).ConfigureAwait(continueOnCapturedContext);`
`93`	`108`	`}`
`94`	`109`
Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,7 @@ namespace Polly.Contrib.Simmy.Behavior`
`10`	`10`	`public class AsyncInjectBehaviourPolicy : AsyncMonkeyPolicy`
`11`	`11`	`{`
`12`	`12`	`private readonly Func<Context, CancellationToken, Task> _behaviour;`
	`13`	`+ private readonly Func<Context, CancellationToken, Task> _beforeInjectCallback;`
`13`	`14`
`14`	`15`	`[Obsolete]`
`15`	`16`	`internal AsyncInjectBehaviourPolicy(Func<Context, CancellationToken, Task> behaviour, Func<Context, CancellationToken, Task<Double>> injectionRate, Func<Context, CancellationToken, Task<bool>> enabled)`
`@@ -22,6 +23,7 @@ internal AsyncInjectBehaviourPolicy(InjectBehaviourAsyncOptions options)`
`22`	`23`	`: base(options.InjectionRate, options.Enabled)`
`23`	`24`	`{`
`24`	`25`	`_behaviour = options.BehaviourInternal ?? throw new ArgumentNullException(nameof(options.BehaviourInternal));`
	`26`	`+ _beforeInjectCallback = options.BeforeInjectCallback;`
`25`	`27`	`}`
`26`	`28`
`27`	`29`	`/// <inheritdoc/>`
`@@ -35,6 +37,7 @@ protected override Task<TResult> ImplementationAsync<TResult>(Func<Context, Canc`
`35`	`37`	`_behaviour,`
`36`	`38`	`InjectionRate,`
`37`	`39`	`Enabled,`
	`40`	`+ _beforeInjectCallback,`
`38`	`41`	`continueOnCapturedContext);`
`39`	`42`	`}`
`40`	`43`	`}`
`@@ -46,6 +49,7 @@ protected override Task<TResult> ImplementationAsync<TResult>(Func<Context, Canc`
`46`	`49`	`public class AsyncInjectBehaviourPolicy<TResult> : AsyncMonkeyPolicy<TResult>`
`47`	`50`	`{`
`48`	`51`	`private readonly Func<Context, CancellationToken, Task> _behaviour;`
	`52`	`+ private readonly Func<Context, CancellationToken, Task> _beforeInjectCallback;`
`49`	`53`
`50`	`54`	`[Obsolete]`
`51`	`55`	`internal AsyncInjectBehaviourPolicy(Func<Context, CancellationToken, Task> behaviour, Func<Context, CancellationToken, Task<Double>> injectionRate, Func<Context, CancellationToken, Task<bool>> enabled)`
`@@ -58,6 +62,7 @@ internal AsyncInjectBehaviourPolicy(InjectBehaviourAsyncOptions options)`
`58`	`62`	`: base(options.InjectionRate, options.Enabled)`
`59`	`63`	`{`
`60`	`64`	`_behaviour = options.BehaviourInternal ?? throw new ArgumentNullException(nameof(options.BehaviourInternal));`
	`65`	`+ _beforeInjectCallback = options.BeforeInjectCallback;`
`61`	`66`	`}`
`62`	`67`
`63`	`68`	`/// <inheritdoc/>`
`@@ -70,6 +75,7 @@ protected override Task<TResult> ImplementationAsync(Func<Context, CancellationT`
`70`	`75`	`_behaviour,`
`71`	`76`	`InjectionRate,`
`72`	`77`	`Enabled,`
	`78`	`+ _beforeInjectCallback,`
`73`	`79`	`continueOnCapturedContext);`
`74`	`80`	`}`
`75`	`81`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,7 @@ namespace Polly.Contrib.Simmy.Behavior`
`9`	`9`	`public class InjectBehaviourPolicy : Simmy.MonkeyPolicy`
`10`	`10`	`{`
`11`	`11`	`private readonly Action<Context, CancellationToken> _behaviour;`
	`12`	`+ private readonly Action<Context, CancellationToken> _beforeInjectCallback;`
`12`	`13`
`13`	`14`	`[Obsolete]`
`14`	`15`	`internal InjectBehaviourPolicy(Action<Context, CancellationToken> behaviour, Func<Context, CancellationToken, double> injectionRate, Func<Context, CancellationToken, bool> enabled)`
`@@ -21,6 +22,7 @@ internal InjectBehaviourPolicy(InjectBehaviourOptions options)`
`21`	`22`	`: base(options.InjectionRate, options.Enabled)`
`22`	`23`	`{`
`23`	`24`	`_behaviour = options.BehaviourInternal ?? throw new ArgumentNullException(nameof(options.BehaviourInternal));`
	`25`	`+ _beforeInjectCallback = options.BeforeInjectCallback;`
`24`	`26`	`}`
`25`	`27`
`26`	`28`	`/// <inheritdoc/>`
`@@ -32,7 +34,8 @@ protected override TResult Implementation<TResult>(Func<Context, CancellationTok`
`32`	`34`	`cancellationToken,`
`33`	`35`	`(ctx, ct) => _behaviour(ctx, ct),`
`34`	`36`	`InjectionRate,`
`35`		`- Enabled);`
	`37`	`+ Enabled,`
	`38`	`+ _beforeInjectCallback);`
`36`	`39`	`}`
`37`	`40`	`}`
`38`	`41`	`/// <summary>`
`@@ -42,6 +45,7 @@ protected override TResult Implementation<TResult>(Func<Context, CancellationTok`
`42`	`45`	`public class InjectBehaviourPolicy<TResult> : MonkeyPolicy<TResult>`
`43`	`46`	`{`
`44`	`47`	`private readonly Action<Context, CancellationToken> _behaviour;`
	`48`	`+ private readonly Action<Context, CancellationToken> _beforeInjectCallback;`
`45`	`49`
`46`	`50`	`[Obsolete]`
`47`	`51`	`internal InjectBehaviourPolicy(Action<Context, CancellationToken> behaviour, Func<Context, CancellationToken, double> injectionRate, Func<Context, CancellationToken, bool> enabled)`
`@@ -54,6 +58,7 @@ internal InjectBehaviourPolicy(InjectBehaviourOptions options)`
`54`	`58`	`: base(options.InjectionRate, options.Enabled)`
`55`	`59`	`{`
`56`	`60`	`_behaviour = options.BehaviourInternal ?? throw new ArgumentNullException(nameof(options.BehaviourInternal));`
	`61`	`+ _beforeInjectCallback = options.BeforeInjectCallback;`
`57`	`62`	`}`
`58`	`63`
`59`	`64`	`/// <inheritdoc/>`
`@@ -65,7 +70,8 @@ protected override TResult Implementation(Func<Context, CancellationToken, TResu`
`65`	`70`	`cancellationToken,`
`66`	`71`	`(ctx, ct) => _behaviour(ctx, ct),`
`67`	`72`	`InjectionRate,`
`68`		`- Enabled);`
	`73`	`+ Enabled,`
	`74`	`+ _beforeInjectCallback);`
`69`	`75`	`}`
`70`	`76`	`}`
`71`	`77`	`}`
Original file line number	Diff line number	Diff line change
`@@ -18,5 +18,10 @@ public abstract class InjectOptionsAsyncBase`
`18`	`18`	`/// Lambda to check if this policy is enabled in current context`
`19`	`19`	`/// </summary>`
`20`	`20`	`internal Func<Context, CancellationToken, Task<bool>> Enabled { get; set; }`
	`21`	`+`
	`22`	`+ /// <summary>`
	`23`	`+ /// Lambda to call immediately before injecting`
	`24`	`+ /// </summary>`
	`25`	`+ internal virtual Func<Context, CancellationToken, Task> BeforeInjectCallback { get; set; }`
`21`	`26`	`}`
`22`	`27`	`}`
Original file line number	Diff line number	Diff line change
`@@ -60,5 +60,17 @@ public static InjectOptionsAsyncBase InjectionRate(this InjectOptionsAsyncBase o`
`60`	`60`	`options.InjectionRate = injectionRateProvider;`
`61`	`61`	`return options;`
`62`	`62`	`}`
	`63`	`+`
	`64`	`+ /// <summary>`
	`65`	`+ /// Configure a callback to be run immediately before injecting chaos.`
	`66`	`+ /// </summary>`
	`67`	`+ /// <param name="options">The configuration object.</param>`
	`68`	`+ /// <param name="beforeInjectCallback">A delegate to be run immediately before injecting chaos.</param>`
	`69`	`+ /// <returns></returns>`
	`70`	`+ public static InjectOptionsAsyncBase BeforeInject(this InjectOptionsAsyncBase options, Func<Context, CancellationToken, Task> beforeInjectCallback)`
	`71`	`+ {`
	`72`	`+ options.BeforeInjectCallback = beforeInjectCallback;`
	`73`	`+ return options;`
	`74`	`+ }`
`63`	`75`	`}`
`64`	`76`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,5 +17,10 @@ public abstract class InjectOptionsBase`
`17`	`17`	`/// Lambda to check if this policy is enabled in current context`
`18`	`18`	`/// </summary>`
`19`	`19`	`internal Func<Context, CancellationToken, bool> Enabled { get; set; }`
	`20`	`+`
	`21`	`+ /// <summary>`
	`22`	`+ /// Lambda to call immediately before injecting`
	`23`	`+ /// </summary>`
	`24`	`+ internal Action<Context, CancellationToken> BeforeInjectCallback { get; set; }`
`20`	`25`	`}`
`21`	`26`	`}`
Original file line number	Diff line number	Diff line change
`@@ -59,5 +59,17 @@ public static InjectOptionsBase InjectionRate(this InjectOptionsBase options, Fu`
`59`	`59`	`options.InjectionRate = injectionRateProvider;`
`60`	`60`	`return options;`
`61`	`61`	`}`
	`62`	`+`
	`63`	`+ /// <summary>`
	`64`	`+ /// Configure a callback to be run immediately before injecting chaos.`
	`65`	`+ /// </summary>`
	`66`	`+ /// <param name="options">The configuration object.</param>`
	`67`	`+ /// <param name="beforeInjectCallback">A delegate to be run immediately before injecting chaos.</param>`
	`68`	`+ /// <returns></returns>`
	`69`	`+ public static InjectOptionsBase BeforeInject(this InjectOptionsBase options, Action<Context, CancellationToken> beforeInjectCallback)`
	`70`	`+ {`
	`71`	`+ options.BeforeInjectCallback = beforeInjectCallback;`
	`72`	`+ return options;`
	`73`	`+ }`
`62`	`74`	`}`
`63`	`75`	`}`
Original file line number	Diff line number	Diff line change
`@@ -11,6 +11,7 @@ namespace Polly.Contrib.Simmy.Latency`
`11`	`11`	`public class AsyncInjectLatencyPolicy : AsyncMonkeyPolicy`
`12`	`12`	`{`
`13`	`13`	`private readonly Func<Context, CancellationToken, Task<TimeSpan>> _latencyProvider;`
	`14`	`+ private readonly Func<Context, CancellationToken, Task> _beforeInjectCallback;`
`14`	`15`
`15`	`16`	`[Obsolete]`
`16`	`17`	`internal AsyncInjectLatencyPolicy(`
`@@ -26,6 +27,7 @@ internal AsyncInjectLatencyPolicy(InjectLatencyAsyncOptions options)`
`26`	`27`	`: base(options.InjectionRate, options.Enabled)`
`27`	`28`	`{`
`28`	`29`	`_latencyProvider = options.LatencyInternal ?? throw new ArgumentNullException(nameof(options.LatencyInternal));`
	`30`	`+ _beforeInjectCallback = options.BeforeInjectCallback;`
`29`	`31`	`}`
`30`	`32`
`31`	`33`	`/// <inheritdoc/>`
`@@ -52,6 +54,7 @@ await SystemClock.SleepAsync(`
`52`	`54`	`},`
`53`	`55`	`InjectionRate,`
`54`	`56`	`Enabled,`
	`57`	`+ _beforeInjectCallback,`
`55`	`58`	`continueOnCapturedContext);`
`56`	`59`	`}`
`57`	`60`	`}`
`@@ -62,6 +65,7 @@ await SystemClock.SleepAsync(`
`62`	`65`	`public class AsyncInjectLatencyPolicy<TResult> : AsyncMonkeyPolicy<TResult>`
`63`	`66`	`{`
`64`	`67`	`private readonly Func<Context, CancellationToken, Task<TimeSpan>> _latencyProvider;`
	`68`	`+ private readonly Func<Context, CancellationToken, Task> _beforeInjectCallback;`
`65`	`69`
`66`	`70`	`[Obsolete]`
`67`	`71`	`internal AsyncInjectLatencyPolicy(`
`@@ -77,6 +81,7 @@ internal AsyncInjectLatencyPolicy(InjectLatencyAsyncOptions options)`
`77`	`81`	`: base(options.InjectionRate, options.Enabled)`
`78`	`82`	`{`
`79`	`83`	`_latencyProvider = options.LatencyInternal ?? throw new ArgumentNullException(nameof(options.LatencyInternal));`
	`84`	`+ _beforeInjectCallback = options.BeforeInjectCallback;`
`80`	`85`	`}`
`81`	`86`
`82`	`87`	`/// <inheritdoc/>`
`@@ -103,6 +108,7 @@ await SystemClock.SleepAsync(`
`103`	`108`	`},`
`104`	`109`	`InjectionRate,`
`105`	`110`	`Enabled,`
	`111`	`+ _beforeInjectCallback,`
`106`	`112`	`continueOnCapturedContext);`
`107`	`113`	`}`
`108`	`114`	`}`