From 32aa4bc46d307948789b53634e6fc2df7fd91437 Mon Sep 17 00:00:00 2001
From: martintmk <103487740+martintmk@users.noreply.github.com>
Date: Wed, 27 Sep 2023 14:56:50 +0200
Subject: [PATCH] Stabilize `AddHedging_IntegrationTest` test (#1644)

---
 ...esiliencePipelineBuilderExtensionsTests.cs | 83 ++++++++++++-------
 1 file changed, 51 insertions(+), 32 deletions(-)

diff --git a/test/Polly.Core.Tests/Hedging/HedgingResiliencePipelineBuilderExtensionsTests.cs b/test/Polly.Core.Tests/Hedging/HedgingResiliencePipelineBuilderExtensionsTests.cs
index c446eabf917..f2d91cdabff 100644
--- a/test/Polly.Core.Tests/Hedging/HedgingResiliencePipelineBuilderExtensionsTests.cs
+++ b/test/Polly.Core.Tests/Hedging/HedgingResiliencePipelineBuilderExtensionsTests.cs
@@ -36,45 +36,64 @@ public async Task AddHedging_IntegrationTest()
     {
         int hedgingCount = 0;
 
-        var strategy = _builder
-            .AddHedging(new()
+        var strategy = _builder.AddHedging(new()
+        {
+            MaxHedgedAttempts = 4,
+            Delay = System.Threading.Timeout.InfiniteTimeSpan,
+            ShouldHandle = args => args.Outcome.Result switch
             {
-                MaxHedgedAttempts = 4,
-                Delay = TimeSpan.FromMilliseconds(20),
-                ShouldHandle = args => args.Outcome.Result switch
-                {
-                    "error" => PredicateResult.True(),
-                    _ => PredicateResult.False()
-                },
-                ActionGenerator = args =>
+                "error" => PredicateResult.True(),
+                _ => PredicateResult.False()
+            },
+            ActionGenerator = args =>
+            {
+                return () => args.AttemptNumber switch
                 {
-                    return async () =>
-                    {
-                        await Task.Delay(25, args.ActionContext.CancellationToken);
+                    3 => Outcome.FromResultAsValueTask("success"),
+                    _ => Outcome.FromResultAsValueTask("error")
+                };
+            },
+            OnHedging = args =>
+            {
+                Interlocked.Increment(ref hedgingCount);
+                return default;
+            }
+        })
+        .Build();
 
-                        if (args.AttemptNumber == 3)
-                        {
-                            return Outcome.FromResult("success");
-                        }
+        var result = await strategy.ExecuteAsync(token => new ValueTask<string>("error"));
+        result.Should().Be("success");
+        hedgingCount.Should().Be(3);
+    }
 
-                        return Outcome.FromResult("error");
-                    };
-                },
-                OnHedging = args =>
+    [Fact]
+    public async Task AddHedging_IntegrationTestWithRealDelay()
+    {
+        var strategy = _builder.AddHedging(new()
+        {
+            MaxHedgedAttempts = 4,
+            ShouldHandle = args => args.Outcome.Result switch
+            {
+                "error" => PredicateResult.True(),
+                _ => PredicateResult.False()
+            },
+            ActionGenerator = args =>
+            {
+                return async () =>
                 {
-                    hedgingCount++;
-                    return default;
-                }
-            })
-            .Build();
+                    await Task.Delay(20);
 
-        var result = await strategy.ExecuteAsync(async token =>
-        {
-            await Task.Delay(25, token);
-            return "error";
-        });
+                    return args.AttemptNumber switch
+                    {
+                        3 => Outcome.FromResult("success"),
+                        _ => Outcome.FromResult("error")
+                    };
+                };
+            }
+        })
+        .Build();
 
+        var result = await strategy.ExecuteAsync(token => new ValueTask<string>("error"));
         result.Should().Be("success");
-        hedgingCount.Should().Be(4);
     }
 }