Introduce Polly.Testing package

Polly.sln

@@ -52,6 +52,10 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "test", "test", "{A6CC41B9-E
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "src", "src", "{B7BF406B-B06F-4025-83E6-7219C53196A6}"
 EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Polly.Testing", "src\Polly.Testing\Polly.Testing.csproj", "{9AD2D6AD-56E4-49D6-B6F1-EE975D5760B9}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Polly.Testing.Tests", "test\Polly.Testing.Tests\Polly.Testing.Tests.csproj", "{D333B5CE-982D-4C11-BDAF-4217AA02306E}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -102,6 +106,14 @@ Global
 		{C04DEE61-C1EA-4028-B457-CDBD304B8ED9}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{C04DEE61-C1EA-4028-B457-CDBD304B8ED9}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{C04DEE61-C1EA-4028-B457-CDBD304B8ED9}.Release|Any CPU.Build.0 = Release|Any CPU
+		{9AD2D6AD-56E4-49D6-B6F1-EE975D5760B9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{9AD2D6AD-56E4-49D6-B6F1-EE975D5760B9}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{9AD2D6AD-56E4-49D6-B6F1-EE975D5760B9}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{9AD2D6AD-56E4-49D6-B6F1-EE975D5760B9}.Release|Any CPU.Build.0 = Release|Any CPU
+		{D333B5CE-982D-4C11-BDAF-4217AA02306E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{D333B5CE-982D-4C11-BDAF-4217AA02306E}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{D333B5CE-982D-4C11-BDAF-4217AA02306E}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{D333B5CE-982D-4C11-BDAF-4217AA02306E}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -119,6 +131,8 @@ Global
 		{BCA09595-A4D3-4D74-AC80-3E7017E51B24} = {B7BF406B-B06F-4025-83E6-7219C53196A6}
 		{06070F42-6738-4D0B-8D7E-9400B4030193} = {A6CC41B9-E0B9-44F8-916B-3E4A78DA3BFB}
 		{C04DEE61-C1EA-4028-B457-CDBD304B8ED9} = {A6CC41B9-E0B9-44F8-916B-3E4A78DA3BFB}
+		{9AD2D6AD-56E4-49D6-B6F1-EE975D5760B9} = {B7BF406B-B06F-4025-83E6-7219C53196A6}
+		{D333B5CE-982D-4C11-BDAF-4217AA02306E} = {A6CC41B9-E0B9-44F8-916B-3E4A78DA3BFB}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {2E5D54CD-770A-4345-B585-1848FC2EA6F4}

src/Polly.Core/Polly.Core.csproj

@@ -15,6 +15,7 @@
   <ItemGroup>
     <Using Include="Polly.Utils" />
     <InternalsVisibleToTest Include="Polly.Core.Tests" />
+    <InternalsVisibleToTest Include="Polly.Testing" />
     <InternalsVisibleToTest Include="Polly.TestUtils" />
   </ItemGroup>
 

src/Polly.Core/ResilienceStrategy.cs

@@ -11,6 +11,8 @@ namespace Polly;
 /// </remarks>
 public abstract partial class ResilienceStrategy
 {
+    internal ResilienceStrategyOptions? Options { get; set; }
+
     /// <summary>
     /// Executes the specified callback.
     /// </summary>

src/Polly.Core/ResilienceStrategyBuilderBase.cs

@@ -137,15 +137,17 @@ private ResilienceStrategy CreateResilienceStrategy(Entry entry)
             builderName: BuilderName,
             builderInstanceName: InstanceName,
             builderProperties: Properties,
-            strategyName: entry.Properties.StrategyName,
-            strategyType: entry.Properties.StrategyType,
+            strategyName: entry.Options.StrategyName,
+            strategyType: entry.Options.StrategyType,
             timeProvider: TimeProvider,
             isGenericBuilder: IsGenericBuilder,
             diagnosticSource: DiagnosticSource,
             randomizer: Randomizer);
 
-        return entry.Factory(context);
+        var strategy = entry.Factory(context);
+        strategy.Options = entry.Options;
+        return strategy;
     }
 
-    private sealed record Entry(Func<ResilienceStrategyBuilderContext, ResilienceStrategy> Factory, ResilienceStrategyOptions Properties);
+    private sealed record Entry(Func<ResilienceStrategyBuilderContext, ResilienceStrategy> Factory, ResilienceStrategyOptions Options);
 }

src/Polly.Testing/Polly.Testing.csproj

@@ -0,0 +1,17 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFrameworks>net7.0;net6.0;netstandard2.0;net472;net462</TargetFrameworks>
+    <AssemblyTitle>Polly.Testing</AssemblyTitle>
+    <RootNamespace>Polly.Testing</RootNamespace>
+    <Nullable>enable</Nullable>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+    <ProjectType>Library</ProjectType>
+    <MutationScore>100</MutationScore>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Polly.Core\Polly.Core.csproj" />
+  </ItemGroup>
+
+</Project>

