RateLimiting: add typed builder/guard tests and external limiter lifetime test

test/Polly.RateLimiting.Tests/RateLimiterExternalLimiterLifetimeTests.cs

@@ -0,0 +1,39 @@
+using System.Threading;
+using System.Threading.RateLimiting;
+using System.Threading.Tasks;
+using Polly.Registry;
+using Shouldly;
+
+namespace Polly.RateLimiting.Tests
+{
+    public class RateLimiterExternalLimiterLifetimeTests
+    {
+        [Fact]
+        public async Task RegistryDispose_DoesNotDisposeExternalLimiter()
+        {
+            using var externalLimiter = new ConcurrencyLimiter(new ConcurrencyLimiterOptions
+            {
+                PermitLimit = 1,
+                QueueLimit = 0
+            });
+
+            var registry = new ResiliencePipelineRegistry<string>();
+            _ = registry.GetOrAddPipeline("ext", p => p.AddRateLimiter(externalLimiter));
+
+            await registry.DisposeAsync();
+
+            await Should.NotThrowAsync(async () =>
+            {
+                var lease = await externalLimiter.AcquireAsync(1, CancellationToken.None);
+                try
+                {
+                    lease.IsAcquired.ShouldBeTrue();
+                }
+                finally
+                {
+                    lease.Dispose();
+                }
+            });
+        }
+    }
+}

test/Polly.RateLimiting.Tests/RateLimiterResiliencePipelineBuilderExtensions_TypedAndNullTests.cs

@@ -0,0 +1,53 @@
+using System;
+using System.ComponentModel.DataAnnotations;
+using Polly.Testing;
+using Shouldly;
+
+namespace Polly.RateLimiting.Tests
+{
+    public class RateLimiterResiliencePipelineBuilderExtensions_TypedAndNullTests
+    {
+        [Fact]
+        public void TypedBuilder_AddConcurrencyLimiter_BuildsRateLimiterStrategy()
+        {
+            var builder = new ResiliencePipelineBuilder<int>()
+                .AddConcurrencyLimiter(permitLimit: 2, queueLimit: 1);
+
+            builder.Build()
+                .GetPipelineDescriptor()
+                .FirstStrategy
+                .StrategyInstance
+                .ShouldBeOfType<RateLimiterResilienceStrategy>();
+        }
+
+        [Fact]
+        public void AddRateLimiter_WithNullLimiter_Throws()
+        {
+            var builder = new ResiliencePipelineBuilder();
+            Should.Throw<ArgumentNullException>(() => builder.AddRateLimiter(limiter: null!));
+        }
+
+        [Fact]
+        public void AddRateLimiter_WithNullOptions_Throws()
+        {
+            var builder = new ResiliencePipelineBuilder();
+            Should.Throw<ArgumentNullException>(() => builder.AddRateLimiter(options: null!));
+        }
+
+        [Fact]
+        public void AddConcurrencyLimiter_WithNullOptions_Throws()
+        {
+            var builder = new ResiliencePipelineBuilder();
+            Should.Throw<ArgumentNullException>(() => builder.AddConcurrencyLimiter(options: null!));
+        }
+
+        [Fact]
+        public void AddRateLimiter_InvalidOptions_ThrowsValidation()
+        {
+            var builder = new ResiliencePipelineBuilder();
+            var options = new RateLimiterStrategyOptions { DefaultRateLimiterOptions = null! };
+
+            Should.Throw<ValidationException>(() => builder.AddRateLimiter(options));
+        }
+    }
+}