Add response routing (#187)

Author: dnperfors

CHANGELOG.md

@@ -5,9 +5,15 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [0.9] - unplanned
+### Deprecated
+- `Responses.NoContent()` has been deprecated, since it doesn't fit well with the rest of the API. Please use `Responses.StatusCode(HttpStatusCode.NoContent)` instead.
+
 ### Removed
 - Official support for .NET Core 3.1 has been removed. This means we no longer provide a specific version for .NET Core 3.0 and we no longer test this version explicitly. Since we support .NET Standard 2.0, the library could still be used.
 
+### Added
+- Added `Responses.Route` that allows changing the response based on the url. The url supports patterns.
+
 ## [0.8] - 2022-11-08
 ### Deprecated
 - `TestableHttpMessageHandler.SimulateTimeout` is deprecated, and can be replaced with `RespondWith(Responses.Timeout())`.

src/TestableHttpClient/HttpRequestMessageAssertionException.cs

@@ -1,18 +1,37 @@
 using System.Diagnostics.CodeAnalysis;
-using System.Runtime.Serialization;
 
 namespace TestableHttpClient;
 
-[Serializable]
-[SuppressMessage("Design", "CA1032:Implement standard exception constructors", Justification = "Not intended for public usage, but could be used for catching.")]
+/// <summary>
+/// Exception thrown when the request assertion failed.
+/// </summary>
+[SuppressMessage("SonarSource", "S3925", Justification = "These exceptions don't need to be serialized.")]
 public sealed class HttpRequestMessageAssertionException : Exception
 {
-    internal HttpRequestMessageAssertionException(string message) : base(message)
+    /// <summary>
+    /// Initializes a new instance of the <see cref="HttpRequestMessageAssertionException"/> class with the default error message.
+    /// </summary>
+    public HttpRequestMessageAssertionException()
+        : this("Assertion failed.")
     {
     }
 
-    [ExcludeFromCodeCoverage]
-    private HttpRequestMessageAssertionException(SerializationInfo info, StreamingContext context) : base(info, context)
+    /// <summary>
+    /// Initializes a new instance of the <see cref="HttpRequestMessageAssertionException"/> class with a specified error message.
+    /// </summary>
+    /// <param name="message">The error message that explains the reason for the exception.</param>
+    public HttpRequestMessageAssertionException(string message) : base(message)
+    {
+    }
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="HttpRequestMessageAssertionException"/>
+    /// class with a specified error message and a reference to the inner exception that is the cause of
+    /// this exception.
+    /// </summary>
+    /// <param name="message">The error message that explains the reason for the exception.</param>
+    /// <param name="innerException">The exception that is the cause of the current exception.</param>
+    public HttpRequestMessageAssertionException(string message, Exception innerException) : base(message, innerException)
     {
     }
 }

src/TestableHttpClient/IRoutingResponseBuilder.cs

@@ -0,0 +1,20 @@
+namespace TestableHttpClient;
+
+/// <summary>
+/// A builder for routing responses.
+/// </summary>
+public interface IRoutingResponseBuilder
+{
+    /// <summary>
+    /// Maps a route to a specified response.
+    /// </summary>
+    /// <param name="route">The route pattern.</param>
+    /// <param name="response">The response the route should return.</param>
+    /// <example>x.Map("*", Responses.StatusCode(HttpStatusCode.OK))</example>
+    void Map(string route, IResponse response);
+    /// <summary>
+    /// Maps a custom response for when a request did't match any route. Defaults to Responses.StatusCode(HttpStatusCode.NotFound).
+    /// </summary>
+    /// <param name="fallBackResponse">The response that should be returned when no route matches.</param>
+    void MapFallBackResponse(IResponse fallBackResponse);
+}

src/TestableHttpClient/PublicAPI.Unshipped.txt

@@ -1 +1,20 @@
-
+static TestableHttpClient.Responses.Route(System.Action<TestableHttpClient.IRoutingResponseBuilder!>! builder) -> TestableHttpClient.IResponse!
+TestableHttpClient.HttpRequestMessageAssertionException.HttpRequestMessageAssertionException() -> void
+TestableHttpClient.HttpRequestMessageAssertionException.HttpRequestMessageAssertionException(string! message) -> void
+TestableHttpClient.HttpRequestMessageAssertionException.HttpRequestMessageAssertionException(string! message, System.Exception! innerException) -> void
+TestableHttpClient.IRoutingResponseBuilder
+TestableHttpClient.IRoutingResponseBuilder.Map(string! route, TestableHttpClient.IResponse! response) -> void
+TestableHttpClient.IRoutingResponseBuilder.MapFallBackResponse(TestableHttpClient.IResponse! fallBackResponse) -> void
+TestableHttpClient.RoutingOptions
+TestableHttpClient.RoutingOptions.HostCaseInsensitive.get -> bool
+TestableHttpClient.RoutingOptions.HostCaseInsensitive.set -> void
+TestableHttpClient.RoutingOptions.PathCaseInsensitive.get -> bool
+TestableHttpClient.RoutingOptions.PathCaseInsensitive.set -> void
+TestableHttpClient.RoutingOptions.RoutingOptions() -> void
+TestableHttpClient.RoutingOptions.SchemeCaseInsensitive.get -> bool
+TestableHttpClient.RoutingOptions.SchemeCaseInsensitive.set -> void
+TestableHttpClient.TestableHttpMessageHandlerOptions.RoutingOptions.get -> TestableHttpClient.RoutingOptions!
+TestableHttpClient.Utils.RouteParserException
+TestableHttpClient.Utils.RouteParserException.RouteParserException() -> void
+TestableHttpClient.Utils.RouteParserException.RouteParserException(string! message) -> void
+TestableHttpClient.Utils.RouteParserException.RouteParserException(string! message, System.Exception! innerException) -> void

src/TestableHttpClient/Response/RoutingResponse.cs

@@ -0,0 +1,32 @@
+using static System.Net.HttpStatusCode;
+using static TestableHttpClient.Responses;
+
+namespace TestableHttpClient.Response;
+internal class RoutingResponse : IResponse
+{
+    public Task ExecuteAsync(HttpResponseContext context, CancellationToken cancellationToken)
+    {
+        IResponse response = FallBackResponse;
+
+        if (context.HttpRequestMessage.RequestUri is not null)
+        {
+            response = GetResponseForRequest(context.HttpRequestMessage.RequestUri, context.Options.RoutingOptions);
+        }
+
+        return response.ExecuteAsync(context, cancellationToken);
+    }
+
+    public Dictionary<RouteDefinition, IResponse> ResponseMap { get; init; } = new();
+    public IResponse FallBackResponse { get; internal set; } = StatusCode(NotFound);
+
+    private IResponse GetResponseForRequest(Uri requestUri, RoutingOptions routingOptions)
+    {
+        var matchingResponse = ResponseMap.FirstOrDefault(x => x.Key.Matches(requestUri, routingOptions));
+
+        return matchingResponse.Value switch
+        {
+            null => FallBackResponse,
+            _ => matchingResponse.Value
+        };
+    }
+}

src/TestableHttpClient/Responses.cs

@@ -55,6 +55,7 @@ public static class Responses
     /// Create a response with the NoContent status code.
     /// </summary>
     /// <returns>An HttpResponse with the configured StatusCode.</returns>
+    [Obsolete("Please use StatusCode(HttpStatusCode.NoContent) instead.")]
     public static IResponse NoContent() => StatusCode(HttpStatusCode.NoContent);
     /// <summary>
     /// Create a response with some text content.
@@ -80,6 +81,23 @@ public static class Responses
     /// <returns>A response with specific content.</returns>
     public static IResponse Json(object? content, HttpStatusCode statusCode, string? contentType = null, JsonSerializerOptions? jsonSerializerOptions = null) => new JsonResponse(content, contentType) { StatusCode = statusCode, JsonSerializerOptions = jsonSerializerOptions };
     /// <summary>
+    /// Create a response for several routes.
+    /// </summary>
+    /// <param name="builder">The route builder that can be used to configure multiple routes.</param>
+    /// <returns>A response with routing capabilities.</returns>
+    /// <exception cref="ArgumentNullException">Thrown when the builder paramater is null.</exception>
+    public static IResponse Route(Action<IRoutingResponseBuilder> builder)
+    {
+        if (builder is null)
+        {
+            throw new ArgumentNullException(nameof(builder));
+        }
+
+        RoutingResponseBuilder routingResponseBuilder = new();
+        builder(routingResponseBuilder);
+        return routingResponseBuilder.RoutingResponse;
+    }
+    /// <summary>
     /// Entrypoint for extensions.
     /// </summary>
     public static IResponsesExtensions Extensions { get; } = new ResponseExtensions();

src/TestableHttpClient/RoutingOptions.cs

@@ -0,0 +1,20 @@
+namespace TestableHttpClient;
+
+/// <summary>
+/// Options specific for routing.
+/// </summary>
+public class RoutingOptions
+{
+    /// <summary>
+    /// Indeicates whether or not the scheme of a route should be treated as case insensitive. Default: true
+    /// </summary>
+    public bool SchemeCaseInsensitive { get; set; } = true;
+    /// <summary>
+    /// Indeicates whether or not the host of a route should be treated as case insensitive. Default: true
+    /// </summary>
+    public bool HostCaseInsensitive { get; set; } = true;
+    /// <summary>
+    /// Indeicates whether or not the path of a route should be treated as case insensitive. Default: true
+    /// </summary>
+    public bool PathCaseInsensitive { get; set; } = true;
+}

src/TestableHttpClient/TestableHttpClient.csproj

@@ -10,6 +10,7 @@
   <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
     <PackageReference Include="System.Net.Http" Version="4.3.4" />
     <PackageReference Include="System.Text.Json" Version="4.6.0" />
+    <PackageReference Include="IndexRange" Version="1.0.2" />
   </ItemGroup>
 
   <ItemGroup>

src/TestableHttpClient/TestableHttpMessageHandler.cs

@@ -56,7 +56,7 @@ protected override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage
     /// <param name="response">The response that should be created.</param>
     /// <remarks>By default each request will receive a new response, however this is dependend on the implementation.</remarks>
     /// <example>
-    /// testableHttpMessageHander.RespondWith(Responses.NoContent());
+    /// testableHttpMessageHander.RespondWith(Responses.StatusCode(HttpStatusCode.OK));
     /// </example>
     public void RespondWith(IResponse response)
     {

src/TestableHttpClient/TestableHttpMessageHandlerOptions.cs

@@ -7,4 +7,6 @@ public sealed class TestableHttpMessageHandlerOptions
         DictionaryKeyPolicy = JsonNamingPolicy.CamelCase,
         PropertyNamingPolicy = JsonNamingPolicy.CamelCase
     };
+
+    public RoutingOptions RoutingOptions { get; } = new RoutingOptions();
 }