1.0.19.0

* HandleBarsFileFragment

* 1.0.17

* {{File}}

CHANGELOG.md

@@ -1,3 +1,29 @@
+# 1.0.19.0 (15 June 2019)
+- [#279](https://github.com/WireMock-Net/WireMock.Net/issues/279) - How to simulate disconnect? [question]
+- [#283](https://github.com/WireMock-Net/WireMock.Net/issues/283) - Support equal-sign in query [bug]
+
+# 1.0.18.0 (10 June 2019)
+- [#282](https://github.com/WireMock-Net/WireMock.Net/pull/282) - WireMock.Net.Standalone : Add --WireMockLogger commandline argument [feature] contributed by [StefH](https://github.com/StefH)
+
+# 1.0.17.0 (05 June 2019)
+- [#278](https://github.com/WireMock-Net/WireMock.Net/pull/278) - Add support for HandleBars File (to read a file) [feature] contributed by [StefH](https://github.com/StefH)
+- [#276](https://github.com/WireMock-Net/WireMock.Net/issues/276) - No server response in Postman and Receive Failure in Fiddler [invalid]
+
+# 1.0.16.0 (16 May 2019)
+- [#274](https://github.com/WireMock-Net/WireMock.Net/pull/274) - Sign Assembly [feature] contributed by [StefH](https://github.com/StefH)
+- [#160](https://github.com/WireMock-Net/WireMock.Net/issues/160) - Feature: Sign 'WireMock.Net' [feature]
+- [#267](https://github.com/WireMock-Net/WireMock.Net/issues/267) - Assembly does not have strong name
+
+# 1.0.15.0 (04 May 2019)
+- [#271](https://github.com/WireMock-Net/WireMock.Net/pull/271) - Support Dynamic response files using Handlebars templating [bug, feature] contributed by [StefH](https://github.com/StefH)
+- [#272](https://github.com/WireMock-Net/WireMock.Net/pull/272) - Add unit test for JsonPath and BodyAsFile mapping contributed by [denstorti](https://github.com/denstorti)
+- [#273](https://github.com/WireMock-Net/WireMock.Net/pull/273) - Dynamic response handlebars templating (2) [bug, feature] contributed by [StefH](https://github.com/StefH)
+- [#270](https://github.com/WireMock-Net/WireMock.Net/issues/270) - Dynamic response files using Handlebars templating [bug, question]
+
+# 1.0.14.0 (20 April 2019)
+- [#269](https://github.com/WireMock-Net/WireMock.Net/pull/269) - Add JmesPath matcher [feature] contributed by [StefH](https://github.com/StefH)
+- [#268](https://github.com/WireMock-Net/WireMock.Net/issues/268) - Swagger UI for admin api [question]
+
 # 1.0.13.0 (11 April 2019)
 - [#266](https://github.com/WireMock-Net/WireMock.Net/pull/266) - [265] Add file upload to allow mocking of file operations contributed by [JackCreativeCrew](https://github.com/JackCreativeCrew)
 - [#265](https://github.com/WireMock-Net/WireMock.Net/issues/265) - File Upload [feature]

Directory.Build.props

@@ -4,7 +4,7 @@
   </PropertyGroup>
 
   <PropertyGroup>
-    <VersionPrefix>1.0.13</VersionPrefix>
+    <VersionPrefix>1.0.19</VersionPrefix>
   </PropertyGroup>
 
   <Choose>

GitHubReleaseNotes.txt

@@ -1,3 +1,3 @@
 https://github.com/StefH/GitHubReleaseNotes
 
-GitHubReleaseNotes.exe --output CHANGELOG.md --skip-empty-releases --version 1.0.13.0
+GitHubReleaseNotes.exe --output CHANGELOG.md --skip-empty-releases --version 1.0.19.0

README.md

@@ -8,7 +8,7 @@ A C# .NET version based on [mock4net](https://github.com/alexvictoor/mock4net) w
 * Record/playback of stubs (proxying)
 * Per-request conditional proxying
 * Stateful behaviour simulation
-* Response transformation
+* Response templating / transformation using Handlebars and extensions
 
 ## Info
 | | |

WireMock.Net Solution.sln.DotSettings

@@ -10,6 +10,7 @@
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=XUA/@EntryIndexedValue">XUA</s:String>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=funcs/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Heyenrath/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=Jmes/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=randomizer/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Stef/@EntryIndexedValue">True</s:Boolean>
 </wpf:ResourceDictionary>

examples/WireMock.Net.Console.Net452.Classic/CustomFileSystemFileHandler.cs

@@ -50,6 +50,12 @@ namespace WireMock.Net.ConsoleApplication
             return File.ReadAllBytes(Path.GetFileName(path) == path ? Path.Combine(GetMappingFolder(), path) : path);
         }
 
+        /// <inheritdoc cref="IFileSystemHandler.ReadResponseBodyAsFile"/>
+        public string ReadResponseBodyAsString(string path)
+        {
+            return File.ReadAllText(Path.GetFileName(path) == path ? Path.Combine(GetMappingFolder(), path) : path);
+        }
+
         /// <inheritdoc cref="IFileSystemHandler.FileExists"/>
         public bool FileExists(string path)
         {

examples/WireMock.Net.Console.Net452.Classic/MainApp.cs

@@ -438,6 +438,15 @@ namespace WireMock.Net.ConsoleApplication
                     .WithBody("<xml>ok</xml>")
                 );
 
+            server.Given(Request.Create()
+                    .WithPath("/services/query/")
+                    .WithParam("q", "SELECT Id from User where username='user@gmail.com'")
+                    .UsingGet())
+                .RespondWith(Response.Create()
+                    .WithStatusCode(200)
+                    .WithHeader("Content-Type", "application/json")
+                    .WithBodyAsJson(new { Id = "5bdf076c-5654-4b3e-842c-7caf1fabf8c9" }));
+
             System.Console.WriteLine("Press any key to stop the server");
             System.Console.ReadKey();
             server.Stop();

examples/WireMock.Net.StandAlone.NETCoreApp/Properties/launchSettings.json

@@ -2,7 +2,7 @@
   "profiles": {
     "WireMock.Net.StandAlone.NETCoreApp": {
       "commandName": "Project",
-      "commandLineArgs": "--Urls http://*:9091"
+      "commandLineArgs": "--Urls http://*:9091 --WireMockLogger WireMockConsoleLogger"
     }
   }
 }

examples/WireMock.Net.StandAlone.Net461/App.config

@@ -44,7 +44,7 @@
       </dependentAssembly>
       <dependentAssembly>
         <assemblyIdentity name="System.Linq.Dynamic.Core" publicKeyToken="0f07ec44de6ac832" culture="neutral" />
-        <bindingRedirect oldVersion="0.0.0.0-1.0.11.0" newVersion="1.0.11.0" />
+        <bindingRedirect oldVersion="0.0.0.0-1.0.12.0" newVersion="1.0.12.0" />
       </dependentAssembly>
       <dependentAssembly>
         <assemblyIdentity name="System.Runtime.CompilerServices.Unsafe" publicKeyToken="b03f5f7f11d50a3a" culture="neutral" />

examples/WireMock.Net.StandAlone.Net461/WireMock.Net.StandAlone.Net461.csproj

@@ -225,8 +225,8 @@
     <Reference Include="System.IO.Pipelines, Version=4.0.0.1, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
       <HintPath>..\..\packages\System.IO.Pipelines.4.5.2\lib\netstandard2.0\System.IO.Pipelines.dll</HintPath>
     </Reference>
-    <Reference Include="System.Linq.Dynamic.Core, Version=1.0.11.0, Culture=neutral, PublicKeyToken=0f07ec44de6ac832, processorArchitecture=MSIL">
-      <HintPath>..\..\packages\System.Linq.Dynamic.Core.1.0.11\lib\net46\System.Linq.Dynamic.Core.dll</HintPath>
+    <Reference Include="System.Linq.Dynamic.Core, Version=1.0.12.0, Culture=neutral, PublicKeyToken=0f07ec44de6ac832, processorArchitecture=MSIL">
+      <HintPath>..\..\packages\System.Linq.Dynamic.Core.1.0.12\lib\net46\System.Linq.Dynamic.Core.dll</HintPath>
     </Reference>
     <Reference Include="System.Memory, Version=4.0.1.0, Culture=neutral, PublicKeyToken=cc7b13ffcd2ddd51, processorArchitecture=MSIL">
       <HintPath>..\..\packages\System.Memory.4.5.1\lib\netstandard2.0\System.Memory.dll</HintPath>

examples/WireMock.Net.StandAlone.Net461/packages.config

@@ -65,7 +65,7 @@
   <package id="System.Collections.Immutable" version="1.5.0" targetFramework="net461" />
   <package id="System.Diagnostics.DiagnosticSource" version="4.5.0" targetFramework="net461" />
   <package id="System.IO.Pipelines" version="4.5.2" targetFramework="net461" />
-  <package id="System.Linq.Dynamic.Core" version="1.0.11" targetFramework="net461" />
+  <package id="System.Linq.Dynamic.Core" version="1.0.12" targetFramework="net461" />
   <package id="System.Memory" version="4.5.1" targetFramework="net461" />
   <package id="System.Numerics.Vectors" version="4.5.0" targetFramework="net461" />
   <package id="System.Reflection.Metadata" version="1.6.0" targetFramework="net461" />

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

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

src/WireMock.Net.StandAlone/StandAloneApp.cs

@@ -50,7 +50,7 @@ namespace WireMock.Net.StandAlone
                 AdminUsername = parser.GetStringValue("AdminUsername"),
                 AdminPassword = parser.GetStringValue("AdminPassword"),
                 MaxRequestLogCount = parser.GetIntValue("MaxRequestLogCount"),
-                RequestLogExpirationDuration = parser.GetIntValue("RequestLogExpirationDuration"),
+                RequestLogExpirationDuration = parser.GetIntValue("RequestLogExpirationDuration")
             };
 
             if (logger != null)
@@ -58,6 +58,11 @@ namespace WireMock.Net.StandAlone
                 settings.Logger = logger;
             }
 
+            if (parser.GetStringValue("WireMockLogger") == "WireMockConsoleLogger")
+            {
+                settings.Logger = new WireMockConsoleLogger();
+            }
+
             if (parser.Contains("Port"))
             {
                 settings.Port = parser.GetIntValue("Port");
@@ -82,9 +87,7 @@ namespace WireMock.Net.StandAlone
 
             settings.Logger.Debug("WireMock.Net server arguments [{0}]", string.Join(", ", args.Select(a => $"'{a}'")));
 
-            FluentMockServer server = Start(settings);
-
-            return server;
+            return Start(settings);
         }
     }
 }

src/WireMock.Net.StandAlone/WireMock.Net.StandAlone.csproj

@@ -25,6 +25,10 @@
     <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
     <GenerateBindingRedirectsOutputType>true</GenerateBindingRedirectsOutputType>
     <CodeAnalysisRuleSet>WireMock.Net.StandAlone.ruleset</CodeAnalysisRuleSet>
+    <SignAssembly>true</SignAssembly>
+    <AssemblyOriginatorKeyFile>../WireMock.Net/WireMock.Net.snk</AssemblyOriginatorKeyFile>
+    <!--<DelaySign>true</DelaySign>-->
+    <PublicSign Condition=" '$(OS)' != 'Windows_NT' ">true</PublicSign>
   </PropertyGroup>
   
   <PropertyGroup Condition=" '$(Configuration)' == 'Release' ">

src/WireMock.Net/Handlers/IFileSystemHandler.cs

@@ -49,12 +49,19 @@ namespace WireMock.Handlers
         void WriteMappingFile([NotNull] string path, [NotNull] string text);
 
         /// <summary>
-        /// Read a response body file as text.
+        /// Read a response body file as byte[].
         /// </summary>
         /// <param name="path">The path or filename from the file to read.</param>
         /// <returns>The file content as bytes.</returns>
         byte[] ReadResponseBodyAsFile([NotNull] string path);
 
+        /// <summary>
+        /// Read a response body file as text.
+        /// </summary>
+        /// <param name="path">The path or filename from the file to read.</param>
+        /// <returns>The file content as text.</returns>
+        string ReadResponseBodyAsString([NotNull] string path);
+
         /// <summary>
         /// Delete a file.
         /// </summary>

src/WireMock.Net/Handlers/LocalFileSystemHandler.cs

@@ -68,6 +68,16 @@ namespace WireMock.Handlers
             return File.ReadAllBytes(Path.GetFileName(path) == path ? Path.Combine(GetMappingFolder(), path) : path);
         }
 
+        /// <inheritdoc cref="IFileSystemHandler.ReadResponseBodyAsString"/>
+        public string ReadResponseBodyAsString(string path)
+        {
+            Check.NotNullOrEmpty(path, nameof(path));
+
+            // In case the path is a filename, the path will be adjusted to the MappingFolder.
+            // Else the path will just be as-is.
+            return File.ReadAllText(Path.GetFileName(path) == path ? Path.Combine(GetMappingFolder(), path) : path);
+        }
+
         /// <inheritdoc cref="IFileSystemHandler.FileExists"/>
         public bool FileExists(string filename)
         {

src/WireMock.Net/Matchers/JmesPathMatcher.cs

@@ -0,0 +1,83 @@
+using DevLab.JmesPath;
+using JetBrains.Annotations;
+using Newtonsoft.Json;
+using System.Linq;
+using WireMock.Validation;
+
+namespace WireMock.Matchers
+{
+    /// <summary>
+    /// http://jmespath.org/
+    /// </summary>
+    public class JmesPathMatcher : IStringMatcher, IObjectMatcher
+    {
+        private readonly string[] _patterns;
+
+        /// <inheritdoc cref="IMatcher.MatchBehaviour"/>
+        public MatchBehaviour MatchBehaviour { get; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JmesPathMatcher"/> class.
+        /// </summary>
+        /// <param name="patterns">The patterns.</param>
+        public JmesPathMatcher([NotNull] params string[] patterns) : this(MatchBehaviour.AcceptOnMatch, patterns)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JmesPathMatcher"/> class.
+        /// </summary>
+        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// <param name="patterns">The patterns.</param>
+        public JmesPathMatcher(MatchBehaviour matchBehaviour, [NotNull] params string[] patterns)
+        {
+            Check.NotNull(patterns, nameof(patterns));
+
+            MatchBehaviour = matchBehaviour;
+            _patterns = patterns;
+        }
+
+        /// <inheritdoc cref="IStringMatcher.IsMatch"/>
+        public double IsMatch(string input)
+        {
+            double match = MatchScores.Mismatch;
+            if (input != null)
+            {
+                try
+                {
+                    match = MatchScores.ToScore(_patterns.Select(pattern => bool.Parse(new JmesPath().Transform(input, pattern))));
+                }
+                catch (JsonException)
+                {
+                    // just ignore JsonException
+                }
+            }
+
+            return MatchBehaviourHelper.Convert(MatchBehaviour, match);
+        }
+
+        /// <inheritdoc cref="IObjectMatcher.IsMatch"/>
+        public double IsMatch(object input)
+        {
+            double match = MatchScores.Mismatch;
+
+            // When input is null or byte[], return Mismatch.
+            if (input != null && !(input is byte[]))
+            {
+                string inputAsString = JsonConvert.SerializeObject(input);
+                return IsMatch(inputAsString);
+            }
+
+            return MatchBehaviourHelper.Convert(MatchBehaviour, match);
+        }
+
+        /// <inheritdoc cref="IStringMatcher.GetPatterns"/>
+        public string[] GetPatterns()
+        {
+            return _patterns;
+        }
+
+        /// <inheritdoc cref="IMatcher.Name"/>
+        public string Name => "JmesPathMatcher";
+    }
+}

src/WireMock.Net/Properties/AssemblyInfo.cs

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

src/WireMock.Net/RequestBuilders/Request.cs

@@ -4,7 +4,6 @@ using System.Collections.ObjectModel;
 using System.Linq;
 using WireMock.Matchers;
 using WireMock.Matchers.Request;
-using WireMock.Util;
 using WireMock.Validation;
 
 namespace WireMock.RequestBuilders

src/WireMock.Net/RequestMessage.cs

@@ -171,40 +171,7 @@ namespace WireMock
             Headers = headers?.ToDictionary(header => header.Key, header => new WireMockList<string>(header.Value));
             Cookies = cookies;
             RawQuery = WebUtility.UrlDecode(urlDetails.Url.Query);
-            Query = ParseQuery(RawQuery);
-        }
-
-        private static IDictionary<string, WireMockList<string>> ParseQuery(string queryString)
-        {
-            if (string.IsNullOrEmpty(queryString))
-            {
-                return null;
-            }
-
-            if (queryString.StartsWith("?"))
-            {
-                queryString = queryString.Substring(1);
-            }
-
-            return queryString.Split(new[] { '&' }, StringSplitOptions.RemoveEmptyEntries)
-                .Aggregate(new Dictionary<string, WireMockList<string>>(),
-                (dict, term) =>
-                {
-                    string[] parts = term.Split(new[] { '=' }, StringSplitOptions.RemoveEmptyEntries);
-                    string key = parts[0];
-                    if (!dict.ContainsKey(key))
-                    {
-                        dict.Add(key, new WireMockList<string>());
-                    }
-
-                    if (parts.Length == 2)
-                    {
-                        string[] values = parts[1].Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries);
-                        dict[key].AddRange(values);
-                    }
-
-                    return dict;
-                });
+            Query = QueryStringParser.Parse(RawQuery);
         }
 
         /// <summary>

src/WireMock.Net/ResponseBuilders/Response.cs

@@ -21,7 +21,8 @@ namespace WireMock.ResponseBuilders
     /// </summary>
     public class Response : IResponseBuilder
     {
-        private readonly IFileSystemHandler _fileSystemHandler = new LocalFileSystemHandler();
+        private readonly IFileSystemHandler _fileSystemHandler;
+        private readonly ResponseMessageTransformer _responseMessageTransformer;
         private HttpClient _httpClientForProxy;
 
         /// <summary>
@@ -93,6 +94,9 @@ namespace WireMock.ResponseBuilders
         private Response(ResponseMessage responseMessage)
         {
             ResponseMessage = responseMessage;
+
+            _fileSystemHandler = new LocalFileSystemHandler();
+            _responseMessageTransformer = new ResponseMessageTransformer(_fileSystemHandler);
         }
 
         /// <summary>
@@ -224,7 +228,7 @@ namespace WireMock.ResponseBuilders
                 BodyAsFileIsCached = cache
             };
 
-            if (cache)
+            if (cache && !UseTransformer)
             {
                 ResponseMessage.BodyData.DetectedBodyType = BodyType.Bytes;
                 ResponseMessage.BodyData.BodyAsBytes = _fileSystemHandler.ReadResponseBodyAsFile(filename);
@@ -417,7 +421,7 @@ namespace WireMock.ResponseBuilders
 
             if (UseTransformer)
             {
-                return ResponseMessageTransformer.Transform(requestMessage, ResponseMessage);
+                return _responseMessageTransformer.Transform(requestMessage, ResponseMessage);
             }
 
             // Just return normal defined ResponseMessage

src/WireMock.Net/Serialization/MatcherMapper.cs

@@ -45,6 +45,9 @@ namespace WireMock.Serialization
                 case "JsonPathMatcher":
                     return new JsonPathMatcher(matchBehaviour, stringPatterns);
 
+                case "JmesPathMatcher":
+                    return new JmesPathMatcher(matchBehaviour, stringPatterns);
+
                 case "XPathMatcher":
                     return new XPathMatcher(matchBehaviour, (string)matcher.Pattern);
 

src/WireMock.Net/Server/FluentMockServer.Admin.cs

@@ -722,6 +722,11 @@ namespace WireMock.Server
                 responseBuilder = responseBuilder.WithDelay(responseModel.Delay.Value);
             }
 
+            if (responseModel.UseTransformer)
+            {
+                responseBuilder = responseBuilder.WithTransformer();
+            }
+
             if (!string.IsNullOrEmpty(responseModel.ProxyUrl))
             {
                 if (string.IsNullOrEmpty(responseModel.X509Certificate2ThumbprintOrSubjectName))
@@ -778,11 +783,6 @@ namespace WireMock.Server
                 responseBuilder = responseBuilder.WithBodyFromFile(responseModel.BodyAsFile);
             }
 
-            if (responseModel.UseTransformer)
-            {
-                responseBuilder = responseBuilder.WithTransformer();
-            }
-
             return responseBuilder;
         }
 

src/WireMock.Net/Server/FluentMockServer.cs

@@ -1,11 +1,11 @@
 using JetBrains.Annotations;
+using Newtonsoft.Json;
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading;
-using Newtonsoft.Json;
 using WireMock.Exceptions;
 using WireMock.Handlers;
 using WireMock.Logging;
@@ -185,7 +185,7 @@ namespace WireMock.Server
 
         private FluentMockServer(IFluentMockServerSettings settings)
         {
-            settings.Logger = settings.Logger ?? new WireMockConsoleLogger();
+            settings.Logger = settings.Logger ?? new WireMockNullLogger();
 
             _logger = settings.Logger;
             _fileSystemHandler = settings.FileSystemHandler ?? new LocalFileSystemHandler();

src/WireMock.Net/Settings/FluentMockServerSettings.cs

@@ -1,6 +1,6 @@
-using System;
-using JetBrains.Annotations;
+using JetBrains.Annotations;
 using Newtonsoft.Json;
+using System;
 using WireMock.Handlers;
 using WireMock.Logging;
 

src/WireMock.Net/Settings/IFluentMockServerSettings.cs

@@ -24,7 +24,7 @@ namespace WireMock.Settings
         bool? UseSSL { get; set; }
 
         /// <summary>
-        /// Gets or sets wether to start admin interface.
+        /// Gets or sets whether to start admin interface.
         /// </summary>
         [PublicAPI]
         bool? StartAdminInterface { get; set; }

src/WireMock.Net/Transformers/HandleBarsFile.cs

@@ -0,0 +1,41 @@
+using HandlebarsDotNet;
+using System;
+using WireMock.Handlers;
+using WireMock.Validation;
+
+namespace WireMock.Transformers
+{
+    internal static class HandleBarsFile
+    {
+        public static void Register(IHandlebars handlebarsContext, IFileSystemHandler fileSystemHandler)
+        {
+            handlebarsContext.RegisterHelper("File", (writer, context, arguments) =>
+            {
+                string value = ParseArgumentAndReadFileFragment(handlebarsContext, context, fileSystemHandler, arguments);
+                writer.Write(value);
+            });
+
+            handlebarsContext.RegisterHelper("File", (writer, options, context, arguments) =>
+            {
+                string value = ParseArgumentAndReadFileFragment(handlebarsContext, context, fileSystemHandler, arguments);
+                options.Template(writer, value);
+            });
+        }
+
+        private static string ParseArgumentAndReadFileFragment(IHandlebars handlebarsContext, dynamic context, IFileSystemHandler fileSystemHandler, object[] arguments)
+        {
+            Check.Condition(arguments, args => args.Length == 1, nameof(arguments));
+            Check.NotNull(arguments[0], "arguments[0]");
+
+            switch (arguments[0])
+            {
+                case string path:
+                    var templateFunc = handlebarsContext.Compile(path);
+                    string transformed = templateFunc(context);
+                    return fileSystemHandler.ReadResponseBodyAsString(transformed);
+            }
+
+            throw new NotSupportedException($"The value '{arguments[0]}' with type '{arguments[0]?.GetType()}' cannot be used in Handlebars File.");
+        }
+    }
+}

src/WireMock.Net/Transformers/HandleBarsHelpers.cs

@@ -1,10 +1,11 @@
 using HandlebarsDotNet;
+using WireMock.Handlers;
 
 namespace WireMock.Transformers
 {
     internal static class HandlebarsHelpers
     {
-        public static void Register(IHandlebars handlebarsContext)
+        public static void Register(IHandlebars handlebarsContext, IFileSystemHandler fileSystemHandler)
         {
             HandleBarsRegex.Register(handlebarsContext);
 
@@ -15,6 +16,8 @@ namespace WireMock.Transformers
             HandleBarsRandom.Register(handlebarsContext);
 
             HandleBarsXeger.Register(handlebarsContext);
+
+            HandleBarsFile.Register(handlebarsContext, fileSystemHandler);
         }
     }
 }

src/WireMock.Net/Transformers/ResponseMessageTransformer.cs

@@ -1,14 +1,17 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using HandlebarsDotNet;
+using HandlebarsDotNet;
+using JetBrains.Annotations;
 using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using WireMock.Handlers;
 using WireMock.Util;
+using WireMock.Validation;
 
 namespace WireMock.Transformers
 {
-    internal static class ResponseMessageTransformer
+    internal class ResponseMessageTransformer
     {
         private static readonly HandlebarsConfiguration HandlebarsConfiguration = new HandlebarsConfiguration
         {
@@ -17,30 +20,33 @@ namespace WireMock.Transformers
 
         private static readonly IHandlebars HandlebarsContext = Handlebars.Create(HandlebarsConfiguration);
 
-        static ResponseMessageTransformer()
+        public ResponseMessageTransformer([NotNull] IFileSystemHandler fileSystemHandler)
         {
-            HandlebarsHelpers.Register(HandlebarsContext);
+            Check.NotNull(fileSystemHandler, nameof(fileSystemHandler));
+
+            HandlebarsHelpers.Register(HandlebarsContext, fileSystemHandler);
         }
 
-        public static ResponseMessage Transform(RequestMessage requestMessage, ResponseMessage original)
+        public ResponseMessage Transform(RequestMessage requestMessage, ResponseMessage original)
         {
-            bool bodyIsJson = original.BodyData.DetectedBodyType == BodyType.Json;
             var responseMessage = new ResponseMessage { StatusCode = original.StatusCode };
 
-            if (!bodyIsJson)
-            {
-                responseMessage.BodyOriginal = original.BodyData.BodyAsString;
-            }
-
             var template = new { request = requestMessage };
 
-            if (!bodyIsJson)
+            switch (original.BodyData.DetectedBodyType)
             {
-                TransformBodyAsString(template, original, responseMessage);
-            }
-            else
-            {
-                TransformBodyAsJson(template, original, responseMessage);
+                case BodyType.Json:
+                    TransformBodyAsJson(template, original, responseMessage);
+                    break;
+
+                case BodyType.File:
+                    TransformBodyAsFile(template, original, responseMessage);
+                    break;
+
+                case BodyType.String:
+                    responseMessage.BodyOriginal = original.BodyData.BodyAsString;
+                    TransformBodyAsString(template, original, responseMessage);
+                    break;
             }
 
             // Headers
@@ -89,14 +95,14 @@ namespace WireMock.Transformers
             };
         }
 
-        private static void WalkNode(JToken node, object template)
+        private static void WalkNode(JToken node, object context)
         {
             if (node.Type == JTokenType.Object)
             {
                 // In case of Object, loop all children. Do a ToArray() to avoid `Collection was modified` exceptions.
                 foreach (JProperty child in node.Children<JProperty>().ToArray())
                 {
-                    WalkNode(child.Value, template);
+                    WalkNode(child.Value, context);
                 }
             }
             else if (node.Type == JTokenType.Array)
@@ -104,7 +110,7 @@ namespace WireMock.Transformers
                 // In case of Array, loop all items. Do a ToArray() to avoid `Collection was modified` exceptions.
                 foreach (JToken child in node.Children().ToArray())
                 {
-                    WalkNode(child, template);
+                    WalkNode(child, context);
                 }
             }
             else if (node.Type == JTokenType.String)
@@ -117,7 +123,7 @@ namespace WireMock.Transformers
                 }
 
                 var templateForStringValue = HandlebarsContext.Compile(stringValue);
-                string transformedString = templateForStringValue(template);
+                string transformedString = templateForStringValue(context);
                 if (!string.Equals(stringValue, transformedString))
                 {
                     ReplaceNodeValue(node, transformedString);
@@ -150,13 +156,25 @@ namespace WireMock.Transformers
 
         private static void TransformBodyAsString(object template, ResponseMessage original, ResponseMessage responseMessage)
         {
-            var templateBody = HandlebarsContext.Compile(original.BodyData.BodyAsString);
+            var templateBodyAsString = HandlebarsContext.Compile(original.BodyData.BodyAsString);
 
             responseMessage.BodyData = new BodyData
             {
                 DetectedBodyType = original.BodyData.DetectedBodyType,
                 DetectedBodyTypeFromContentType = original.BodyData.DetectedBodyTypeFromContentType,
-                BodyAsString = templateBody(template)
+                BodyAsString = templateBodyAsString(template)
+            };
+        }
+
+        private static void TransformBodyAsFile(object template, ResponseMessage original, ResponseMessage responseMessage)
+        {
+            var templateBodyAsFile = HandlebarsContext.Compile(original.BodyData.BodyAsFile);
+
+            responseMessage.BodyData = new BodyData
+            {
+                DetectedBodyType = original.BodyData.DetectedBodyType,
+                DetectedBodyTypeFromContentType = original.BodyData.DetectedBodyTypeFromContentType,
+                BodyAsFile = templateBodyAsFile(template)
             };
         }
     }

src/WireMock.Net/Util/QueryStringParser.cs

@@ -0,0 +1,41 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace WireMock.Util
+{
+    /// <summary>
+    /// Based on https://stackoverflow.com/questions/659887/get-url-parameters-from-a-string-in-net
+    /// </summary>
+    internal static class QueryStringParser
+    {
+        public static IDictionary<string, WireMockList<string>> Parse(string queryString)
+        {
+            if (string.IsNullOrEmpty(queryString))
+            {
+                return new Dictionary<string, WireMockList<string>>();
+            }
+
+            string[] JoinParts(string[] parts)
+            {
+                if (parts.Length > 2)
+                {
+                    return new[] { string.Join("=", parts, 1, parts.Length - 1) };
+                }
+
+                if (parts.Length > 1)
+                {
+                    return parts[1].Split(new[] { "," }, StringSplitOptions.RemoveEmptyEntries); // support "?key=1,2"
+                }
+
+                return new string[0];
+            }
+
+            return queryString.TrimStart('?')
+                .Split(new[] { '&', ';' }, StringSplitOptions.RemoveEmptyEntries) // Support "?key=value;key=anotherValue" and "?key=value&key=anotherValue"
+                .Select(parameter => parameter.Split(new[] { '=' }, StringSplitOptions.RemoveEmptyEntries))
+                .GroupBy(parts => parts[0], JoinParts)
+                .ToDictionary(grouping => grouping.Key, grouping => new WireMockList<string>(grouping.SelectMany(x => x)));
+        }
+    }
+}

src/WireMock.Net/WireMock.Net.csproj

@@ -25,6 +25,10 @@
     <AutoGenerateBindingRedirects>true</AutoGenerateBindingRedirects>
     <GenerateBindingRedirectsOutputType>true</GenerateBindingRedirectsOutputType>
     <CodeAnalysisRuleSet>WireMock.Net.ruleset</CodeAnalysisRuleSet>
+    <SignAssembly>true</SignAssembly>
+    <AssemblyOriginatorKeyFile>WireMock.Net.snk</AssemblyOriginatorKeyFile>
+    <!--<DelaySign>true</DelaySign>-->
+    <PublicSign Condition=" '$(OS)' != 'Windows_NT' ">true</PublicSign>
   </PropertyGroup>
 
   <PropertyGroup Condition="'$(Configuration)' == 'Release'">
@@ -57,8 +61,9 @@
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="System.Linq.Dynamic.Core" Version="1.0.11" />
-    <PackageReference Include="RandomDataGenerator.Net" Version="1.0.7" />
+    <PackageReference Include="System.Linq.Dynamic.Core" Version="1.0.12" />
+    <PackageReference Include="RandomDataGenerator.Net" Version="1.0.8" />
+    <PackageReference Include="JmesPath.Net" Version="1.0.125" />
   </ItemGroup>
 
   <ItemGroup Condition=" '$(TargetFramework)' == 'net451' ">

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

@@ -0,0 +1,166 @@
+using Newtonsoft.Json.Linq;
+using NFluent;
+using WireMock.Matchers;
+using Xunit;
+
+namespace WireMock.Net.Tests.Matchers
+{
+    public class JmesPathMatcherTests
+    {
+        [Fact]
+        public void JmesPathMatcher_GetName()
+        {
+            // Assign
+            var matcher = new JmesPathMatcher("X");
+
+            // Act
+            string name = matcher.Name;
+
+            // Assert
+            Check.That(name).Equals("JmesPathMatcher");
+        }
+
+        [Fact]
+        public void JmesPathMatcher_GetPatterns()
+        {
+            // Assign
+            var matcher = new JmesPathMatcher("X");
+
+            // Act
+            string[] patterns = matcher.GetPatterns();
+
+            // Assert
+            Check.That(patterns).ContainsExactly("X");
+        }
+
+        [Fact]
+        public void JmesPathMatcher_IsMatch_ByteArray()
+        {
+            // Assign
+            var bytes = new byte[0];
+            var matcher = new JmesPathMatcher("");
+
+            // Act 
+            double match = matcher.IsMatch(bytes);
+
+            // Assert 
+            Check.That(match).IsEqualTo(0);
+        }
+
+        [Fact]
+        public void JmesPathMatcher_IsMatch_NullString()
+        {
+            // Assign
+            string s = null;
+            var matcher = new JmesPathMatcher("");
+
+            // Act 
+            double match = matcher.IsMatch(s);
+
+            // Assert 
+            Check.That(match).IsEqualTo(0);
+        }
+
+        [Fact]
+        public void JmesPathMatcher_IsMatch_NullObject()
+        {
+            // Assign
+            object o = null;
+            var matcher = new JmesPathMatcher("");
+
+            // Act 
+            double match = matcher.IsMatch(o);
+
+            // Assert 
+            Check.That(match).IsEqualTo(0);
+        }
+
+        [Fact]
+        public void JmesPathMatcher_IsMatch_String_Exception_Mismatch()
+        {
+            // Assign
+            var matcher = new JmesPathMatcher("xxx");
+
+            // Act 
+            double match = matcher.IsMatch("");
+
+            // Assert 
+            Check.That(match).IsEqualTo(0);
+        }
+
+        [Fact]
+        public void JmesPathMatcher_IsMatch_Object_Exception_Mismatch()
+        {
+            // Assign
+            var matcher = new JmesPathMatcher("");
+
+            // Act 
+            double match = matcher.IsMatch("x");
+
+            // Assert 
+            Check.That(match).IsEqualTo(0);
+        }
+
+        [Fact]
+        public void JmesPathMatcher_IsMatch_AnonymousObject()
+        {
+            // Assign 
+            var matcher = new JmesPathMatcher("things.name == 'RequiredThing'");
+
+            // Act
+            double match = matcher.IsMatch(new { things = new { name = "RequiredThing" } });
+
+            // Assert 
+            Check.That(match).IsEqualTo(1);
+        }
+
+        [Fact]
+        public void JmesPathMatcher_IsMatch_JObject()
+        {
+            // Assign 
+            string[] patterns = { "things.x == 'RequiredThing'" };
+            var matcher = new JmesPathMatcher(patterns);
+
+            // Act
+            var sub = new JObject
+            {
+                { "x", new JValue("RequiredThing") }
+            };
+            var jobject = new JObject
+            {
+                { "Id", new JValue(1) },
+                { "things", sub }
+            };
+            double match = matcher.IsMatch(jobject);
+
+            // Assert 
+            Check.That(match).IsEqualTo(1);
+        }
+
+        [Fact]
+        public void JmesPathMatcher_IsMatch_JObject_Parsed()
+        {
+            // Assign 
+            var matcher = new JmesPathMatcher("things.x == 'RequiredThing'");
+
+            // Act 
+            double match = matcher.IsMatch(JObject.Parse("{ \"things\": { \"x\": \"RequiredThing\" } }"));
+
+            // Assert 
+            Check.That(match).IsEqualTo(1);
+        }
+
+        [Fact]
+        public void JmesPathMatcher_IsMatch_RejectOnMatch()
+        {
+            // Assign
+            var matcher = new JmesPathMatcher(MatchBehaviour.RejectOnMatch, "things.x == 'RequiredThing'");
+
+            // Act
+            double match = matcher.IsMatch(JObject.Parse("{ \"things\": { \"x\": \"RequiredThing\" } }"));
+
+            // Assert
+            Check.That(match).IsEqualTo(0.0);
+        }
+    }
+}

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

@@ -0,0 +1,102 @@
+using Moq;
+using Newtonsoft.Json.Linq;
+using NFluent;
+using System;
+using System.Threading.Tasks;
+using WireMock.Handlers;
+using WireMock.Models;
+using WireMock.ResponseBuilders;
+using WireMock.Transformers;
+using Xunit;
+
+namespace WireMock.Net.Tests.ResponseBuilders
+{
+    public class ResponseWithHandlebarsFileTests
+    {
+        private readonly Mock<IFileSystemHandler> _filesystemHandlerMock;
+        private const string ClientIp = "::1";
+
+        public ResponseWithHandlebarsFileTests()
+        {
+            _filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
+            _filesystemHandlerMock.Setup(fs => fs.ReadResponseBodyAsString(It.IsAny<string>())).Returns("abc");
+        }
+
+        [Fact]
+        public async Task Response_ProvideResponseAsync_Handlebars_File()
+        {
+            // Assign
+            var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "GET", ClientIp);
+
+            var response = Response.Create()
+                .WithBodyAsJson(new
+                {
+                    Data = "{{File \"x.json\"}}"
+                })
+                .WithTransformer();
+
+            response.SetPrivateFieldValue("_fileSystemHandler", _filesystemHandlerMock.Object);
+            response.SetPrivateFieldValue("_responseMessageTransformer", new ResponseMessageTransformer(_filesystemHandlerMock.Object));
+
+            // Act
+            var responseMessage = await response.ProvideResponseAsync(request);
+
+            // Assert
+            JObject j = JObject.FromObject(responseMessage.BodyData.BodyAsJson);
+            Check.That(j["Data"].Value<string>()).Equals("abc");
+
+            // Verify
+            _filesystemHandlerMock.Verify(fs => fs.ReadResponseBodyAsString("x.json"), Times.Once);
+            _filesystemHandlerMock.VerifyNoOtherCalls();
+        }
+
+        [Fact]
+        public async Task Response_ProvideResponseAsync_Handlebars_File_Replace()
+        {
+            // Assign
+            var request = new RequestMessage(new UrlDetails("http://localhost:1234?id=x"), "GET", ClientIp);
+
+            var response = Response.Create()
+                .WithBodyAsJson(new
+                {
+                    Data = "{{File \"{{request.query.id}}.json\"}}"
+                })
+                .WithTransformer();
+
+            response.SetPrivateFieldValue("_fileSystemHandler", _filesystemHandlerMock.Object);
+            response.SetPrivateFieldValue("_responseMessageTransformer", new ResponseMessageTransformer(_filesystemHandlerMock.Object));
+
+            // Act
+            var responseMessage = await response.ProvideResponseAsync(request);
+
+            // Assert
+            JObject j = JObject.FromObject(responseMessage.BodyData.BodyAsJson);
+            Check.That(j["Data"].Value<string>()).Equals("abc");
+
+            // Verify
+            _filesystemHandlerMock.Verify(fs => fs.ReadResponseBodyAsString("x.json"), Times.Once);
+            _filesystemHandlerMock.VerifyNoOtherCalls();
+        }
+
+        [Fact]
+        public void Response_ProvideResponseAsync_Handlebars_File_WithMissingArgument_ThrowsArgumentOutOfRangeException()
+        {
+            // Assign
+            var request = new RequestMessage(new UrlDetails("http://localhost:1234"), "GET", ClientIp);
+
+            var response = Response.Create()
+                .WithBodyAsJson(new
+                {
+                    Data = "{{File}}"
+                })
+                .WithTransformer();
+
+            // Act
+            Check.ThatAsyncCode(() => response.ProvideResponseAsync(request)).Throws<ArgumentOutOfRangeException>();
+
+            // Verify
+            _filesystemHandlerMock.Verify(fs => fs.ReadResponseBodyAsString(It.IsAny<string>()), Times.Never);
+            _filesystemHandlerMock.VerifyNoOtherCalls();
+        }
+    }
+}

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

@@ -214,5 +214,49 @@ namespace WireMock.Net.Tests.ResponseBuilders
             // Assert
             Check.That(JsonConvert.SerializeObject(responseMessage.BodyData.BodyAsJson)).Equals("[\"first\",\"/foo_array\",\"test 1\",\"test 2\",\"last\"]");
         }
+
+        [Fact]
+        public async Task Response_ProvideResponse_Handlebars_WithBodyAsFile()
+        {
+            // Assign
+            var request = new RequestMessage(new UrlDetails("http://localhost/foo?MyUniqueNumber=1"), "GET", ClientIp);
+
+            var response = Response.Create()
+                .WithTransformer()
+                .WithBodyFromFile(@"c:\\{{request.query.MyUniqueNumber}}\test.xml"); // why use a \\ here ?
+
+            // Act
+            var responseMessage = await response.ProvideResponseAsync(request);
+
+            // Assert
+            Check.That(responseMessage.BodyData.BodyAsFile).Equals(@"c:\1\test.xml");
+        }
+
+        [Fact]
+        public async Task Response_ProvideResponse_Handlebars_WithBodyAsFile_JsonPath()
+        {
+            // Assign
+            string jsonString = "{ \"MyUniqueNumber\": \"1\" }";
+            var bodyData = new BodyData
+            {
+                BodyAsString = jsonString,
+                BodyAsJson = JsonConvert.DeserializeObject(jsonString),
+                DetectedBodyType = BodyType.Json,
+                DetectedBodyTypeFromContentType = BodyType.Json,
+                Encoding = Encoding.UTF8
+            };
+            var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "POST", ClientIp, bodyData);
+
+            string jsonPath = "\"$.MyUniqueNumber\"";
+            var response = Response.Create()
+                .WithTransformer()
+                .WithBodyFromFile(@"c:\\{{JsonPath.SelectToken request.body " + jsonPath + "}}\\test.json"); // why use a \\ here ?
+
+            // Act
+            var responseMessage = await response.ProvideResponseAsync(request);
+
+            // Assert
+            Check.That(responseMessage.BodyData.BodyAsFile).Equals(@"c:\1\test.json");
+        }
     }
 }

test/WireMock.Net.Tests/TestUtils.cs

@@ -1,4 +1,5 @@
-using System.Reflection;
+using System;
+using System.Reflection;
 
 namespace WireMock.Net.Tests
 {
@@ -10,5 +11,53 @@ namespace WireMock.Net.Tests
 
             return (T)field.GetValue(obj);
         }
+
+        /// <summary>
+        /// Set a _private_ Field Value on a given Object
+        /// </summary>
+        /// <typeparam name="T">Type of the Property</typeparam>
+        /// <param name="obj">Object from where the Property Value is returned</param>
+        /// <param name="propertyName">Property name as string.</param>
+        /// <param name="value">the value to set</param>
+        public static void SetPrivateFieldValue<T>(this object obj, string propertyName, T value)
+        {
+            if (obj == null)
+            {
+                throw new ArgumentNullException(nameof(obj));
+            }
+
+            Type t = obj.GetType();
+            FieldInfo fi = null;
+            while (fi == null && t != null)
+            {
+                fi = t.GetField(propertyName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
+                t = t.BaseType;
+            }
+
+            if (fi == null)
+            {
+                throw new ArgumentOutOfRangeException(nameof(propertyName), $"Field {propertyName} was not found in Type {obj.GetType().FullName}");
+            }
+
+            fi.SetValue(obj, value);
+        }
+
+        /// <summary>
+        /// Sets a _private_ Property Value from a given Object.
+        /// </summary>
+        /// <typeparam name="T">Type of the Property</typeparam>
+        /// <param name="obj">Object from where the Property Value is set</param>
+        /// <param name="propertyName">Property name as string.</param>
+        /// <param name="value">Value to set.</param>
+        public static void SetPrivatePropertyValue<T>(this object obj, string propertyName, T value)
+        {
+            Type t = obj.GetType();
+            if (t.GetProperty(propertyName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance) == null)
+            {
+                throw new ArgumentOutOfRangeException(nameof(propertyName), $"Property {propertyName} was not found in Type {obj.GetType().FullName}");
+            }
+
+            t.InvokeMember(propertyName, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.SetProperty | BindingFlags.Instance, null, obj, new object[] { value });
+        }
     }
 }

test/WireMock.Net.Tests/Util/QueryStringParserTests.cs

@@ -0,0 +1,224 @@
+using FluentAssertions;
+using System.Collections.Generic;
+using WireMock.Util;
+using Xunit;
+
+namespace WireMock.Net.Tests.Util
+{
+    public class QueryStringParserTests
+    {
+        [Fact]
+        public void Parse_WithNullString()
+        {
+            // Assign
+            string query = null;
+
+            // Act
+            var result = QueryStringParser.Parse(query);
+
+            // Assert
+            result.Should().Equal(new Dictionary<string, WireMockList<string>>());
+        }
+
+        [Fact]
+        public void Parse_WithEmptyString()
+        {
+            // Assign
+            string query = "";
+
+            // Act
+            var result = QueryStringParser.Parse(query);
+
+            // Assert
+            result.Should().Equal(new Dictionary<string, WireMockList<string>>());
+        }
+
+        [Fact]
+        public void Parse_WithQuestionMark()
+        {
+            // Assign
+            string query = "?";
+
+            // Act
+            var result = QueryStringParser.Parse(query);
+
+            // Assert
+            result.Should().Equal(new Dictionary<string, WireMockList<string>>());
+        }
+
+        [Fact]
+        public void Parse_With1Param()
+        {
+            // Assign
+            string query = "?key=bla/blub.xml";
+
+            // Act
+            var result = QueryStringParser.Parse(query);
+
+            // Assert
+            result.Count.Should().Be(1);
+            result["key"].Should().Equal(new WireMockList<string>("bla/blub.xml"));
+        }
+
+        [Fact]
+        public void Parse_With2Params()
+        {
+            // Assign
+            string query = "?x=1&y=2";
+
+            // Act
+            var result = QueryStringParser.Parse(query);
+
+            // Assert
+            result.Count.Should().Be(2);
+            result["x"].Should().Equal(new WireMockList<string>("1"));
+            result["y"].Should().Equal(new WireMockList<string>("2"));
+        }
+
+        [Fact]
+        public void Parse_With1ParamNoValue()
+        {
+            // Assign
+            string query = "?empty";
+
+            // Act
+            var result = QueryStringParser.Parse(query);
+
+            // Assert
+            result.Count.Should().Be(1);
+            result["empty"].Should().Equal(new WireMockList<string>());
+        }
+
+        [Fact]
+        public void Parse_With1ParamNoValueWithEqualSign()
+        {
+            // Assign
+            string query = "?empty=";
+
+            // Act
+            var result = QueryStringParser.Parse(query);
+
+            // Assert
+            result.Count.Should().Be(1);
+            result["empty"].Should().Equal(new WireMockList<string>());
+        }
+
+        [Fact]
+        public void Parse_With1ParamAndJustAndSign()
+        {
+            // Assign
+            string query = "?key=1&";
+
+            // Act
+            var result = QueryStringParser.Parse(query);
+
+            // Assert
+            result.Count.Should().Be(1);
+            result["key"].Should().Equal(new WireMockList<string>("1"));
+        }
+
+        [Fact]
+        public void Parse_With2ParamsAndWhereOneHasAQuestion()
+        {
+            // Assign
+            string query = "?key=value?&b=c";
+
+            // Act
+            var result = QueryStringParser.Parse(query);
+
+            // Assert
+            result.Count.Should().Be(2);
+            result["key"].Should().Equal(new WireMockList<string>("value?"));
+            result["b"].Should().Equal(new WireMockList<string>("c"));
+        }
+
+        [Fact]
+        public void Parse_With1ParamWithEqualSign()
+        {
+            // Assign
+            string query = "?key=value=what";
+
+            // Act
+            var result = QueryStringParser.Parse(query);
+
+            // Assert
+            result.Count.Should().Be(1);
+            result["key"].Should().Equal(new WireMockList<string>("value=what"));
+        }
+
+        [Fact]
+        public void Parse_WithMultipleParamWithSameKeySeparatedBySemiColon()
+        {
+            // Assign
+            string query = "?key=value;key=anotherValue";
+
+            // Act
+            var result = QueryStringParser.Parse(query);
+
+            // Assert
+            result.Count.Should().Be(1);
+            result["key"].Should().Equal(new WireMockList<string>(new[] { "value", "anotherValue" }));
+        }
+
+        [Fact]
+        public void Parse_With1ParamContainingComma()
+        {
+            // Assign
+            string query = "?key=1,2&key=3";
+
+            // Act
+            var result = QueryStringParser.Parse(query);
+
+            // Assert
+            result.Count.Should().Be(1);
+            result["key"].Should().Equal(new WireMockList<string>(new[] { "1", "2", "3" }));
+        }
+
+        [Fact]
+        public void Parse_WithMultipleParamWithSameKey()
+        {
+            // Assign
+            string query = "?key=value&key=anotherValue";
+
+            // Act
+            var result = QueryStringParser.Parse(query);
+
+            // Assert
+            result.Count.Should().Be(1);
+            result["key"].Should().Equal(new WireMockList<string>(new[] { "value", "anotherValue" }));
+        }
+
+        [Fact]
+        public void Parse_With1ParamContainingSpacesAndEqualSign()
+        {
+            // Assign
+            string query = "?q=SELECT Id from User where username='user@gmail.com'";
+
+            // Act
+            var result = QueryStringParser.Parse(query);
+
+            // Assert
+            result.Count.Should().Be(1);
+            result["q"].Should().Equal(new WireMockList<string>("SELECT Id from User where username='user@gmail.com'"));
+        }
+
+        [Fact]
+        public void Parse_WithComplex()
+        {
+            // Assign
+            string query = "?q=energy+edge&rls=com.microsoft:en-au&ie=UTF-8&oe=UTF-8&startIndex=&startPage=1%22";
+
+            // Act
+            var result = QueryStringParser.Parse(query);
+
+            // Assert
+            result.Count.Should().Be(6);
+            result["q"].Should().Equal(new WireMockList<string>("energy+edge"));
+            result["rls"].Should().Equal(new WireMockList<string>("com.microsoft:en-au"));
+            result["ie"].Should().Equal(new WireMockList<string>("UTF-8"));
+            result["oe"].Should().Equal(new WireMockList<string>("UTF-8"));
+            result["startIndex"].Should().Equal(new WireMockList<string>());
+            result["startPage"].Should().Equal(new WireMockList<string>("1%22"));
+        }
+    }
+}

test/WireMock.Net.Tests/WireMock.Net.Tests.csproj

@@ -13,6 +13,14 @@
     <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
     <SonarQubeTestProject>True</SonarQubeTestProject>
     <SonarQubeExclude>True</SonarQubeExclude>
+
+    <SignAssembly>true</SignAssembly>
+    <AssemblyOriginatorKeyFile>../../src/WireMock.Net/WireMock.Net.snk</AssemblyOriginatorKeyFile>
+    <!--<DelaySign>true</DelaySign>-->
+    <PublicSign Condition=" '$(OS)' != 'Windows_NT' ">true</PublicSign>
+  </PropertyGroup>
+
+  <PropertyGroup Condition="'$(Configuration)' == 'Release'">
   </PropertyGroup>
 
   <ItemGroup>
@@ -26,8 +34,10 @@
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
     </PackageReference>
+    <PackageReference Include="FluentAssertions" Version="5.7.0" />
     <PackageReference Include="System.Threading" Version="4.3.0" />
-
+    <PackageReference Include="RestEase" Version="1.4.7" />
+    <PackageReference Include="RandomDataGenerator.Net" Version="1.0.8" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.9.0" />
     <PackageReference Include="MimeKitLite" Version="2.0.7" />
     <PackageReference Include="Moq" Version="4.10.1" />
@@ -36,12 +46,13 @@
     <PackageReference Include="OpenCover" Version="4.6.519" />
     <PackageReference Include="ReportGenerator" Version="3.1.2" />
     <PackageReference Include="SimMetrics.Net" Version="1.0.5" />
-    <PackageReference Include="System.Linq.Dynamic.Core" Version="1.0.11" />
+    <PackageReference Include="System.Linq.Dynamic.Core" Version="1.0.12" />
     <PackageReference Include="xunit" Version="2.4.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.1">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
     </PackageReference>
+    <!--<PackageReference Include="StrongNamer" Version="0.0.8" />-->
   </ItemGroup>
 
   <ItemGroup Condition="'$(TargetFramework)' == 'net452'">