1.9.0

* Create new project for GraphQL

* ...

* .

* ok?

* Update src/WireMock.Net.Shared/Extensions/AnyOfExtensions.cs

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* --

* ...

---------

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

.github/ISSUE_TEMPLATE/feature_request.md

@@ -8,7 +8,7 @@ assignees: ''
 ---
 
 **Is your feature request related to a problem? Please describe.**
-A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+A clear and concise description of what the problem is.
 
 **Describe the solution you'd like**
 A clear and concise description of what you want to happen.
@@ -17,7 +17,7 @@ A clear and concise description of what you want to happen.
 A clear and concise description of any alternative solutions or features you've considered.
 
 **Is your feature request supported by [WireMock (java version)](https://www.wiremock.org)? Please provide details.**
-Provide relevant information if requested feature is supported in [Handlebarsjs](https://handlebarsjs.com/) but is missing in our implementation.
+Provide relevant information if requested feature is supported but is missing in this implementation.
 
 **Additional context**
 Add any other context or screenshots about the feature request here.

CHANGELOG.md

@@ -1,3 +1,32 @@
+# 1.9.0 (10 August 2025)
+- [#1334](https://github.com/wiremock/WireMock.Net/pull/1334) - Create GraphQL project [feature] contributed by [StefH](https://github.com/StefH)
+
+# 1.8.18 (04 August 2025)
+- [#1339](https://github.com/wiremock/WireMock.Net/pull/1339) - Fixes an issue with matching JSON bodies as bytes [bug] contributed by [smfields](https://github.com/smfields)
+- [#1338](https://github.com/wiremock/WireMock.Net/issues/1338) - Specifying .WithBody(byte[]) fails to match for JSON bodies [bug]
+
+# 1.8.17 (23 July 2025)
+- [#1337](https://github.com/wiremock/WireMock.Net/pull/1337) - Make CSharpCodeMatcher public [bug] contributed by [StefH](https://github.com/StefH)
+- [#1336](https://github.com/wiremock/WireMock.Net/issues/1336) - Is CSharpCodeMatcher actually usable? [bug]
+
+# 1.8.16 (19 July 2025)
+- [#1332](https://github.com/wiremock/WireMock.Net/pull/1332) - Use correct Handlebars.Net.Helpers.Xslt (2.5.2) [bug] contributed by [StefH](https://github.com/StefH)
+- [#1328](https://github.com/wiremock/WireMock.Net/issues/1328) - ReflectionTypeLoadException occurs when running multiple unit tests (Nunit 3) [bug]
+
+# 1.8.15 (18 July 2025)
+- [#1331](https://github.com/wiremock/WireMock.Net/pull/1331) - Correctly map the Pact Interaction Description property [bug] contributed by [StefH](https://github.com/StefH)
+- [#1330](https://github.com/wiremock/WireMock.Net/issues/1330) - Generated Pact-compatible consumer contract does not contain description [bug]
+
+# 1.8.14 (13 July 2025)
+- [#1325](https://github.com/wiremock/WireMock.Net/pull/1325) - Add method CreateHttpClientFactory [feature] contributed by [StefH](https://github.com/StefH)
+- [#1326](https://github.com/wiremock/WireMock.Net/pull/1326) - Implement IMimeMessageData [feature] contributed by [StefH](https://github.com/StefH)
+- [#1329](https://github.com/wiremock/WireMock.Net/pull/1329) - Fix HandlebarsContext.ParseAndEvaluate [bug] contributed by [StefH](https://github.com/StefH)
+- [#1327](https://github.com/wiremock/WireMock.Net/issues/1327) - Response Body Does Not Evaluate Multiple Handlebars Templates [bug]
+
+# 1.8.13 (23 June 2025)
+- [#1322](https://github.com/wiremock/WireMock.Net/pull/1322) - Add Scenario set State method [feature] contributed by [StefH](https://github.com/StefH)
+- [#1321](https://github.com/wiremock/WireMock.Net/issues/1321) - Feature: Setting individual scenario state via Admin API [feature]
+
 # 1.8.12 (15 June 2025)
 - [#1317](https://github.com/wiremock/WireMock.Net/pull/1317) - Set description when converting MappingModel to IRespondWithAProvider [feature] contributed by [BodrickLight](https://github.com/BodrickLight)
 - [#1320](https://github.com/wiremock/WireMock.Net/pull/1320) - Fix TypeLoader [bug] contributed by [StefH](https://github.com/StefH)

Directory.Build.props

@@ -4,7 +4,7 @@
     </PropertyGroup>
 
     <PropertyGroup>
-        <VersionPrefix>1.8.12</VersionPrefix>
+        <VersionPrefix>1.9.0</VersionPrefix>
         <PackageIcon>WireMock.Net-Logo.png</PackageIcon>
         <PackageProjectUrl>https://github.com/wiremock/WireMock.Net</PackageProjectUrl>
         <PackageLicenseExpression>Apache-2.0</PackageLicenseExpression>

Generate-ReleaseNotes.cmd

@@ -1,6 +1,6 @@
 rem https://github.com/StefH/GitHubReleaseNotes
 
-SET version=1.8.12
+SET version=1.9.0
 
 GitHubReleaseNotes --output CHANGELOG.md --skip-empty-releases --exclude-labels wontfix test question invalid doc duplicate example environment --version %version% --token %GH_TOKEN%
 

PackageReleaseNotes.txt

@@ -1,6 +1,4 @@
-# 1.8.12 (15 June 2025)
-- #1317 Set description when converting MappingModel to IRespondWithAProvider [feature]
-- #1320 Fix TypeLoader [bug]
-- #1319 Why is IRequestMessage.BodyAsMimeMessage null in new versions (> 1.8.7) [bug]
+# 1.9.0 (10 August 2025)
+- #1334 Create GraphQL project [feature]
 
 The full release notes can be found here: https://github.com/wiremock/WireMock.Net/blob/master/CHANGELOG.md

README.md

@@ -54,13 +54,14 @@ For more info, see also this WIKI page: [What is WireMock.Net](https://github.co
 |   **WireMock.Net.Matchers.CSharpCode** | [![NuGet Badge WireMock.Net.Matchers.CSharpCode](https://img.shields.io/nuget/v/WireMock.Net.Matchers.CSharpCode)](https://www.nuget.org/packages/WireMock.Net.Matchers.CSharpCode) | [![MyGet Badge WireMock.Net.Matchers.CSharpCode](https://img.shields.io/myget/wiremock-net/vpre/WireMock.Net.Matchers.CSharpCode?includePreReleases=true&label=MyGet)](https://www.myget.org/feed/wiremock-net/package/nuget/WireMock.Net.Matchers.CSharpCode)
 |   **WireMock.Net.OpenApiParser** | [![NuGet Badge WireMock.Net.OpenApiParser](https://img.shields.io/nuget/v/WireMock.Net.OpenApiParser)](https://www.nuget.org/packages/WireMock.Net.OpenApiParser) | [![MyGet Badge WireMock.Net.OpenApiParser](https://img.shields.io/myget/wiremock-net/vpre/WireMock.Net.OpenApiParser?includePreReleases=true&label=MyGet)](https://www.myget.org/feed/wiremock-net/package/nuget/WireMock.Net.OpenApiParser)
 |   **WireMock.Net.MimePart** | [![NuGet Badge WireMock.Net.MimePart](https://img.shields.io/nuget/v/WireMock.Net.MimePart)](https://www.nuget.org/packages/WireMock.Net.MimePart) | [![MyGet Badge WireMock.Net.MimePart](https://img.shields.io/myget/wiremock-net/vpre/WireMock.Net.MimePart?includePreReleases=true&label=MyGet)](https://www.myget.org/feed/wiremock-net/package/nuget/WireMock.Net.MimePart)
+|   **WireMock.Net.GraphQL** | [![NuGet Badge WireMock.Net.GraphQL](https://img.shields.io/nuget/v/WireMock.Net.GraphQL)](https://www.nuget.org/packages/WireMock.Net.GraphQL) | [![MyGet Badge WireMock.Net.GraphQL](https://img.shields.io/myget/wiremock-net/vpre/WireMock.Net.GraphQL?includePreReleases=true&label=MyGet)](https://www.myget.org/feed/wiremock-net/package/nuget/WireMock.Net.GraphQL)
 | | | |
 |   **WireMock.Net.RestClient** | [![NuGet Badge WireMock.Net.RestClient](https://img.shields.io/nuget/v/WireMock.Net.RestClient)](https://www.nuget.org/packages/WireMock.Net.RestClient) | [![MyGet Badge WireMock.Net.RestClient](https://img.shields.io/myget/wiremock-net/vpre/WireMock.Net.RestClient?includePreReleases=true&label=MyGet)](https://www.myget.org/feed/wiremock-net/package/nuget/WireMock.Net.RestClient)
 |   **WireMock.Org.RestClient** | [![NuGet Badge WireMock.Org.RestClient](https://img.shields.io/nuget/v/WireMock.Org.RestClient)](https://www.nuget.org/packages/WireMock.Org.RestClient) | [![MyGet Badge WireMock.Org.RestClient](https://img.shields.io/myget/wiremock-net/vpre/WireMock.Org.RestClient?includePreReleases=true&label=MyGet)](https://www.myget.org/feed/wiremock-net/package/nuget/WireMock.Org.RestClient)
 
 <br />
 
-🔺 **WireMock.Net.Minimal** does not include: **WireMock.Net.MimePart**
+🔺 **WireMock.Net.Minimal** does not include *WireMock.Net.MimePart* and *WireMock.Net.GraphQL*.
 
 ---
 
@@ -132,3 +133,8 @@ For more details see also [Docker](https://github.com/wiremock/WireMock.Net-dock
 
 #### HTTPS / SSL
 More details on using HTTPS (SSL) can be found here [Wiki : HTTPS](https://github.com/wiremock/WireMock.Net/wiki/Using-HTTPS-(SSL))
+
+---
+
+## Powered by
+[![JetBrains logo.](https://resources.jetbrains.com/storage/products/company/brand/logos/jetbrains.svg)](https://jb.gg/OpenSource)

WireMock.Net Solution.sln

@@ -136,6 +136,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WireMock.Net.ConsoleApp.Usi
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WireMock.Net.Tests.UsingNuGet", "test\WireMock.Net.Tests.UsingNuGet\WireMock.Net.Tests.UsingNuGet.csproj", "{BBA332C6-28A9-42E7-9C4D-A0816E52A198}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WireMock.Net.GraphQL", "src\WireMock.Net.GraphQL\WireMock.Net.GraphQL.csproj", "{B6269AAC-170A-4346-8B9A-444DED3D9A45}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -326,6 +328,10 @@ Global
 		{BBA332C6-28A9-42E7-9C4D-A0816E52A198}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{BBA332C6-28A9-42E7-9C4D-A0816E52A198}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{BBA332C6-28A9-42E7-9C4D-A0816E52A198}.Release|Any CPU.Build.0 = Release|Any CPU
+		{B6269AAC-170A-4346-8B9A-444DED3D9A45}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{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
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -379,6 +385,7 @@ Global
 		{BFEF8990-65B3-4274-310F-7355F0B84035} = {8F890C6F-9ACC-438D-928A-AD61CDA862F2}
 		{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}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {DC539027-9852-430C-B19F-FD035D018458}

examples/WireMock.Net.Console.NET8/MainApp.cs

@@ -132,7 +132,42 @@ namespace WireMock.Net.ConsoleApplication
             }
             """;
 
-        private const string TestSchema =
+        private const string TestSchemaQueryStudents =
+            """
+            type Query {
+                students:[Student]
+            }
+
+            type Student {
+                id:ID!
+                firstName:String
+                lastName:String
+                fullName:String 
+            }
+            """;
+
+        private const string TestSchemaQueryStudentById =
+            """
+            type Query {
+                studentById(id:ID!):Student
+            }
+
+            type Student {
+                id:ID!
+                firstName:String
+                lastName:String
+                fullName:String 
+            }
+            """;
+
+        private const string TestSchemaQueryGreeting =
+            """
+            type Query {
+                greeting:String
+            }
+            """;
+
+        private const string TestSchemaMutationMessage =
             """
             scalar DateTime
             scalar MyCustomScalar
@@ -153,19 +188,6 @@ namespace WireMock.Net.ConsoleApplication
                 createAnotherMessage(x: MyCustomScalar, dt: DateTime): Message
                 updateMessage(id: ID!, input: MessageInput): Message
             }
-
-            type Query {
-                greeting:String
-                students:[Student]
-                studentById(id:ID!):Student
-            }
-
-            type Student {
-                id:ID!
-                firstName:String
-                lastName:String
-                fullName:String 
-            }
             """;
 
         private static void RunSse()
@@ -433,10 +455,73 @@ namespace WireMock.Net.ConsoleApplication
                 .Given(Request.Create()
                     .WithPath("/graphql")
                     .UsingPost()
-                    .WithBodyAsGraphQL(TestSchema, customScalars)
+                    .WithGraphQLSchema(TestSchemaQueryStudents)
                 )
                 .RespondWith(Response.Create()
-                    .WithBody("GraphQL is ok")
+                    .WithHeader("Content-Type", "application/json")
+                    .WithBody(
+                        """
+                        {
+                          "data": {
+                            "students": [
+                              {
+                                "id": "1",
+                                "firstName": "Alice",
+                                "lastName": "Johnson",
+                                "fullName": "Alice Johnson"
+                              },
+                              {
+                                "id": "2",
+                                "firstName": "Bob",
+                                "lastName": "Smith",
+                                "fullName": "Bob Smith"
+                              }
+                            ]
+                          }
+                        }
+                        """)
+                );
+
+            server
+                .Given(Request.Create()
+                    .WithPath("/graphql")
+                    .UsingPost()
+                    .WithGraphQLSchema(TestSchemaQueryStudentById)
+                    .WithBody(new JsonPartialWildcardMatcher("{ \"variables\": { \"sid\": \"1\" } }"))
+                )
+                .WithTitle("Student found")
+                .RespondWith(Response.Create()
+                    .WithHeader("Content-Type", "application/json")
+                    .WithBody(
+                        """
+                        {
+                          "data": {
+                            "studentById": {
+                              "id": "123",
+                              "firstName": "John",
+                              "lastName": "Doe",
+                              "fullName": "John Doe"
+                            }
+                          }
+                        }
+                        """)
+                );
+
+            server
+                .Given(Request.Create()
+                    .WithPath("/graphql")
+                    .UsingPost()
+                    .WithGraphQLSchema(TestSchemaQueryStudentById)
+                )
+                .WithTitle("Student not found")
+                .RespondWith(Response.Create()
+                    .WithHeader("Content-Type", "application/json")
+                    .WithBody(
+                        """
+                        {
+                          "data": null
+                        }
+                        """)
                 );
 #endif
 

examples/WireMock.Net.ConsoleApp.UsingNuGet/WireMock.Net.ConsoleApp.UsingNuGet.csproj

@@ -11,6 +11,10 @@
     <ProjectReference Include="..\..\src\WireMock.Net\WireMock.Net.csproj" />
   </ItemGroup>
 
+  <ItemGroup>
+    <PackageReference Update="SonarAnalyzer.CSharp" Version="10.12.0.118525" />
+  </ItemGroup>
+
   <!--<ItemGroup>
     <PackageReference Include="WireMock.Net" Version="1.8.11" />
   </ItemGroup>-->

src/WireMock.Net.Abstractions/Admin/Scenarios/ScenarioStateUpdateModel.cs

@@ -0,0 +1,15 @@
+// Copyright © WireMock.Net
+
+namespace WireMock.Admin.Scenarios;
+
+/// <summary>
+/// ScenarioStateModel
+/// </summary>
+[FluentBuilder.AutoGenerateBuilder]
+public class ScenarioStateUpdateModel
+{
+    /// <summary>
+    /// Gets or sets the NextState.
+    /// </summary>
+    public string? State { get; set; }
+}

src/WireMock.Net.Abstractions/IRequestMessage.cs

@@ -123,7 +123,7 @@ public interface IRequestMessage
     /// The original body as MimeMessage.
     /// Convenience getter for Handlebars and WireMockAssertions.
     /// </summary>
-    object? BodyAsMimeMessage { get; }
+    Models.Mime.IMimeMessageData? BodyAsMimeMessage { get; }
 #endif
 
     /// <summary>

src/WireMock.Net.Abstractions/Models/GraphQL/ISchemaData.cs

@@ -0,0 +1,5 @@
+// Copyright © WireMock.Net
+
+namespace WireMock.Models.GraphQL;
+
+public interface ISchemaData;

src/WireMock.Net.Abstractions/Models/Mime/IContentDispositionData.cs

@@ -0,0 +1,60 @@
+// Copyright © WireMock.Net
+
+using System;
+using System.Collections.Generic;
+
+namespace WireMock.Models.Mime;
+
+/// <summary>
+/// An interface exposing the public, readable properties of a ContentDisposition.
+/// </summary>
+public interface IContentDispositionData
+{
+    /// <summary>
+    /// Get the disposition.
+    /// </summary>
+    /// <value>The disposition.</value>
+    string Disposition { get; }
+
+    /// <summary>
+    /// Get a value indicating whether the <see cref="IMimeEntityData"/> is an attachment.
+    /// </summary>
+    /// <value><see langword="true" /> if the <see cref="IMimeEntityData"/> is an attachment; otherwise, <see langword="false" />.</value>
+    bool IsAttachment { get; }
+
+    /// <summary>
+    /// Get the list of parameters on the ContentDisposition.
+    /// </summary>
+    /// <value>The parameters.</value>
+    public IList<string> Parameters { get; }
+
+    /// <summary>
+    /// Get the name of the file.
+    /// </summary>
+    /// <value>The name of the file.</value>
+    string FileName { get; }
+
+    /// <summary>
+    /// Get the creation-date parameter.
+    /// </summary>
+    /// <value>The creation date.</value>
+    DateTimeOffset? CreationDate { get; }
+
+    /// <summary>
+    /// Get the modification-date parameter.
+    /// </summary>
+    /// <value>The modification date.</value>
+    DateTimeOffset? ModificationDate { get; }
+
+    /// <summary>
+    /// Get the read-date parameter.
+    /// </summary>
+    /// <value>The read date.</value>
+    DateTimeOffset? ReadDate { get; }
+
+    /// <summary>
+    /// Get the size parameter.
+    /// </summary>
+    /// <value>The size.</value>
+    long? Size { get; }
+}

src/WireMock.Net.Abstractions/Models/Mime/IContentTypeData.cs

@@ -0,0 +1,67 @@
+// Copyright © WireMock.Net
+
+using System.Collections.Generic;
+using System.Text;
+
+namespace WireMock.Models.Mime;
+
+/// <summary>
+/// An interface exposing the public, readable properties of a ContentType
+/// with complex types simplified to a generic object.
+/// </summary>
+public interface IContentTypeData
+{
+    /// <summary>
+    /// Get the type of the media.
+    /// </summary>
+    /// <value>The type of the media.</value>
+    string MediaType { get; }
+
+    /// <summary>
+    /// Get the media subtype.
+    /// </summary>
+    /// <value>The media subtype.</value>
+    string MediaSubtype { get; }
+
+    /// <summary>
+    /// Get the list of parameters on the ContentType.
+    /// </summary>
+    /// <value>The parameters.</value>
+    IList<string> Parameters { get; }
+
+    /// <summary>
+    /// Get the boundary parameter.
+    /// </summary>
+    /// <value>The boundary.</value>
+    string Boundary { get; }
+
+    /// <summary>
+    /// Get the charset parameter.
+    /// </summary>
+    /// <value>The charset.</value>
+    string Charset { get; }
+
+    /// <summary>
+    /// Get the charset parameter as an Encoding.
+    /// </summary>
+    /// <value>The charset encoding.</value>
+    Encoding CharsetEncoding { get; }
+
+    /// <summary>
+    /// Get the format parameter.
+    /// </summary>
+    /// <value>The format.</value>
+    string Format { get; }
+
+    /// <summary>
+    /// Get the simple mime-type.
+    /// </summary>
+    /// <value>The mime-type.</value>
+    string MimeType { get; }
+
+    /// <summary>
+    /// Get the name parameter.
+    /// </summary>
+    /// <value>The name.</value>
+    string Name { get; }
+}

src/WireMock.Net.Abstractions/Models/Mime/IMimeEntityData.cs

@@ -0,0 +1,54 @@
+// Copyright © WireMock.Net
+
+using System;
+using System.Collections.Generic;
+
+namespace WireMock.Models.Mime;
+
+/// <summary>
+/// A simplified interface exposing the public, readable properties of MimeEntity.
+/// </summary>
+public interface IMimeEntityData
+{
+    /// <summary>
+    /// Get the list of headers.
+    /// </summary>
+    /// <value>The list of headers.</value>
+    IList<string> Headers { get; }
+
+    /// <summary>
+    /// Get the content disposition.
+    /// </summary>
+    /// <value>The content disposition.</value>
+    IContentDispositionData? ContentDisposition { get; }
+
+    /// <summary>
+    /// Get the type of the content.
+    /// </summary>
+    /// <value>The type of the content.</value>
+    IContentTypeData? ContentType { get; }
+
+    /// <summary>
+    /// Get the base content URI.
+    /// </summary>
+    /// <value>The base content URI or <see langword="null"/>.</value>
+    Uri ContentBase { get; }
+
+    /// <summary>
+    /// Get the content location.
+    /// </summary>
+    /// <value>The content location or <see langword="null"/>.</value>
+    Uri ContentLocation { get; }
+
+    /// <summary>
+    /// Get the Content-Id.
+    /// </summary>
+    /// <value>The content identifier.</value>
+    string ContentId { get; }
+
+    /// <summary>
+    /// Get a value indicating whether this <see cref="IMimeEntityData"/> is an attachment.
+    /// </summary>
+    /// <value><see langword="true" /> if this <see cref="IMimeEntityData"/> is an attachment; otherwise, <see langword="false" />.</value>
+    bool IsAttachment { get; }
+}

src/WireMock.Net.Abstractions/Models/Mime/IMimeMessageData.cs

@@ -0,0 +1,186 @@
+// Copyright © WireMock.Net
+
+using System;
+using System.Collections.Generic;
+
+namespace WireMock.Models.Mime;
+
+/// <summary>
+/// A simplified interface exposing the public, readable properties of a MIME message.
+/// </summary>
+public interface IMimeMessageData
+{
+    /// <summary>
+    /// Get the list of headers.
+    /// </summary>
+    /// <value>The list of headers.</value>
+    IList<string> Headers { get; }
+
+    /// <summary>
+    /// Get the value of the Importance header.
+    /// </summary>
+    /// <value>The importance, as an integer.</value>
+    int Importance { get; }
+
+    /// <summary>
+    /// Get the value of the Priority header.
+    /// </summary>
+    /// <value>The priority, as an integer.</value>
+    int Priority { get; }
+
+    /// <summary>
+    /// Get the value of the X-Priority header.
+    /// </summary>
+    /// <value>The X-priority, as an integer.</value>
+    int XPriority { get; }
+
+    /// <summary>
+    /// Get the address in the Sender header.
+    /// </summary>
+    /// <value>The address in the Sender header.</value>
+    string Sender { get; }
+
+    /// <summary>
+    /// Get the address in the Resent-Sender header.
+    /// </summary>
+    /// <value>The address in the Resent-Sender header.</value>
+    string ResentSender { get; }
+
+    /// <summary>
+    /// Get the list of addresses in the From header.
+    /// </summary>
+    /// <value>The list of addresses in the From header.</value>
+    IList<string> From { get; }
+
+    /// <summary>
+    /// Get the list of addresses in the Resent-From header.
+    /// </summary>
+    /// <value>The list of addresses in the Resent-From header.</value>
+    IList<string> ResentFrom { get; }
+
+    /// <summary>
+    /// Get the list of addresses in the Reply-To header.
+    /// </summary>
+    /// <value>The list of addresses in the Reply-To header.</value>
+    IList<string> ReplyTo { get; }
+
+    /// <summary>
+    /// Get the list of addresses in the Resent-Reply-To header.
+    /// </summary>
+    /// <value>The list of addresses in the Resent-Reply-To header.</value>
+    IList<string> ResentReplyTo { get; }
+
+    /// <summary>
+    /// Get the list of addresses in the To header.
+    /// </summary>
+    /// <value>The list of addresses in the To header.</value>
+    IList<string> To { get; }
+
+    /// <summary>
+    /// Get the list of addresses in the Resent-To header.
+    /// </summary>
+    /// <value>The list of addresses in the Resent-To header.</value>
+    IList<string> ResentTo { get; }
+
+    /// <summary>
+    /// Get the list of addresses in the Cc header.
+    /// </summary>
+    /// <value>The list of addresses in the Cc header.</value>
+    IList<string> Cc { get; }
+
+    /// <summary>
+    /// Get the list of addresses in the Resent-Cc header.
+    /// </summary>
+    /// <value>The list of addresses in the Resent-Cc header.</value>
+    IList<string> ResentCc { get; }
+
+    /// <summary>
+    /// Get the list of addresses in the Bcc header.
+    /// </summary>
+    /// <value>The list of addresses in the Bcc header.</value>
+    IList<string> Bcc { get; }
+
+    /// <summary>
+    /// Get the list of addresses in the Resent-Bcc header.
+    /// </summary>
+    /// <value>The list of addresses in the Resent-Bcc header.</value>
+    IList<string> ResentBcc { get; }
+        
+    /// <summary>
+    /// Get the subject of the message.
+    /// </summary>
+    /// <value>The subject of the message.</value>
+    string Subject { get; }
+
+    /// <summary>
+    /// Get the date of the message.
+    /// </summary>
+    /// <value>The date of the message.</value>
+    DateTimeOffset Date { get; }
+
+    /// <summary>
+    /// Get the Resent-Date of the message.
+    /// </summary>
+    /// <value>The Resent-Date of the message.</value>
+    DateTimeOffset ResentDate { get; }
+
+    /// <summary>
+    /// Get the list of references to other messages.
+    /// </summary>
+    /// <value>The references.</value>
+    IList<string> References { get; }
+
+    /// <summary>
+    /// Get the Message-Id that this message is replying to.
+    /// </summary>
+    /// <value>The message id that this message is in reply to.</value>
+    string InReplyTo { get; }
+
+    /// <summary>
+    /// Get the message identifier.
+    /// </summary>
+    /// <value>The message identifier.</value>
+    string MessageId { get; }
+
+    /// <summary>
+    /// Get the Resent-Message-Id header.
+    /// </summary>
+    /// <value>The Resent-Message-Id.</value>
+    string ResentMessageId { get; }
+
+    /// <summary>
+    /// Get the MIME-Version.
+    /// </summary>
+    /// <value>The MIME version.</value>
+    Version MimeVersion { get; }
+
+    /// <summary>
+    /// Get the body of the message.
+    /// </summary>
+    /// <value>The body of the message.</value>
+    IMimeEntityData Body { get; }
+
+    /// <summary>
+    /// Get the text body of the message if it exists.
+    /// </summary>
+    /// <value>The text body if it exists; otherwise, <see langword="null"/>.</value>
+    string TextBody { get; }
+
+    /// <summary>
+    /// Get the html body of the message if it exists.
+    /// </summary>
+    /// <value>The html body if it exists; otherwise, <see langword="null"/>.</value>
+    string HtmlBody { get; }
+
+    /// <summary>
+    /// Get the body parts of the message.
+    /// </summary>
+    /// <value>The body parts.</value>
+    IList<IMimePartData> BodyParts { get; }
+
+    /// <summary>
+    /// Get the attachments.
+    /// </summary>
+    /// <value>The attachments.</value>
+    IList<IMimeEntityData> Attachments { get; }
+}

src/WireMock.Net.Abstractions/Models/Mime/IMimePartData.cs

@@ -0,0 +1,57 @@
+// Copyright © WireMock.Net
+
+using System.Collections.Generic;
+using System.IO;
+
+namespace WireMock.Models.Mime;
+
+/// <summary>
+/// A simplified interface exposing the public, readable properties of MimePart.
+/// </summary>
+public interface IMimePartData : IMimeEntityData
+{
+    /// <summary>
+    /// Get the description of the content if available.
+    /// </summary>
+    /// <value>The description of the content.</value>
+    string ContentDescription { get; }
+
+    /// <summary>
+    /// Get the duration of the content if available.
+    /// </summary>
+    /// <value>The duration of the content.</value>
+    int? ContentDuration { get; }
+
+    /// <summary>
+    /// Get the md5sum of the content.
+    /// </summary>
+    /// <value>The md5sum of the content.</value>
+    string ContentMd5 { get; }
+
+    /// <summary>
+    /// Get the content transfer encoding.
+    /// </summary>
+    /// <value>The content transfer encoding as a string.</value>
+    string ContentTransferEncoding { get; }
+
+    /// <summary>
+    /// Get the name of the file.
+    /// </summary>
+    /// <value>The name of the file.</value>
+    string FileName { get; }
+
+    /// <summary>
+    /// Get the MIME content.
+    /// </summary>
+    /// <value>The MIME content.</value>
+    IDictionary<string, object?> Content { get; }
+
+    /// <summary>
+    /// Open the decoded content stream.
+    /// </summary>
+    /// <remarks>
+    /// Provides a means of reading the decoded content without having to first write it to another stream.
+    /// </remarks>
+    /// <returns>The decoded content stream.</returns>
+    Stream Open();
+}

src/WireMock.Net.Abstractions/Server/IWireMockServer.cs

@@ -161,6 +161,11 @@ public interface IWireMockServer : IDisposable
     /// </summary>
     bool ResetScenario(string name);
 
+    /// <summary>
+    /// Sets a scenario to a state.
+    /// </summary>
+    bool SetScenarioState(string name, string? state);
+
     /// <summary>
     /// Resets the LogEntries.
     /// </summary>

src/WireMock.Net.GraphQL/Matchers/GraphQLMatcher.cs

@@ -1,6 +1,5 @@
 // Copyright © WireMock.Net
 
-#if GRAPHQL
 using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
@@ -14,17 +13,17 @@ using Newtonsoft.Json;
 using Stef.Validation;
 using WireMock.Exceptions;
 using WireMock.Extensions;
-using WireMock.Matchers.Models;
+using WireMock.GraphQL.Models;
 using WireMock.Models;
-using WireMock.Util;
+using WireMock.Models.GraphQL;
+using WireMock.Utils;
 
 namespace WireMock.Matchers;
 
 /// <summary>
 /// GrapQLMatcher Schema Matcher
 /// </summary>
-/// <inheritdoc cref="IStringMatcher"/>
-public class GraphQLMatcher : IStringMatcher
+public class GraphQLMatcher : IGraphQLMatcher
 {
     private sealed class GraphQLRequest
     {
@@ -54,7 +53,7 @@ public class GraphQLMatcher : IStringMatcher
     /// <param name="matchBehaviour">The match behaviour. (default = "AcceptOnMatch")</param>
     /// <param name="matchOperator">The <see cref="Matchers.MatchOperator"/> to use. (default = "Or")</param>
     public GraphQLMatcher(
-        AnyOf<string, StringPattern, ISchema> schema,
+        AnyOf<string, StringPattern, ISchemaData> schema,
         MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch,
         MatchOperator matchOperator = MatchOperator.Or
     ) : this(schema, null, matchBehaviour, matchOperator)
@@ -69,7 +68,7 @@ public class GraphQLMatcher : IStringMatcher
     /// <param name="matchBehaviour">The match behaviour. (default = "AcceptOnMatch")</param>
     /// <param name="matchOperator">The <see cref="Matchers.MatchOperator"/> to use. (default = "Or")</param>
     public GraphQLMatcher(
-        AnyOf<string, StringPattern, ISchema> schema,
+        AnyOf<string, StringPattern, ISchemaData> schema,
         IDictionary<string, Type>? customScalars,
         MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch,
         MatchOperator matchOperator = MatchOperator.Or
@@ -94,7 +93,7 @@ public class GraphQLMatcher : IStringMatcher
                 break;
 
             case AnyOfType.Third:
-                _schema = schema.Third;
+                _schema = ((SchemaDataWrapper)schema.Third).Schema;
                 break;
 
             default:
@@ -201,7 +200,7 @@ public class GraphQLMatcher : IStringMatcher
                     throw new WireMockException($"The GraphQL Scalar type '{scalarTypeDefinitionName}' is not defined in the CustomScalars dictionary.");
                 }
 
-                // Create a this custom Scalar GraphType (extending the WireMockCustomScalarGraphType<{clrType}> class)
+                // Create a custom Scalar GraphType (extending the WireMockCustomScalarGraphType<{clrType}> class)
                 var customScalarGraphType = ReflectionUtils.CreateGenericType(customScalarGraphTypeName, typeof(WireMockCustomScalarGraphType<>), clrType);
                 schema.RegisterType(customScalarGraphType);
             }
@@ -209,5 +208,4 @@ public class GraphQLMatcher : IStringMatcher
 
         return schema;
     }
-}
-#endif
+}

src/WireMock.Net.GraphQL/Models/SchemaDataWrapper.cs

@@ -0,0 +1,18 @@
+// Copyright © WireMock.Net
+
+using GraphQL.Types;
+using WireMock.Models.GraphQL;
+
+namespace WireMock.Models;
+
+/// <summary>
+/// Represents a wrapper for schema data, providing access to the associated schema.
+/// </summary>
+/// <param name="schema"></param>
+public class SchemaDataWrapper(ISchema schema) : ISchemaData
+{
+    /// <summary>
+    /// Gets the schema associated with the current instance.
+    /// </summary>
+    public ISchema Schema { get; } = schema;
+}

src/WireMock.Net.GraphQL/Models/WireMockCustomScalarGraphType.cs

@@ -1,10 +1,10 @@
 // Copyright © WireMock.Net
 
-#if GRAPHQL
 using System;
 using GraphQL.Types;
 
-namespace WireMock.Matchers.Models;
+// ReSharper disable once CheckNamespace
+namespace WireMock.GraphQL.Models;
 
 /// <inheritdoc />
 public abstract class WireMockCustomScalarGraphType<T> : ScalarGraphType
@@ -28,5 +28,4 @@ public abstract class WireMockCustomScalarGraphType<T> : ScalarGraphType
 
         return (T)Convert.ChangeType(value, typeof(T));
     }
-}
-#endif
+}

src/WireMock.Net.GraphQL/Properties/AssemblyInfo.cs

@@ -0,0 +1,8 @@
+// Copyright © WireMock.Net
+
+using System.Runtime.CompilerServices;
+
+// [assembly: InternalsVisibleTo("WireMock.Net.Tests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100e138ec44d93acac565953052636eb8d5e7e9f27ddb030590055cd1a0ab2069a5623f1f77ca907d78e0b37066ca0f6d63da7eecc3fcb65b76aa8ebeccf7ebe1d11264b8404cd9b1cbbf2c83f566e033b3e54129f6ef28daffff776ba7aebbc53c0d635ebad8f45f78eb3f7e0459023c218f003416e080f96a1a3c5ffeb56bee9e")]
+
+// Needed for Moq in the UnitTest project
+// [assembly: InternalsVisibleTo("DynamicProxyGenAssembly2, PublicKey=0024000004800000940000000602000000240000525341310004000001000100c547cac37abd99c8db225ef2f6c8a3602f3b3606cc9891605d02baa56104f4cfc0734aa39b93bf7852f7d9266654753cc297e7d2edfe0bac1cdcf9f717241550e0a7b191195b7667bb4f64bcb8e2121380fd1d9d46ad2d92d2d15605093924cceaf74c4861eff62abf69b9291ed0a340e113be11e6a7d3113e92484cf7045cc7")]

src/WireMock.Net.GraphQL/RequestBuilders/IRequestBuilderExtensions.cs

@@ -0,0 +1,94 @@
+// Copyright © WireMock.Net
+
+using System;
+using System.Collections.Generic;
+using GraphQL.Types;
+using Stef.Validation;
+using WireMock.Matchers;
+using WireMock.Matchers.Request;
+using WireMock.Models;
+using WireMock.Models.GraphQL;
+
+namespace WireMock.RequestBuilders;
+
+/// <summary>
+/// IRequestBuilderExtensions extensions for GraphQL.
+/// </summary>
+// ReSharper disable once InconsistentNaming
+public static class IRequestBuilderExtensions
+{
+    /// <summary>
+    /// WithBodyAsGraphQL: The GraphQL body as a string.
+    /// </summary>
+    /// <param name="requestBuilder">The <see cref="IRequestBuilder"/>.</param>
+    /// <param name="schema">The GraphQL schema.</param>
+    /// <param name="matchBehaviour">The match behaviour. (Default is <c>MatchBehaviour.AcceptOnMatch</c>).</param>
+    /// <returns>The <see cref="IRequestBuilder"/>.</returns>
+    public static IRequestBuilder WithGraphQLSchema(this IRequestBuilder requestBuilder, string schema, MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch)
+    {
+        return Guard.NotNull(requestBuilder).Add(new RequestMessageGraphQLMatcher(matchBehaviour, schema));
+    }
+
+    /// <summary>
+    /// WithBodyAsGraphQL: The GraphQL schema as a string.
+    /// </summary>
+    /// <param name="requestBuilder">The <see cref="IRequestBuilder"/>.</param>
+    /// <param name="schema">The GraphQL schema.</param>
+    /// <param name="customScalars">A dictionary defining the custom scalars used in this schema. (optional)</param>
+    /// <param name="matchBehaviour">The match behaviour. (Default is <c>MatchBehaviour.AcceptOnMatch</c>).</param>
+    /// <returns>The <see cref="IRequestBuilder"/>.</returns>
+    public static IRequestBuilder WithGraphQLSchema(this IRequestBuilder requestBuilder, string schema, IDictionary<string, Type>? customScalars, MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch)
+    {
+        return Guard.NotNull(requestBuilder).Add(new RequestMessageGraphQLMatcher(matchBehaviour, schema, customScalars));
+    }
+
+    /// <summary>
+    /// WithBodyAsGraphQL: The GraphQL schema as a <see cref="ISchema"/>.
+    /// </summary>
+    /// <param name="requestBuilder">The <see cref="IRequestBuilder"/>.</param>
+    /// <param name="schema">The GraphQL schema.</param>
+    /// <param name="matchBehaviour">The match behaviour. (Default is <c>MatchBehaviour.AcceptOnMatch</c>).</param>
+    /// <returns>The <see cref="IRequestBuilder"/>.</returns>
+    public static IRequestBuilder WithGraphQLSchema(this IRequestBuilder requestBuilder, ISchema schema, MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch)
+    {
+        return Guard.NotNull(requestBuilder).Add(new RequestMessageGraphQLMatcher(matchBehaviour, new SchemaDataWrapper(schema)));
+    }
+
+    /// <summary>
+    /// WithBodyAsGraphQL: The GraphQL schema as a <see cref="ISchema"/>.
+    /// </summary>
+    /// <param name="requestBuilder">The <see cref="IRequestBuilder"/>.</param>
+    /// <param name="schema">The GraphQL schema.</param>
+    /// <param name="customScalars">A dictionary defining the custom scalars used in this schema. (optional)</param>
+    /// <param name="matchBehaviour">The match behaviour. (Default is <c>MatchBehaviour.AcceptOnMatch</c>).</param>
+    /// <returns>The <see cref="IRequestBuilder"/>.</returns>
+    public static IRequestBuilder WithGraphQLSchema(this IRequestBuilder requestBuilder, ISchema schema, IDictionary<string, Type>? customScalars, MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch)
+    {
+        return Guard.NotNull(requestBuilder).Add(new RequestMessageGraphQLMatcher(matchBehaviour, new SchemaDataWrapper(schema), customScalars));
+    }
+
+    /// <summary>
+    /// WithBodyAsGraphQL: The GraphQL schema as a <see cref="ISchemaData"/>.
+    /// </summary>
+    /// <param name="requestBuilder">The <see cref="IRequestBuilder"/>.</param>
+    /// <param name="schema">The GraphQL schema.</param>
+    /// <param name="matchBehaviour">The match behaviour. (Default is <c>MatchBehaviour.AcceptOnMatch</c>).</param>
+    /// <returns>The <see cref="IRequestBuilder"/>.</returns>
+    public static IRequestBuilder WithGraphQLSchema(this IRequestBuilder requestBuilder, ISchemaData schema, MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch)
+    {
+        return Guard.NotNull(requestBuilder).Add(new RequestMessageGraphQLMatcher(matchBehaviour, schema));
+    }
+
+    /// <summary>
+    /// WithBodyAsGraphQL: The GraphQL schema as a <see cref="ISchemaData"/>.
+    /// </summary>
+    /// <param name="requestBuilder">The <see cref="IRequestBuilder"/>.</param>
+    /// <param name="schema">The GraphQL schema.</param>
+    /// <param name="customScalars">A dictionary defining the custom scalars used in this schema. (optional)</param>
+    /// <param name="matchBehaviour">The match behaviour. (Default is <c>MatchBehaviour.AcceptOnMatch</c>).</param>
+    /// <returns>The <see cref="IRequestBuilder"/>.</returns>
+    public static IRequestBuilder WithGraphQLSchema(this IRequestBuilder requestBuilder, ISchemaData schema, IDictionary<string, Type>? customScalars, MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch)
+    {
+        return Guard.NotNull(requestBuilder).Add(new RequestMessageGraphQLMatcher(matchBehaviour, schema, customScalars));
+    }
+}

src/WireMock.Net.GraphQL/Utils/ReflectionUtils.cs

@@ -6,7 +6,7 @@ using System.Linq;
 using System.Reflection;
 using System.Reflection.Emit;
 
-namespace WireMock.Util;
+namespace WireMock.Utils;
 
 internal static class ReflectionUtils
 {

src/WireMock.Net.GraphQL/WireMock.Net.GraphQL.csproj

@@ -0,0 +1,47 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+    <PropertyGroup>
+        <Description>GraphQL support for WireMock.Net</Description>
+        <AssemblyTitle>WireMock.Net.Matchers.GraphQL</AssemblyTitle>
+        <Authors>Stef Heyenrath</Authors>
+        <TargetFrameworks>netstandard2.0;netstandard2.1;netcoreapp3.1;net5.0;net6.0;net8.0</TargetFrameworks>
+        <GenerateDocumentationFile>true</GenerateDocumentationFile>
+        <PackageTags>wiremock;matchers;matcher;graphql</PackageTags>
+        <RootNamespace>WireMock</RootNamespace>
+        <ProjectGuid>{B6269AAC-170A-4346-8B9A-444DED3D9A45}</ProjectGuid>
+        <PublishRepositoryUrl>true</PublishRepositoryUrl>
+        <EmbedUntrackedSources>true</EmbedUntrackedSources>
+        <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
+        <GenerateBindingRedirectsOutputType>true</GenerateBindingRedirectsOutputType>
+        <CodeAnalysisRuleSet>../WireMock.Net/WireMock.Net.ruleset</CodeAnalysisRuleSet>
+        <SignAssembly>true</SignAssembly>
+        <AssemblyOriginatorKeyFile>../WireMock.Net/WireMock.Net.snk</AssemblyOriginatorKeyFile>
+        <!--<DelaySign>true</DelaySign>-->
+        <PublicSign Condition=" '$(OS)' != 'Windows_NT' ">true</PublicSign>
+        <PackageLicenseExpression>MIT</PackageLicenseExpression>
+    </PropertyGroup>
+
+    <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">
+        <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
+    </PropertyGroup>
+
+    <ItemGroup>
+        <PackageReference Include="GraphQL.NewtonsoftJson" Version="8.2.1" />
+    </ItemGroup>
+
+    <ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0' ">
+        <PackageReference Include="System.Reflection.Emit" Version="4.3.0" />
+    </ItemGroup>
+
+    <ItemGroup>
+        <ProjectReference Include="..\WireMock.Net.Shared\WireMock.Net.Shared.csproj" />
+    </ItemGroup>
+
+    <ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0' ">
+        <PackageReference Include="Nullable" Version="1.3.1">
+            <PrivateAssets>all</PrivateAssets>
+            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+        </PackageReference>
+    </ItemGroup>
+
+</Project>

src/WireMock.Net.Matchers.CSharpCode/Matchers/CSharpCodeMatcher.cs

@@ -18,7 +18,7 @@ namespace WireMock.Matchers;
 /// CSharpCode / CS-Script Matcher
 /// </summary>
 /// <inheritdoc cref="ICSharpCodeMatcher"/>
-internal class CSharpCodeMatcher : ICSharpCodeMatcher
+public class CSharpCodeMatcher : ICSharpCodeMatcher
 {
     private const string TemplateForIsMatchWithString = "public class CodeHelper {{ public bool IsMatch(string it) {{ {0} }} }}";
 
@@ -63,17 +63,24 @@ internal class CSharpCodeMatcher : ICSharpCodeMatcher
         Value = patterns;
     }
 
-    public MatchResult IsMatch(string? input)
+    /// <inheritdoc />
+    public MatchResult IsMatch(string? input) => IsMatchInternal(input);
+
+    /// <inheritdoc />
+    public MatchResult IsMatch(object? input) => IsMatchInternal(input);
+
+    /// <inheritdoc />
+    public string GetCSharpCodeArguments()
     {
-        return IsMatchInternal(input);
+        return $"new {Name}" +
+               $"(" +
+               $"{MatchBehaviour.GetFullyQualifiedEnumValue()}, " +
+               $"{MatchOperator.GetFullyQualifiedEnumValue()}, " +
+               $"{MappingConverterUtils.ToCSharpCodeArguments(_patterns)}" +
+               $")";
     }
 
-    public MatchResult IsMatch(object? input)
-    {
-        return IsMatchInternal(input);
-    }
-
-    public MatchResult IsMatchInternal(object? input)
+    private MatchResult IsMatchInternal(object? input)
     {
         var score = MatchScores.Mismatch;
         Exception? exception = null;
@@ -93,17 +100,6 @@ internal class CSharpCodeMatcher : ICSharpCodeMatcher
         return new MatchResult(MatchBehaviourHelper.Convert(MatchBehaviour, score), exception);
     }
 
-    /// <inheritdoc />
-    public string GetCSharpCodeArguments()
-    {
-        return $"new {Name}" +
-               $"(" +
-               $"{MatchBehaviour.GetFullyQualifiedEnumValue()}, " +
-               $"{MatchOperator.GetFullyQualifiedEnumValue()}, " +
-               $"{MappingConverterUtils.ToCSharpCodeArguments(_patterns)}" +
-               $")";
-    }
-
     private bool IsMatch(dynamic input, string pattern)
     {
         var isMatchWithString = input is string;

src/WireMock.Net.MimePart/Matchers/MimePartMatcher.cs

@@ -1,8 +1,8 @@
 // Copyright © WireMock.Net
 
 using System;
-using MimeKit;
 using WireMock.Matchers.Helpers;
+using WireMock.Models.Mime;
 using WireMock.Util;
 
 namespace WireMock.Matchers;
@@ -12,7 +12,7 @@ namespace WireMock.Matchers;
 /// </summary>
 public class MimePartMatcher : IMimePartMatcher
 {
-    private readonly Func<MimePart, MatchResult>[] _funcs;
+    private readonly Func<IMimePartData, MatchResult>[] _funcs;
 
     /// <inheritdoc />
     public string Name => nameof(MimePartMatcher);
@@ -52,21 +52,21 @@ public class MimePartMatcher : IMimePartMatcher
         _funcs =
         [
             mp => ContentTypeMatcher?.IsMatch(GetContentTypeAsString(mp.ContentType)) ?? MatchScores.Perfect,
-            mp => ContentDispositionMatcher?.IsMatch(mp.ContentDisposition.ToString().Replace("Content-Disposition: ", string.Empty)) ?? MatchScores.Perfect,
-            mp => ContentTransferEncodingMatcher?.IsMatch(mp.ContentTransferEncoding.ToString().ToLowerInvariant()) ?? MatchScores.Perfect,
+            mp => ContentDispositionMatcher?.IsMatch(mp.ContentDisposition?.ToString()?.Replace("Content-Disposition: ", string.Empty)) ?? MatchScores.Perfect,
+            mp => ContentTransferEncodingMatcher?.IsMatch(mp.ContentTransferEncoding.ToLowerInvariant()) ?? MatchScores.Perfect,
             MatchOnContent
         ];
     }
 
     /// <inheritdoc />
-    public MatchResult IsMatch(object value)
+    public MatchResult IsMatch(IMimePartData value)
     {
         var score = MatchScores.Mismatch;
         Exception? exception = null;
 
         try
         {
-            if (value is MimePart mimePart && Array.TrueForAll(_funcs, func => func(mimePart).IsPerfect()))
+            if (Array.TrueForAll(_funcs, func => func(value).IsPerfect()))
             {
                 score = MatchScores.Perfect;
             }
@@ -85,7 +85,7 @@ public class MimePartMatcher : IMimePartMatcher
         return "NotImplemented";
     }
 
-    private MatchResult MatchOnContent(MimePart mimePart)
+    private MatchResult MatchOnContent(IMimePartData mimePart)
     {
         if (ContentMatcher == null)
         {
@@ -94,10 +94,10 @@ public class MimePartMatcher : IMimePartMatcher
 
         var bodyParserSettings = new BodyParserSettings
         {
-            Stream = mimePart.Content.Open(),
+            Stream = mimePart.Open(),
             ContentType = GetContentTypeAsString(mimePart.ContentType),
             DeserializeJson = true,
-            ContentEncoding = null, // mimePart.ContentType.CharsetEncoding.ToString(),
+            ContentEncoding = null, // mimePart.ContentType?.CharsetEncoding.ToString(),
             DecompressGZipAndDeflate = true
         };
 
@@ -105,8 +105,8 @@ public class MimePartMatcher : IMimePartMatcher
         return BodyDataMatchScoreCalculator.CalculateMatchScore(bodyData, ContentMatcher);
     }
 
-    private static string? GetContentTypeAsString(ContentType? contentType)
+    private static string? GetContentTypeAsString(IContentTypeData? contentType)
     {
-        return contentType?.ToString().Replace("Content-Type: ", string.Empty);
+        return contentType?.ToString()?.Replace("Content-Type: ", string.Empty);
     }
 }

src/WireMock.Net.MimePart/Models/ContentDispositionDataWrapper.cs

@@ -0,0 +1,63 @@
+// Copyright © WireMock.Net
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using MimeKit;
+using Stef.Validation;
+using WireMock.Models.Mime;
+
+namespace WireMock.Models;
+
+/// <summary>
+/// A wrapper class that implements the IContentDispositionData interface
+/// by wrapping a ContentDisposition object.
+/// </summary>
+/// <remarks>
+/// This class provides a simplified, read-only view of a ContentDisposition.
+/// </remarks>
+public class ContentDispositionDataWrapper : IContentDispositionData
+{
+    private readonly ContentDisposition _contentDisposition;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ContentDispositionDataWrapper"/> class.
+    /// </summary>
+    /// <param name="contentDisposition">The ContentDisposition to wrap.</param>
+    public ContentDispositionDataWrapper(ContentDisposition contentDisposition)
+    {
+        _contentDisposition = Guard.NotNull(contentDisposition);
+
+        Parameters = _contentDisposition.Parameters.Select(p => p.ToString()).ToList();
+    }
+
+    /// <inheritdoc/>
+    public string Disposition => _contentDisposition.Disposition;
+
+    /// <inheritdoc/>
+    public bool IsAttachment => _contentDisposition.IsAttachment;
+
+    /// <inheritdoc/>
+    public IList<string> Parameters { get; private set; }
+
+    /// <inheritdoc/>
+    public string FileName => _contentDisposition.FileName;
+
+    /// <inheritdoc/>
+    public DateTimeOffset? CreationDate => _contentDisposition.CreationDate;
+
+    /// <inheritdoc/>
+    public DateTimeOffset? ModificationDate => _contentDisposition.ModificationDate;
+
+    /// <inheritdoc/>
+    public DateTimeOffset? ReadDate => _contentDisposition.ReadDate;
+
+    /// <inheritdoc/>
+    public long? Size => _contentDisposition.Size;
+
+    /// <inheritdoc/>
+    public override string ToString()
+    {
+        return _contentDisposition.ToString();
+    }
+}

src/WireMock.Net.MimePart/Models/ContentTypeDataWrapper.cs

@@ -0,0 +1,65 @@
+// Copyright © WireMock.Net
+
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using MimeKit;
+using Stef.Validation;
+using WireMock.Models.Mime;
+
+namespace WireMock.Models;
+
+/// <summary>
+/// A wrapper class that implements the <see cref="IContentTypeData"/> interface by wrapping a <see cref="ContentType"/> object.
+/// </summary>
+/// <remarks>
+/// This class provides a simplified, read-only view of a <see cref="ContentType"/>.
+/// </remarks>
+public class ContentTypeDataWrapper : IContentTypeData
+{
+    private readonly ContentType _contentType;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="ContentTypeDataWrapper"/> class.
+    /// </summary>
+    /// <param name="contentType">The ContentType to wrap.</param>
+    public ContentTypeDataWrapper(ContentType contentType)
+    {
+        _contentType = Guard.NotNull(contentType);
+
+        Parameters = _contentType.Parameters.Select(p => p.ToString()).ToList();
+    }
+
+    /// <inheritdoc/>
+    public string MediaType => _contentType.MediaType;
+
+    /// <inheritdoc/>
+    public string MediaSubtype => _contentType.MediaSubtype;
+
+    /// <inheritdoc/>
+    public IList<string> Parameters { get; private set; }
+
+    /// <inheritdoc/>
+    public string Boundary => _contentType.Boundary;
+
+    /// <inheritdoc/>
+    public string Charset => _contentType.Charset;
+
+    /// <inheritdoc/>
+    public Encoding CharsetEncoding => _contentType.CharsetEncoding;
+
+    /// <inheritdoc/>
+    public string Format => _contentType.Format;
+
+    /// <inheritdoc/>
+    public string MimeType => _contentType.MimeType;
+
+    /// <inheritdoc/>
+    public string Name => _contentType.Name;
+
+    /// <inheritdoc/>
+    public override string ToString()
+    {
+        return _contentType.ToString();
+    }
+}

src/WireMock.Net.MimePart/Models/MimeEntityDataWrapper.cs

@@ -0,0 +1,61 @@
+// Copyright © WireMock.Net
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using MimeKit;
+using Stef.Validation;
+using WireMock.Models.Mime;
+
+namespace WireMock.Models;
+
+/// <summary>
+/// A wrapper class that implements the <see cref="IMimeEntityData" /> interface by wrapping an <see cref="IMimeEntity" /> interface.
+/// </summary>
+/// <remarks>
+/// This class provides a simplified, read-only view of an <see cref="IMimeEntity"/>.
+/// </remarks>
+public class MimeEntityDataWrapper : IMimeEntityData
+{
+    private readonly IMimeEntity _entity;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="MimeEntityDataWrapper"/> class.
+    /// </summary>
+    /// <param name="entity">The MIME entity to wrap.</param>
+    public MimeEntityDataWrapper(IMimeEntity entity)
+    {
+        _entity = Guard.NotNull(entity);
+
+        ContentDisposition = _entity.ContentDisposition != null ? new ContentDispositionDataWrapper(_entity.ContentDisposition) : null;
+        ContentType = _entity.ContentType != null ? new ContentTypeDataWrapper(_entity.ContentType) : null;
+        Headers = _entity.Headers.Select(h => h.ToString()).ToList();
+    }
+
+    /// <inheritdoc/>
+    public IList<string> Headers { get; private set; }
+
+    /// <inheritdoc/>
+    public IContentDispositionData? ContentDisposition { get; private set; }
+
+    /// <inheritdoc/>
+    public IContentTypeData? ContentType { get; private set; }
+
+    /// <inheritdoc/>
+    public Uri ContentBase => _entity.ContentBase;
+
+    /// <inheritdoc/>
+    public Uri ContentLocation => _entity.ContentLocation;
+
+    /// <inheritdoc/>
+    public string ContentId => _entity.ContentId;
+
+    /// <inheritdoc/>
+    public bool IsAttachment => _entity.IsAttachment;
+
+    /// <inheritdoc/>
+    public override string ToString()
+    {
+        return _entity.ToString()!;
+    }
+}

src/WireMock.Net.MimePart/Models/MimeMessageDataWrapper.cs

@@ -0,0 +1,140 @@
+// Copyright © WireMock.Net
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using MimeKit;
+using Stef.Validation;
+using WireMock.Models.Mime;
+
+namespace WireMock.Models;
+
+/// <summary>
+/// A wrapper class that implements the <see cref="IMimeMessageData" /> interface by wrapping an <see cref="IMimeMessage" /> interface.
+/// </summary>
+/// <remarks>
+/// This class provides a simplified, read-only view of an <see cref="IMimeMessage"/>.
+/// </remarks>
+internal class MimeMessageDataWrapper : IMimeMessageData
+{
+    private readonly IMimeMessage _message;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="MimeMessageDataWrapper"/> class.
+    /// </summary>
+    /// <param name="message">The MIME message to wrap.</param>
+    public MimeMessageDataWrapper(IMimeMessage message)
+    {
+        _message = Guard.NotNull(message);
+
+        Bcc = _message.Bcc.Select(h => h.ToString()).ToList();
+        Cc = _message.Cc.Select(h => h.ToString()).ToList();
+        From = _message.From.Select(h => h.ToString()).ToList();
+        Headers = _message.Headers.Select(h => h.ToString()).ToList();
+        References = _message.References.ToList();
+        ReplyTo = _message.ReplyTo.Select(h => h.ToString()).ToList();
+        ResentBcc = _message.ResentBcc.Select(h => h.ToString()).ToList();
+        ResentCc = _message.ResentCc.Select(h => h.ToString()).ToList();
+        ResentFrom = _message.ResentFrom.Select(h => h.ToString()).ToList();
+        ResentReplyTo = _message.ResentReplyTo.Select(h => h.ToString()).ToList();
+        ResentTo = _message.ResentTo.Select(h => h.ToString()).ToList();
+        To = _message.To.Select(h => h.ToString()).ToList();
+
+        Body = new MimeEntityDataWrapper(_message.Body);
+        BodyParts = _message.BodyParts.OfType<MimePart>().Select(mp => new MimePartDataWrapper(mp)).ToList<IMimePartData>();
+        Attachments = _message.Attachments.Select(me => new MimeEntityDataWrapper(me)).ToList<IMimeEntityData>();
+    }
+
+    /// <inheritdoc/>
+    public IList<string> Headers { get; private set; }
+
+    /// <inheritdoc/>
+    public int Importance => (int)_message.Importance;
+
+    /// <inheritdoc/>
+    public int Priority => (int)_message.Priority;
+
+    /// <inheritdoc/>
+    public int XPriority => (int)_message.XPriority;
+
+    /// <inheritdoc/>
+    public string Sender => _message.Sender.Address;
+
+    /// <inheritdoc/>
+    public string ResentSender => _message.ResentSender.ToString();
+
+    /// <inheritdoc/>
+    public IList<string> From { get; private set; }
+
+    /// <inheritdoc/>
+    public IList<string> ResentFrom { get; private set; }
+
+    /// <inheritdoc/>
+    public IList<string> ReplyTo { get; private set; }
+
+    /// <inheritdoc/>
+    public IList<string> ResentReplyTo { get; private set; }
+
+    /// <inheritdoc/>
+    public IList<string> To { get; private set; }
+
+    /// <inheritdoc/>
+    public IList<string> ResentTo { get; private set; }
+
+    /// <inheritdoc/>
+    public IList<string> Cc { get; private set; }
+
+    /// <inheritdoc/>
+    public IList<string> ResentCc { get; private set; }
+
+    /// <inheritdoc/>
+    public IList<string> Bcc { get; private set; }
+
+    /// <inheritdoc/>
+    public IList<string> ResentBcc { get; private set; }
+
+    /// <inheritdoc/>
+    public string Subject => _message.Subject;
+
+    /// <inheritdoc/>
+    public DateTimeOffset Date => _message.Date;
+
+    /// <inheritdoc/>
+    public DateTimeOffset ResentDate => _message.ResentDate;
+
+    /// <inheritdoc/>
+    public IList<string> References { get; private set; }
+
+    /// <inheritdoc/>
+    public string InReplyTo => _message.InReplyTo;
+
+    /// <inheritdoc/>
+    public string MessageId => _message.MessageId;
+
+    /// <inheritdoc/>
+    public string ResentMessageId => _message.ResentMessageId;
+
+    /// <inheritdoc/>
+    public Version MimeVersion => _message.MimeVersion;
+
+    /// <inheritdoc/>
+    public IMimeEntityData Body { get; private set; }
+
+    /// <inheritdoc/>
+    public string TextBody => _message.TextBody;
+
+    /// <inheritdoc/>
+    public string HtmlBody => _message.HtmlBody;
+
+    /// <inheritdoc/>
+    public IList<IMimePartData> BodyParts { get; private set; }
+
+    /// <inheritdoc/>
+    public IList<IMimeEntityData> Attachments { get; private set; }
+
+    /// <inheritdoc/>
+    public override string ToString()
+    {
+        return _message.ToString();
+    }
+}

src/WireMock.Net.MimePart/Models/MimePartDataWrapper.cs

@@ -0,0 +1,64 @@
+// Copyright © WireMock.Net
+
+using System.Collections.Generic;
+using System.IO;
+using MimeKit;
+using Stef.Validation;
+using WireMock.Models.Mime;
+
+namespace WireMock.Models;
+
+/// <summary>
+/// A wrapper class that implements the <see cref="IMimePartData" /> interface by wrapping an <see cref="IMimePart"/> interface.
+/// </summary>
+/// <remarks>
+/// This class provides a simplified, read-only view of an <see cref="IMimePart"/>.
+/// </remarks>
+public class MimePartDataWrapper : MimeEntityDataWrapper, IMimePartData
+{
+    private readonly IMimePart _part;
+
+    /// <summary>
+    /// Initializes a new instance of the <see cref="MimePartDataWrapper"/> class.
+    /// </summary>
+    /// <param name="part">The MIME part to wrap.</param>
+    /// <exception cref="System.ArgumentNullException">
+    /// <paramref name="part"/> is <see langword="null"/>.
+    /// </exception>
+    public MimePartDataWrapper(IMimePart part) : base(part)
+    {
+        _part = Guard.NotNull(part);
+    }
+
+    /// <inheritdoc/>
+    public string ContentDescription => _part.ContentDescription;
+
+    /// <inheritdoc/>
+    public int? ContentDuration => _part.ContentDuration;
+
+    /// <inheritdoc/>
+    public string ContentMd5 => _part.ContentMd5;
+
+    /// <inheritdoc/>
+    public string ContentTransferEncoding => _part.ContentTransferEncoding.ToString();
+
+    /// <inheritdoc/>
+    public string FileName => _part.FileName;
+
+    /// <inheritdoc/>
+    public IDictionary<string, object?> Content => new Dictionary<string, object?>()
+    {
+        { nameof(MimePart.Content.Encoding),  _part.Content.Encoding },
+        { nameof(MimePart.Content.NewLineFormat),  _part.Content.NewLineFormat },
+        { nameof(MimePart.Content.Stream),  _part.Content.Stream }
+    };
+
+    /// <inheritdoc/>
+    public Stream Open() => _part.Content.Open();
+
+    /// <inheritdoc/>
+    public override string ToString()
+    {
+        return _part.ToString()!;
+    }
+}

src/WireMock.Net.MimePart/Util/MimeKitUtils.cs

@@ -9,6 +9,8 @@ using System.Text;
 using MimeKit;
 using Stef.Validation;
 using WireMock.Http;
+using WireMock.Models;
+using WireMock.Models.Mime;
 using WireMock.Types;
 
 namespace WireMock.Util;
@@ -16,13 +18,13 @@ namespace WireMock.Util;
 internal class MimeKitUtils : IMimeKitUtils
 {
     /// <inheritdoc />
-    public object LoadFromStream(Stream stream)
+    public IMimeMessageData LoadFromStream(Stream stream)
     {
-        return MimeMessage.Load(Guard.NotNull(stream));
+        return new MimeMessageDataWrapper(MimeMessage.Load(Guard.NotNull(stream)));
     }
 
     /// <inheritdoc />
-    public bool TryGetMimeMessage(IRequestMessage requestMessage, [NotNullWhen(true)] out object? mimeMessage)
+    public bool TryGetMimeMessage(IRequestMessage requestMessage, [NotNullWhen(true)] out IMimeMessageData? mimeMessageData)
     {
         Guard.NotNull(requestMessage);
 
@@ -44,26 +46,14 @@ internal class MimeKitUtils : IMimeKitUtils
 
             var fixedBytes = FixBytes(bytes, contentTypeHeader[0]);
 
-            mimeMessage = LoadFromStream(new MemoryStream(fixedBytes));
+            mimeMessageData = LoadFromStream(new MemoryStream(fixedBytes));
             return true;
         }
 
-        mimeMessage = null;
+        mimeMessageData = null;
         return false;
     }
 
-    /// <inheritdoc />
-    public IReadOnlyList<object> GetBodyParts(object mimeMessage)
-    {
-        if (mimeMessage is not MimeMessage mm)
-        {
-            throw new ArgumentException($"The mimeMessage must be of type {nameof(MimeMessage)}", nameof(mimeMessage));
-        }
-
-        return mm.BodyParts
-            .OfType<MimePart>()
-            .ToArray();
-    }
 
     private static bool StartsWithMultiPart(WireMockList<string> contentTypeHeader)
     {

src/WireMock.Net.Minimal/Http/WireMockHttpClientFactory.cs

@@ -0,0 +1,18 @@
+// Copyright © WireMock.Net
+#if NET5_0_OR_GREATER
+using System;
+using System.Net.Http;
+using WireMock.Server;
+
+namespace WireMock.Http;
+
+internal class WireMockHttpClientFactory(WireMockServer server, params DelegatingHandler[] handlers) : IHttpClientFactory
+{
+    private readonly Lazy<HttpClient> _lazyHttpClient = new(() => server.CreateClient());
+
+    public HttpClient CreateClient(string name)
+    {
+        return handlers.Length > 0 ? server.CreateClient(handlers) : _lazyHttpClient.Value;
+    }
+}
+#endif

src/WireMock.Net.Minimal/IMapping.cs

@@ -86,7 +86,7 @@ public interface IMapping
     WireMockServerSettings Settings { get; }
 
     /// <summary>
-    /// Is State started ?
+    /// Indicates if the state is started or manually set to a value.
     /// </summary>
     bool IsStartState { get; }
 

src/WireMock.Net.Minimal/Matchers/Request/RequestMessageMultiPartMatcher.cs

@@ -72,7 +72,8 @@ public class RequestMessageMultiPartMatcher : IRequestMatcher
             foreach (var mimePartMatcher in Matchers.OfType<IMimePartMatcher>().ToArray())
             {
                 score = MatchScores.Mismatch;
-                foreach (var mimeBodyPart in MimeKitUtils.GetBodyParts(message))
+
+                foreach (var mimeBodyPart in message.BodyParts)
                 {
                     var matchResult = mimePartMatcher.IsMatch(mimeBodyPart);
                     if (matchResult.IsPerfect())

src/WireMock.Net.Minimal/Models/GraphQLSchemaDetails.cs

@@ -4,6 +4,7 @@ using System;
 using System.Collections.Generic;
 using AnyOfTypes;
 using Newtonsoft.Json;
+using WireMock.Models.GraphQL;
 
 namespace WireMock.Models;
 
@@ -22,17 +23,16 @@ public class GraphQLSchemaDetails
     /// </summary>
     public StringPattern? SchemaAsStringPattern { get; set; }
 
-#if GRAPHQL
     /// <summary>
-    /// The GraphQL schema as a <seealso cref="GraphQL.Types.ISchema"/>.
+    /// The GraphQL schema as a <seealso cref="ISchemaData"/>.
     /// </summary>
-    public GraphQL.Types.ISchema? SchemaAsISchema { get; set; }
+    public ISchemaData? SchemaAsISchemaData { get; set; }
 
     /// <summary>
     /// The GraphQL Schema.
     /// </summary>
     [JsonIgnore]
-    public AnyOf<string, StringPattern, GraphQL.Types.ISchema>? Schema
+    public AnyOf<string, StringPattern, ISchemaData>? Schema
     {
         get
         {
@@ -46,15 +46,14 @@ public class GraphQLSchemaDetails
                 return SchemaAsStringPattern;
             }
 
-            if (SchemaAsISchema != null)
+            if (SchemaAsISchemaData != null)
             {
-                return new AnyOf<string, StringPattern, GraphQL.Types.ISchema>(SchemaAsISchema);
+                return new AnyOf<string, StringPattern, ISchemaData>(SchemaAsISchemaData);
             }
 
             return null;
         }
     }
-#endif
 
     /// <summary>
     /// The custom Scalars to define for this schema.

src/WireMock.Net.Minimal/RequestBuilders/IGraphQLRequestBuilder.cs

@@ -1,83 +0,0 @@
-// Copyright © WireMock.Net
-
-using System;
-using System.Collections.Generic;
-using WireMock.Matchers;
-
-namespace WireMock.RequestBuilders;
-
-/// <summary>
-/// The GraphQLRequestBuilder interface.
-/// </summary>
-public interface IGraphQLRequestBuilder : IMultiPartRequestBuilder
-{
-    /// <summary>
-    /// WithGraphQLSchema: The GraphQL schema as a string.
-    /// </summary>
-    /// <param name="schema">The GraphQL schema.</param>
-    /// <param name="matchBehaviour">The match behaviour. (Default is <c>MatchBehaviour.AcceptOnMatch</c>).</param>
-    /// <returns>The <see cref="IRequestBuilder"/>.</returns>
-    IRequestBuilder WithGraphQLSchema(string schema, MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch);
-
-    /// <summary>
-    /// WithGraphQLSchema: The GraphQL schema as a string.
-    /// </summary>
-    /// <param name="schema">The GraphQL schema.</param>
-    /// <param name="customScalars">A dictionary defining the custom scalars used in this schema. (optional)</param>
-    /// <param name="matchBehaviour">The match behaviour. (Default is <c>MatchBehaviour.AcceptOnMatch</c>).</param>
-    /// <returns>The <see cref="IRequestBuilder"/>.</returns>
-    IRequestBuilder WithGraphQLSchema(string schema, IDictionary<string, Type>? customScalars, MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch);
-
-    /// <summary>
-    /// WithBodyAsGraphQL: The GraphQL schema as a string.
-    /// </summary>
-    /// <param name="schema">The GraphQL schema.</param>
-    /// <param name="matchBehaviour">The match behaviour. (Default is <c>MatchBehaviour.AcceptOnMatch</c>).</param>
-    /// <returns>The <see cref="IRequestBuilder"/>.</returns>
-    IRequestBuilder WithBodyAsGraphQL(string schema, MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch);
-
-    /// <summary>
-    /// WithBodyAsGraphQL: The GraphQL schema as a string.
-    /// </summary>
-    /// <param name="schema">The GraphQL schema.</param>
-    /// <param name="customScalars">A dictionary defining the custom scalars used in this schema. (optional)</param>
-    /// <param name="matchBehaviour">The match behaviour. (Default is <c>MatchBehaviour.AcceptOnMatch</c>).</param>
-    /// <returns>The <see cref="IRequestBuilder"/>.</returns>
-    IRequestBuilder WithBodyAsGraphQL(string schema, IDictionary<string, Type>? customScalars, MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch);
-
-#if GRAPHQL
-    /// <summary>
-    /// WithGraphQLSchema: The GraphQL schema as a ISchema.
-    /// </summary>
-    /// <param name="schema">The GraphQL schema.</param>
-    /// <param name="matchBehaviour">The match behaviour. (Default is <c>MatchBehaviour.AcceptOnMatch</c>).</param>
-    /// <returns>The <see cref="IRequestBuilder"/>.</returns>
-    IRequestBuilder WithGraphQLSchema(GraphQL.Types.ISchema schema, MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch);
-
-    /// <summary>
-    /// WithGraphQLSchema: The GraphQL schema as a ISchema.
-    /// </summary>
-    /// <param name="schema">The GraphQL schema.</param>
-    /// <param name="customScalars">A dictionary defining the custom scalars used in this schema. (optional)</param>
-    /// <param name="matchBehaviour">The match behaviour. (Default is <c>MatchBehaviour.AcceptOnMatch</c>).</param>
-    /// <returns>The <see cref="IRequestBuilder"/>.</returns>
-    IRequestBuilder WithGraphQLSchema(GraphQL.Types.ISchema schema, IDictionary<string, Type>? customScalars, MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch);
-
-    /// <summary>
-    /// WithBodyAsGraphQL: The GraphQL schema as a ISchema.
-    /// </summary>
-    /// <param name="schema">The GraphQL schema.</param>
-    /// <param name="matchBehaviour">The match behaviour. (Default is <c>MatchBehaviour.AcceptOnMatch</c>).</param>
-    /// <returns>The <see cref="IRequestBuilder"/>.</returns>
-    IRequestBuilder WithBodyAsGraphQL(GraphQL.Types.ISchema schema, MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch);
-
-    /// <summary>
-    /// WithBodyAsGraphQL: The GraphQL schema as a ISchema.
-    /// </summary>
-    /// <param name="schema">The GraphQL schema.</param>
-    /// <param name="customScalars">A dictionary defining the custom scalars used in this schema. (optional)</param>
-    /// <param name="matchBehaviour">The match behaviour. (Default is <c>MatchBehaviour.AcceptOnMatch</c>).</param>
-    /// <returns>The <see cref="IRequestBuilder"/>.</returns>
-    IRequestBuilder WithBodyAsGraphQL(GraphQL.Types.ISchema schema, IDictionary<string, Type>? customScalars, MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch);
-#endif
-}

src/WireMock.Net.Minimal/RequestBuilders/Request.WithBody.cs

@@ -98,10 +98,4 @@ public partial class Request
         _requestMatchers.Add(new RequestMessageBodyMatcher(Guard.NotNull(func)));
         return this;
     }
-
-    /// <inheritdoc />
-    public IRequestBuilder WithBodyAsGraphQLSchema(string body, MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch)
-    {
-        return WithGraphQLSchema(body, matchBehaviour);
-    }
 }

src/WireMock.Net.Minimal/RequestBuilders/Request.WithGraphQLSchema.cs

@@ -1,61 +0,0 @@
-// Copyright © WireMock.Net
-
-using System.Collections.Generic;
-using System;
-using WireMock.Matchers;
-using WireMock.Matchers.Request;
-
-namespace WireMock.RequestBuilders;
-
-public partial class Request
-{
-    /// <inheritdoc />
-    public IRequestBuilder WithGraphQLSchema(string schema, MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch)
-    {
-        return WithBodyAsGraphQL(schema, matchBehaviour);
-    }
-
-    /// <inheritdoc />
-    public IRequestBuilder WithGraphQLSchema(string schema, IDictionary<string, Type>? customScalars, MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch)
-    {
-        return WithBodyAsGraphQL(schema, customScalars, matchBehaviour);
-    }
-
-    /// <inheritdoc />
-    public IRequestBuilder WithBodyAsGraphQL(string schema, MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch)
-    {
-        return Add(new RequestMessageGraphQLMatcher(matchBehaviour, schema));
-    }
-
-    /// <inheritdoc />
-    public IRequestBuilder WithBodyAsGraphQL(string schema, IDictionary<string, Type>? customScalars, MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch)
-    {
-        return Add(new RequestMessageGraphQLMatcher(matchBehaviour, schema, customScalars));
-    }
-
-#if GRAPHQL
-    /// <inheritdoc />
-    public IRequestBuilder WithGraphQLSchema(GraphQL.Types.ISchema schema, MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch)
-    {
-        return WithBodyAsGraphQL(schema, matchBehaviour);
-    }
-
-    /// <inheritdoc />
-    public IRequestBuilder WithGraphQLSchema(GraphQL.Types.ISchema schema, IDictionary<string, Type>? customScalars, MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch)
-    {
-        return WithBodyAsGraphQL(schema, customScalars, matchBehaviour);
-    }
-
-    /// <inheritdoc />
-    public IRequestBuilder WithBodyAsGraphQL(GraphQL.Types.ISchema schema, MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch)
-    {
-        return Add(new RequestMessageGraphQLMatcher(matchBehaviour, schema));
-    }
-
-    /// <inheritdoc />
-    public IRequestBuilder WithBodyAsGraphQL(GraphQL.Types.ISchema schema, IDictionary<string, Type>? customScalars, MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch)
-    {
-        return Add(new RequestMessageGraphQLMatcher(matchBehaviour, schema, customScalars));
-    }
-#endif
-}

src/WireMock.Net.Minimal/RequestBuilders/Request.cs

@@ -73,6 +73,17 @@ public partial class Request : RequestMessageCompositeMatcher, IRequestBuilder
         return _requestMatchers.OfType<T>().FirstOrDefault(func);
     }
 
+    public IRequestBuilder Add<T>(T requestMatcher) where T : IRequestMatcher
+    {
+        foreach (var existing in _requestMatchers.OfType<T>().ToArray())
+        {
+            _requestMatchers.Remove(existing);
+        }
+
+        _requestMatchers.Add(requestMatcher);
+        return this;
+    }
+
     internal bool TryGetProtoBufMatcher([NotNullWhen(true)] out IProtoBufMatcher? protoBufMatcher)
     {
         protoBufMatcher = GetRequestMessageMatcher<RequestMessageProtoBufMatcher>()?.Matcher;
@@ -85,15 +96,4 @@ public partial class Request : RequestMessageCompositeMatcher, IRequestBuilder
         protoBufMatcher = bodyMatcher?.Matchers?.OfType<IProtoBufMatcher>().FirstOrDefault();
         return protoBufMatcher != null;
     }
-
-    private IRequestBuilder Add<T>(T requestMatcher) where T : IRequestMatcher
-    {
-        foreach (var existing in _requestMatchers.OfType<T>().ToArray())
-        {
-            _requestMatchers.Remove(existing);
-        }
-
-        _requestMatchers.Add(requestMatcher);
-        return this;
-    }
 }

src/WireMock.Net.Minimal/RequestMessage.cs

@@ -85,7 +85,7 @@ public class RequestMessage : IRequestMessage
 #if MIMEKIT
     /// <inheritdoc />
     [Newtonsoft.Json.JsonIgnore] // Issue 1001
-    public object? BodyAsMimeMessage { get; }
+    public Models.Mime.IMimeMessageData? BodyAsMimeMessage { get; }
 #endif
 
     /// <inheritdoc />

src/WireMock.Net.Minimal/Serialization/MappingConverter.cs

@@ -13,7 +13,6 @@ using WireMock.Constants;
 using WireMock.Extensions;
 using WireMock.Matchers;
 using WireMock.Matchers.Request;
-using WireMock.Models;
 using WireMock.RequestBuilders;
 using WireMock.ResponseBuilders;
 using WireMock.Types;
@@ -111,15 +110,13 @@ internal class MappingConverter(MatcherMapper mapper)
             sb.AppendLine($"        .WithHttpVersion({requestMessageHttpVersionMatcher.HttpVersion})");
         }
 
-#if GRAPHQL
         if (requestMessageGraphQLMatcher?.Matchers != null)
         {
-            if (requestMessageGraphQLMatcher.Matchers.OfType<GraphQLMatcher>().FirstOrDefault() is { } graphQLMatcher && graphQLMatcher.GetPatterns().Any())
+            if (requestMessageGraphQLMatcher.Matchers.OfType<IGraphQLMatcher>().FirstOrDefault() is { } graphQLMatcher && graphQLMatcher.GetPatterns().Any())
             {
                 sb.AppendLine($"        .WithGraphQLSchema({GetString(graphQLMatcher)})");
             }
         }
-#endif
 
         if (requestMessageMultiPartMatcher?.Matchers != null)
         {

src/WireMock.Net.Minimal/Serialization/MatcherMapper.cs

@@ -10,6 +10,7 @@ using WireMock.Admin.Mappings;
 using WireMock.Extensions;
 using WireMock.Matchers;
 using WireMock.Models;
+using WireMock.Models.GraphQL;
 using WireMock.Settings;
 using WireMock.Util;
 
@@ -70,10 +71,11 @@ internal class MatcherMapper
 
             case nameof(ExactObjectMatcher):
                 return CreateExactObjectMatcher(matchBehaviour, stringPatterns[0]);
-#if GRAPHQL
-            case nameof(GraphQLMatcher):
-                return new GraphQLMatcher(stringPatterns[0].GetPattern(), matcherModel.CustomScalars, matchBehaviour, matchOperator);
-#endif
+
+            case "GraphQLMatcher":
+                var patternAsString = stringPatterns[0].GetPattern();
+                var schema = new AnyOf<string, StringPattern, ISchemaData>(patternAsString);
+                return TypeLoader.LoadNewInstance<IGraphQLMatcher>(schema, matcherModel.CustomScalars, matchBehaviour, matchOperator);
 
             case "MimePartMatcher":
                 return CreateMimePartMatcher(matchBehaviour, matcherModel);
@@ -165,11 +167,10 @@ internal class MatcherMapper
             case XPathMatcher xpathMatcher:
                 model.XmlNamespaceMap = xpathMatcher.XmlNamespaceMap;
                 break;
-#if GRAPHQL
-            case GraphQLMatcher graphQLMatcher:
+
+            case IGraphQLMatcher graphQLMatcher:
                 model.CustomScalars = graphQLMatcher.CustomScalars;
                 break;
-#endif
         }
 
         switch (matcher)
@@ -277,10 +278,10 @@ internal class MatcherMapper
 
     private IMimePartMatcher CreateMimePartMatcher(MatchBehaviour matchBehaviour, MatcherModel matcher)
     {
-        var contentTypeMatcher = Map(matcher?.ContentTypeMatcher) as IStringMatcher;
-        var contentDispositionMatcher = Map(matcher?.ContentDispositionMatcher) as IStringMatcher;
-        var contentTransferEncodingMatcher = Map(matcher?.ContentTransferEncodingMatcher) as IStringMatcher;
-        var contentMatcher = Map(matcher?.ContentMatcher);
+        var contentTypeMatcher = Map(matcher.ContentTypeMatcher) as IStringMatcher;
+        var contentDispositionMatcher = Map(matcher.ContentDispositionMatcher) as IStringMatcher;
+        var contentTransferEncodingMatcher = Map(matcher.ContentTransferEncodingMatcher) as IStringMatcher;
+        var contentMatcher = Map(matcher.ContentMatcher);
 
         return TypeLoader.LoadNewInstance<IMimePartMatcher>(matchBehaviour, contentTypeMatcher, contentDispositionMatcher, contentTransferEncodingMatcher, contentMatcher);
     }

src/WireMock.Net.Minimal/Serialization/PactMapper.cs

@@ -42,8 +42,7 @@ internal static class PactMapper
 
             var interaction = new Interaction
             {
-                Description = mapping.Description,
-                ProviderState = mapping.Title,
+                Description = !string.IsNullOrWhiteSpace(mapping.Description) ? mapping.Description : mapping.Title ?? string.Empty,
                 Request = MapRequest(mapping.Request, path),
                 Response = MapResponse(mapping.Response)
             };

src/WireMock.Net.Minimal/Server/WireMockServer.Admin.cs

@@ -66,6 +66,7 @@ public partial class WireMockServer
         public RegexMatcher MappingsCodeGuidPathMatcher => new($"^{_prefixEscaped}\\/mappings\\/code\\/([0-9A-Fa-f]{{8}}[-][0-9A-Fa-f]{{4}}[-][0-9A-Fa-f]{{4}}[-][0-9A-Fa-f]{{4}}[-][0-9A-Fa-f]{{12}})$");
         public RegexMatcher RequestsGuidPathMatcher => new($"^{_prefixEscaped}\\/requests\\/([0-9A-Fa-f]{{8}}[-][0-9A-Fa-f]{{4}}[-][0-9A-Fa-f]{{4}}[-][0-9A-Fa-f]{{4}}[-][0-9A-Fa-f]{{12}})$");
         public RegexMatcher ScenariosNameMatcher => new($"^{_prefixEscaped}\\/scenarios\\/.+$");
+        public RegexMatcher ScenariosNameWithStateMatcher => new($"^{_prefixEscaped}\\/scenarios\\/.+\\/state$");
         public RegexMatcher ScenariosNameWithResetMatcher => new($"^{_prefixEscaped}\\/scenarios\\/.+\\/reset$");
         public RegexMatcher FilesFilenamePathMatcher => new($"^{_prefixEscaped}\\/files\\/.+$");
         public RegexMatcher ProtoDefinitionsIdPathMatcher => new($"^{_prefixEscaped}\\/protodefinitions\\/.+$");
@@ -138,6 +139,9 @@ public partial class WireMockServer
         Given(Request.Create().WithPath(_adminPaths.Scenarios + "/reset").UsingPost()).AtPriority(WireMockConstants.AdminPriority).RespondWith(new DynamicResponseProvider(ScenariosReset));
         Given(Request.Create().WithPath(_adminPaths.ScenariosNameWithResetMatcher).UsingPost()).AtPriority(WireMockConstants.AdminPriority).RespondWith(new DynamicResponseProvider(ScenarioReset));
 
+        // __admin/scenarios/{scenario}/state
+        Given(Request.Create().WithPath(_adminPaths.ScenariosNameWithStateMatcher).UsingPut()).AtPriority(WireMockConstants.AdminPriority).RespondWith(new DynamicResponseProvider(ScenariosSetState));
+
         // __admin/files/{filename}
         Given(Request.Create().WithPath(_adminPaths.FilesFilenamePathMatcher).UsingPost()).AtPriority(WireMockConstants.AdminPriority).RespondWith(new DynamicResponseProvider(FilePost));
         Given(Request.Create().WithPath(_adminPaths.FilesFilenamePathMatcher).UsingPut()).AtPriority(WireMockConstants.AdminPriority).RespondWith(new DynamicResponseProvider(FilePut));
@@ -705,6 +709,21 @@ public partial class WireMockServer
             ResponseMessageBuilder.Create(200, "Scenario reset") :
             ResponseMessageBuilder.Create(HttpStatusCode.NotFound, $"No scenario found by name '{name}'.");
     }
+
+    private IResponseMessage ScenariosSetState(IRequestMessage requestMessage)
+    {
+        var name = requestMessage.Path.Split('/').Reverse().Skip(1).First();
+        if (!_options.Scenarios.ContainsKey(name))
+        {
+            ResponseMessageBuilder.Create(HttpStatusCode.NotFound, $"No scenario found by name '{name}'.");
+        }
+
+        var update = DeserializeObject<ScenarioStateUpdateModel>(requestMessage);
+
+        return SetScenarioState(name, update.State) ?
+            ResponseMessageBuilder.Create(200, $"Scenario state set to '{update.State}'") :
+            ResponseMessageBuilder.Create(HttpStatusCode.NotFound, $"No scenario found by name '{name}'.");
+    }
     #endregion
 
     #region Pact

src/WireMock.Net.Minimal/Server/WireMockServer.cs

@@ -120,6 +120,32 @@ public partial class WireMockServer : IWireMockServer
     #endregion
 
     #region HttpClient
+#if NET5_0_OR_GREATER
+    private readonly Lazy<IHttpClientFactory> _lazyHttpClientFactory;
+
+    /// <summary>
+    /// Create a <see cref="IHttpClientFactory"/> which can be used to generate a HttpClient to call this instance.
+    /// <param name="handlers">
+    /// An ordered list of System.Net.Http.DelegatingHandler instances to be invoked
+    /// as an System.Net.Http.HttpRequestMessage travels from the System.Net.Http.HttpClient
+    /// to the network and an System.Net.Http.HttpResponseMessage travels from the network
+    /// back to System.Net.Http.HttpClient. The handlers are invoked in a top-down fashion.
+    /// That is, the first entry is invoked first for an outbound request message but
+    /// last for an inbound response message.
+    /// </param>
+    /// </summary>
+    [PublicAPI]
+    public IHttpClientFactory CreateHttpClientFactory(params DelegatingHandler[] handlers)
+    {
+        if (!IsStarted)
+        {
+            throw new InvalidOperationException("Unable to create IHttpClientFactory because the service is not started.");
+        }
+
+        return handlers.Length > 0 ? new WireMockHttpClientFactory(this, handlers) : _lazyHttpClientFactory.Value;
+    }
+#endif
+
     /// <summary>
     /// Create a <see cref="HttpClient"/> which can be used to call this instance.
     /// <param name="handlers">
@@ -427,6 +453,10 @@ public partial class WireMockServer : IWireMockServer
         }
 
         InitSettings(settings);
+
+#if NET5_0_OR_GREATER
+        _lazyHttpClientFactory = new Lazy<IHttpClientFactory>(() => new WireMockHttpClientFactory(this));
+#endif
     }
 
     /// <inheritdoc cref="IWireMockServer.Stop" />
@@ -567,6 +597,32 @@ public partial class WireMockServer : IWireMockServer
         return _options.Scenarios.ContainsKey(name) && _options.Scenarios.TryRemove(name, out _);
     }
 
+    /// <inheritdoc />
+    [PublicAPI]
+    public bool SetScenarioState(string name, string? state)
+    {
+        if (state == null)
+        {
+            return ResetScenario(name);
+        }
+
+        _options.Scenarios.AddOrUpdate(
+            name,
+            _ => new ScenarioState
+            {
+                Name = name,
+                NextState = state
+            },
+            (_, current) =>
+            {
+                current.NextState = state;
+                return current;
+            }
+        );
+
+        return true;
+    }
+
     /// <inheritdoc cref="IWireMockServer.WithMapping(MappingModel[])" />
     [PublicAPI]
     public IWireMockServer WithMapping(params MappingModel[] mappings)

src/WireMock.Net.Minimal/Transformers/Handlebars/HandlebarsContext.cs

@@ -1,5 +1,6 @@
 // Copyright © WireMock.Net
 
+using System.Text.RegularExpressions;
 using HandlebarsDotNet;
 using HandlebarsDotNet.Helpers.Extensions;
 using Stef.Validation;
@@ -9,6 +10,8 @@ namespace WireMock.Transformers.Handlebars;
 
 internal class HandlebarsContext : IHandlebarsContext
 {
+    private static readonly Regex _tryEvaluateRegex = new(@"\{\{.*?\}\}", RegexOptions.Compiled);
+
     public IHandlebars Handlebars { get; }
 
     public IFileSystemHandler FileSystemHandler { get; }
@@ -27,9 +30,8 @@ internal class HandlebarsContext : IHandlebarsContext
 
     public object? ParseAndEvaluate(string text, object model)
     {
-        if (text.StartsWith("{{") && text.EndsWith("}}") &&
-            Handlebars.TryEvaluate(text, model, out var result) &&
-            result is not UndefinedBindingResult)
+        // Only try to evaluate if the text matches the pattern `{{ xxx }}` exactly once.
+        if (_tryEvaluateRegex.Matches(text).Count == 1 && Handlebars.TryEvaluate(text, model, out var result) && result is not UndefinedBindingResult)
         {
             return result;
         }

src/WireMock.Net.Minimal/WireMock.Net.Minimal.csproj

@@ -126,7 +126,6 @@
     </ItemGroup>
 
     <ItemGroup Condition="'$(TargetFramework)' != 'netstandard1.3' and '$(TargetFramework)' != 'net451' and '$(TargetFramework)' != 'net452' and '$(TargetFramework)' != 'net46' and '$(TargetFramework)' != 'net461'">
-        <PackageReference Include="GraphQL.NewtonsoftJson" Version="8.2.1" />
         <PackageReference Include="ProtoBufJsonConverter" Version="0.10.0" />
     </ItemGroup>
 
@@ -167,7 +166,7 @@
     </ItemGroup>
 
     <ItemGroup Condition="'$(TargetFramework)' != 'netstandard1.3' and '$(TargetFramework)' != 'net451' and '$(TargetFramework)' != 'net452' ">
-        <PackageReference Include="Handlebars.Net.Helpers.Xslt" Version="2.4.6" />
+        <PackageReference Include="Handlebars.Net.Helpers.Xslt" Version="2.5.2" />
     </ItemGroup>
 
     <!--<ItemGroup>

src/WireMock.Net.RestClient/IWireMockAdminApi.cs

@@ -256,7 +256,7 @@ public interface IWireMockAdminApi
     /// Delete (reset) all scenarios
     /// </summary>
     /// <param name="cancellationToken">The optional cancellationToken.</param>
-    [Post("scenarios")]
+    [Post("scenarios/reset")]
     Task<StatusModel> ResetScenariosAsync(CancellationToken cancellationToken = default);
 
     /// <summary>
@@ -269,7 +269,7 @@ public interface IWireMockAdminApi
     Task<StatusModel> DeleteScenarioAsync([Path] string name, CancellationToken cancellationToken = default);
 
     /// <summary>
-    /// Delete (reset) all scenarios
+    /// Delete (reset) a specific scenario
     /// </summary>
     /// <param name="name">Scenario name.</param>
     /// <param name="cancellationToken">The optional cancellationToken.</param>
@@ -277,6 +277,16 @@ public interface IWireMockAdminApi
     [AllowAnyStatusCode]
     Task<StatusModel> ResetScenarioAsync([Path] string name, CancellationToken cancellationToken = default);
 
+    /// <summary>
+    /// Update the state for a scenario.
+    /// </summary>
+    /// <param name="name">Scenario name.</param>
+    /// <param name="updateModel">Scenario state update model.</param>
+    /// <param name="cancellationToken">The optional cancellationToken.</param>
+    [Put("scenarios/{name}/state")]
+    [AllowAnyStatusCode]
+    Task<StatusModel> PutScenarioStateAsync([Path] string name, [Body] ScenarioStateUpdateModel updateModel, CancellationToken cancellationToken = default);
+
     /// <summary>
     /// Create a new File
     /// </summary>

src/WireMock.Net.Shared/Extensions/AnyOfExtensions.cs

@@ -13,10 +13,10 @@ namespace WireMock.Extensions;
 public static class AnyOfExtensions
 {
     /// <summary>
-    /// Gets the pattern.
+    /// Gets the pattern as string value.
     /// </summary>
     /// <param name="value">AnyOf type</param>
-    /// <returns>string value</returns>
+    /// <returns>The string value</returns>
     public static string GetPattern(this AnyOf<string, StringPattern> value)
     {
         return value.IsFirst ? value.First : value.Second.Pattern;

src/WireMock.Net.Shared/Matchers/Helpers/BodyDataMatchScoreCalculator.cs

@@ -34,14 +34,10 @@ internal static class BodyDataMatchScoreCalculator
             }
         }
 
-        if (matcher is ExactObjectMatcher exactObjectMatcher)
+        if (matcher is ExactObjectMatcher { Value: byte[] } exactObjectMatcher)
         {
             // If the body is a byte array, try to match.
-            var detectedBodyType = requestMessage.DetectedBodyType;
-            if (detectedBodyType is BodyType.Bytes or BodyType.String or BodyType.FormUrlEncoded)
-            {
-                return exactObjectMatcher.IsMatch(requestMessage.BodyAsBytes);
-            }
+            return exactObjectMatcher.IsMatch(requestMessage.BodyAsBytes);
         }
 
         // Check if the matcher is a IObjectMatcher
@@ -74,4 +70,4 @@ internal static class BodyDataMatchScoreCalculator
 
         return default;
     }
-}
+}

src/WireMock.Net.Shared/Matchers/ICSharpCodeMatcher.cs

@@ -7,6 +7,4 @@ namespace WireMock.Matchers;
 /// </summary>
 /// <inheritdoc cref="IObjectMatcher"/>
 /// <inheritdoc cref="IStringMatcher"/>
-public interface ICSharpCodeMatcher : IObjectMatcher, IStringMatcher
-{
-}
+public interface ICSharpCodeMatcher : IObjectMatcher, IStringMatcher;

src/WireMock.Net.Shared/Matchers/IGraphQLMatcher.cs

@@ -0,0 +1,18 @@
+// Copyright © WireMock.Net
+
+using System;
+using System.Collections.Generic;
+
+namespace WireMock.Matchers;
+
+/// <summary>
+/// GraphQLMatcher
+/// </summary>
+/// <inheritdoc cref="IStringMatcher"/>
+public interface IGraphQLMatcher : IStringMatcher
+{
+    /// <summary>
+    /// An optional dictionary defining the custom Scalar and the type.
+    /// </summary>
+    public IDictionary<string, Type>? CustomScalars { get; }
+}

src/WireMock.Net.Shared/Matchers/IMimePartMatcher.cs

@@ -1,5 +1,7 @@
 // Copyright © WireMock.Net
 
+using WireMock.Models.Mime;
+
 namespace WireMock.Matchers;
 
 /// <summary>
@@ -33,5 +35,5 @@ public interface IMimePartMatcher : IMatcher
     /// </summary>
     /// <param name="value">The MimePart.</param>
     /// <returns>A value between 0.0 - 1.0 of the similarity.</returns>
-    public MatchResult IsMatch(object value);
+    public MatchResult IsMatch(IMimePartData value);
 }

src/WireMock.Net.Shared/Matchers/Request/RequestMessageGraphQLMatcher.cs

@@ -3,8 +3,12 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using AnyOfTypes;
 using Stef.Validation;
+using WireMock.Models;
+using WireMock.Models.GraphQL;
 using WireMock.Types;
+using WireMock.Util;
 
 namespace WireMock.Matchers.Request;
 
@@ -34,18 +38,16 @@ public class RequestMessageGraphQLMatcher : IRequestMatcher
     {
     }
 
-#if GRAPHQL
     /// <summary>
     /// Initializes a new instance of the <see cref="RequestMessageGraphQLMatcher"/> class.
     /// </summary>
     /// <param name="matchBehaviour">The match behaviour.</param>
     /// <param name="schema">The schema.</param>
     /// <param name="customScalars">A dictionary defining the custom scalars used in this schema. [optional]</param>
-    public RequestMessageGraphQLMatcher(MatchBehaviour matchBehaviour, GraphQL.Types.ISchema schema, IDictionary<string, Type>? customScalars = null) :
-        this(CreateMatcherArray(matchBehaviour, new AnyOfTypes.AnyOf<string, WireMock.Models.StringPattern, GraphQL.Types.ISchema>(schema), customScalars))
+    public RequestMessageGraphQLMatcher(MatchBehaviour matchBehaviour, ISchemaData schema, IDictionary<string, Type>? customScalars = null) :
+        this(CreateMatcherArray(matchBehaviour, new AnyOf<string, StringPattern, ISchemaData>(schema), customScalars))
     {
     }
-#endif
 
     /// <summary>
     /// Initializes a new instance of the <see cref="RequestMessageGraphQLMatcher"/> class.
@@ -89,22 +91,16 @@ public class RequestMessageGraphQLMatcher : IRequestMatcher
 
     private IReadOnlyList<MatchResult> CalculateMatchResults(IRequestMessage requestMessage)
     {
-        return Matchers == null ? new[] { new MatchResult() } : Matchers.Select(matcher => CalculateMatchResult(requestMessage, matcher)).ToArray();
+        return Matchers == null ? [new MatchResult()] : Matchers.Select(matcher => CalculateMatchResult(requestMessage, matcher)).ToArray();
     }
 
-#if GRAPHQL
     private static IMatcher[] CreateMatcherArray(
         MatchBehaviour matchBehaviour,
-        AnyOfTypes.AnyOf<string, WireMock.Models.StringPattern, GraphQL.Types.ISchema> schema,
+        AnyOf<string, StringPattern, ISchemaData> schema,
         IDictionary<string, Type>? customScalars
     )
     {
-        return new[] { new GraphQLMatcher(schema, customScalars, matchBehaviour) }.Cast<IMatcher>().ToArray();
+        var graphQLMatcher = TypeLoader.LoadNewInstance<IGraphQLMatcher>(schema, customScalars, matchBehaviour, MatchOperator.Or);
+        return [graphQLMatcher];
     }
-#else
-    private static IMatcher[] CreateMatcherArray(MatchBehaviour matchBehaviour, object schema, IDictionary<string, Type>? customScalars)
-    {
-        throw new System.NotSupportedException("The GrapQLMatcher can not be used for .NETStandard1.3 or .NET Framework 4.6.1 or lower.");
-    }
-#endif
 }

src/WireMock.Net.Shared/Properties/AssemblyInfo.cs

@@ -4,6 +4,7 @@ using System.Runtime.CompilerServices;
 
 [assembly: InternalsVisibleTo("WireMock.Net.Minimal, PublicKey=0024000004800000940000000602000000240000525341310004000001000100e138ec44d93acac565953052636eb8d5e7e9f27ddb030590055cd1a0ab2069a5623f1f77ca907d78e0b37066ca0f6d63da7eecc3fcb65b76aa8ebeccf7ebe1d11264b8404cd9b1cbbf2c83f566e033b3e54129f6ef28daffff776ba7aebbc53c0d635ebad8f45f78eb3f7e0459023c218f003416e080f96a1a3c5ffeb56bee9e")]
 [assembly: InternalsVisibleTo("WireMock.Net.MimePart, PublicKey=0024000004800000940000000602000000240000525341310004000001000100e138ec44d93acac565953052636eb8d5e7e9f27ddb030590055cd1a0ab2069a5623f1f77ca907d78e0b37066ca0f6d63da7eecc3fcb65b76aa8ebeccf7ebe1d11264b8404cd9b1cbbf2c83f566e033b3e54129f6ef28daffff776ba7aebbc53c0d635ebad8f45f78eb3f7e0459023c218f003416e080f96a1a3c5ffeb56bee9e")]
+[assembly: InternalsVisibleTo("WireMock.Net.GraphQL, PublicKey=0024000004800000940000000602000000240000525341310004000001000100e138ec44d93acac565953052636eb8d5e7e9f27ddb030590055cd1a0ab2069a5623f1f77ca907d78e0b37066ca0f6d63da7eecc3fcb65b76aa8ebeccf7ebe1d11264b8404cd9b1cbbf2c83f566e033b3e54129f6ef28daffff776ba7aebbc53c0d635ebad8f45f78eb3f7e0459023c218f003416e080f96a1a3c5ffeb56bee9e")]
 [assembly: InternalsVisibleTo("WireMock.Net.Matchers.CSharpCode, PublicKey=0024000004800000940000000602000000240000525341310004000001000100e138ec44d93acac565953052636eb8d5e7e9f27ddb030590055cd1a0ab2069a5623f1f77ca907d78e0b37066ca0f6d63da7eecc3fcb65b76aa8ebeccf7ebe1d11264b8404cd9b1cbbf2c83f566e033b3e54129f6ef28daffff776ba7aebbc53c0d635ebad8f45f78eb3f7e0459023c218f003416e080f96a1a3c5ffeb56bee9e")]
 // [assembly: InternalsVisibleTo("WireMock.Net.StandAlone, PublicKey=0024000004800000940000000602000000240000525341310004000001000100e138ec44d93acac565953052636eb8d5e7e9f27ddb030590055cd1a0ab2069a5623f1f77ca907d78e0b37066ca0f6d63da7eecc3fcb65b76aa8ebeccf7ebe1d11264b8404cd9b1cbbf2c83f566e033b3e54129f6ef28daffff776ba7aebbc53c0d635ebad8f45f78eb3f7e0459023c218f003416e080f96a1a3c5ffeb56bee9e")]
 [assembly: InternalsVisibleTo("WireMock.Net.Tests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100e138ec44d93acac565953052636eb8d5e7e9f27ddb030590055cd1a0ab2069a5623f1f77ca907d78e0b37066ca0f6d63da7eecc3fcb65b76aa8ebeccf7ebe1d11264b8404cd9b1cbbf2c83f566e033b3e54129f6ef28daffff776ba7aebbc53c0d635ebad8f45f78eb3f7e0459023c218f003416e080f96a1a3c5ffeb56bee9e")]

src/WireMock.Net.Shared/RequestBuilders/IBodyRequestBuilder.cs

@@ -52,7 +52,7 @@ public interface IBodyRequestBuilder : IProtoBufRequestBuilder
     IRequestBuilder WithBody(object body, MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch);
 
     /// <summary>
-    /// WithBodyAsJson: A <see cref="JsonMatcher"/> will be used to match this object.
+    /// WithBodyAsJson: A JsonMatcher will be used to match this object.
     /// </summary>
     /// <param name="body">The body.</param>
     /// <param name="matchBehaviour">The match behaviour [default is AcceptOnMatch].</param>
@@ -93,12 +93,4 @@ public interface IBodyRequestBuilder : IProtoBufRequestBuilder
     /// <param name="func">The form-urlencoded values.</param>
     /// <returns>The <see cref="IRequestBuilder"/>.</returns>
     IRequestBuilder WithBody(Func<IDictionary<string, string>?, bool> func);
-
-    /// <summary>
-    /// WithBodyAsGraphQLSchema: Body as GraphQL schema as a string.
-    /// </summary>
-    /// <param name="body">The GraphQL schema.</param>
-    /// <param name="matchBehaviour">The match behaviour. (Default is <c>MatchBehaviour.AcceptOnMatch</c>).</param>
-    /// <returns>The <see cref="IRequestBuilder"/>.</returns>
-    IRequestBuilder WithBodyAsGraphQLSchema(string body, MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch);
 }

src/WireMock.Net.Shared/RequestBuilders/IMultiPartRequestBuilder.cs

@@ -1,7 +1,6 @@
 // Copyright © WireMock.Net
 
 using WireMock.Matchers;
-using WireMock.Matchers.Request;
 
 namespace WireMock.RequestBuilders;
 

src/WireMock.Net.Shared/RequestBuilders/IProtoBufRequestBuilder.cs

@@ -8,7 +8,7 @@ namespace WireMock.RequestBuilders;
 /// <summary>
 /// The ProtoBufRequestBuilder interface.
 /// </summary>
-public interface IProtoBufRequestBuilder : IGraphQLRequestBuilder
+public interface IProtoBufRequestBuilder : IMultiPartRequestBuilder
 {
     /// <summary>
     /// WithBodyAsProtoBuf

src/WireMock.Net.Shared/RequestBuilders/IRequestBuilder.cs

@@ -1,5 +1,7 @@
 // Copyright © WireMock.Net
 
+using WireMock.Matchers.Request;
+
 namespace WireMock.RequestBuilders;
 
 /// <summary>
@@ -7,4 +9,5 @@ namespace WireMock.RequestBuilders;
 /// </summary>
 public interface IRequestBuilder : IClientIPRequestBuilder
 {
+    public IRequestBuilder Add<T>(T requestMatcher) where T : IRequestMatcher;
 }

src/WireMock.Net.Shared/Util/IMimeKitUtils.cs

@@ -1,8 +1,8 @@
 // Copyright © WireMock.Net
 
-using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.IO;
+using WireMock.Models.Mime;
 
 namespace WireMock.Util;
 
@@ -12,24 +12,16 @@ namespace WireMock.Util;
 public interface IMimeKitUtils
 {
     /// <summary>
-    /// Loads the MimeKit.MimeMessage from the stream.
+    /// Loads the <see cref="IMimeMessageData"/> from the stream.
     /// </summary>
     /// <param name="stream">The stream</param>
-    /// <returns>MimeKit.MimeMessage</returns>
-    object LoadFromStream(Stream stream);
+    IMimeMessageData LoadFromStream(Stream stream);
 
     /// <summary>
-    /// Tries to get the MimeKit.MimeMessage from the request message.
+    /// Tries to get the <see cref="IMimeMessageData"/> from the request message.
     /// </summary>
     /// <param name="requestMessage">The request message.</param>
-    /// <param name="mimeMessage">The MimeKit.MimeMessage</param>
+    /// <param name="mimeMessageData">A class MimeMessageDataWrapper which wraps a MimeKit.MimeMessage.</param>
     /// <returns><c>true</c> when parsed correctly, else <c>false</c></returns>
-    bool TryGetMimeMessage(IRequestMessage requestMessage, [NotNullWhen(true)] out object? mimeMessage);
-
-    /// <summary>
-    /// Gets the body parts from the MimeKit.MimeMessage.
-    /// </summary>
-    /// <param name="mimeMessage">The MimeKit.MimeMessage.</param>
-    /// <returns>A list of MimeParts.</returns>
-    IReadOnlyList<object> GetBodyParts(object mimeMessage);
+    bool TryGetMimeMessage(IRequestMessage requestMessage, [NotNullWhen(true)] out IMimeMessageData? mimeMessageData);
 }

src/WireMock.Net.Shared/WireMock.Net.Shared.csproj

@@ -39,6 +39,10 @@
         <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
     </ItemGroup>
 
+    <ItemGroup Condition=" '$(TargetFramework)' == 'netstandard1.3' ">
+        <PackageReference Include="System.Reflection.TypeExtensions" Version="4.7.0" />
+    </ItemGroup>
+
     <ItemGroup>
         <ProjectReference Include="..\WireMock.Net.Abstractions\WireMock.Net.Abstractions.csproj" />
     </ItemGroup>

src/WireMock.Net/WireMock.Net.csproj

@@ -34,5 +34,6 @@
 
     <ItemGroup Condition="'$(TargetFramework)' != 'netstandard1.3' and '$(TargetFramework)' != 'net451' and '$(TargetFramework)' != 'net452' and '$(TargetFramework)' != 'net46' and '$(TargetFramework)' != 'net461'">
         <ProjectReference Include="../WireMock.Net.MimePart/WireMock.Net.MimePart.csproj" />
+        <ProjectReference Include="../WireMock.Net.GraphQL/WireMock.Net.GraphQL.csproj" />
     </ItemGroup>
 </Project>

test/WireMock.Net.Tests/AdminApi/WireMockAdminApiTests.cs

@@ -17,13 +17,13 @@ using RestEase;
 using VerifyTests;
 using VerifyXunit;
 using WireMock.Admin.Mappings;
+using WireMock.Admin.Scenarios;
 using WireMock.Admin.Settings;
 using WireMock.Client;
 using WireMock.Client.Extensions;
 using WireMock.Handlers;
 using WireMock.Logging;
 using WireMock.Matchers;
-using WireMock.Models;
 using WireMock.Net.Tests.VerifyExtensions;
 using WireMock.RequestBuilders;
 using WireMock.ResponseBuilders;
@@ -184,7 +184,7 @@ public partial class WireMockAdminApiTests
         server.Stop();
     }
 
-    
+
 
     [Fact]
     public async Task IWireMockAdminApi_FindRequestsAsync()
@@ -743,6 +743,57 @@ public partial class WireMockAdminApiTests
         status.Status.Should().Be("No scenario found by name 'x'.");
     }
 
+    [Fact]
+    public async Task IWireMockAdminApi_UpdateNonExistingScenarioState()
+    {
+        // Arrange
+        using var server = WireMockServer.StartWithAdminInterface();
+
+        var api = RestClient.For<IWireMockAdminApi>(server.Urls[0]);
+
+        // Act
+        var update = new ScenarioStateUpdateModel
+        {
+            State = null
+        };
+        var status = await api.PutScenarioStateAsync("x", update).ConfigureAwait(false);
+        status.Status.Should().Be("No scenario found by name 'x'.");
+    }
+
+    [Fact]
+    public async Task IWireMockAdminApi_UpdateScenarioState()
+    {
+        // Arrange
+        using var server = WireMockServer.StartWithAdminInterface();
+        server
+            .Given(Request.Create()
+                .WithPath("/state1")
+                .UsingGet())
+            .InScenario("s1")
+            .WillSetStateTo("Test state 1")
+            .RespondWith(Response.Create()
+                .WithBody("No state msg 1"));
+
+        server
+            .Given(Request.Create()
+                .WithPath("/foostate1")
+                .UsingGet())
+            .InScenario("s1")
+            .WhenStateIs("Test state 1")
+            .RespondWith(Response.Create()
+                .WithBody("Test state msg 1"));
+
+        var api = RestClient.For<IWireMockAdminApi>(server.Urls[0]);
+
+        // Act
+        var update = new ScenarioStateUpdateModel
+        {
+            State = null
+        };
+        var status = await api.PutScenarioStateAsync("s1", update).ConfigureAwait(false);
+        status.Status.Should().Be("Scenario state set to ''");
+    }
+
     [Fact]
     public async Task IWireMockAdminApi_GetMappingByGuidAsync()
     {

test/WireMock.Net.Tests/Constants.cs

@@ -6,5 +6,5 @@ internal static class Constants
 {
     internal const int NumStaticMappings = 10;
 
-    internal const int NumAdminMappings = 36;
+    internal const int NumAdminMappings = 37;
 }

test/WireMock.Net.Tests/Matchers/MimePartMatcherTests.cs

@@ -48,7 +48,7 @@ public class MimePartMatcherTests
     {
         // Arrange
         var message = MimeKitUtils.LoadFromStream(StreamUtils.CreateStream(TestMultiPart));
-        var part = MimeKitUtils.GetBodyParts(message)[0];
+        var part = message.BodyParts[0];
 
         // Act
         var contentTypeMatcher = new ContentTypeMatcher("text/plain");
@@ -67,7 +67,7 @@ public class MimePartMatcherTests
     {
         // Arrange
         var message = MimeKitUtils.LoadFromStream(StreamUtils.CreateStream(TestMultiPart));
-        var part = MimeKitUtils.GetBodyParts(message)[1];
+        var part = message.BodyParts[1];
 
         // Act
         var contentTypeMatcher = new ContentTypeMatcher("text/json");
@@ -85,7 +85,7 @@ public class MimePartMatcherTests
     {
         // Arrange
         var message = MimeKitUtils.LoadFromStream(StreamUtils.CreateStream(TestMultiPart));
-        var part = MimeKitUtils.GetBodyParts(message)[2];
+        var part = message.BodyParts[2];
 
         // Act
         var contentTypeMatcher = new ContentTypeMatcher("image/png");

test/WireMock.Net.Tests/Matchers/Models/WireMockCustomScalarGraphTypeTests.cs

@@ -3,7 +3,7 @@
 #if GRAPHQL
 using System;
 using FluentAssertions;
-using WireMock.Matchers.Models;
+using WireMock.GraphQL.Models;
 using Xunit;
 
 namespace WireMock.Net.Tests.Matchers.Models;

test/WireMock.Net.Tests/Pact/PactTests.SavePact_Get_Request_And_Response_WithBodyAsJson.verified.json

@@ -0,0 +1,32 @@
+{
+  "consumer": {
+    "name": "Something API Consumer Get"
+  },
+  "interactions": [
+    {
+      "description": "A GET request to retrieve the something",
+      "request": {
+        "headers": {
+          "Accept": "application/json"
+        },
+        "method": "GET",
+        "path": "/tester",
+        "query": "q1=test&q2=ok"
+      },
+      "response": {
+        "body": {
+          "id": "tester",
+          "firstName": "Totally",
+          "lastName": "Awesome"
+        },
+        "headers": {
+          "Content-Type": "application/json; charset=utf-8"
+        },
+        "status": 200
+      }
+    }
+  ],
+  "provider": {
+    "name": "Something API"
+  }
+}

test/WireMock.Net.Tests/Pact/PactTests.SavePact_Post_Request_WithDescription.verified.json

@@ -0,0 +1,20 @@
+{
+  "consumer": {
+    "name": "Default Consumer"
+  },
+  "interactions": [
+    {
+      "description": "A POST request to change something",
+      "request": {
+        "method": "POST",
+        "path": "/tester"
+      },
+      "response": {
+        "status": 200
+      }
+    }
+  ],
+  "provider": {
+    "name": "Default Provider"
+  }
+}

test/WireMock.Net.Tests/Pact/PactTests.cs

@@ -1,11 +1,14 @@
+#if !(NET452 || NET461 || NETCOREAPP3_1)
 // Copyright © WireMock.Net
 
 using System.IO;
 using System.Net;
 using System.Text;
+using System.Threading.Tasks;
 using FluentAssertions;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
+using VerifyXunit;
 using WireMock.Matchers;
 using WireMock.RequestBuilders;
 using WireMock.ResponseBuilders;
@@ -14,10 +17,11 @@ using Xunit;
 
 namespace WireMock.Net.Tests.Pact;
 
+[UsesVerify]
 public class PactTests
 {
     [Fact]
-    public void SavePact_Get_Request_And_Response_WithBodyAsJson()
+    public async Task SavePact_Get_Request_And_Response_WithBodyAsJson()
     {
         var server = WireMockServer.Start();
         server
@@ -46,12 +50,34 @@ public class PactTests
 
         var folder = Path.Combine("../../../", "Pact", "files");
         var file = "pact-get.json";
+        var path = Path.Combine(folder, file);
 
         // Act
         server.SavePact(folder, file);
 
         // Assert
-        File.ReadAllBytes(Path.Combine(folder, file)).Length.Should().BeGreaterThan(1);
+        await Verifier.VerifyFile(path);
+    }
+
+    [Fact]
+    public async Task SavePact_Post_Request_WithDescription()
+    {
+        var server = WireMockServer.Start();
+        server
+            .Given(Request.Create().UsingPost().WithPath("/tester"))
+            .WithTitle("POST something")
+            .WithDescription("A POST request to change something")
+            .RespondWith(Response.Create().WithStatusCode(HttpStatusCode.OK));
+
+        var folder = Path.Combine("../../../", "Pact", "files");
+        var file = "pact-post.json";
+        var path = Path.Combine(folder, file);
+
+        // Act
+        server.SavePact(folder, file);
+
+        // Assert
+        await Verifier.VerifyFile(path);
     }
 
     [Fact]
@@ -219,4 +245,5 @@ public class PactTests
         // Assert
         File.ReadAllBytes(Path.Combine(folder, file)).Length.Should().BeGreaterThan(1);
     }
-}
+}
+#endif

test/WireMock.Net.Tests/Pact/files/pact-get.json

@@ -4,7 +4,7 @@
   },
   "interactions": [
     {
-      "providerState": "A GET request to retrieve the something",
+      "description": "A GET request to retrieve the something",
       "request": {
         "headers": {
           "Accept": "application/json"

test/WireMock.Net.Tests/Pact/files/pact-multiple.json

@@ -4,7 +4,7 @@
   },
   "interactions": [
     {
-      "providerState": "A GET request to retrieve the something",
+      "description": "A GET request to retrieve the something",
       "request": {
         "headers": {
           "Accept": "application/json"
@@ -26,7 +26,7 @@
       }
     },
     {
-      "providerState": "A Post request to add the something",
+      "description": "A Post request to add the something",
       "request": {
         "headers": {
           "Accept": "application/json"

test/WireMock.Net.Tests/Pact/files/pact-post.json

@@ -0,0 +1,20 @@
+{
+  "consumer": {
+    "name": "Default Consumer"
+  },
+  "interactions": [
+    {
+      "description": "A POST request to change something",
+      "request": {
+        "method": "POST",
+        "path": "/tester"
+      },
+      "response": {
+        "status": 200
+      }
+    }
+  ],
+  "provider": {
+    "name": "Default Provider"
+  }
+}

test/WireMock.Net.Tests/RequestMatchers/RequestMessageBodyMatcherTests.cs

@@ -404,6 +404,79 @@ public class RequestMessageBodyMatcherTests
         objectMatcherMock.Verify(m => m.IsMatch(It.IsAny<byte[]>()), Times.Once);
     }
 
+    [Theory]
+    [InlineData(new byte[] { 1 })]
+    [InlineData(new byte[] { 48 })]
+    public void RequestMessageBodyMatcher_GetMatchingScore_BodyTypeBytes_BodyAsBytes_ExactObjectMapper(byte[] bytes)
+    {
+        // Assign
+        var body = new BodyData
+        {
+            BodyAsBytes = bytes,
+            DetectedBodyType = BodyType.Bytes
+        };
+        var exactObjectMapper = new ExactObjectMatcher(bytes);
+
+        var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", body);
+
+        var matcher = new RequestMessageBodyMatcher(exactObjectMapper);
+
+        // Act
+        var result = new RequestMatchResult();
+        double score = matcher.GetMatchingScore(requestMessage, result);
+
+        // Assert
+        Check.That(score).IsEqualTo(1.0d);
+    }
+
+    [Fact]
+    public void RequestMessageBodyMatcher_GetMatchingScore_BodyTypeString_BodyAsBytes_ExactObjectMapper()
+    {
+        // Assign
+        var bytes = Encoding.UTF8.GetBytes("hello");
+        var body = new BodyData
+        {
+            BodyAsBytes = bytes,
+            DetectedBodyType = BodyType.String
+        };
+        var exactObjectMapper = new ExactObjectMatcher(bytes);
+
+        var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", body);
+
+        var matcher = new RequestMessageBodyMatcher(exactObjectMapper);
+
+        // Act
+        var result = new RequestMatchResult();
+        double score = matcher.GetMatchingScore(requestMessage, result);
+
+        // Assert
+        Check.That(score).IsEqualTo(1.0d);
+    }
+
+    [Fact]
+    public void RequestMessageBodyMatcher_GetMatchingScore_BodyTypeJson_BodyAsBytes_ExactObjectMapper()
+    {
+        // Assign
+        var bytes = Encoding.UTF8.GetBytes("""{"value":42}""");
+        var body = new BodyData
+        {
+            BodyAsBytes = bytes,
+            DetectedBodyType = BodyType.Json
+        };
+        var exactObjectMapper = new ExactObjectMatcher(bytes);
+
+        var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", body);
+
+        var matcher = new RequestMessageBodyMatcher(exactObjectMapper);
+
+        // Act
+        var result = new RequestMatchResult();
+        double score = matcher.GetMatchingScore(requestMessage, result);
+
+        // Assert
+        Check.That(score).IsEqualTo(1.0d);
+    }
+
     [Theory]
     [MemberData(nameof(MatchingScoreData))]
     public async Task RequestMessageBodyMatcher_GetMatchingScore_Funcs_Matching(object body, RequestMessageBodyMatcher matcher, bool shouldMatch)
@@ -459,13 +532,13 @@ public class RequestMessageBodyMatcherTests
                 {json, new RequestMessageBodyMatcher((object? o) => ((dynamic) o!).a == "b"), true},
                 {json, new RequestMessageBodyMatcher((string? s) => s == json), true},
                 {json, new RequestMessageBodyMatcher((byte[]? b) => b?.SequenceEqual(Encoding.UTF8.GetBytes(json)) == true), true},
-                
+
                 // JSON no match ---
                 {json, new RequestMessageBodyMatcher((object? o) => false), false},
                 {json, new RequestMessageBodyMatcher((string? s) => false), false},
                 {json, new RequestMessageBodyMatcher((byte[]? b) => false), false},
                 {json, new RequestMessageBodyMatcher(), false },
-                
+
                 // string match +++
                 {str, new RequestMessageBodyMatcher((object? o) => o == null), true},
                 {str, new RequestMessageBodyMatcher((string? s) => s == str), true},
@@ -476,7 +549,7 @@ public class RequestMessageBodyMatcherTests
                 {str, new RequestMessageBodyMatcher((string? s) => false), false},
                 {str, new RequestMessageBodyMatcher((byte[]? b) => false), false},
                 {str, new RequestMessageBodyMatcher(), false },
-                
+
                 // binary match +++
                 {bytes, new RequestMessageBodyMatcher((object? o) => o == null), true},
                 {bytes, new RequestMessageBodyMatcher((string? s) => s == null), true},

test/WireMock.Net.Tests/ResponseBuilders/ResponseWithTransformerTests.cs

@@ -120,21 +120,21 @@ public class ResponseWithTransformerTests
         var request = new RequestMessage(urlDetails, "POST", ClientIp);
 
         var responseBuilder = Response.Create()
-            .WithBody("{{request.PathSegments.[0]}} {{request.AbsolutePathSegments.[0]}}")
+            .WithBody("{{request.PathSegments.[0]}} {{request.PathSegments.[1]}} {{request.AbsolutePathSegments.[0]}}")
             .WithTransformer();
 
         // Act
         var response = await responseBuilder.ProvideResponseAsync(_mappingMock.Object, request, _settings).ConfigureAwait(false);
 
         // Assert
-        Check.That(response.Message.BodyData!.BodyAsString).Equals("a wiremock");
+        Check.That(response.Message.BodyData!.BodyAsString).Equals("a b wiremock");
     }
 
     [Theory]
-    [InlineData("{{request.PathSegments.[0]}}", "a")]
-    [InlineData("prefix_{{request.PathSegments.[0]}}", "prefix_a")]
-    [InlineData("{{request.PathSegments.[0]}}_postfix", "a_postfix")]
-    [InlineData("prefix_{{request.PathSegments.[0]}}_postfix", "prefix_a_postfix")]
+    [InlineData("{{request.PathSegments.[0]}} {{request.PathSegments.[1]}}", "a b")]
+    [InlineData("prefix_{{request.PathSegments.[0]}} {{request.PathSegments.[1]}}", "prefix_a b")]
+    [InlineData("{{request.PathSegments.[0]}} {{request.PathSegments.[1]}}_postfix", "a b_postfix")]
+    [InlineData("prefix_{{request.PathSegments.[0]}} {{request.PathSegments.[1]}}_postfix", "prefix_a b_postfix")]
     public async Task Response_ProvideResponse_Handlebars_BodyAsJson_PathSegments(string field, string expected)
     {
         // Assign

test/WireMock.Net.Tests/Serialization/MappingConverterTests.cs

@@ -549,7 +549,7 @@ message HelloReply {
    lastName:String
    fullName:String 
   }";
-        var request = Request.Create().WithBodyAsGraphQLSchema(schema);
+        var request = Request.Create().WithGraphQLSchema(schema);
         var response = Response.Create();
         var mapping = new Mapping(_guid, _updatedAt, string.Empty, string.Empty, null, _settings, request, response, 42, null, null, null, null, null, false, null, null);
 

test/WireMock.Net.Tests/Serialization/MatcherMapperTests.cs

@@ -1076,7 +1076,7 @@ message HelloReply {
         };
 
         // Act
-        var matcher = (GraphQLMatcher)_sut.Map(model)!;
+        var matcher = (IGraphQLMatcher)_sut.Map(model)!;
 
         // Assert
         matcher.GetPatterns().Should().HaveElementAt(0, testSchema);

test/WireMock.Net.Tests/StatefulBehaviorTests.cs

@@ -12,340 +12,447 @@ using WireMock.ResponseBuilders;
 using WireMock.Server;
 using Xunit;
 
-namespace WireMock.Net.Tests
+namespace WireMock.Net.Tests;
+
+public class StatefulBehaviorTests
 {
-    public class StatefulBehaviorTests
+    [Fact]
+    public async Task Scenarios_Should_skip_non_relevant_states()
     {
-        [Fact]
-        public async Task Scenarios_Should_skip_non_relevant_states()
-        {
-            // given
-            string path = $"/foo_{Guid.NewGuid()}";
-            var server = WireMockServer.Start();
+        // given
+        string path = $"/foo_{Guid.NewGuid()}";
+        var server = WireMockServer.Start();
 
-            server
-                .Given(Request.Create().WithPath(path).UsingGet())
-                .InScenario("s")
-                .WhenStateIs("Test state")
-                .RespondWith(Response.Create());
+        server
+            .Given(Request.Create().WithPath(path).UsingGet())
+            .InScenario("s")
+            .WhenStateIs("Test state")
+            .RespondWith(Response.Create());
 
-            // when
-            var response = await new HttpClient().GetAsync("http://localhost:" + server.Ports[0] + path).ConfigureAwait(false);
+        // when
+        var response = await new HttpClient().GetAsync("http://localhost:" + server.Ports[0] + path).ConfigureAwait(false);
 
-            // then
-            Check.That(response.StatusCode).IsEqualTo(HttpStatusCode.NotFound);
+        // then
+        Check.That(response.StatusCode).IsEqualTo(HttpStatusCode.NotFound);
 
-            server.Stop();
-        }
+        server.Stop();
+    }
 
-        [Fact]
-        public async Task Scenarios_Should_process_request_if_equals_state_and_single_state_defined()
-        {
-            // given
-            string path = $"/foo_{Guid.NewGuid()}";
-            var server = WireMockServer.Start();
+    [Fact]
+    public async Task Scenarios_Should_process_request_if_equals_state_and_single_state_defined()
+    {
+        // Arrange
+        var path = $"/foo_{Guid.NewGuid()}";
+        using var server = WireMockServer.Start();
 
-            server
-                .Given(Request.Create().WithPath(path).UsingGet())
-                .InScenario("s")
-                .WillSetStateTo("Test state")
-                .RespondWith(Response.Create().WithBody("No state msg"));
+        server
+            .Given(Request.Create().WithPath(path).UsingGet())
+            .InScenario("s")
+            .WillSetStateTo("Test state")
+            .RespondWith(Response.Create().WithBody("No state msg"));
 
-            server
-                .Given(Request.Create().WithPath(path).UsingGet())
-                .InScenario("s")
-                .WhenStateIs("Test state")
-                .RespondWith(Response.Create().WithBody("Test state msg"));
+        server
+            .Given(Request.Create().WithPath(path).UsingGet())
+            .InScenario("s")
+            .WhenStateIs("Test state")
+            .RespondWith(Response.Create().WithBody("Test state msg"));
 
-            // when
-            var responseNoState = await new HttpClient().GetStringAsync("http://localhost:" + server.Ports[0] + path).ConfigureAwait(false);
-            var responseWithState = await new HttpClient().GetStringAsync("http://localhost:" + server.Ports[0] + path).ConfigureAwait(false);
+        // Act
+        var responseNoState = await new HttpClient().GetStringAsync(server.Url + path).ConfigureAwait(false);
+        var responseWithState = await new HttpClient().GetStringAsync(server.Url + path).ConfigureAwait(false);
 
-            // then
-            Check.That(responseNoState).Equals("No state msg");
-            Check.That(responseWithState).Equals("Test state msg");
+        // Assert
+        Check.That(responseNoState).Equals("No state msg");
+        Check.That(responseWithState).Equals("Test state msg");
+    }
 
-            server.Stop();
-        }
+    [Theory]
+    [InlineData(null, "step 1", "step 2")]
+    [InlineData("step 2", "step 2", "step 3")]
+    public async Task Scenarios_Should_ContinueOnCorrectState_WhenStateIsUpdated(string? state, string expected1, string expected2)
+    {
+        // Arrange
+        var path = $"/foo_{Guid.NewGuid()}";
+        var scenario = "s";
+        using var server = WireMockServer.Start();
 
-        [Fact]
-        public async Task Scenarios_With_Same_Path_Should_Use_Times_When_Moving_To_Next_State()
-        {
-            // given
-            const int times = 2;
-            string path = $"/foo_{Guid.NewGuid()}";
-            string body1 = "Scenario S1, No State, Setting State T2";
-            string body2 = "Scenario S1, State T2, End";
-            var server = WireMockServer.Start();
+        server
+            .Given(Request.Create().WithPath(path).UsingGet())
+            .InScenario(scenario)
+            .WillSetStateTo("step 2")
+            .RespondWith(Response.Create().WithBody("step 1"));
 
-            server
-                .Given(Request.Create().WithPath(path).UsingGet())
-                .InScenario(1)
-                .WillSetStateTo(2, times)
-                .RespondWith(Response.Create().WithBody(body1));
+        server
+            .Given(Request.Create().WithPath(path).UsingGet())
+            .InScenario(scenario)
+            .WhenStateIs("step 2")
+            .WillSetStateTo("step 3")
+            .RespondWith(Response.Create().WithBody("step 2"));
 
-            server
-                .Given(Request.Create().WithPath(path).UsingGet())
-                .InScenario(1)
-                .WhenStateIs(2)
-                .RespondWith(Response.Create().WithBody(body2));
+        server
+            .Given(Request.Create().WithPath(path).UsingGet())
+            .InScenario(scenario)
+            .WhenStateIs("step 3")
+            .RespondWith(Response.Create().WithBody("step 3"));
 
-            // when
-            var client = new HttpClient();
-            var responseScenario1 = await client.GetStringAsync("http://localhost:" + server.Ports[0] + path).ConfigureAwait(false);
-            var responseScenario2 = await client.GetStringAsync("http://localhost:" + server.Ports[0] + path).ConfigureAwait(false);
-            var responseWithState = await client.GetStringAsync("http://localhost:" + server.Ports[0] + path).ConfigureAwait(false);
+        // Act
+        var client = server.CreateClient();
+        var response1 = await client.GetStringAsync(server.Url + path);
+        var response2 = await client.GetStringAsync(server.Url + path);
+        var response3 = await client.GetStringAsync(server.Url + path);
 
-            // then
-            responseScenario1.Should().Be(body1);
-            responseScenario2.Should().Be(body1);
-            responseWithState.Should().Be(body2);
+        server.SetScenarioState(scenario, state);
+        var responseA = await client.GetStringAsync(server.Url + path);
+        var responseB = await client.GetStringAsync(server.Url + path);
 
-            server.Stop();
-        }
+        // Assert
+        Check.That(response1).Equals("step 1");
+        Check.That(response2).Equals("step 2");
+        Check.That(response3).Equals("step 3");
+        Check.That(responseA).Equals(expected1);
+        Check.That(responseB).Equals(expected2);
+    }
 
-        [Fact]
-        public async Task Scenarios_With_Different_Paths_Should_Use_Times_When_Moving_To_Next_State()
-        {
-            // given
-            const int times = 2;
-            string path1 = $"/a_{Guid.NewGuid()}";
-            string path2 = $"/b_{Guid.NewGuid()}";
-            string path3 = $"/c_{Guid.NewGuid()}";
-            string body1 = "Scenario S1, No State, Setting State T2";
-            string body2 = "Scenario S1, State T2, Setting State T3";
-            string body3 = "Scenario S1, State T3, End";
+    [Fact]
+    public async Task Scenarios_With_Same_Path_Should_Use_Times_When_Moving_To_Next_State()
+    {
+        // given
+        const int times = 2;
+        string path = $"/foo_{Guid.NewGuid()}";
+        string body1 = "Scenario S1, No State, Setting State T2";
+        string body2 = "Scenario S1, State T2, End";
+        var server = WireMockServer.Start();
 
-            var server = WireMockServer.Start();
+        server
+            .Given(Request.Create().WithPath(path).UsingGet())
+            .InScenario(1)
+            .WillSetStateTo(2, times)
+            .RespondWith(Response.Create().WithBody(body1));
 
-            server
-                .Given(Request.Create().WithPath(path1).UsingGet())
-                .InScenario("S1")
-                .WillSetStateTo("T2", times)
-                .RespondWith(Response.Create().WithBody(body1));
+        server
+            .Given(Request.Create().WithPath(path).UsingGet())
+            .InScenario(1)
+            .WhenStateIs(2)
+            .RespondWith(Response.Create().WithBody(body2));
 
-            server
-                .Given(Request.Create().WithPath(path2).UsingGet())
-                .InScenario("S1")
-                .WhenStateIs("T2")
-                .WillSetStateTo("T3", times)
-                .RespondWith(Response.Create().WithBody(body2));
+        // when
+        var client = new HttpClient();
+        var responseScenario1 = await client.GetStringAsync("http://localhost:" + server.Ports[0] + path).ConfigureAwait(false);
+        var responseScenario2 = await client.GetStringAsync("http://localhost:" + server.Ports[0] + path).ConfigureAwait(false);
+        var responseWithState = await client.GetStringAsync("http://localhost:" + server.Ports[0] + path).ConfigureAwait(false);
 
-            server
-                .Given(Request.Create().WithPath(path3).UsingGet())
-                .InScenario("S1")
-                .WhenStateIs("T3")
-                .RespondWith(Response.Create().WithBody(body3));
+        // then
+        responseScenario1.Should().Be(body1);
+        responseScenario2.Should().Be(body1);
+        responseWithState.Should().Be(body2);
 
-            // when
-            var client = new HttpClient();
-            var t1a = await client.GetStringAsync("http://localhost:" + server.Ports[0] + path1).ConfigureAwait(false);
-            var t1b = await client.GetStringAsync("http://localhost:" + server.Ports[0] + path1).ConfigureAwait(false);
-            var t2a = await client.GetStringAsync("http://localhost:" + server.Ports[0] + path2).ConfigureAwait(false);
-            var t2b = await client.GetStringAsync("http://localhost:" + server.Ports[0] + path2).ConfigureAwait(false);
-            var t3 = await client.GetStringAsync("http://localhost:" + server.Ports[0] + path3).ConfigureAwait(false);
+        server.Stop();
+    }
 
-            // then
-            t1a.Should().Be(body1);
-            t1b.Should().Be(body1);
-            t2a.Should().Be(body2);
-            t2b.Should().Be(body2);
-            t3.Should().Be(body3);
+    [Fact]
+    public async Task Scenarios_With_Different_Paths_Should_Use_Times_When_Moving_To_Next_State()
+    {
+        // given
+        const int times = 2;
+        string path1 = $"/a_{Guid.NewGuid()}";
+        string path2 = $"/b_{Guid.NewGuid()}";
+        string path3 = $"/c_{Guid.NewGuid()}";
+        string body1 = "Scenario S1, No State, Setting State T2";
+        string body2 = "Scenario S1, State T2, Setting State T3";
+        string body3 = "Scenario S1, State T3, End";
 
-            server.Stop();
-        }
+        var server = WireMockServer.Start();
 
-        [Fact]
-        public async Task Scenarios_Should_Respect_Int_Valued_Scenarios_and_States()
-        {
-            // given
-            string path = $"/foo_{Guid.NewGuid()}";
-            var server = WireMockServer.Start();
+        server
+            .Given(Request.Create().WithPath(path1).UsingGet())
+            .InScenario("S1")
+            .WillSetStateTo("T2", times)
+            .RespondWith(Response.Create().WithBody(body1));
 
-            server
-                .Given(Request.Create().WithPath(path).UsingGet())
-                .InScenario(1)
-                .WillSetStateTo(2)
-                .RespondWith(Response.Create().WithBody("Scenario 1, Setting State 2"));
+        server
+            .Given(Request.Create().WithPath(path2).UsingGet())
+            .InScenario("S1")
+            .WhenStateIs("T2")
+            .WillSetStateTo("T3", times)
+            .RespondWith(Response.Create().WithBody(body2));
 
-            server
-                .Given(Request.Create().WithPath(path).UsingGet())
-                .InScenario(1)
-                .WhenStateIs(2)
-                .RespondWith(Response.Create().WithBody("Scenario 1, State 2"));
+        server
+            .Given(Request.Create().WithPath(path3).UsingGet())
+            .InScenario("S1")
+            .WhenStateIs("T3")
+            .RespondWith(Response.Create().WithBody(body3));
 
-            // when
-            var responseIntScenario = await new HttpClient().GetStringAsync("http://localhost:" + server.Ports[0] + path).ConfigureAwait(false);
-            var responseWithIntState = await new HttpClient().GetStringAsync("http://localhost:" + server.Ports[0] + path).ConfigureAwait(false);
+        // when
+        var client = new HttpClient();
+        var t1a = await client.GetStringAsync("http://localhost:" + server.Ports[0] + path1).ConfigureAwait(false);
+        var t1b = await client.GetStringAsync("http://localhost:" + server.Ports[0] + path1).ConfigureAwait(false);
+        var t2a = await client.GetStringAsync("http://localhost:" + server.Ports[0] + path2).ConfigureAwait(false);
+        var t2b = await client.GetStringAsync("http://localhost:" + server.Ports[0] + path2).ConfigureAwait(false);
+        var t3 = await client.GetStringAsync("http://localhost:" + server.Ports[0] + path3).ConfigureAwait(false);
 
-            // then
-            Check.That(responseIntScenario).Equals("Scenario 1, Setting State 2");
-            Check.That(responseWithIntState).Equals("Scenario 1, State 2");
+        // then
+        t1a.Should().Be(body1);
+        t1b.Should().Be(body1);
+        t2a.Should().Be(body2);
+        t2b.Should().Be(body2);
+        t3.Should().Be(body3);
 
-            server.Stop();
-        }
+        server.Stop();
+    }
 
-        [Fact]
-        public async Task Scenarios_Should_Respect_Mixed_String_Scenario_and_Int_State()
-        {
-            // given
-            string path = $"/foo_{Guid.NewGuid()}";
-            var server = WireMockServer.Start();
+    [Fact]
+    public async Task Scenarios_Should_Respect_Int_Valued_Scenarios_and_States()
+    {
+        // given
+        string path = $"/foo_{Guid.NewGuid()}";
+        var server = WireMockServer.Start();
 
-            server
-                .Given(Request.Create().WithPath(path).UsingGet())
-                .InScenario("state string")
-                .WillSetStateTo(1)
-                .RespondWith(Response.Create().WithBody("string state, Setting State 2"));
+        server
+            .Given(Request.Create().WithPath(path).UsingGet())
+            .InScenario(1)
+            .WillSetStateTo(2)
+            .RespondWith(Response.Create().WithBody("Scenario 1, Setting State 2"));
 
-            server
-                .Given(Request.Create().WithPath(path).UsingGet())
-                .InScenario("state string")
-                .WhenStateIs(1)
-                .RespondWith(Response.Create().WithBody("string state, State 2"));
+        server
+            .Given(Request.Create().WithPath(path).UsingGet())
+            .InScenario(1)
+            .WhenStateIs(2)
+            .RespondWith(Response.Create().WithBody("Scenario 1, State 2"));
 
-            // when
-            var responseIntScenario = await new HttpClient().GetStringAsync("http://localhost:" + server.Ports[0] + path).ConfigureAwait(false);
-            var responseWithIntState = await new HttpClient().GetStringAsync("http://localhost:" + server.Ports[0] + path).ConfigureAwait(false);
+        // when
+        var responseIntScenario = await new HttpClient().GetStringAsync("http://localhost:" + server.Ports[0] + path).ConfigureAwait(false);
+        var responseWithIntState = await new HttpClient().GetStringAsync("http://localhost:" + server.Ports[0] + path).ConfigureAwait(false);
 
-            // then
-            Check.That(responseIntScenario).Equals("string state, Setting State 2");
-            Check.That(responseWithIntState).Equals("string state, State 2");
+        // then
+        Check.That(responseIntScenario).Equals("Scenario 1, Setting State 2");
+        Check.That(responseWithIntState).Equals("Scenario 1, State 2");
 
-            server.Stop();
-        }
+        server.Stop();
+    }
 
-        [Fact]
-        public async Task Scenarios_Should_Respect_Mixed_Int_Scenario_and_String_Scenario_and_String_State()
-        {
-            // given
-            string path = $"/foo_{Guid.NewGuid()}";
-            var server = WireMockServer.Start();
+    [Fact]
+    public async Task Scenarios_Should_Respect_Mixed_String_Scenario_and_Int_State()
+    {
+        // given
+        string path = $"/foo_{Guid.NewGuid()}";
+        var server = WireMockServer.Start();
 
-            server
-                .Given(Request.Create().WithPath(path).UsingGet())
-                .InScenario(1)
-                .WillSetStateTo("Next State")
-                .RespondWith(Response.Create().WithBody("int state, Setting State 2"));
+        server
+            .Given(Request.Create().WithPath(path).UsingGet())
+            .InScenario("state string")
+            .WillSetStateTo(1)
+            .RespondWith(Response.Create().WithBody("string state, Setting State 2"));
 
-            server
-                .Given(Request.Create().WithPath(path).UsingGet())
-                .InScenario("1")
-                .WhenStateIs("Next State")
-                .RespondWith(Response.Create().WithBody("string state, State 2"));
+        server
+            .Given(Request.Create().WithPath(path).UsingGet())
+            .InScenario("state string")
+            .WhenStateIs(1)
+            .RespondWith(Response.Create().WithBody("string state, State 2"));
 
-            // when
-            var responseIntScenario = await new HttpClient().GetStringAsync("http://localhost:" + server.Ports[0] + path).ConfigureAwait(false);
-            var responseWithIntState = await new HttpClient().GetStringAsync("http://localhost:" + server.Ports[0] + path).ConfigureAwait(false);
+        // when
+        var responseIntScenario = await new HttpClient().GetStringAsync("http://localhost:" + server.Ports[0] + path).ConfigureAwait(false);
+        var responseWithIntState = await new HttpClient().GetStringAsync("http://localhost:" + server.Ports[0] + path).ConfigureAwait(false);
 
-            // then
-            Check.That(responseIntScenario).Equals("int state, Setting State 2");
-            Check.That(responseWithIntState).Equals("string state, State 2");
+        // then
+        Check.That(responseIntScenario).Equals("string state, Setting State 2");
+        Check.That(responseWithIntState).Equals("string state, State 2");
 
-            server.Stop();
-        }
+        server.Stop();
+    }
 
-        [Fact]
-        public async Task Scenarios_TodoList_Example()
-        {
-            // Assign
-            var server = WireMockServer.Start();
+    [Fact]
+    public async Task Scenarios_Should_Respect_Mixed_Int_Scenario_and_String_Scenario_and_String_State()
+    {
+        // given
+        string path = $"/foo_{Guid.NewGuid()}";
+        var server = WireMockServer.Start();
 
-            server
-                .Given(Request.Create().WithPath("/todo/items").UsingGet())
-                .InScenario("To do list")
-                .WillSetStateTo("TodoList State Started")
-                .RespondWith(Response.Create().WithBody("Buy milk"));
+        server
+            .Given(Request.Create().WithPath(path).UsingGet())
+            .InScenario(1)
+            .WillSetStateTo("Next State")
+            .RespondWith(Response.Create().WithBody("int state, Setting State 2"));
 
-            server
-                .Given(Request.Create().WithPath("/todo/items").UsingPost())
-                .InScenario("To do list")
-                .WhenStateIs("TodoList State Started")
-                .WillSetStateTo("Cancel newspaper item added")
-                .RespondWith(Response.Create().WithStatusCode(201));
+        server
+            .Given(Request.Create().WithPath(path).UsingGet())
+            .InScenario("1")
+            .WhenStateIs("Next State")
+            .RespondWith(Response.Create().WithBody("string state, State 2"));
 
-            server
-                .Given(Request.Create().WithPath("/todo/items").UsingGet())
-                .InScenario("To do list")
-                .WhenStateIs("Cancel newspaper item added")
-                .RespondWith(Response.Create().WithBody("Buy milk;Cancel newspaper subscription"));
+        // when
+        var responseIntScenario = await new HttpClient().GetStringAsync("http://localhost:" + server.Ports[0] + path).ConfigureAwait(false);
+        var responseWithIntState = await new HttpClient().GetStringAsync("http://localhost:" + server.Ports[0] + path).ConfigureAwait(false);
 
-            Check.That(server.Scenarios.Any()).IsFalse();
+        // then
+        Check.That(responseIntScenario).Equals("int state, Setting State 2");
+        Check.That(responseWithIntState).Equals("string state, State 2");
 
-            // Act and Assert
-            string url = "http://localhost:" + server.Ports[0];
-            string getResponse1 = new HttpClient().GetStringAsync(url + "/todo/items").Result;
-            Check.That(getResponse1).Equals("Buy milk");
+        server.Stop();
+    }
 
-            Check.That(server.Scenarios["To do list"].Name).IsEqualTo("To do list");
-            Check.That(server.Scenarios["To do list"].NextState).IsEqualTo("TodoList State Started");
-            Check.That(server.Scenarios["To do list"].Started).IsTrue();
-            Check.That(server.Scenarios["To do list"].Finished).IsFalse();
+    [Fact]
+    public async Task Scenarios_TodoList_Example()
+    {
+        // Arrange
+        var server = WireMockServer.Start();
+        var client = server.CreateClient();
 
-            var postResponse = await new HttpClient().PostAsync(url + "/todo/items", new StringContent("Cancel newspaper subscription")).ConfigureAwait(false);
-            Check.That(postResponse.StatusCode).Equals(HttpStatusCode.Created);
+        server
+            .Given(Request.Create().WithPath("/todo/items").UsingGet())
+            .InScenario("To do list")
+            .WillSetStateTo("TodoList State Started")
+            .RespondWith(Response.Create().WithBody("Buy milk"));
 
-            Check.That(server.Scenarios["To do list"].Name).IsEqualTo("To do list");
-            Check.That(server.Scenarios["To do list"].NextState).IsEqualTo("Cancel newspaper item added");
-            Check.That(server.Scenarios["To do list"].Started).IsTrue();
-            Check.That(server.Scenarios["To do list"].Finished).IsFalse();
+        server
+            .Given(Request.Create().WithPath("/todo/items").UsingPost())
+            .InScenario("To do list")
+            .WhenStateIs("TodoList State Started")
+            .WillSetStateTo("Cancel newspaper item added")
+            .RespondWith(Response.Create().WithStatusCode(201));
 
-            string getResponse2 = await new HttpClient().GetStringAsync(url + "/todo/items").ConfigureAwait(false);
-            Check.That(getResponse2).Equals("Buy milk;Cancel newspaper subscription");
+        server
+            .Given(Request.Create().WithPath("/todo/items").UsingGet())
+            .InScenario("To do list")
+            .WhenStateIs("Cancel newspaper item added")
+            .RespondWith(Response.Create().WithBody("Buy milk;Cancel newspaper subscription"));
 
-            Check.That(server.Scenarios["To do list"].Name).IsEqualTo("To do list");
-            Check.That(server.Scenarios["To do list"].NextState).IsNull();
-            Check.That(server.Scenarios["To do list"].Started).IsTrue();
-            Check.That(server.Scenarios["To do list"].Finished).IsTrue();
+        Check.That(server.Scenarios.Any()).IsFalse();
 
-            server.Stop();
-        }
+        // Act and Assert
+        var getResponse1 = await client.GetStringAsync("/todo/items").ConfigureAwait(false);
+        Check.That(getResponse1).Equals("Buy milk");
 
-        [Fact]
-        public async Task Scenarios_Should_process_request_if_equals_state_and_multiple_state_defined()
-        {
-            // Assign
-            var server = WireMockServer.Start();
+        Check.That(server.Scenarios["To do list"].Name).IsEqualTo("To do list");
+        Check.That(server.Scenarios["To do list"].NextState).IsEqualTo("TodoList State Started");
+        Check.That(server.Scenarios["To do list"].Started).IsTrue();
+        Check.That(server.Scenarios["To do list"].Finished).IsFalse();
 
-            server
-                .Given(Request.Create().WithPath("/state1").UsingGet())
-                .InScenario("s1")
-                .WillSetStateTo("Test state 1")
-                .RespondWith(Response.Create().WithBody("No state msg 1"));
+        var postResponse = await client.PostAsync("/todo/items", new StringContent("Cancel newspaper subscription")).ConfigureAwait(false);
+        Check.That(postResponse.StatusCode).Equals(HttpStatusCode.Created);
 
-            server
-                .Given(Request.Create().WithPath("/foo1X").UsingGet())
-                .InScenario("s1")
-                .WhenStateIs("Test state 1")
-                .RespondWith(Response.Create().WithBody("Test state msg 1"));
+        Check.That(server.Scenarios["To do list"].Name).IsEqualTo("To do list");
+        Check.That(server.Scenarios["To do list"].NextState).IsEqualTo("Cancel newspaper item added");
+        Check.That(server.Scenarios["To do list"].Started).IsTrue();
+        Check.That(server.Scenarios["To do list"].Finished).IsFalse();
 
-            server
-                .Given(Request.Create().WithPath("/state2").UsingGet())
-                .InScenario("s2")
-                .WillSetStateTo("Test state 2")
-                .RespondWith(Response.Create().WithBody("No state msg 2"));
+        string getResponse2 = await client.GetStringAsync("/todo/items").ConfigureAwait(false);
+        Check.That(getResponse2).Equals("Buy milk;Cancel newspaper subscription");
 
-            server
-                .Given(Request.Create().WithPath("/foo2X").UsingGet())
-                .InScenario("s2")
-                .WhenStateIs("Test state 2")
-                .RespondWith(Response.Create().WithBody("Test state msg 2"));
+        Check.That(server.Scenarios["To do list"].Name).IsEqualTo("To do list");
+        Check.That(server.Scenarios["To do list"].NextState).IsNull();
+        Check.That(server.Scenarios["To do list"].Started).IsTrue();
+        Check.That(server.Scenarios["To do list"].Finished).IsTrue();
 
-            // Act and Assert
-            string url = "http://localhost:" + server.Ports[0];
-            var responseNoState1 = await new HttpClient().GetStringAsync(url + "/state1").ConfigureAwait(false);
-            Check.That(responseNoState1).Equals("No state msg 1");
+        server.Stop();
+    }
 
-            var responseNoState2 = await new HttpClient().GetStringAsync(url + "/state2").ConfigureAwait(false);
-            Check.That(responseNoState2).Equals("No state msg 2");
+    [Fact]
+    public async Task Scenarios_TodoList_WithSetState()
+    {
+        // Arrange
+        var scenario = "To do list";
+        using var server = WireMockServer.Start();
+        var client = server.CreateClient();
 
-            var responseWithState1 = await new HttpClient().GetStringAsync(url + "/foo1X").ConfigureAwait(false);
-            Check.That(responseWithState1).Equals("Test state msg 1");
+        server
+            .Given(Request.Create().WithPath("/todo/items").UsingGet())
+            .InScenario(scenario)
+            .WhenStateIs("Buy milk")
+            .RespondWith(Response.Create().WithBody("Buy milk"));
 
-            var responseWithState2 = await new HttpClient().GetStringAsync(url + "/foo2X").ConfigureAwait(false);
-            Check.That(responseWithState2).Equals("Test state msg 2");
+        server
+            .Given(Request.Create().WithPath("/todo/items").UsingGet())
+            .InScenario(scenario)
+            .WhenStateIs("Cancel newspaper")
+            .RespondWith(Response.Create().WithBody("Buy milk;Cancel newspaper subscription"));
 
-            server.Stop();
-        }
+        // Act and Assert
+        server.SetScenarioState(scenario, "Buy milk");
+        server.Scenarios[scenario].Should().BeEquivalentTo(new { Name = scenario, NextState = "Buy milk" });
+        
+        var getResponse1 = await client.GetStringAsync("/todo/items").ConfigureAwait(false);
+        getResponse1.Should().Be("Buy milk");
+
+        server.SetScenarioState(scenario, "Cancel newspaper");
+        server.Scenarios[scenario].Name.Should().Be(scenario);
+        server.Scenarios[scenario].Should().BeEquivalentTo(new { Name = scenario, NextState = "Cancel newspaper" });
+
+        var getResponse2 = await client.GetStringAsync("/todo/items").ConfigureAwait(false);
+        getResponse2.Should().Be("Buy milk;Cancel newspaper subscription");
+    }
+
+    [Fact]
+    public void Scenarios_TodoList_WithSetStateToNull_ShouldThrowException()
+    {
+        // Arrange
+        var scenario = "To do list";
+        using var server = WireMockServer.Start();
+        var client = server.CreateClient();
+
+        server
+            .Given(Request.Create().WithPath("/todo/items").UsingGet())
+            .InScenario(scenario)
+            .WhenStateIs("Buy milk")
+            .RespondWith(Response.Create().WithBody("Buy milk"));
+
+        server
+            .Given(Request.Create().WithPath("/todo/items").UsingGet())
+            .InScenario(scenario)
+            .WhenStateIs("Cancel newspaper")
+            .RespondWith(Response.Create().WithBody("Buy milk;Cancel newspaper subscription"));
+
+        // Act
+        server.SetScenarioState(scenario, null);
+        var action = async () => await client.GetStringAsync("/todo/items");
+
+        // Assert
+        action.Should().ThrowAsync<HttpRequestException>();
+    }
+
+    [Fact]
+    public async Task Scenarios_Should_process_request_if_equals_state_and_multiple_state_defined()
+    {
+        // Assign
+        var server = WireMockServer.Start();
+
+        server
+            .Given(Request.Create().WithPath("/state1").UsingGet())
+            .InScenario("s1")
+            .WillSetStateTo("Test state 1")
+            .RespondWith(Response.Create().WithBody("No state msg 1"));
+
+        server
+            .Given(Request.Create().WithPath("/foo1X").UsingGet())
+            .InScenario("s1")
+            .WhenStateIs("Test state 1")
+            .RespondWith(Response.Create().WithBody("Test state msg 1"));
+
+        server
+            .Given(Request.Create().WithPath("/state2").UsingGet())
+            .InScenario("s2")
+            .WillSetStateTo("Test state 2")
+            .RespondWith(Response.Create().WithBody("No state msg 2"));
+
+        server
+            .Given(Request.Create().WithPath("/foo2X").UsingGet())
+            .InScenario("s2")
+            .WhenStateIs("Test state 2")
+            .RespondWith(Response.Create().WithBody("Test state msg 2"));
+
+        // Act and Assert
+        string url = "http://localhost:" + server.Ports[0];
+        var responseNoState1 = await new HttpClient().GetStringAsync(url + "/state1").ConfigureAwait(false);
+        Check.That(responseNoState1).Equals("No state msg 1");
+
+        var responseNoState2 = await new HttpClient().GetStringAsync(url + "/state2").ConfigureAwait(false);
+        Check.That(responseNoState2).Equals("No state msg 2");
+
+        var responseWithState1 = await new HttpClient().GetStringAsync(url + "/foo1X").ConfigureAwait(false);
+        Check.That(responseWithState1).Equals("Test state msg 1");
+
+        var responseWithState2 = await new HttpClient().GetStringAsync(url + "/foo2X").ConfigureAwait(false);
+        Check.That(responseWithState2).Equals("Test state msg 2");
+
+        server.Stop();
     }
 }

test/WireMock.Net.Tests/WireMockServer.Admin.cs

@@ -560,6 +560,30 @@ public class WireMockServerAdminTests
         Check.That(await response.Content.ReadAsStringAsync().ConfigureAwait(false)).Equals($"{{\"Status\":\"Mappings deleted. Affected GUIDs: [{guid1}, {guid2}]\"}}");
     }
 
+#if NET5_0_OR_GREATER
+    [Fact]
+    public async Task WireMockServer_CreateHttpClientFactory_And_CallEndpoint()
+    {
+        // Arrange
+        var server = WireMockServer.Start();
+        var factory = server.CreateHttpClientFactory();
+        var client = factory.CreateClient("any name");
+
+        // Act
+        await client.GetAsync($"{server.Url}/foo").ConfigureAwait(false);
+
+        // Assert
+        Check.That(server.LogEntries).HasSize(1);
+        var requestLogged = server.LogEntries.First();
+        Check.That(requestLogged.RequestMessage.Method).IsEqualTo("GET");
+        Check.That(requestLogged.RequestMessage.BodyData).IsNull();
+
+        // Cleanup
+        server.Stop();
+        server.Dispose();
+    }
+#endif
+
     [Fact]
     public async Task WireMockServer_CreateClient_And_CallEndpoint()
     {