src/Polly.Testing/README.md

@@ -0,0 +1,3 @@
+# About Polly.Testing
+
+

src/Polly.Testing/ResilienceStrategyDescriptor.cs

@@ -0,0 +1,12 @@
+namespace Polly.Testing;
+
+/// <summary>
+/// This class provides additional information about <see cref="ResilienceStrategy"/>.
+/// </summary>
+/// <param name="Options">The options used by the resilience strategy, if any.</param>
+/// <param name="Type">The type of strategy as an enum.</param>
+/// <param name="StrategyType">The type of the strategy.</param>
+public record ResilienceStrategyDescriptor(ResilienceStrategyOptions? Options, ResilienceStrategyType Type, Type StrategyType)
+{
+}
+

src/Polly.Testing/ResilienceStrategyExtensions.cs

@@ -0,0 +1,78 @@
+using Polly.CircuitBreaker;
+using Polly.Fallback;
+using Polly.Hedging;
+using Polly.Retry;
+using Polly.Timeout;
+using Polly.Utils;
+
+namespace Polly.Testing;
+
+/// <summary>
+/// The test-related extensions for <see cref="ResilienceStrategy"/> and <see cref="ResilienceStrategy{TResult}"/>.
+/// </summary>
+public static class ResilienceStrategyExtensions
+{
+    /// <summary>
+    /// Gets the inner strategies the <paramref name="strategy"/> is composed of.
+    /// </summary>
+    /// <typeparam name="TResult">The type of result.</typeparam>
+    /// <param name="strategy">The strategy instance.</param>
+    /// <returns>A list of inner strategies.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="strategy"/> is <see langword="null"/>.</exception>
+    public static IReadOnlyList<ResilienceStrategyDescriptor> GetInnerStrategies<TResult>(this ResilienceStrategy<TResult> strategy)
+    {
+        Guard.NotNull(strategy);
+
+        return strategy.Strategy.GetInnerStrategies();
+    }
+
+    /// <summary>
+    /// Gets the inner strategies the <paramref name="strategy"/> is composed of.
+    /// </summary>
+    /// <param name="strategy">The strategy instance.</param>
+    /// <returns>A list of inner strategies.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when <paramref name="strategy"/> is <see langword="null"/>.</exception>
+    public static IReadOnlyList<ResilienceStrategyDescriptor> GetInnerStrategies(this ResilienceStrategy strategy)
+    {
+        Guard.NotNull(strategy);
+
+        var strategies = new List<ResilienceStrategy>();
+        strategy.ExpandStrategies(strategies);
+
+        return strategies.Select(s => new ResilienceStrategyDescriptor(s.Options, GetType(s), s.GetType())).ToList();
+    }
+
+    private static void ExpandStrategies(this ResilienceStrategy strategy, List<ResilienceStrategy> strategies)
+    {
+        if (strategy is ResilienceStrategyPipeline pipeline)
+        {
+            foreach (var inner in pipeline.Strategies)
+            {
+                inner.ExpandStrategies(strategies);
+            }
+        }
+        else if (strategy is ReloadableResilienceStrategy reloadable)
+        {
+            strategies.Add(reloadable);
+            ExpandStrategies(reloadable.Strategy, strategies);
+        }
+        else
+        {
+            strategies.Add(strategy);
+        }
+    }
+
+    private static ResilienceStrategyType GetType(ResilienceStrategy strategy) => strategy switch
+    {
+        TimeoutResilienceStrategy => ResilienceStrategyType.Timeout,
+        ReloadableResilienceStrategy => ResilienceStrategyType.Reload,
+        _ when strategy.GetType().FullName == "Polly.RateLimiting.RateLimiterResilienceStrategy" => ResilienceStrategyType.RateLimiter,
+        _ when strategy.GetType().FullName == "Polly.Extensions.Telemetry.TelemetryResilienceStrategy" => ResilienceStrategyType.Telemetry,
+        _ when strategy.GetType().IsGenericType && strategy.GetType().GetGenericTypeDefinition() == typeof(RetryResilienceStrategy<>) => ResilienceStrategyType.Retry,
+        _ when strategy.GetType().IsGenericType && strategy.GetType().GetGenericTypeDefinition() == typeof(CircuitBreakerResilienceStrategy<>) => ResilienceStrategyType.CircuitBreaker,
+        _ when strategy.GetType().IsGenericType && strategy.GetType().GetGenericTypeDefinition() == typeof(HedgingResilienceStrategy<>) => ResilienceStrategyType.Hedging,
+        _ when strategy.GetType().IsGenericType && strategy.GetType().GetGenericTypeDefinition() == typeof(FallbackResilienceStrategy<>) => ResilienceStrategyType.Fallback,
+
+        _ => ResilienceStrategyType.Custom
+    };
+}

