Introduce Polly.Testing package

src/Polly.Testing/InnerStrategiesDescriptor.cs

@@ -0,0 +1,9 @@
+namespace Polly.Testing;
+
+/// <summary>
+/// Describes the pipeline of resilience strategy.
+/// </summary>
+/// <param name="Strategies">The strategies the pipeline is composed of.</param>
+/// <param name="HasTelemetry">Gets a value indicating whether the pipeline has telemetry enabled.</param>
+/// <param name="IsReloadable">Gets a value indicating whether the resilience strategy is reloadable.</param>
+public record class InnerStrategiesDescriptor(IReadOnlyList<ResilienceStrategyDescriptor> Strategies, bool HasTelemetry, bool IsReloadable);

src/Polly.Testing/Polly.Testing.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
-    <TargetFrameworks>net7.0;net6.0;netstandard2.0;net472;net462</TargetFrameworks>
+    <TargetFrameworks>netstandard2.0</TargetFrameworks>
     <AssemblyTitle>Polly.Testing</AssemblyTitle>
     <RootNamespace>Polly.Testing</RootNamespace>
     <Nullable>enable</Nullable>

src/Polly.Testing/ResilienceStrategyDescriptor.cs

@@ -4,9 +4,7 @@
 /// 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)
+public record ResilienceStrategyDescriptor(ResilienceStrategyOptions? Options, Type StrategyType)
 {
 }
-

src/Polly.Testing/ResilienceStrategyExtensions.cs

@@ -1,9 +1,4 @@
-using Polly.CircuitBreaker;
-using Polly.Fallback;
-using Polly.Hedging;
-using Polly.Retry;
-using Polly.Timeout;
-using Polly.Utils;
+using Polly.Utils;
 
 namespace Polly.Testing;
 
@@ -19,7 +14,7 @@ public static class ResilienceStrategyExtensions
     /// <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)
+    public static InnerStrategiesDescriptor GetInnerStrategies<TResult>(this ResilienceStrategy<TResult> strategy)
     {
         Guard.NotNull(strategy);
 
@@ -32,16 +27,23 @@ public static IReadOnlyList<ResilienceStrategyDescriptor> GetInnerStrategies<TRe
     /// <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)
+    public static InnerStrategiesDescriptor 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();
+        var innerStrategies = strategies.Select(s => new ResilienceStrategyDescriptor(s.Options, s.GetType())).ToList();
+
+        return new InnerStrategiesDescriptor(
+            innerStrategies.Where(s => !ShouldSkip(s.StrategyType)).ToList().AsReadOnly(),
+            HasTelemetry: innerStrategies.Exists(s => s.StrategyType.FullName == "Polly.Extensions.Telemetry.TelemetryResilienceStrategy"),
+            IsReloadable: innerStrategies.Exists(s => s.StrategyType == typeof(ReloadableResilienceStrategy)));
     }
 
+    private static bool ShouldSkip(Type type) => type == typeof(ReloadableResilienceStrategy) || type.FullName == "Polly.Extensions.Telemetry.TelemetryResilienceStrategy";
+
     private static void ExpandStrategies(this ResilienceStrategy strategy, List<ResilienceStrategy> strategies)
     {
         if (strategy is ResilienceStrategyPipeline pipeline)
@@ -61,18 +63,4 @@ private static void ExpandStrategies(this ResilienceStrategy strategy, List<Resi
             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
-    };
 }

test/Polly.Testing.Tests/ResilienceStrategyExtensionsTests.cs

@@ -1,7 +1,12 @@
 using System;
-using System.Collections.Generic;
 using FluentAssertions;
 using Microsoft.Extensions.Logging.Abstractions;
+using Polly.CircuitBreaker;
+using Polly.Fallback;
+using Polly.Hedging;
+using Polly.RateLimiting;
+using Polly.Registry;
+using Polly.Retry;
 using Polly.Timeout;
 
 namespace Polly.Testing.Tests;
@@ -30,21 +35,44 @@ public void GetInnerStrategies_Ok()
         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
+        strategies.HasTelemetry.Should().BeTrue();
+        strategies.Strategies.Should().HaveCount(7);
+        strategies.Strategies[0].Options.Should().BeOfType<FallbackStrategyOptions<string>>();
+        strategies.Strategies[1].Options.Should().BeOfType<RetryStrategyOptions<string>>();
+        strategies.Strategies[2].Options.Should().BeOfType<AdvancedCircuitBreakerStrategyOptions<string>>();
+        strategies.Strategies[3].Options.Should().BeOfType<TimeoutStrategyOptions>();
+        strategies.Strategies[3].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));
+        strategies.Strategies[4].Options.Should().BeOfType<HedgingStrategyOptions<string>>();
+        strategies.Strategies[5].Options.Should().BeOfType<RateLimiterStrategyOptions>();
+        strategies.Strategies[6].StrategyType.Should().Be(typeof(CustomStrategy));
+    }
+
+    [Fact]
+    public void GetInnerStrategies_Reloadable_Ok()
+    {
+        // arrange
+        var strategy = new ResilienceStrategyRegistry<string>().GetOrAddStrategy("dummy", (builder, context) =>
+        {
+            context.EnableReloads(() => () => CancellationToken.None);
+
+            builder
+                .AddConcurrencyLimiter(10)
+                .AddStrategy(new CustomStrategy());
+        });
+
+        // act
+        var strategies = strategy.GetInnerStrategies();
+
+        // assert
+        strategies.IsReloadable.Should().BeTrue();
+        strategies.HasTelemetry.Should().BeFalse();
+        strategies.Strategies.Should().HaveCount(2);
+        strategies.Strategies[0].Options.Should().BeOfType<RateLimiterStrategyOptions>();
+        strategies.Strategies[1].StrategyType.Should().Be(typeof(CustomStrategy));
     }
 
     private sealed class CustomStrategy : ResilienceStrategy