Introduce ClearRequests method to reset the handler (#195)

* Add ClearRequests method to partly reset the TestableHttpMessageHandler
* Make sure SequencedResponse can recover from resets.

Fixes #193

Author: dnperfors

CHANGELOG.md

@@ -15,15 +15,18 @@ this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.htm
 - `TestableHttpMessageHandler.RespondWith(Func<HttpRequestMessage, HttpResponseMessage>)` has been removed, it's functionality is replaced by IResponse.
 - `RespondWith(this TestableHttpMessageHandler, HttpResponseMessage)` has been removed, the response is modified with every call, so it doesn't work reliably and is different from how HttpClientHandler works, which creates a HttpResponseMessage for every request.
 - `HttpResponseMessageBuilder` and `RespondWith(this TestableHttpMessageHandler, HttpResponseMessageBuilder)` has been removed, it's functionality can be replaced with ConfiguredResponse or a custom IResponse.
+- `HttpResponseContext` now has an internal constructor instead of a public one.
 
 ### Added
 - URI patterns now support query parameters and by default will use the unescaped values, note that the order is still important.
 - URI pattern parsing is extended to be able to parse most URI's.
+- `TestableHttpMessageHandler.ClearRequests` was added for situations where it is not possible to create and use a new instance.
 
 ### Changed
 - Use the same parser for the assertion methods `WithRequestUri` (which is used by `ShouldHaveMadeRequestsTo`) as for the RoutingResponse functionality.
 - `RouteParserException` has been renamed to `UriPatternParserException`.
 - Renamed `RoutingOptions` to `UriPatternMatchingOptions`.
+- `SequencedResponse` now is able to recover from a reset.
 
 ## [0.9] - 2022-11-25
 ### Deprecated

src/TestableHttpClient/HttpResponseContext.cs

@@ -5,9 +5,10 @@
 /// </summary>
 public class HttpResponseContext
 {
-    public HttpResponseContext(HttpRequestMessage httpRequestMessage, HttpResponseMessage httpResponseMessage, TestableHttpMessageHandlerOptions? options = null)
+    internal HttpResponseContext(HttpRequestMessage httpRequestMessage, IReadOnlyCollection<HttpRequestMessage> httpRequestMessages, HttpResponseMessage httpResponseMessage, TestableHttpMessageHandlerOptions? options = null)
     {
         HttpRequestMessage = httpRequestMessage;
+        HttpRequestMessages = httpRequestMessages;
         HttpResponseMessage = httpResponseMessage;
         Options = options ?? new TestableHttpMessageHandlerOptions();
     }
@@ -17,8 +18,15 @@ public HttpResponseContext(HttpRequestMessage httpRequestMessage, HttpResponseMe
     /// </summary>
     public HttpRequestMessage HttpRequestMessage { get; }
     /// <summary>
+    /// The requests that were send by the HttpClient.
+    /// </summary>
+    public IReadOnlyCollection<HttpRequestMessage> HttpRequestMessages { get; }
+    /// <summary>
     /// The response message that will be send back to the HttpClient.
     /// </summary>
     public HttpResponseMessage HttpResponseMessage { get; }
+    /// <summary>
+    /// The options that can be used by different responses.
+    /// </summary>
     public TestableHttpMessageHandlerOptions Options { get; }
 }

src/TestableHttpClient/PublicAPI.Shipped.txt

@@ -43,7 +43,6 @@ static TestableHttpClient.Responses.Timeout() -> TestableHttpClient.IResponse!
 
 TestableHttpClient.HttpResponseContext
 TestableHttpClient.HttpResponseContext.HttpRequestMessage.get -> System.Net.Http.HttpRequestMessage!
-TestableHttpClient.HttpResponseContext.HttpResponseContext(System.Net.Http.HttpRequestMessage! httpRequestMessage, System.Net.Http.HttpResponseMessage! httpResponseMessage, TestableHttpClient.TestableHttpMessageHandlerOptions? options = null) -> void
 TestableHttpClient.HttpResponseContext.HttpResponseMessage.get -> System.Net.Http.HttpResponseMessage!
 TestableHttpClient.HttpResponseContext.Options.get -> TestableHttpClient.TestableHttpMessageHandlerOptions!
 

src/TestableHttpClient/PublicAPI.Unshipped.txt

@@ -1,4 +1,6 @@
-TestableHttpClient.TestableHttpMessageHandlerOptions.UriPatternMatchingOptions.get -> TestableHttpClient.UriPatternMatchingOptions!
+TestableHttpClient.HttpResponseContext.HttpRequestMessages.get -> System.Collections.Generic.IReadOnlyCollection<System.Net.Http.HttpRequestMessage!>!
+TestableHttpClient.TestableHttpMessageHandler.ClearRequests() -> void
+TestableHttpClient.TestableHttpMessageHandlerOptions.UriPatternMatchingOptions.get -> TestableHttpClient.UriPatternMatchingOptions!
 TestableHttpClient.UriPatternMatchingOptions
 TestableHttpClient.UriPatternMatchingOptions.DefaultQueryFormat.get -> System.UriFormat
 TestableHttpClient.UriPatternMatchingOptions.DefaultQueryFormat.set -> void

src/TestableHttpClient/Response/SequencedResponse.cs

@@ -1,29 +1,22 @@
-using System.Collections.Concurrent;
-
-namespace TestableHttpClient.Response;
+namespace TestableHttpClient.Response;
 
 internal class SequencedResponse : IResponse
 {
-    private readonly ConcurrentQueue<IResponse> responses;
-    private readonly IResponse _lastResponse;
+    private readonly List<IResponse> responses;
     public SequencedResponse(IEnumerable<IResponse> responses)
     {
         this.responses = new(responses ?? throw new ArgumentNullException(nameof(responses)));
-        if (this.responses.IsEmpty)
+        if (this.responses.Count == 0)
         {
             throw new ArgumentException("Responses can't be empty.", nameof(responses));
         }
-        _lastResponse = this.responses.Last();
     }
 
     public Task ExecuteAsync(HttpResponseContext context, CancellationToken cancellationToken)
     {
-        var response = GetResponse();
-        return response.ExecuteAsync(context, cancellationToken);
-    }
+        int responseIndex = Math.Min(responses.Count - 1, context.HttpRequestMessages.Count - 1);
 
-    private IResponse GetResponse()
-    {
-        return responses.TryDequeue(out var response) ? response : _lastResponse;
+        IResponse response = responses[responseIndex];
+        return response.ExecuteAsync(context, cancellationToken);
     }
 }

src/TestableHttpClient/TestableHttpMessageHandler.cs

@@ -1,14 +1,13 @@
-using System.Collections.Concurrent;
-
-using TestableHttpClient.Response;
+using TestableHttpClient.Response;
 
 namespace TestableHttpClient;
 /// <summary>
 /// A testable HTTP message handler that captures all requests and always returns the same response.
 /// </summary>
 public class TestableHttpMessageHandler : HttpMessageHandler
 {
-    private readonly ConcurrentQueue<HttpRequestMessage> httpRequestMessages = new();
+    private readonly Queue<HttpRequestMessage> httpRequestMessages = new();
+
     private IResponse response = new HttpResponse(HttpStatusCode.OK);
 
     public TestableHttpMessageHandlerOptions Options { get; } = new TestableHttpMessageHandlerOptions();
@@ -24,7 +23,7 @@ protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage
 
         HttpResponseMessage responseMessage;
         responseMessage = new();
-        HttpResponseContext context = new(request, responseMessage, Options);
+        HttpResponseContext context = new(request, httpRequestMessages, responseMessage, Options);
         await response.ExecuteAsync(context, cancellationToken).ConfigureAwait(false);
 
         if (responseMessage.RequestMessage is null)
@@ -54,4 +53,15 @@ public void RespondWith(IResponse response)
     {
         this.response = response ?? throw new ArgumentNullException(nameof(response));
     }
+
+    /// <summary>
+    /// Clear the registration of requests that were made with this handler.
+    /// </summary>
+    /// Sometimes the TestableHttpMessageHandler can't be replaced with a new instance, but it can be cleared.
+    /// The configuration is not cleared and will be kept the same.
+    /// <remarks>The configuration it self (Options and the configure IResponse) will not be cleared or reset.</remarks>
+    public void ClearRequests()
+    {
+        httpRequestMessages.Clear();
+    }
 }

test/TestableHttpClient.IntegrationTests/UsingIHttpClientFactory.cs

@@ -15,10 +15,10 @@ public class UsingIHttpClientFactory
     public async Task ConfigureIHttpClientFactoryToUseTestableHttpClient()
     {
         // Create TestableHttpMessageHandler as usual.
-        using var testableHttpMessageHandler = new TestableHttpMessageHandler();
+        using TestableHttpMessageHandler testableHttpMessageHandler = new();
         testableHttpMessageHandler.RespondWith(StatusCode(HttpStatusCode.NoContent));
 
-        var services = new ServiceCollection();
+        ServiceCollection services = new();
         // Register an HttpClient and configure the TestableHttpMessageHandler as the PrimaryHttpMessageHandler
         services.AddHttpClient(string.Empty).ConfigurePrimaryHttpMessageHandler(() => testableHttpMessageHandler);
 
@@ -27,12 +27,18 @@ public async Task ConfigureIHttpClientFactoryToUseTestableHttpClient()
         // Request the IHttpClientFactory
         var httpClientFactory = serviceProvider.GetRequiredService<IHttpClientFactory>();
         // Create the HttpClient
-        using var client = httpClientFactory.CreateClient();
+        using HttpClient client = httpClientFactory.CreateClient();
         // And use it...
         _ = await client.GetAsync("https://httpbin.com/get");
 
         // Now use the assertions to make sure the request was actually made.
         testableHttpMessageHandler.ShouldHaveMadeRequestsTo("https://httpbin.com/get");
+
+        // Since we already have created the serviceProvider, we can't (easily) replace the TestableHttpMessageHandler.
+        // So in case you need to start fresh, i.e. when the serviceProvider is part of shared context, you can clear it.
+        testableHttpMessageHandler.ClearRequests();
+
+        testableHttpMessageHandler.ShouldHaveMadeRequests(0);
     }
 
     [Fact]

test/TestableHttpClient.Tests/Response/ConfiguredResponseTests.cs

@@ -1,6 +1,4 @@
-using System.Threading;
-
-using TestableHttpClient.Response;
+using TestableHttpClient.Response;
 
 namespace TestableHttpClient.Tests.Response;
 
@@ -31,11 +29,9 @@ public async Task ExecuteAsync_ByDefault_CallsConfigureResponse()
         HttpResponse response = new(HttpStatusCode.OK);
 
         void configureResponse(HttpResponseMessage _) => wasCalled = true;
-        using HttpRequestMessage requestMessage = new();
-        using HttpResponseMessage responseMessage = new();
         ConfiguredResponse sut = new(response, configureResponse);
 
-        await sut.ExecuteAsync(new HttpResponseContext(requestMessage, responseMessage), CancellationToken.None);
+        using HttpResponseMessage responseMessage = await sut.TestAsync();
 
         Assert.True(wasCalled, "configureResponse action was not called.");
     }

test/TestableHttpClient.Tests/Response/DelayedResponseTests.cs

@@ -1,7 +1,4 @@
-using System.Diagnostics;
-using System.Threading;
-
-using TestableHttpClient.Response;
+using TestableHttpClient.Response;
 
 namespace TestableHttpClient.Tests.Response;
 
@@ -22,12 +19,10 @@ public void Constructor_NullResponse_ThrowsArgumentNullException()
     [Fact]
     public async Task GetResponseAsync_ByDefault_ReturnsInnerResponse()
     {
-        using HttpRequestMessage requestMessage = new();
-        using HttpResponseMessage responseMessage = new();
         HttpResponse delayedResponse = new(HttpStatusCode.Created);
         DelayedResponse sut = new(delayedResponse, TimeSpan.Zero);
 
-        await sut.ExecuteAsync(new HttpResponseContext(requestMessage, responseMessage), CancellationToken.None);
+        using HttpResponseMessage responseMessage = await sut.TestAsync();
 
         Assert.Equal(HttpStatusCode.Created, responseMessage.StatusCode);
     }

test/TestableHttpClient.Tests/Response/HttpResponseTests.cs

@@ -19,11 +19,9 @@ public async Task ExecuteAsync_WithNullContext_ThrowsArgumentNullException()
     [Fact]
     public async Task ExecuteAsync_WithHttpStatusCode_ReturnsCorrectStatusCode()
     {
-        using HttpRequestMessage requestMessage = new();
-        using HttpResponseMessage responseMessage = new();
         HttpResponse sut = new(HttpStatusCode.Continue);
 
-        await sut.ExecuteAsync(new HttpResponseContext(requestMessage, responseMessage), CancellationToken.None);
+        using HttpResponseMessage responseMessage = await sut.TestAsync();
 
         Assert.Equal(HttpStatusCode.Continue, responseMessage.StatusCode);
         Assert.Equal(HttpStatusCode.Continue, sut.StatusCode);