src/Polly.Testing/ResilienceStrategyType.cs

@@ -0,0 +1,52 @@
+namespace Polly.Testing;
+
+/// <summary>
+/// The type of resilience strategy.
+/// </summary>
+public enum ResilienceStrategyType
+{
+    /// <summary>
+    /// The strategy is custome one, i.e. defined in the external library and not built-in into Polly.
+    /// </summary>
+    Custom,
+
+    /// <summary>
+    /// The retry strategy.
+    /// </summary>
+    Retry,
+
+    /// <summary>
+    /// The timeout strategy.
+    /// </summary>
+    Timeout,
+
+    /// <summary>
+    /// The hedging strategy.
+    /// </summary>
+    Hedging,
+
+    /// <summary>
+    /// The circuit breaker strategy.
+    /// </summary>
+    CircuitBreaker,
+
+    /// <summary>
+    /// The fallback strategy.
+    /// </summary>
+    Fallback,
+
+    /// <summary>
+    /// The rate limiter strategy.
+    /// </summary>
+    RateLimiter,
+
+    /// <summary>
+    /// The telemetry strategy.
+    /// </summary>
+    Telemetry,
+
+    /// <summary>
+    /// The reload strategy.
+    /// </summary>
+    Reload
+}

test/Polly.Testing.Tests/Polly.Testing.Tests.csproj

@@ -0,0 +1,17 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFrameworks>net7.0;net6.0</TargetFrameworks>
+    <TargetFrameworks Condition="$([MSBuild]::IsOSPlatform('Windows'))">$(TargetFrameworks);net481</TargetFrameworks>
+    <ProjectType>Test</ProjectType>
+    <Nullable>enable</Nullable>
+    <Threshold>100</Threshold>
+    <NoWarn>$(NoWarn);SA1600;SA1204</NoWarn>
+    <Include>[Polly.Testing]*</Include>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\Polly.Extensions\Polly.Extensions.csproj" />
+    <ProjectReference Include="..\..\src\Polly.RateLimiting\Polly.RateLimiting.csproj" />
+    <ProjectReference Include="..\..\src\Polly.Testing\Polly.Testing.csproj" />
+  </ItemGroup>
+</Project>

test/Polly.Testing.Tests/ResilienceStrategyExtensionsTests.cs

@@ -0,0 +1,55 @@
+using System;
+using System.Collections.Generic;
+using FluentAssertions;
+using Microsoft.Extensions.Logging.Abstractions;
+using Polly.Timeout;
+
+namespace Polly.Testing.Tests;
+
+public class ResilienceStrategyExtensionsTests
+{
+    [Fact]
+    public void GetInnerStrategies_Ok()
+    {
+        // arrange
+        var strategy = new ResilienceStrategyBuilder<string>()
+            .AddFallback(new()
+            {
+                FallbackAction = _ => Outcome.FromResultAsTask("dummy"),
+            })
+            .AddRetry(new())
+            .AddAdvancedCircuitBreaker(new())
+            .AddTimeout(TimeSpan.FromSeconds(1))
+            .AddHedging(new())
+            .AddConcurrencyLimiter(10)
+            .AddStrategy(new CustomStrategy())
+            .ConfigureTelemetry(NullLoggerFactory.Instance)
+            .Build();
+
+        // act
+        var strategies = strategy.GetInnerStrategies();
+
+        // assert
+        strategies.Should().HaveCount(8);
+        strategies[0].Type.Should().Be(ResilienceStrategyType.Telemetry);
+        strategies[1].Type.Should().Be(ResilienceStrategyType.Fallback);
+        strategies[2].Type.Should().Be(ResilienceStrategyType.Retry);
+        strategies[3].Type.Should().Be(ResilienceStrategyType.CircuitBreaker);
+        strategies[4].Type.Should().Be(ResilienceStrategyType.Timeout);
+        strategies[4].Options
+            .Should()
+            .BeOfType<TimeoutStrategyOptions>().Subject.Timeout
+            .Should().Be(TimeSpan.FromSeconds(1));
+
+        strategies[5].Type.Should().Be(ResilienceStrategyType.Hedging);
+        strategies[6].Type.Should().Be(ResilienceStrategyType.RateLimiter);
+        strategies[7].Type.Should().Be(ResilienceStrategyType.Custom);
+        strategies[7].StrategyType.Should().Be(typeof(CustomStrategy));
+    }
+
+    private sealed class CustomStrategy : ResilienceStrategy
+    {
+        protected override ValueTask<Outcome<TResult>> ExecuteCoreAsync<TResult, TState>(Func<ResilienceContext, TState, ValueTask<Outcome<TResult>>> callback, ResilienceContext context, TState state)
+            => throw new NotSupportedException();
+    }
+}