test: DRY up ResponseIdValidationServiceTests (#1078)

## What changed

Refactored `ResponseIdValidationServiceTests` to eliminate repetitive
setup boilerplate across all 9 tests.

**Before:** Each test created its own `MemoryCache` and
`ResponseIdValidationService` via two static factory helpers, resulting
in a 2-line setup block in every test body.

**After:** A single `_service` field is initialized once using the
production parameterless constructor (which already creates a bounded
`MemoryCache` with `SizeLimit = 10_000`). Cleanup is handled via
`[After(Test)]` (TUnit-idiomatic) plus
`IDisposable`/`GC.SuppressFinalize` to satisfy CA1001/CA1816 analyzers.

## Why

- Removes ~30 lines of repeated setup boilerplate
- Drops the `using Microsoft.Extensions.Caching.Memory` import entirely
- tests no longer need to know cache configuration details
- Uses the production constructor, so the `SizeLimit` is inherently
exercised without duplication
- All 11 tests continue to pass

Author: BenjaminMichaelis

EssentialCSharp.Web.Tests/ResponseIdValidationServiceTests.cs

@@ -1,24 +1,24 @@
 using EssentialCSharp.Web.Services;
-using Microsoft.Extensions.Caching.Memory;
 
 namespace EssentialCSharp.Web.Tests;
 
-public class ResponseIdValidationServiceTests
+public class ResponseIdValidationServiceTests : IDisposable
 {
     // Match production SizeLimit so SetSize(1) is exercised in tests, not silently ignored.
-    private static MemoryCache CreateCache() => new(new MemoryCacheOptions { SizeLimit = 10_000 });
+    private readonly ResponseIdValidationService _service = new();
 
-    private static ResponseIdValidationService CreateService(MemoryCache cache) => new(cache);
+    public void Dispose()
+    {
+        _service.Dispose();
+        GC.SuppressFinalize(this);
+    }
 
     [Test]
     [Arguments(null)]
     [Arguments("")]
     public async Task ValidateResponseId_BlankResponseId_AllowsNewConversation(string? responseId)
     {
-        using var cache = CreateCache();
-        var service = CreateService(cache);
-
-        bool result = service.ValidateResponseId("user1", responseId);
+        bool result = _service.ValidateResponseId("user1", responseId);
 
         await Assert.That(result).IsTrue();
     }
@@ -28,103 +28,83 @@ public async Task ValidateResponseId_BlankResponseId_AllowsNewConversation(strin
     [Arguments("")]
     public async Task ValidateResponseId_BlankUserId_Rejects(string? userId)
     {
-        using var cache = CreateCache();
-        var service = CreateService(cache);
-
-        bool result = service.ValidateResponseId(userId, "resp_123");
+        bool result = _service.ValidateResponseId(userId, "resp_123");
 
         await Assert.That(result).IsFalse();
     }
 
     [Test]
     public async Task ValidateResponseId_CacheMiss_AllowsGracefulDegradation()
     {
-        using var cache = CreateCache();
-        var service = CreateService(cache);
         // No RecordResponseId call — simulate server restart / different instance
-
-        bool result = service.ValidateResponseId("user1", "resp_unknown");
+        bool result = _service.ValidateResponseId("user1", "resp_unknown");
 
         await Assert.That(result).IsTrue();
     }
 
     [Test]
     public async Task ValidateResponseId_RecordedByOwner_Validates()
     {
-        using var cache = CreateCache();
-        var service = CreateService(cache);
-        service.RecordResponseId("user1", "resp_abc");
+        _service.RecordResponseId("user1", "resp_abc");
 
-        bool result = service.ValidateResponseId("user1", "resp_abc");
+        bool result = _service.ValidateResponseId("user1", "resp_abc");
 
         await Assert.That(result).IsTrue();
     }
 
     [Test]
     public async Task ValidateResponseId_RecordedByDifferentUser_Rejects()
     {
-        using var cache = CreateCache();
-        var service = CreateService(cache);
-        service.RecordResponseId("user1", "resp_abc");
+        _service.RecordResponseId("user1", "resp_abc");
 
-        bool result = service.ValidateResponseId("user2", "resp_abc");
+        bool result = _service.ValidateResponseId("user2", "resp_abc");
 
         await Assert.That(result).IsFalse();
     }
 
     [Test]
     public async Task RecordResponseId_NullInputs_DoesNotThrow()
     {
-        using var cache = CreateCache();
-        var service = CreateService(cache);
-
-        service.RecordResponseId(null, "resp_abc");
-        service.RecordResponseId("user1", null);
-        service.RecordResponseId(null, null);
+        _service.RecordResponseId(null, "resp_abc");
+        _service.RecordResponseId("user1", null);
+        _service.RecordResponseId(null, null);
 
         // Verify the service is still functional after no-op calls
-        service.RecordResponseId("user1", "resp_abc");
-        await Assert.That(service.ValidateResponseId("user1", "resp_abc")).IsTrue();
+        _service.RecordResponseId("user1", "resp_abc");
+        await Assert.That(_service.ValidateResponseId("user1", "resp_abc")).IsTrue();
     }
 
     [Test]
     public async Task ValidateResponseId_MultipleResponseIds_EachValidatedIndependently()
     {
-        using var cache = CreateCache();
-        var service = CreateService(cache);
-        service.RecordResponseId("user1", "resp_001");
-        service.RecordResponseId("user1", "resp_002");
+        _service.RecordResponseId("user1", "resp_001");
+        _service.RecordResponseId("user1", "resp_002");
 
-        await Assert.That(service.ValidateResponseId("user1", "resp_001")).IsTrue();
-        await Assert.That(service.ValidateResponseId("user1", "resp_002")).IsTrue();
+        await Assert.That(_service.ValidateResponseId("user1", "resp_001")).IsTrue();
+        await Assert.That(_service.ValidateResponseId("user1", "resp_002")).IsTrue();
         // Unrecorded ID for same user → cache miss → allow
-        await Assert.That(service.ValidateResponseId("user1", "resp_003")).IsTrue();
+        await Assert.That(_service.ValidateResponseId("user1", "resp_003")).IsTrue();
     }
 
     [Test]
     public async Task ValidateResponseId_TwoUsers_IsolatedFromEachOther()
     {
-        using var cache = CreateCache();
-        var service = CreateService(cache);
-        service.RecordResponseId("user1", "resp_A");
-        service.RecordResponseId("user2", "resp_B");
-
-        await Assert.That(service.ValidateResponseId("user1", "resp_A")).IsTrue();
-        await Assert.That(service.ValidateResponseId("user2", "resp_B")).IsTrue();
-        await Assert.That(service.ValidateResponseId("user2", "resp_A")).IsFalse();
-        await Assert.That(service.ValidateResponseId("user1", "resp_B")).IsFalse();
+        _service.RecordResponseId("user1", "resp_A");
+        _service.RecordResponseId("user2", "resp_B");
+
+        await Assert.That(_service.ValidateResponseId("user1", "resp_A")).IsTrue();
+        await Assert.That(_service.ValidateResponseId("user2", "resp_B")).IsTrue();
+        await Assert.That(_service.ValidateResponseId("user2", "resp_A")).IsFalse();
+        await Assert.That(_service.ValidateResponseId("user1", "resp_B")).IsFalse();
     }
 
     [Test]
     public async Task RecordResponseId_SizeLimitEnforced_EntryCountedInCache()
     {
-        using var cache = CreateCache();
-        var service = CreateService(cache);
-
         // Record an entry — with SizeLimit set, SetSize(1) should count toward the cache size.
-        service.RecordResponseId("user1", "resp_size_test");
+        _service.RecordResponseId("user1", "resp_size_test");
 
         // Verify it was recorded (i.e., not silently evicted due to misconfiguration).
-        await Assert.That(service.ValidateResponseId("user1", "resp_size_test")).IsTrue();
+        await Assert.That(_service.ValidateResponseId("user1", "resp_size_test")).IsTrue();
     }
 }

EssentialCSharp.Web/Services/ResponseIdValidationService.cs

@@ -31,6 +31,7 @@ public sealed class ResponseIdValidationService : IDisposable
 
     private readonly IMemoryCache _cache;
     private readonly bool _ownsCache;
+    private bool _disposed;
 
     /// <summary>
     /// Production constructor. Creates and owns a dedicated <see cref="MemoryCache"/> with a bounded
@@ -54,8 +55,16 @@ private ResponseIdValidationService(IMemoryCache cache, bool ownsCache)
     /// <inheritdoc />
     public void Dispose()
     {
+        if (_disposed)
+        {
+            return;
+        }
+        _disposed = true;
+
         if (_ownsCache && _cache is IDisposable disposable)
+        {
             disposable.Dispose();
+        }
     }
 
     /// <summary>