starred/WireMock.Net-wiremock
1
0
Fork 0
mirror of https://github.com/wiremock/WireMock.Net.git synced 2026-01-11 14:20:29 +01:00
Code Issues 32 Packages Projects Releases 10 Wiki Activity

Add new package WireMock.Net.Extensions.Routing which provides minimal-API-style routing for WireMock.Net (#1344)

Browse Source 
* Add new package WireMock.Net.Extensions.Routing

* Update documentation for WireMock.Net.Extensions.Routing

* Cleanup imports

* Add header to all source files inside WireMock.Net.Extensions.Routing

* Add header to all source files inside WireMock.Net.Extensions.Routing.Tests

* Revert unintended changes

* Remove redundant build configurations

* Remove incorrect links from documentation

* Update nuget package references

* Revert unintended changes

* Migrate to AwesomeAssertions

* Remove redundant project reference

* Adjust formatting

* Migrate to primary constructor

* Refactoring: rename delegate parameter

* Abstract over JSON converter

* Replace WireMock with WireMock.Net in comments

* Move local functions to the bottom of the methods
This commit is contained in:
Gennadii Saltyshchak
2025-08-18 20:52:42 +03:00
committed by GitHub
parent 60eb519ae2
commit be2ea67b89
20 changed files with 1118 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
WireMock.Net Solution.sln
View File

@@ -138,6 +138,10 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WireMock.Net.Tests.UsingNuG
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WireMock.Net.GraphQL", "src\WireMock.Net.GraphQL\WireMock.Net.GraphQL.csproj", "{B6269AAC-170A-4346-8B9A-444DED3D9A45}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WireMock.Net.Extensions.Routing.Tests", "test\WireMock.Net.Extensions.Routing.Tests\WireMock.Net.Extensions.Routing.Tests.csproj", "{3FCBCA9C-9DB0-4A96-B47E-30470764CC9C}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WireMock.Net.Extensions.Routing", "src\WireMock.Net.Extensions.Routing\WireMock.Net.Extensions.Routing.csproj", "{1E874C8F-08A2-493B-8421-619F9A6E9E77}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
@@ -332,6 +336,14 @@ Global
{B6269AAC-170A-4346-8B9A-444DED3D9A45}.Debug|Any CPU.Build.0 = Debug|Any CPU
{B6269AAC-170A-4346-8B9A-444DED3D9A45}.Release|Any CPU.ActiveCfg = Release|Any CPU
{B6269AAC-170A-4346-8B9A-444DED3D9A45}.Release|Any CPU.Build.0 = Release|Any CPU
{3FCBCA9C-9DB0-4A96-B47E-30470764CC9C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{3FCBCA9C-9DB0-4A96-B47E-30470764CC9C}.Debug|Any CPU.Build.0 = Debug|Any CPU
{3FCBCA9C-9DB0-4A96-B47E-30470764CC9C}.Release|Any CPU.ActiveCfg = Release|Any CPU
{3FCBCA9C-9DB0-4A96-B47E-30470764CC9C}.Release|Any CPU.Build.0 = Release|Any CPU
{1E874C8F-08A2-493B-8421-619F9A6E9E77}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{1E874C8F-08A2-493B-8421-619F9A6E9E77}.Debug|Any CPU.Build.0 = Debug|Any CPU
{1E874C8F-08A2-493B-8421-619F9A6E9E77}.Release|Any CPU.ActiveCfg = Release|Any CPU
{1E874C8F-08A2-493B-8421-619F9A6E9E77}.Release|Any CPU.Build.0 = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
@@ -386,6 +398,8 @@ Global
{1F80A6E6-D146-4E40-9EA8-49DB8494239F} = {985E0ADB-D4B4-473A-AA40-567E279B7946}
{BBA332C6-28A9-42E7-9C4D-A0816E52A198} = {0BB8B634-407A-4610-A91F-11586990767A}
{B6269AAC-170A-4346-8B9A-444DED3D9A45} = {8F890C6F-9ACC-438D-928A-AD61CDA862F2}
{3FCBCA9C-9DB0-4A96-B47E-30470764CC9C} = {0BB8B634-407A-4610-A91F-11586990767A}
{1E874C8F-08A2-493B-8421-619F9A6E9E77} = {8F890C6F-9ACC-438D-928A-AD61CDA862F2}
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
SolutionGuid = {DC539027-9852-430C-B19F-FD035D018458}

10
src/WireMock.Net.Extensions.Routing/Delegates/WireMockHttpRequestHandler.cs Normal file
View File

@@ -0,0 +1,10 @@
// Copyright © WireMock.Net
namespace WireMock.Net.Extensions.Routing.Delegates;
/// <summary>
/// Represents a handler for processing WireMock.Net HTTP requests and returning a response asynchronously.
/// </summary>
/// <param name="requestMessage">The incoming request message.</param>
/// <returns>A task that resolves to a <see cref="ResponseMessage"/>.</returns>
public delegate Task<ResponseMessage> WireMockHttpRequestHandler(IRequestMessage requestMessage);

10
src/WireMock.Net.Extensions.Routing/Delegates/WireMockMiddleware.cs Normal file
View File

@@ -0,0 +1,10 @@
// Copyright © WireMock.Net
namespace WireMock.Net.Extensions.Routing.Delegates;
/// <summary>
/// Represents a middleware component for WireMock.Net HTTP request handling.
/// </summary>
/// <param name="next">The next request handler in the middleware pipeline.</param>
/// <returns>A <see cref="WireMockHttpRequestHandler"/> that processes the request.</returns>
public delegate WireMockHttpRequestHandler WireMockMiddleware(WireMockHttpRequestHandler next);

19
src/WireMock.Net.Extensions.Routing/Extensions/DictionaryExtensions.cs Normal file
View File

@@ -0,0 +1,19 @@
// Copyright © WireMock.Net
using System.Collections.Immutable;
namespace WireMock.Net.Extensions.Routing.Extensions;
internal static class DictionaryExtensions
{
public static IDictionary<TKey, TValue> AddIf<TKey, TValue>(
this IDictionary<TKey, TValue> source,
bool condition,
TKey key,
TValue value,
IEqualityComparer<TKey>? keyComparer = null)
where TKey : notnull =>
condition
? source.ToImmutableDictionary(keyComparer).Add(key, value)
: source;
}

34
src/WireMock.Net.Extensions.Routing/Extensions/HttpResponseExtensions.cs Normal file
View File

@@ -0,0 +1,34 @@
// Copyright © WireMock.Net
using Microsoft.AspNetCore.Http;
using WireMock.Types;
using WireMock.Util;
namespace WireMock.Net.Extensions.Routing.Extensions;
internal static class HttpResponseExtensions
{
public static async Task<ResponseMessage> ToResponseMessageAsync(
this HttpResponse response)
{
var headers = response.Headers.ToDictionary(
header => header.Key, header => new WireMockList<string?>(header.Value.ToArray()));
return new()
{
Headers = headers!,
BodyData = new BodyData
{
DetectedBodyType = BodyType.String,
BodyAsString = await response.ReadBodyAsStringAsync(),
},
StatusCode = response.StatusCode,
};
}
public static async Task<string> ReadBodyAsStringAsync(this HttpResponse response)
{
response.Body.Seek(0, SeekOrigin.Begin);
using var reader = new StreamReader(response.Body);
return await reader.ReadToEndAsync();
}
}

16
src/WireMock.Net.Extensions.Routing/Extensions/RequestMessageExtensions.cs Normal file
View File

@@ -0,0 +1,16 @@
// Copyright © WireMock.Net
using JsonConverter.Abstractions;
namespace WireMock.Net.Extensions.Routing.Extensions;
internal static class RequestMessageExtensions
{
public static T? GetBodyAsJson<T>(
this IRequestMessage requestMessage,
IJsonConverter jsonConverter,
JsonConverterOptions? jsonOptions = null) =>
requestMessage.Body is not null
? jsonConverter.Deserialize<T>(requestMessage.Body, jsonOptions)
: default;
}

9
src/WireMock.Net.Extensions.Routing/Extensions/StringExtensions.cs Normal file
View File

@@ -0,0 +1,9 @@
// Copyright © WireMock.Net
namespace WireMock.Net.Extensions.Routing.Extensions;
internal static class StringExtensions
{
public static string ToMatchFullStringRegex(this string regex) =>
$"^{regex}$";
}

39
src/WireMock.Net.Extensions.Routing/Extensions/TaskExtensions.cs Normal file
View File

@@ -0,0 +1,39 @@
// Copyright © WireMock.Net
using System.Reflection;
namespace WireMock.Net.Extensions.Routing.Extensions;
internal static class TaskExtensions
{
[System.Diagnostics.CodeAnalysis.SuppressMessage(
"Usage",
"VSTHRD003:Avoid awaiting foreign Tasks",
Justification = "Await is required here to transform base task to generic one.")]
public static async Task<object?> ToGenericTaskAsync(this Task task)
{
await task;
var taskType = task.GetType();
if (!IsAssignableToGenericTaskType(taskType))
{
return null;
}
return task
.GetType()
.GetProperty("Result", BindingFlags.Instance | BindingFlags.Public)!
.GetValue(task);
}
private static bool IsAssignableToGenericTaskType(Type type)
{
if (type.IsGenericType &&
type.GetGenericTypeDefinition() == typeof(Task<>) &&
type.GetGenericArguments()[0] != Type.GetType("System.Threading.Tasks.VoidTaskResult"))
{
return true;
}
return type.BaseType is not null && IsAssignableToGenericTaskType(type.BaseType);
}
}

17
src/WireMock.Net.Extensions.Routing/Extensions/WireMockHttpRequestHandlerExtensions.cs Normal file
View File

@@ -0,0 +1,17 @@
// Copyright © WireMock.Net
using WireMock.Net.Extensions.Routing.Delegates;
namespace WireMock.Net.Extensions.Routing.Extensions;
internal static class WireMockHttpRequestHandlerExtensions
{
public static WireMockHttpRequestHandler UseMiddleware(
this WireMockHttpRequestHandler handler, WireMockMiddleware middleware) =>
middleware(handler);
public static WireMockHttpRequestHandler UseMiddlewareCollection(
this WireMockHttpRequestHandler handler,
IReadOnlyCollection<WireMockMiddleware> middlewareCollection) =>
middlewareCollection.Aggregate(handler, UseMiddleware);
}

224
src/WireMock.Net.Extensions.Routing/Extensions/WireMockRouterExtensions.cs Normal file
View File

@@ -0,0 +1,224 @@
// Copyright © WireMock.Net
using JsonConverter.Abstractions;
using WireMock.Net.Extensions.Routing.Models;
namespace WireMock.Net.Extensions.Routing.Extensions;
/// <summary>
/// Provides extension methods for mapping HTTP routes to handlers in <see cref="WireMockRouter"/>.
/// </summary>
public static class WireMockRouterExtensions
{
/// <summary>
/// Maps a GET request to a synchronous request handler.
/// </summary>
/// <param name="source">The router to extend.</param>
/// <param name="pattern">The route pattern.</param>
/// <param name="requestHandler">The request handler function.</param>
/// <returns>The current <see cref="WireMockRouter"/> instance.</returns>
public static WireMockRouter MapGet(
this WireMockRouter source,
string pattern,
Func<WireMockRequestInfo, object?> requestHandler) =>
source.Map(HttpMethod.Get.Method, pattern, requestHandler);
/// <summary>
/// Maps a GET request to an asynchronous request handler.
/// </summary>
/// <param name="source">The router to extend.</param>
/// <param name="pattern">The route pattern.</param>
/// <param name="requestHandler">The asynchronous request handler function.</param>
/// <returns>The current <see cref="WireMockRouter"/> instance.</returns>
public static WireMockRouter MapGet(
this WireMockRouter source,
string pattern,
Func<WireMockRequestInfo, Task<object?>> requestHandler) =>
source.Map(HttpMethod.Get.Method, pattern, requestHandler);
/// <summary>
/// Maps a POST request to a synchronous request handler.
/// </summary>
/// <param name="source">The router to extend.</param>
/// <param name="pattern">The route pattern.</param>
/// <param name="requestHandler">The request handler function.</param>
/// <returns>The current <see cref="WireMockRouter"/> instance.</returns>
public static WireMockRouter MapPost(
this WireMockRouter source,
string pattern,
Func<WireMockRequestInfo, object?> requestHandler) =>
source.Map(HttpMethod.Post.Method, pattern, requestHandler);
/// <summary>
/// Maps a POST request to an asynchronous request handler.
/// </summary>
/// <param name="source">The router to extend.</param>
/// <param name="pattern">The route pattern.</param>
/// <param name="requestHandler">The asynchronous request handler function.</param>
/// <returns>The current <see cref="WireMockRouter"/> instance.</returns>
public static WireMockRouter MapPost(
this WireMockRouter source,
string pattern,
Func<WireMockRequestInfo, Task<object?>> requestHandler) =>
source.Map(HttpMethod.Post.Method, pattern, requestHandler);
/// <summary>
/// Maps a POST request to a synchronous request handler with a typed body.
/// </summary>
/// <typeparam name="TRequest">The type of the request body.</typeparam>
/// <param name="source">The router to extend.</param>
/// <param name="pattern">The route pattern.</param>
/// <param name="requestHandler">The request handler function.</param>
/// <param name="jsonConverter">The <see cref="IJsonConverter"/> [optional]. Default value is NewtonsoftJsonConverter.</param>
/// <param name="jsonOptions">The <see cref="JsonConverterOptions"/> [optional].</param>
/// <returns>The current <see cref="WireMockRouter"/> instance.</returns>
public static WireMockRouter MapPost<TRequest>(
this WireMockRouter source,
string pattern,
Func<WireMockRequestInfo<TRequest>, object?> requestHandler,
IJsonConverter? jsonConverter = null,
JsonConverterOptions? jsonOptions = null) =>
source.Map(HttpMethod.Post.Method, pattern, requestHandler, jsonConverter, jsonOptions);
/// <summary>
/// Maps a POST request to an asynchronous request handler with a typed body.
/// </summary>
/// <typeparam name="TRequest">The type of the request body.</typeparam>
/// <param name="source">The router to extend.</param>
/// <param name="pattern">The route pattern.</param>
/// <param name="requestHandler">The asynchronous request handler function.</param>
/// <param name="jsonConverter">The <see cref="IJsonConverter"/> [optional]. Default value is NewtonsoftJsonConverter.</param>
/// <param name="jsonOptions">The <see cref="JsonConverterOptions"/> [optional].</param>
/// <returns>The current <see cref="WireMockRouter"/> instance.</returns>
public static WireMockRouter MapPost<TRequest>(
this WireMockRouter source,
string pattern,
Func<WireMockRequestInfo<TRequest>, Task<object?>> requestHandler,
IJsonConverter? jsonConverter = null,
JsonConverterOptions? jsonOptions = null) =>
source.Map(HttpMethod.Post.Method, pattern, requestHandler, jsonConverter, jsonOptions);
/// <summary>
/// Maps a PUT request to a synchronous request handler.
/// </summary>
/// <param name="source">The router to extend.</param>
/// <param name="pattern">The route pattern.</param>
/// <param name="requestHandler">The request handler function.</param>
/// <returns>The current <see cref="WireMockRouter"/> instance.</returns>
public static WireMockRouter MapPut(
this WireMockRouter source,
string pattern,
Func<WireMockRequestInfo, object?> requestHandler) =>
source.Map(HttpMethod.Put.Method, pattern, requestHandler);
/// <summary>
/// Maps a PUT request to an asynchronous request handler.
/// </summary>
/// <param name="source">The router to extend.</param>
/// <param name="pattern">The route pattern.</param>
/// <param name="requestHandler">The asynchronous request handler function.</param>
/// <returns>The current <see cref="WireMockRouter"/> instance.</returns>
public static WireMockRouter MapPut(
this WireMockRouter source,
string pattern,
Func<WireMockRequestInfo, Task<object?>> requestHandler) =>
source.Map(HttpMethod.Put.Method, pattern, requestHandler);
/// <summary>
/// Maps a PUT request to a synchronous request handler with a typed body.
/// </summary>
/// <typeparam name="TRequest">The type of the request body.</typeparam>
/// <param name="source">The router to extend.</param>
/// <param name="pattern">The route pattern.</param>
/// <param name="requestHandler">The request handler function.</param>
/// <param name="jsonConverter">The <see cref="IJsonConverter"/> [optional]. Default value is NewtonsoftJsonConverter.</param>
/// <param name="jsonOptions">The <see cref="JsonConverterOptions"/> [optional].</param>
/// <returns>The current <see cref="WireMockRouter"/> instance.</returns>
public static WireMockRouter MapPut<TRequest>(
this WireMockRouter source,
string pattern,
Func<WireMockRequestInfo<TRequest>, object?> requestHandler,
IJsonConverter? jsonConverter = null,
JsonConverterOptions? jsonOptions = null) =>
source.Map(HttpMethod.Put.Method, pattern, requestHandler, jsonConverter, jsonOptions);
/// <summary>
/// Maps a PUT request to an asynchronous request handler with a typed body.
/// </summary>
/// <typeparam name="TRequest">The type of the request body.</typeparam>
/// <param name="source">The router to extend.</param>
/// <param name="pattern">The route pattern.</param>
/// <param name="requestHandler">The asynchronous request handler function.</param>
/// <param name="jsonConverter">The <see cref="IJsonConverter"/> [optional]. Default value is NewtonsoftJsonConverter.</param>
/// <param name="jsonOptions">The <see cref="JsonConverterOptions"/> [optional].</param>
/// <returns>The current <see cref="WireMockRouter"/> instance.</returns>
public static WireMockRouter MapPut<TRequest>(
this WireMockRouter source,
string pattern,
Func<WireMockRequestInfo<TRequest>, Task<object?>> requestHandler,
IJsonConverter? jsonConverter = null,
JsonConverterOptions? jsonOptions = null) =>
source.Map(HttpMethod.Put.Method, pattern, requestHandler, jsonConverter, jsonOptions);
/// <summary>
/// Maps a DELETE request to a synchronous request handler.
/// </summary>
/// <param name="source">The router to extend.</param>
/// <param name="pattern">The route pattern.</param>
/// <param name="requestHandler">The request handler function.</param>
/// <returns>The current <see cref="WireMockRouter"/> instance.</returns>
public static WireMockRouter MapDelete(
this WireMockRouter source,
string pattern,
Func<WireMockRequestInfo, object?> requestHandler) =>
source.Map(HttpMethod.Delete.Method, pattern, requestHandler);
/// <summary>
/// Maps a DELETE request to an asynchronous request handler.
/// </summary>
/// <param name="source">The router to extend.</param>
/// <param name="pattern">The route pattern.</param>
/// <param name="requestHandler">The asynchronous request handler function.</param>
/// <returns>The current <see cref="WireMockRouter"/> instance.</returns>
public static WireMockRouter MapDelete(
this WireMockRouter source,
string pattern,
Func<WireMockRequestInfo, Task<object?>> requestHandler) =>
source.Map(HttpMethod.Delete.Method, pattern, requestHandler);
/// <summary>
/// Maps a DELETE request to a synchronous request handler with a typed body.
/// </summary>
/// <typeparam name="TRequest">The type of the request body.</typeparam>
/// <param name="source">The router to extend.</param>
/// <param name="pattern">The route pattern.</param>
/// <param name="requestHandler">The request handler function.</param>
/// <param name="jsonConverter">The <see cref="IJsonConverter"/> [optional]. Default value is NewtonsoftJsonConverter.</param>
/// <param name="jsonOptions">The <see cref="JsonConverterOptions"/> [optional].</param>
/// <returns>The current <see cref="WireMockRouter"/> instance.</returns>
public static WireMockRouter MapDelete<TRequest>(
this WireMockRouter source,
string pattern,
Func<WireMockRequestInfo<TRequest>, object?> requestHandler,
IJsonConverter? jsonConverter = null,
JsonConverterOptions? jsonOptions = null) =>
source.Map(HttpMethod.Delete.Method, pattern, requestHandler, jsonConverter, jsonOptions);
/// <summary>
/// Maps a DELETE request to an asynchronous request handler with a typed body.
/// </summary>
/// <typeparam name="TRequest">The type of the request body.</typeparam>
/// <param name="source">The router to extend.</param>
/// <param name="pattern">The route pattern.</param>
/// <param name="requestHandler">The asynchronous request handler function.</param>
/// <param name="jsonConverter">The <see cref="IJsonConverter"/> [optional]. Default value is NewtonsoftJsonConverter.</param>
/// <param name="jsonOptions">The <see cref="JsonConverterOptions"/> [optional].</param>
/// <returns>The current <see cref="WireMockRouter"/> instance.</returns>
public static WireMockRouter MapDelete<TRequest>(
this WireMockRouter source,
string pattern,
Func<WireMockRequestInfo<TRequest>, Task<object?>> requestHandler,
IJsonConverter? jsonConverter = null,
JsonConverterOptions? jsonOptions = null) =>
source.Map(HttpMethod.Delete.Method, pattern, requestHandler, jsonConverter, jsonOptions);
}

35
src/WireMock.Net.Extensions.Routing/Extensions/WireMockServerExtensions.cs Normal file
View File

@@ -0,0 +1,35 @@
// Copyright © WireMock.Net
using WireMock.Matchers;
using WireMock.Net.Extensions.Routing.Delegates;
using WireMock.RequestBuilders;
using WireMock.ResponseBuilders;
using WireMock.Server;
namespace WireMock.Net.Extensions.Routing.Extensions;
/// <summary>
/// Provides extension methods for mapping HTTP requests to handlers in <see cref="WireMockServer"/>.
/// </summary>
public static class WireMockServerExtensions
{
/// <summary>
/// Maps a request to a WireMock.Net server using the specified method, path matcher, and request handler.
/// </summary>
/// <param name="source">The WireMock.Net server to extend.</param>
/// <param name="method">The HTTP method to match.</param>
/// <param name="pathMatcher">The matcher for the request path.</param>
/// <param name="httpRequestHandler">The handler to process the request.</param>
/// <returns>The current <see cref="WireMockServer"/> instance.</returns>
public static WireMockServer Map(
this WireMockServer source,
string method,
IStringMatcher pathMatcher,
WireMockHttpRequestHandler httpRequestHandler)
{
source
.Given(Request.Create().WithPath(pathMatcher).UsingMethod(method))
.RespondWith(Response.Create().WithCallback(req => httpRequestHandler(req)));
return source;
}
}

29
src/WireMock.Net.Extensions.Routing/Models/WireMockRequestInfo.cs Normal file
View File

@@ -0,0 +1,29 @@
// Copyright © WireMock.Net
namespace WireMock.Net.Extensions.Routing.Models;
/// <summary>
/// Represents request information for WireMock.Net routing, including the request message and route arguments.
/// </summary>
public class WireMockRequestInfo
{
/// <summary>
/// Initializes a new instance of the <see cref="WireMockRequestInfo"/> class.
/// </summary>
/// <param name="request">The incoming request message.</param>
public WireMockRequestInfo(IRequestMessage request)
{
Request = request;
}
/// <summary>
/// Gets the incoming request message.
/// </summary>
public IRequestMessage Request { get; }
/// <summary>
/// Gets or initializes the route arguments extracted from the request path.
/// </summary>
public IDictionary<string, object> RouteArgs { get; init; } =
new Dictionary<string, object>();
}

24
src/WireMock.Net.Extensions.Routing/Models/WireMockRequestInfo{TBody}.cs Normal file
View File

@@ -0,0 +1,24 @@
// Copyright © WireMock.Net
namespace WireMock.Net.Extensions.Routing.Models;
/// <summary>
/// Represents request information with a strongly-typed deserialized body for WireMock.Net routing.
/// </summary>
/// <typeparam name="TBody">The type of the deserialized request body.</typeparam>
public sealed class WireMockRequestInfo<TBody> : WireMockRequestInfo
{
/// <summary>
/// Initializes a new instance of the <see cref="WireMockRequestInfo{TBody}"/> class.
/// </summary>
/// <param name="request">The incoming request message.</param>
public WireMockRequestInfo(IRequestMessage request)
: base(request)
{
}
/// <summary>
/// Gets or initializes the deserialized request body.
/// </summary>
public TBody? Body { get; init; }
}

138
src/WireMock.Net.Extensions.Routing/README.md Normal file
View File

@@ -0,0 +1,138 @@
# WireMock.Net.Extensions.Routing
**WireMock.Net.Extensions.Routing** extends [WireMock.Net](https://github.com/wiremock/wiremock) with modern, minimal-API-style routing for .NET. It provides extension methods for expressive, maintainable, and testable HTTP routing, inspired by [ASP.NET Core Minimal APIs](https://learn.microsoft.com/en-us/aspnet/core/fundamentals/minimal-apis?view=aspnetcore-9.0).
---
## Motivation
While [WireMock.Net](https://github.com/WireMock-Net/WireMock.Net) is a powerful tool for HTTP mocking in .NET, its native API for defining routes and request handlers can be verbose and require significant boilerplate. Setting up even simple endpoints often involves multiple chained method calls, manual parsing of request data, and repetitive configuration, which can make tests harder to read and maintain.
**WireMock.Net.Extensions.Routing** addresses these pain points by introducing a concise, fluent, and minimal-API-inspired approach to routing. This makes your test code:
- **More readable:** Route definitions are clear and expressive, closely resembling production minimal APIs.
- **Easier to maintain:** Less boilerplate means fewer places for errors and easier refactoring.
- **Faster to write:** Define routes and handlers in a single line, with strong typing and async support.
### Example: Native WireMock.Net vs. WireMock.Net.Extensions.Routing
#### Native WireMock.Net
```csharp
server.Given(
Request.Create().WithPath("/hello").UsingGet()
)
.RespondWith(
Response.Create().WithBody("Hello, world!")
);
server.Given(
Request.Create().WithPath("/user/*").UsingGet()
)
.RespondWith(
Response.Create().WithCallback(request =>
{
var id = request.PathSegments[1];
// ...fetch user by id...
return new ResponseMessage { Body = $"User: {id}" };
})
);
```
#### With WireMock.Net.Extensions.Routing
```csharp
router.MapGet("/hello", _ => "Hello, world!");
router.MapGet("/user/{id:int}", requestInfo =>
{
var id = requestInfo.RouteArgs["id"];
// ...fetch user by id...
return $"User: {id}";
});
```
With **WireMock.Net.Extensions.Routing**, you get:
- Minimal, one-line route definitions
- Typed route parameters (e.g., `{id:int}`)
- Direct access to parsed route arguments and request bodies
- Async handler support
This leads to more maintainable, scalable, and production-like test code.
---
## Features
- Minimal API-style route definitions for WireMock.Net
- Strongly-typed request handling
- Routing parameters with constraints (`int` and `string` are currently supported)
- Asynchronous handlers
- Fluent, composable routing extensions
- Easy integration with existing WireMock.Net servers
- .NET 8+ support
---
## Installation
Install from NuGet:
```shell
dotnet add package WireMock.Net.Extensions.Routing
```
---
## Quick Start
```csharp
using System.Net.Http.Json;
using WireMock.Net.Extensions.Routing;
using WireMock.Net.Extensions.Routing.Extensions;
using WireMock.Server;
var server = WireMockServer.Start();
var router = new WireMockRouter(server);
router.MapGet("/hello", _ => "Hello, world!");
using var client = server.CreateClient();
var result = await client.GetFromJsonAsync<string>("/hello");
// Hello, world!
```
---
## Usage
### Routing with route parameters
```csharp
router.MapGet("/user/{id:int}", async requestInfo => {
var userId = requestInfo.RouteArgs["id"];
// var user = await ...
return user;
});
```
### Strongly-Typed Request Info
```csharp
router.MapPost<Item>("/api/items", requestInfo => {
var item = requestInfo.Body!;
// process item
return Results.Json(new { success = true });
});
```
### Supported Methods
- `MapGet`, `MapPost`, `MapPut`, `MapDelete`
---
## Documentation
- [API Reference](./src/WireMock.Net.Extensions.Routing/)
- [WireMock.Net Documentation](https://github.com/WireMock-Net/WireMock.Net)

107
src/WireMock.Net.Extensions.Routing/Utils/RoutePattern.cs Normal file
View File

@@ -0,0 +1,107 @@
// Copyright © WireMock.Net
using System.Diagnostics.CodeAnalysis;
using System.Reflection;
using System.Text.RegularExpressions;
using WireMock.Net.Extensions.Routing.Extensions;
namespace WireMock.Net.Extensions.Routing.Utils;
internal static class RoutePattern
{
private static readonly Regex ArgRegex =
new(@"{(?'name'\w+)(?::(?'type'\w+))?}", RegexOptions.Compiled);
public static IDictionary<string, object> GetArgs(string pattern, string route) =>
TryGetArgs(pattern, route, out var args)
? args
: throw new InvalidOperationException(
$"Url {route} does not match route pattern {pattern}");
public static bool TryGetArgs(
string pattern, string route, [NotNullWhen(true)] out IDictionary<string, object>? args)
{
var regex = new Regex(ToRegex(pattern), RegexOptions.IgnoreCase);
var match = regex.Match(route);
if (!match.Success)
{
args = null;
return false;
}
var routeArgTypeMap = GetArgTypeMap(pattern);
args = match.Groups
.Cast<Group>()
.Where(g => g.Index > 0)
.ToDictionary(g => g.Name, g => routeArgTypeMap[g.Name].Parse(g.Value));
return true;
}
public static string ToRegex(string pattern)
{
return ArgRegex
.Replace(pattern, m => $"(?'{m.Groups["name"].Value}'{GetArgMatchingRegex(m)})")
.ToMatchFullStringRegex();
static string GetArgMatchingRegex(Match match) =>
ArgType.GetByName(match.Groups["type"].Value).GetRegex();
}
private static IDictionary<string, ArgType> GetArgTypeMap(string pattern) =>
ArgRegex
.Matches(pattern)
.ToDictionary(
m => m.Groups["name"].Value, m => ArgType.GetByName(m.Groups["type"].Value));
private abstract record ArgType
{
private ArgType(string name)
{
Name = name;
}
public string Name { get; }
public static ArgType String { get; } = new StringArgType();
public static ArgType Int { get; } = new IntArgType();
private static IReadOnlyCollection<ArgType> All { get; } =
typeof(ArgType)
.GetProperties(BindingFlags.Public | BindingFlags.Static)
.Where(p => p.PropertyType.IsAssignableTo(typeof(ArgType)))
.Select(p => p.GetValue(null))
.Cast<ArgType>()
.ToList();
private static IReadOnlyDictionary<string, ArgType> MapByName { get; } =
All.ToDictionary(x => x.Name);
public static ArgType GetByName(string name) =>
GetByNameOrDefault(name)
?? throw new InvalidOperationException($"Route argument type {name} is not found");
public static ArgType? GetByNameOrDefault(string name) =>
!string.IsNullOrEmpty(name)
? MapByName.GetValueOrDefault(name)
: String;
public abstract object Parse(string input);
public abstract string GetRegex();
private sealed record StringArgType() : ArgType("string")
{
public override object Parse(string input) => input;
public override string GetRegex() => @".*";
}
private sealed record IntArgType() : ArgType("int")
{
public override object Parse(string input) => int.Parse(input);
public override string GetRegex() => @"-?\d+";
}
}
}

30
src/WireMock.Net.Extensions.Routing/WireMock.Net.Extensions.Routing.csproj Normal file
View File

@@ -0,0 +1,30 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<Description>WireMock.Net.Routing extends WireMock.Net with modern, minimal-API-style routing for .NET</Description>
<Authors>Gennadii Saltyshchak</Authors>
<TargetFrameworks>net8.0</TargetFrameworks>
<GenerateDocumentationFile>true</GenerateDocumentationFile>
<PackageTags>tdd;mock;http;wiremock;test;server;unittest;routing;minimalapi</PackageTags>
<PublishRepositoryUrl>true</PublishRepositoryUrl>
<AllowedOutputExtensionsInPackageBuildOutputFolder>$(AllowedOutputExtensionsInPackageBuildOutputFolder);.pdb</AllowedOutputExtensionsInPackageBuildOutputFolder>
<EmbedUntrackedSources>true</EmbedUntrackedSources>
<SignAssembly>true</SignAssembly>
<AssemblyOriginatorKeyFile>../WireMock.Net/WireMock.Net.snk</AssemblyOriginatorKeyFile>
<PublicSign Condition=" '$(OS)' != 'Windows_NT' ">true</PublicSign>
<PackageReadmeFile>README.md</PackageReadmeFile>
<ImplicitUsings>enable</ImplicitUsings>
<TreatWarningsAsErrors>true</TreatWarningsAsErrors>
</PropertyGroup>
<ItemGroup>
<None Include="..\..\README.md" Link="README.md" Pack="true" PackagePath="" />
</ItemGroup>
<ItemGroup>
<PackageReference Include="JsonConverter.Newtonsoft.Json" Version="0.7.0" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\WireMock.Net.Minimal\WireMock.Net.Minimal.csproj" />
</ItemGroup>
</Project>

153
src/WireMock.Net.Extensions.Routing/WireMockRouter.cs Normal file
View File

@@ -0,0 +1,153 @@
// Copyright © WireMock.Net
using JsonConverter.Abstractions;
using JsonConverter.Newtonsoft.Json;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;
using WireMock.Matchers;
using WireMock.Net.Extensions.Routing.Delegates;
using WireMock.Net.Extensions.Routing.Extensions;
using WireMock.Net.Extensions.Routing.Models;
using WireMock.Net.Extensions.Routing.Utils;
using WireMock.Server;
namespace WireMock.Net.Extensions.Routing;
/// <summary>
/// Provides routing and request mapping functionality for WireMock.Net,
/// mimicking ASP.NET Core Minimal APIs routing style.
/// </summary>
/// <remarks>
/// Initializes a new instance of the <see cref="WireMockRouter"/> class.
/// </remarks>
/// <param name="server">The WireMock.Net server instance.</param>
public sealed class WireMockRouter(WireMockServer server)
{
private readonly WireMockServer _server = server;
/// <summary>
/// Gets or initializes the collection of middleware for the router.
/// </summary>
public IReadOnlyCollection<WireMockMiddleware> MiddlewareCollection { get; init; } = [];
/// <summary>
/// Gets or initializes the default <see cref="IJsonConverter"/> [optional].
/// </summary>
public IJsonConverter? DefaultJsonConverter { get; init; }
/// <summary>
/// Gets or initializes the default <see cref="JsonConverterOptions"/> [optional].
/// </summary>
public JsonConverterOptions? DefaultJsonOptions { get; init; }
/// <summary>
/// Maps a route to a synchronous request handler.
/// </summary>
/// <param name="method">The HTTP method.</param>
/// <param name="pattern">The route pattern.</param>
/// <param name="requestHandler">The request handler function.</param>
/// <returns>The current <see cref="WireMockRouter"/> instance.</returns>
public WireMockRouter Map(
string method, string pattern, Func<WireMockRequestInfo, object?> requestHandler)
{
return Map(method, pattern, CreateResponse);
object? CreateResponse(IRequestMessage request) =>
requestHandler(CreateRequestInfo(request, pattern));
}
/// <summary>
/// Maps a route to an asynchronous request handler.
/// </summary>
/// <param name="method">The HTTP method.</param>
/// <param name="pattern">The route pattern.</param>
/// <param name="requestHandler">The asynchronous request handler function.</param>
/// <returns>The current <see cref="WireMockRouter"/> instance.</returns>
public WireMockRouter Map(
string method, string pattern, Func<WireMockRequestInfo, Task<object?>> requestHandler)
{
return Map(method, pattern, CreateResponseAsync);
Task<object?> CreateResponseAsync(IRequestMessage request) =>
requestHandler(CreateRequestInfo(request, pattern));
}
/// <summary>
/// Maps a route to a request handler with a typed body.
/// </summary>
/// <typeparam name="TRequest">The type of the request body.</typeparam>
/// <param name="method">The HTTP method.</param>
/// <param name="pattern">The route pattern.</param>
/// <param name="requestHandler">The request handler function.</param>
/// <param name="jsonConverter">The <see cref="IJsonConverter"/> [optional]. Default value is NewtonsoftJsonConverter.</param>
/// <param name="jsonOptions">The <see cref="JsonConverterOptions"/> [optional].</param>
/// <returns>The current <see cref="WireMockRouter"/> instance.</returns>
public WireMockRouter Map<TRequest>(
string method,
string pattern,
Func<WireMockRequestInfo<TRequest>, object?> requestHandler,
IJsonConverter? jsonConverter = null,
JsonConverterOptions? jsonOptions = null)
{
return Map(method, pattern, CreateBody);
object? CreateBody(IRequestMessage request) =>
requestHandler(CreateRequestInfo<TRequest>(request, pattern, jsonConverter, jsonOptions));
}
private static WireMockRequestInfo CreateRequestInfo(IRequestMessage request, string pattern) =>
new(request)
{
RouteArgs = RoutePattern.GetArgs(pattern, request.Path),
};
private static WireMockHttpRequestHandler CreateHttpRequestHandler(
Func<IRequestMessage, object?> requestHandler) =>
request => CreateResponseMessageAsync(requestHandler(request));
private static async Task<ResponseMessage> CreateResponseMessageAsync(object? response)
{
var awaitedResponse = response is Task task
? await task.ToGenericTaskAsync()
: response;
var result = awaitedResponse as IResult ?? Results.Ok(awaitedResponse);
var httpContext = CreateHttpContext();
await result.ExecuteAsync(httpContext);
return await httpContext.Response.ToResponseMessageAsync();
}
private static HttpContext CreateHttpContext() =>
new DefaultHttpContext
{
RequestServices = new ServiceCollection().AddLogging().BuildServiceProvider(),
Response = { Body = new MemoryStream() },
};
private WireMockRequestInfo<TRequest> CreateRequestInfo<TRequest>(
IRequestMessage request,
string pattern,
IJsonConverter? jsonConverter = null,
JsonConverterOptions? jsonOptions = null)
{
var requestInfo = CreateRequestInfo(request, pattern);
var establishedJsonConverter =
jsonConverter ?? DefaultJsonConverter ?? new NewtonsoftJsonConverter();
var establishedJsonOptions = jsonOptions ?? DefaultJsonOptions;
return new WireMockRequestInfo<TRequest>(requestInfo.Request)
{
RouteArgs = requestInfo.RouteArgs,
Body = requestInfo.Request.GetBodyAsJson<TRequest>(
establishedJsonConverter, establishedJsonOptions),
};
}
private WireMockRouter Map(
string method, string pattern, Func<IRequestMessage, object?> requestHandler)
{
var matcher = new RegexMatcher(RoutePattern.ToRegex(pattern), ignoreCase: true);
var httpRequestHandler =
CreateHttpRequestHandler(requestHandler).UseMiddlewareCollection(MiddlewareCollection);
_server.Map(method, matcher, httpRequestHandler);
return this;
}
}

73
src/WireMock.Net.Extensions.Routing/WireMockServerRouterBuilder.cs Normal file
View File

@@ -0,0 +1,73 @@
// Copyright © WireMock.Net
using System.Collections.Concurrent;
using JsonConverter.Abstractions;
using WireMock.Net.Extensions.Routing.Delegates;
using WireMock.Server;
namespace WireMock.Net.Extensions.Routing;
/// <summary>
/// Provides a builder for configuring and creating a <see cref="WireMockRouter"/> with middleware and JSON settings.
/// </summary>
/// <remarks>
/// Initializes a new instance of the <see cref="WireMockServerRouterBuilder"/> class.
/// </remarks>
/// <param name="server">The WireMock.Net server instance.</param>
public sealed class WireMockServerRouterBuilder(WireMockServer server)
{
private readonly WireMockServer _server = server;
private readonly ConcurrentQueue<WireMockMiddleware> _middlewareCollection = new();
private IJsonConverter? _defaultJsonConverter;
private JsonConverterOptions? _defaultJsonOptions;
/// <summary>
/// Builds a <see cref="WireMockRouter"/> with the configured middleware and JSON settings.
/// </summary>
/// <returns>The configured <see cref="WireMockRouter"/>.</returns>
public WireMockRouter Build() =>
new(_server)
{
MiddlewareCollection = _middlewareCollection,
DefaultJsonConverter = _defaultJsonConverter,
DefaultJsonOptions = _defaultJsonOptions,
};
/// <summary>
/// Adds a middleware to the router builder.
/// </summary>
/// <param name="middleware">The middleware to add.</param>
/// <returns>The current <see cref="WireMockServerRouterBuilder"/> instance.</returns>
public WireMockServerRouterBuilder Use(WireMockMiddleware middleware)
{
_middlewareCollection.Enqueue(middleware);
return this;
}
/// <summary>
/// Sets the default <see cref="IJsonConverter"/>.
/// </summary>
/// <param name="defaultJsonConverter">the default <see cref="IJsonConverter"/></param>
/// <returns>The current <see cref="WireMockServerRouterBuilder"/> instance.</returns>
public WireMockServerRouterBuilder WithDefaultJsonConverter(
IJsonConverter? defaultJsonConverter)
{
_defaultJsonConverter = defaultJsonConverter;
return this;
}
/// <summary>
/// Sets the default <see cref="JsonConverterOptions"/> [optional].
/// </summary>
/// <param name="defaultJsonOptions">the default <see cref="JsonConverterOptions"/> [optional]</param>
/// <returns>The current <see cref="WireMockServerRouterBuilder"/> instance.</returns>
public WireMockServerRouterBuilder WithDefaultJsonOptions(
JsonConverterOptions? defaultJsonOptions)
{
_defaultJsonOptions = defaultJsonOptions;
return this;
}
}

100
test/WireMock.Net.Extensions.Routing.Tests/Tests/WireMockRouterTests.cs Normal file
View File

@@ -0,0 +1,100 @@
// Copyright © WireMock.Net
using System.Net.Http;
using System.Net.Http.Json;
using System.Threading.Tasks;
using AwesomeAssertions;
using WireMock.Net.Extensions.Routing.Extensions;
using WireMock.Server;
namespace WireMock.Net.Extensions.Routing.Tests.Tests;
public sealed class WireMockRouterTests
{
private const string DefaultUrlPattern = "/test";
private readonly WireMockServer _server = WireMockServer.Start();
private readonly WireMockRouter _sut;
public WireMockRouterTests()
{
_sut = new WireMockRouter(_server);
}
[Fact]
public async Task Map_ShouldReturnResultFromHandler_ForGetMethod()
{
const int handlerResult = 5;
_sut.Map(HttpMethod.Get.ToString(), DefaultUrlPattern, _ => handlerResult);
using var client = _server.CreateClient();
var result = await client.GetFromJsonAsync<int>(DefaultUrlPattern);
result.Should().Be(handlerResult);
}
[Fact]
public async Task Map_ShouldReturnResultFromAsyncHandler_ForGetMethod()
{
const int handlerResult = 5;
_sut.Map(HttpMethod.Get.ToString(), DefaultUrlPattern, _ => Task.FromResult(handlerResult));
using var client = _server.CreateClient();
var result = await client.GetFromJsonAsync<int>(DefaultUrlPattern);
result.Should().Be(handlerResult);
}
[Fact]
public async Task Map_ShouldReturnResultFromAsyncHandlerWithAwait_ForGetMethod()
{
const int handlerResult = 5;
_sut.Map(
HttpMethod.Get.ToString(),
DefaultUrlPattern,
async _ => await Task.FromResult(handlerResult));
using var client = _server.CreateClient();
var result = await client.GetFromJsonAsync<int>(DefaultUrlPattern);
result.Should().Be(handlerResult);
}
[Fact]
public async Task Map_ShouldReturnResultFromAsyncHandlerWithDelayAndAwait_ForGetMethod()
{
const int handlerResult = 5;
async Task<object?> HandleRequestAsync()
{
await Task.Delay(1);
return handlerResult;
}
_sut.Map(HttpMethod.Get.ToString(), DefaultUrlPattern, _ => HandleRequestAsync());
using var client = _server.CreateClient();
var result = await client.GetFromJsonAsync<int>(DefaultUrlPattern);
result.Should().Be(handlerResult);
}
[Fact]
public async Task MapGet_ShouldReturnResultFromAsyncHandlerWithDelayAwait()
{
const int handlerResult = 5;
async Task<object?> HandleRequestAsync()
{
await Task.Delay(1);
return handlerResult;
}
_sut.MapGet(DefaultUrlPattern, _ => HandleRequestAsync());
using var client = _server.CreateClient();
var result = await client.GetFromJsonAsync<int>(DefaultUrlPattern);
result.Should().Be(handlerResult);
}
}

37
test/WireMock.Net.Extensions.Routing.Tests/WireMock.Net.Extensions.Routing.Tests.csproj Normal file
View File

@@ -0,0 +1,37 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<Authors>Gennadii Saltyshchak</Authors>
<TargetFrameworks>net8.0</TargetFrameworks>
<Nullable>enable</Nullable>
<IsPackable>false</IsPackable>
<DebugType>full</DebugType>
<GenerateRuntimeConfigurationFiles>true</GenerateRuntimeConfigurationFiles>
<IsTestProject>true</IsTestProject>
<SonarQubeExclude>true</SonarQubeExclude>
<SignAssembly>true</SignAssembly>
<AssemblyOriginatorKeyFile>../../src/WireMock.Net/WireMock.Net.snk</AssemblyOriginatorKeyFile>
<PublicSign Condition=" '$(OS)' != 'Windows_NT' ">true</PublicSign>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="AwesomeAssertions" Version="9.1.0" />
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.1" />
<PackageReference Include="coverlet.collector" Version="6.0.4">
<PrivateAssets>all</PrivateAssets>
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
</PackageReference>
<PackageReference Include="xunit" Version="2.9.3" />
<PackageReference Include="xunit.runner.visualstudio" Version="3.1.3">
<PrivateAssets>all</PrivateAssets>
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
</PackageReference>
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\..\src\WireMock.Net.Extensions.Routing\WireMock.Net.Extensions.Routing.csproj" />
</ItemGroup>
<ItemGroup>
<Using Include="Xunit" />
</ItemGroup>
</Project>