141

* matcher

* wip

* fix

* <VersionPrefix>1.4.0</VersionPrefix>

* .

* x

* ?

* netstandard2.1

* {}

* test

* Fix: Assembly with same name is already loaded

* _format file

* AssemblyFile = $"WireMock.CodeHelper.Class{Guid.NewGuid()}"

* AssemblyFile = $"WireMock.CodeHelper.Class{Guid.NewGuid().ToString().Replace("-", "")}"

* GC

* x

* remove load ex

* ret

* readme

* no GC

* GetImplementationTypeByInterface

* ``

* PluginLoader

* type

CHANGELOG.md

@@ -1,4 +1,22 @@
+# 1.4.1 (19 January 2021)
+- [#562](https://github.com/WireMock-Net/WireMock.Net/pull/562) - Refactor Transformer (add Scriban) [feature] contributed by [StefH](https://github.com/StefH)
+- [#214](https://github.com/WireMock-Net/WireMock.Net/issues/214) - Feature: Add support for template language DotLiquid [feature]
+
+# 1.4.0 (12 January 2021)
+- [#548](https://github.com/WireMock-Net/WireMock.Net/pull/548) - Move CSharpCodeMatcher to a new project [feature] contributed by [StefH](https://github.com/StefH)
+
+# 1.3.10 (23 December 2020)
+- [#555](https://github.com/WireMock-Net/WireMock.Net/pull/555) - Add more tests for Proxy with Authorization [feature] contributed by [StefH](https://github.com/StefH)
+- [#561](https://github.com/WireMock-Net/WireMock.Net/pull/561) - Do not save "admin" mappings when running in Proxy - mode contributed by [StefH](https://github.com/StefH)
+- [#559](https://github.com/WireMock-Net/WireMock.Net/issues/559) - WireMock Setting 'SaveMappingToFile' raising cast object to type error [bug]
+
+# 1.3.9 (08 December 2020)
+- [#550](https://github.com/WireMock-Net/WireMock.Net/pull/550) - WithProxy(...) also use all proxy settings [bug] contributed by [StefH](https://github.com/StefH)
+- [#551](https://github.com/WireMock-Net/WireMock.Net/pull/551) - Add obsolete warning: CSharpCodeMatcher will be moved to a separate NuGet package 'WireMock.Net.Matchers.CSharpCode' [feature] contributed by [StefH](https://github.com/StefH)
+- [#549](https://github.com/WireMock-Net/WireMock.Net/issues/549) - WithProxy(...) does not save the mappings to file [bug]
+
 # 1.3.8 (03 December 2020)
+- [#539](https://github.com/WireMock-Net/WireMock.Net/pull/539) - Support for partial JSON matching contributed by [gleb-osokin](https://github.com/gleb-osokin)
 - [#542](https://github.com/WireMock-Net/WireMock.Net/pull/542) - Create dotnet-wiremock tool [feature] contributed by [StefH](https://github.com/StefH)
 - [#543](https://github.com/WireMock-Net/WireMock.Net/pull/543) - Add support for .NET 5 [feature] contributed by [StefH](https://github.com/StefH)
 - [#544](https://github.com/WireMock-Net/WireMock.Net/pull/544) - Use Java 11 in Azure Pipelines (needed for SonarCloud) [feature] contributed by [StefH](https://github.com/StefH)
@@ -6,9 +24,6 @@
 - [#547](https://github.com/WireMock-Net/WireMock.Net/pull/547) - Fix Proxying with SSL and NetCoreApp3.1 [bug] contributed by [StefH](https://github.com/StefH)
 - [#524](https://github.com/WireMock-Net/WireMock.Net/issues/524) - Proxying with SSL Not Working in .NET Core 3.1 [bug]
 
-# 1.3.7 (17 November 2020)
-- [#539](https://github.com/WireMock-Net/WireMock.Net/pull/539) - Support for partial JSON matching contributed by [gleb-osokin](https://github.com/gleb-osokin)
-
 # 1.3.6 (10 November 2020)
 - [#529](https://github.com/WireMock-Net/WireMock.Net/pull/529) - Add assertions for ClientIP, Url and ProxyUrl [feature] contributed by [akamud](https://github.com/akamud)
 - [#535](https://github.com/WireMock-Net/WireMock.Net/pull/535) - WithCallback should use also use enum HttpStatusCode [bug] contributed by [StefH](https://github.com/StefH)

Directory.Build.props

@@ -4,7 +4,7 @@
   </PropertyGroup>
 
   <PropertyGroup>
-    <VersionPrefix>1.3.8</VersionPrefix>
+    <VersionPrefix>1.4.1</VersionPrefix>
     <PackageReleaseNotes>See CHANGELOG.md</PackageReleaseNotes>
     <PackageIconUrl>https://raw.githubusercontent.com/WireMock-Net/WireMock.Net/master/WireMock.Net-Logo.png</PackageIconUrl>
     <PackageProjectUrl>https://github.com/WireMock-Net/WireMock.Net</PackageProjectUrl>

GitHubReleaseNotes.txt

@@ -1,3 +1,3 @@
 https://github.com/StefH/GitHubReleaseNotes
 
-GitHubReleaseNotes --output CHANGELOG.md --skip-empty-releases --exclude-labels question invalid doc --version 1.3.8
+GitHubReleaseNotes --output CHANGELOG.md --skip-empty-releases --exclude-labels question invalid doc --version 1.4.1

README.md

@@ -12,7 +12,7 @@ For more info, see also this WIKI page: [What is WireMock.Net](https://github.co
 * Per-request conditional proxying
 * Stateful behaviour simulation
 * Response templating / transformation using Handlebars and extensions
-* Can be used locally or in CI/CD scenarios.
+* Can be used locally or in CI/CD scenarios
 
 ## Info
 | | |
@@ -35,6 +35,7 @@ For more info, see also this WIKI page: [What is WireMock.Net](https://github.co
 |   **WireMock.Net.StandAlone** | [![NuGet Badge WireMock.Net](https://buildstats.info/nuget/WireMock.Net.StandAlone)](https://www.nuget.org/packages/WireMock.Net.StandAlone) |  [![MyGet Badge WireMock.Net.StandAlone](https://buildstats.info/myget/wiremock-net/WireMock.Net.StandAlone?includePreReleases=true)](https://www.myget.org/feed/wiremock-net/package/nuget/WireMock.Net.StandAlone)
 |   **WireMock.Net.FluentAssertions** | [![NuGet Badge WireMock.Net.FluentAssertions](https://buildstats.info/nuget/WireMock.Net.FluentAssertions)](https://www.nuget.org/packages/WireMock.Net.FluentAssertions) | [![MyGet Badge WireMock.Net.FluentAssertions](https://buildstats.info/myget/wiremock-net/WireMock.Net.FluentAssertions?includePreReleases=true)](https://www.myget.org/feed/wiremock-net/package/nuget/WireMock.Net.FluentAssertions)
 |   **WireMock.Net.RestClient** | [![NuGet Badge WireMock.Net.RestClient](https://buildstats.info/nuget/WireMock.Net.RestClient)](https://www.nuget.org/packages/WireMock.Net.RestClient) | [![MyGet Badge WireMock.Net.RestClient](https://buildstats.info/myget/wiremock-net/WireMock.Net.RestClient?includePreReleases=true)](https://www.myget.org/feed/wiremock-net/package/nuget/WireMock.Net.RestClient)
+|   **WireMock.Net.Matchers.CSharpCode** | [![NuGet Badge WireMock.Net.Matchers.CSharpCode](https://buildstats.info/nuget/WireMock.Net.Matchers.CSharpCode)](https://www.nuget.org/packages/WireMock.Net.Matchers.CSharpCode) | [![MyGet Badge WireMock.Net.Matchers.CSharpCode](https://buildstats.info/myget/wiremock-net/WireMock.Net.Matchers.CSharpCode?includePreReleases=true)](https://www.myget.org/feed/wiremock-net/package/nuget/WireMock.Net.Matchers.CSharpCode)
 
 ## Development
 For the supported frameworks and build information, see [this](https://github.com/WireMock-Net/WireMock.Net/wiki/Development-Information) page.

WireMock.Net Solution.sln

@@ -78,6 +78,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "dotnet-WireMock", "src\dotn
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "WireMock.Net.Console.NET5", "examples\WireMock.Net.Console.NET5\WireMock.Net.Console.NET5.csproj", "{3F8CF0AE-5F24-4A54-89E7-A3EE829DB5F8}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WireMock.Net.Matchers.CSharpCode", "src\WireMock.Net.Matchers.CSharpCode\WireMock.Net.Matchers.CSharpCode.csproj", "{6437CE56-8AB9-4D6D-90F1-70CC5BBE1572}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -192,6 +194,10 @@ Global
 		{3F8CF0AE-5F24-4A54-89E7-A3EE829DB5F8}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{3F8CF0AE-5F24-4A54-89E7-A3EE829DB5F8}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{3F8CF0AE-5F24-4A54-89E7-A3EE829DB5F8}.Release|Any CPU.Build.0 = Release|Any CPU
+		{6437CE56-8AB9-4D6D-90F1-70CC5BBE1572}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{6437CE56-8AB9-4D6D-90F1-70CC5BBE1572}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{6437CE56-8AB9-4D6D-90F1-70CC5BBE1572}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{6437CE56-8AB9-4D6D-90F1-70CC5BBE1572}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -224,6 +230,7 @@ Global
 		{925E421A-1B3F-4202-B48F-734743573A4B} = {985E0ADB-D4B4-473A-AA40-567E279B7946}
 		{40BF24B5-12E6-4610-9489-138798632E28} = {8F890C6F-9ACC-438D-928A-AD61CDA862F2}
 		{3F8CF0AE-5F24-4A54-89E7-A3EE829DB5F8} = {985E0ADB-D4B4-473A-AA40-567E279B7946}
+		{6437CE56-8AB9-4D6D-90F1-70CC5BBE1572} = {8F890C6F-9ACC-438D-928A-AD61CDA862F2}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {DC539027-9852-430C-B19F-FD035D018458}

azure-pipelines-nuget.yml

@@ -1,5 +1,5 @@
 pool:
-  vmImage: 'vs2017-win2016'
+  vmImage: 'windows-2019'
 
 variables:
   Prerelease: ''

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

@@ -13,6 +13,7 @@ using WireMock.Server;
 using WireMock.Settings;
 using WireMock.Util;
 using System.Threading.Tasks;
+using WireMock.Types;
 
 namespace WireMock.Net.ConsoleApplication
 {
@@ -346,7 +347,7 @@ namespace WireMock.Net.ConsoleApplication
                     .WithHeader("Transformed-Postman-Token", "token is {{request.headers.Postman-Token}}")
                     .WithHeader("xyz_{{request.headers.Postman-Token}}", "token is {{request.headers.Postman-Token}}")
                     .WithBody(@"{""msg"": ""Hello world CATCH-ALL on /*, {{request.path}}, add={{Math.Add request.query.start.[0] 42}} bykey={{request.query.start}}, bykey={{request.query.stop}}, byidx0={{request.query.stop.[0]}}, byidx1={{request.query.stop.[1]}}"" }")
-                    .WithTransformer()
+                    .WithTransformer(TransformerType.Handlebars)
                     .WithDelay(TimeSpan.FromMilliseconds(100))
                 );
 

examples/WireMock.Net.Console.Proxy.NETCoreApp2/Program.cs

@@ -3,6 +3,7 @@ using System.Net.Http;
 using System.Threading;
 using System.Threading.Tasks;
 using Newtonsoft.Json;
+using WireMock.Logging;
 using WireMock.RequestBuilders;
 using WireMock.ResponseBuilders;
 using WireMock.Server;
@@ -14,9 +15,6 @@ namespace WireMock.Net.Console.Proxy.NETCoreApp2
     {
         static void Main(string[] args)
         {
-            RunTestDifferentPort().Wait(20000); // prints "1"
-            RunTestDifferentPort().Wait(20000); // prints "1"
-
             var server = WireMockServer.Start(new WireMockServerSettings
             {
                 Urls = new[] { "http://localhost:9091", "https://localhost:9443" },
@@ -29,34 +27,18 @@ namespace WireMock.Net.Console.Proxy.NETCoreApp2
                     SaveMapping = true,
                     SaveMappingToFile = false,
                     ExcludedHeaders = new[] { "dnt", "Content-Length" }
-                }
+                },
+                Logger= new WireMockConsoleLogger()
             });
 
-            server.LogEntriesChanged += (sender, eventRecordArgs) =>
-            {
-                System.Console.WriteLine(JsonConvert.SerializeObject(eventRecordArgs.NewItems, Formatting.Indented));
-            };
+            //server.LogEntriesChanged += (sender, eventRecordArgs) =>
+            //{
+            //    System.Console.WriteLine(JsonConvert.SerializeObject(eventRecordArgs.NewItems, Formatting.Indented));
+            //};
 
             System.Console.WriteLine("Press any key to stop the server");
             System.Console.ReadKey();
             server.Stop();
         }
-
-        private static async Task RunTestDifferentPort()
-        {
-            var server = WireMockServer.Start();
-
-            server.Given(Request.Create().WithPath("/").UsingGet())
-                .RespondWith(Response.Create().WithStatusCode(200).WithBody("Hello"));
-
-            Thread.Sleep(1000);
-
-            var response = await new HttpClient().GetAsync(server.Urls[0]);
-            response.EnsureSuccessStatusCode();
-
-            System.Console.WriteLine("RunTestDifferentPort - server.LogEntries.Count() = " + server.LogEntries.Count());
-
-            server.Stop();
-        }
     }
 }

examples/WireMock.Net.Console.Proxy.NETCoreApp2/WireMock.Net.Console.Proxy.NETCoreApp2.csproj

@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>netcoreapp2.1</TargetFramework>
+    <TargetFrameworks>netcoreapp2.1;netcoreapp3.1;net5.0</TargetFrameworks>
     <ApplicationIcon>../../WireMock.Net-Logo.ico</ApplicationIcon>
   </PropertyGroup>
 

examples/WireMock.Net.Console.Record.NETCoreApp/Program.cs

@@ -1,4 +1,6 @@
 using Newtonsoft.Json;
+using WireMock.RequestBuilders;
+using WireMock.ResponseBuilders;
 using WireMock.Server;
 using WireMock.Settings;
 
@@ -13,16 +15,26 @@ namespace WireMock.Net.Console.Proxy.NETCoreApp
                 Urls = new[] { "http://localhost:9091/", "https://localhost:9443/" },
                 StartAdminInterface = true,
                 ReadStaticMappings = false,
-                ProxyAndRecordSettings = new ProxyAndRecordSettings
-                {
-                    Url = "https://www.google.com",
-                    //ClientX509Certificate2ThumbprintOrSubjectName = "www.yourclientcertname.com OR yourcertificatethumbprint (only if the service you're proxying to requires it)",
-                    SaveMapping = true,
-                    SaveMappingToFile = false,
-                    ExcludedHeaders = new [] { "dnt", "Content-Length" }
-                }
+                //ProxyAndRecordSettings = new ProxyAndRecordSettings
+                //{
+                //    Url = "https://www.google.com",
+                //    //ClientX509Certificate2ThumbprintOrSubjectName = "www.yourclientcertname.com OR yourcertificatethumbprint (only if the service you're proxying to requires it)",
+                //    SaveMapping = true,
+                //    SaveMappingToFile = false,
+                //    ExcludedHeaders = new [] { "dnt", "Content-Length" }
+                //}
             });
 
+            server
+                .Given(Request.Create().UsingGet())
+                .RespondWith(Response.Create()
+                   .WithProxy(new ProxyAndRecordSettings
+                   {
+                       Url = "http://postman-echo.com/post",
+                       SaveMapping = true,
+                       SaveMappingToFile = true
+                   }));
+
             System.Console.WriteLine("Press any key to stop the server");
             System.Console.ReadKey();
             server.Stop();

examples/WireMock.Net.Console.Record.NETCoreApp/WireMock.Net.Console.Proxy.NETCoreApp.csproj

@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <OutputType>Exe</OutputType>
-    <TargetFramework>netcoreapp1.1</TargetFramework>
+    <TargetFramework>net5.0</TargetFramework>
     <ApplicationIcon>../../WireMock.Net-Logo.ico</ApplicationIcon>
   </PropertyGroup>
 

src/WireMock.Net.Abstractions/Admin/Mappings/ResponseModel.cs

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using WireMock.Types;
 
 namespace WireMock.Admin.Mappings
 {
@@ -53,10 +54,15 @@ namespace WireMock.Admin.Mappings
         public EncodingModel BodyEncoding { get; set; }
 
         /// <summary>
-        /// Use Handlebars transformer.
+        /// Use ResponseMessage Transformer.
         /// </summary>
         public bool? UseTransformer { get; set; }
 
+        /// <summary>
+        /// Gets the type of the transformer.
+        /// </summary>
+        public string TransformerType { get; set; }
+
         /// <summary>
         /// Use the Handlerbars transformer for the content from the referenced BodyAsFile.
         /// </summary>

src/WireMock.Net.Abstractions/Types/TransformerType.cs

@@ -0,0 +1,23 @@
+namespace WireMock.Types
+{
+    /// <summary>
+    /// The ResponseMessage Transformers
+    /// </summary>
+    public enum TransformerType
+    {
+        /// <summary>
+        /// https://github.com/Handlebars-Net/Handlebars.Net
+        /// </summary>
+        Handlebars,
+
+        /// <summary>
+        /// https://github.com/scriban/scriban : default
+        /// </summary>
+        Scriban,
+
+        /// <summary>
+        /// https://github.com/scriban/scriban : DotLiquid
+        /// </summary>
+        ScribanDotLiquid
+    }
+}

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

@@ -1,5 +1,7 @@
 using System;
 using System.Linq;
+using System.Reflection;
+using System.Text;
 using JetBrains.Annotations;
 using Newtonsoft.Json.Linq;
 using WireMock.Exceptions;
@@ -10,13 +12,12 @@ namespace WireMock.Matchers
     /// <summary>
     /// CSharpCode / CS-Script Matcher
     /// </summary>
-    /// <inheritdoc cref="IObjectMatcher"/>
-    /// <inheritdoc cref="IStringMatcher"/>
-    internal class CSharpCodeMatcher : IObjectMatcher, IStringMatcher
+    /// <inheritdoc cref="ICSharpCodeMatcher"/>
+    internal class CSharpCodeMatcher : ICSharpCodeMatcher
     {
-        private const string TemplateForIsMatchWithString = "{0} public class CodeHelper {{ public bool IsMatch(string it) {{ {1} }} }}";
+        private const string TemplateForIsMatchWithString = "public class CodeHelper {{ public bool IsMatch(string it) {{ {0} }} }}";
 
-        private const string TemplateForIsMatchWithDynamic = "{0} public class CodeHelper {{ public bool IsMatch(dynamic it) {{ {1} }} }}";
+        private const string TemplateForIsMatchWithDynamic = "public class CodeHelper {{ public bool IsMatch(dynamic it) {{ {0} }} }}";
 
         private readonly string[] _usings =
         {
@@ -152,20 +153,28 @@ namespace WireMock.Matchers
             }
 
 #elif (NETSTANDARD2_0 || NETSTANDARD2_1 || NETCOREAPP3_1 || NET5_0)
-            dynamic script;
+            Assembly assembly;
             try
+            {
+                assembly = CSScriptLib.CSScript.Evaluator.CompileCode(source);
+            }
+            catch (Exception ex)
             {
-                var assembly = CSScriptLib.CSScript.Evaluator.CompileCode(source);
+                throw new WireMockException($"CSharpCodeMatcher: Unable to compile code `{source}` for WireMock.CodeHelper", ex);
+            }
 
+            dynamic script;
+            try
+            {
 #if NETSTANDARD2_0
                 script = csscript.GenericExtensions.CreateObject(assembly, "*");
 #else
                 script = CSScriptLib.ReflectionExtensions.CreateObject(assembly, "*");
-#endif
+#endif
             }
             catch (Exception ex)
-            {
-                throw new WireMockException("CSharpCodeMatcher: Unable to compile code for WireMock.CodeHelper", ex);
+            {
+                throw new WireMockException("CSharpCodeMatcher: Unable to create object from assembly", ex);
             }
 
             try
@@ -175,9 +184,9 @@ namespace WireMock.Matchers
             catch (Exception ex)
             {
                 throw new WireMockException("CSharpCodeMatcher: Problem calling method 'IsMatch' in WireMock.CodeHelper", ex);
-            }
+            }
 #else
-                throw new NotSupportedException("The 'CSharpCodeMatcher' cannot be used in netstandard 1.3");
+            throw new NotSupportedException("The 'CSharpCodeMatcher' cannot be used in netstandard 1.3");
 #endif
             try
             {
@@ -192,7 +201,16 @@ namespace WireMock.Matchers
         private string GetSourceForIsMatchWithString(string pattern, bool isMatchWithString)
         {
             string template = isMatchWithString ? TemplateForIsMatchWithString : TemplateForIsMatchWithDynamic;
-            return string.Format(template, string.Join(Environment.NewLine, _usings.Select(u => $"using {u};")), pattern);
+
+            var stringBuilder = new StringBuilder();
+            foreach (string @using in _usings)
+            {
+                stringBuilder.AppendLine($"using {@using};");
+            }
+            stringBuilder.AppendLine();
+            stringBuilder.AppendFormat(template, pattern);
+
+            return stringBuilder.ToString();
         }
 
         /// <inheritdoc cref="IStringMatcher.GetPatterns"/>

src/WireMock.Net.Matchers.CSharpCode/Properties/AssemblyInfo.cs

@@ -0,0 +1,6 @@
+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.Matchers.CSharpCode/WireMock.Net.Matchers.CSharpCode.csproj

@@ -0,0 +1,60 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <Description>A CSharpCodeMatcher which can be used to match WireMock.Net Requests using C# code.</Description>
+    <AssemblyTitle>WireMock.Net.Matchers.CSharpCode</AssemblyTitle>
+    <Authors>Stef Heyenrath</Authors>
+    <TargetFrameworks>net451;net452;net46;net461;netstandard1.3;netstandard2.0;netstandard2.1;netcoreapp3.1;net5.0</TargetFrameworks>
+    <GenerateDocumentationFile>true</GenerateDocumentationFile>
+    <PackageTags>wiremock;matchers;matcher;csharp;csharpcode</PackageTags>
+    <RootNamespace>WireMock</RootNamespace>
+    <ProjectGuid>{B6269AAC-170A-4346-8B9A-444DED3D9A44}</ProjectGuid>
+    <PublishRepositoryUrl>true</PublishRepositoryUrl>
+    <AllowedOutputExtensionsInPackageBuildOutputFolder>$(AllowedOutputExtensionsInPackageBuildOutputFolder);.pdb</AllowedOutputExtensionsInPackageBuildOutputFolder>
+    <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>
+
+  <!-- https://github.com/aspnet/RoslynCodeDomProvider/issues/51 -->
+  <!-- This is needed else we cannot build net452 in Azure DevOps Pipeline -->
+  <Target Name="CheckIfShouldKillVBCSCompiler" />
+
+  <ItemGroup>
+    <PackageReference Include="JetBrains.Annotations" Version="2020.1.0" PrivateAssets="All" />
+    <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="All" />
+
+    <ProjectReference Include="..\WireMock.Net\WireMock.Net.csproj" />
+  </ItemGroup>
+
+  <ItemGroup Condition=" '$(TargetFramework)' == 'net451' or '$(TargetFramework)' == 'net452' ">
+    <PackageReference Include="Microsoft.CodeDom.Providers.DotNetCompilerPlatform" Version="3.6.0" />
+  </ItemGroup>
+
+  <ItemGroup Condition=" '$(TargetFramework)' == 'net46' or '$(TargetFramework)' == 'net461' ">
+    <PackageReference Include="CS-Script" Version="3.30.3" />
+  </ItemGroup>
+
+  <ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0'">
+    <PackageReference Include="CS-Script.Core" Version="1.1.1" />
+  </ItemGroup>
+
+  <ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.1'">
+    <PackageReference Include="CS-Script.Core" Version="1.4.2-preview" />
+  </ItemGroup>
+
+  <ItemGroup Condition=" '$(TargetFramework)' == 'netcoreapp3.1' or '$(TargetFramework)' == 'net5.0'">
+    <PackageReference Include="CS-Script.Core" Version="1.4.2-preview" />
+  </ItemGroup>
+
+</Project>

src/WireMock.Net/Http/HttpClientBuilder.cs

@@ -1,17 +1,13 @@
-using JetBrains.Annotations;
-using System;
-using System.Net;
+using System.Net;
 using System.Net.Http;
-using System.Threading.Tasks;
 using WireMock.HttpsCertificate;
 using WireMock.Settings;
-using WireMock.Validation;
 
 namespace WireMock.Http
 {
-    internal static class HttpClientHelper
+    internal static class HttpClientBuilder
     {
-        public static HttpClient CreateHttpClient(IProxyAndRecordSettings settings)
+        public static HttpClient Build(IProxyAndRecordSettings settings)
         {
 #if NETSTANDARD || NETCOREAPP3_1 || NET5_0
             var handler = new HttpClientHandler
@@ -57,32 +53,14 @@ namespace WireMock.Http
                 {
                     handler.Proxy.Credentials = new NetworkCredential(settings.WebProxySettings.UserName, settings.WebProxySettings.Password);
                 }
-            }
-
+            }
+
 #if !NETSTANDARD1_3
             ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12 | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls;
             ServicePointManager.ServerCertificateValidationCallback = (message, cert, chain, errors) => true;
 #endif
-
+
             return new HttpClient(handler);
         }
-
-        public static async Task<ResponseMessage> SendAsync([NotNull] HttpClient client, [NotNull] RequestMessage requestMessage, string url, bool deserializeJson, bool decompressGzipAndDeflate)
-        {
-            Check.NotNull(client, nameof(client));
-            Check.NotNull(requestMessage, nameof(requestMessage));
-
-            var originalUri = new Uri(requestMessage.Url);
-            var requiredUri = new Uri(url);
-
-            // Create HttpRequestMessage
-            var httpRequestMessage = HttpRequestMessageHelper.Create(requestMessage, url);
-
-            // Call the URL
-            var httpResponseMessage = await client.SendAsync(httpRequestMessage, HttpCompletionOption.ResponseContentRead);
-
-            // Create ResponseMessage
-            return await HttpResponseMessageHelper.CreateAsync(httpResponseMessage, requiredUri, originalUri, deserializeJson, decompressGzipAndDeflate);
-        }
     }
 }

src/WireMock.Net/IMapping.cs

@@ -71,7 +71,7 @@ namespace WireMock
         /// The WireMockServerSettings.
         /// </summary>
         IWireMockServerSettings Settings { get; }
-
+        
         /// <summary>
         /// Is State started ?
         /// </summary>

src/WireMock.Net/Mapping.cs

@@ -68,9 +68,18 @@ namespace WireMock
         /// <param name="executionConditionState">State in which the current mapping can occur. [Optional]</param>
         /// <param name="nextState">The next state which will occur after the current mapping execution. [Optional]</param>
         /// <param name="stateTimes">Only when the current state is executed this number, the next state which will occur. [Optional]</param>
-        public Mapping(Guid guid, [CanBeNull] string title, [CanBeNull] string path,
-            [NotNull] IWireMockServerSettings settings, [NotNull] IRequestMatcher requestMatcher, [NotNull] IResponseProvider provider,
-            int priority, [CanBeNull] string scenario, [CanBeNull] string executionConditionState, [CanBeNull] string nextState, [CanBeNull] int? stateTimes)
+        public Mapping(
+            Guid guid,
+            [CanBeNull] string title,
+            [CanBeNull] string path,
+            [NotNull] IWireMockServerSettings settings,
+            [NotNull] IRequestMatcher requestMatcher,
+            [NotNull] IResponseProvider provider,
+            int priority,
+            [CanBeNull] string scenario,
+            [CanBeNull] string executionConditionState,
+            [CanBeNull] string nextState,
+            [CanBeNull] int? stateTimes)
         {
             Guid = guid;
             Title = title;
@@ -82,7 +91,7 @@ namespace WireMock
             Scenario = scenario;
             ExecutionConditionState = executionConditionState;
             NextState = nextState;
-            StateTimes = stateTimes; 
+            StateTimes = stateTimes;
         }
 
         /// <inheritdoc cref="IMapping.ProvideResponseAsync" />

src/WireMock.Net/Matchers/ICSharpCodeMatcher.cs

@@ -0,0 +1,11 @@
+namespace WireMock.Matchers
+{
+    /// <summary>
+    /// CSharpCode / CS-Script Matcher
+    /// </summary>
+    /// <inheritdoc cref="IObjectMatcher"/>
+    /// <inheritdoc cref="IStringMatcher"/>
+    public interface ICSharpCodeMatcher : IObjectMatcher, IStringMatcher
+    {
+    }
+}

src/WireMock.Net/Owin/WireMockMiddleware.cs

@@ -8,6 +8,7 @@ using WireMock.Owin.Mappers;
 using WireMock.Serialization;
 using WireMock.Types;
 using WireMock.Validation;
+using WireMock.ResponseBuilders;
 #if !USE_ASPNETCORE
 using Microsoft.Owin;
 using IContext = Microsoft.Owin.IOwinContext;
@@ -129,6 +130,25 @@ namespace WireMock.Owin
 
                 response = await targetMapping.ProvideResponseAsync(request);
 
+                var responseBuilder = targetMapping.Provider as Response;
+
+                if (!targetMapping.IsAdminInterface)
+                {
+                    if (responseBuilder?.ProxyAndRecordSettings?.SaveMapping == true || targetMapping?.Settings?.ProxyAndRecordSettings?.SaveMapping == true)
+                    {
+                        _options.Mappings.TryAdd(targetMapping.Guid, targetMapping);
+                    }
+
+                    if (responseBuilder?.ProxyAndRecordSettings?.SaveMappingToFile == true || targetMapping?.Settings?.ProxyAndRecordSettings?.SaveMappingToFile == true)
+                    {
+                        var matcherMapper = new MatcherMapper(targetMapping.Settings);
+                        var mappingConverter = new MappingConverter(matcherMapper);
+                        var mappingToFileSaver = new MappingToFileSaver(targetMapping.Settings, mappingConverter);
+
+                        mappingToFileSaver.SaveMappingToFile(targetMapping);
+                    }
+                }
+
                 if (targetMapping.Scenario != null)
                 {
                     UpdateScenarioState(targetMapping);

src/WireMock.Net/Plugin/PluginLoader.cs

@@ -0,0 +1,57 @@
+using System;
+using System.Collections.Concurrent;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+
+namespace WireMock.Plugin
+{
+    internal static class PluginLoader
+    {
+        private static readonly ConcurrentDictionary<Type, Type> Assemblies = new ConcurrentDictionary<Type, Type>();
+
+        public static T Load<T>(params object[] args) where T : class
+        {
+            var foundType = Assemblies.GetOrAdd(typeof(T), (type) =>
+            {
+                var files = Directory.GetFiles(Directory.GetCurrentDirectory(), "*.dll");
+
+                Type pluginType = null;
+                foreach (var file in files)
+                {
+                    try
+                    {
+                        var assembly = Assembly.Load(new AssemblyName
+                        {
+                            Name = Path.GetFileNameWithoutExtension(file)
+                        });
+
+                        pluginType = GetImplementationTypeByInterface<T>(assembly);
+                        if (pluginType != null)
+                        {
+                            break;
+                        }
+                    }
+                    catch
+                    {
+                        // no-op: just try next .dll
+                    }
+                }
+
+                if (pluginType != null)
+                {
+                    return pluginType;
+                }
+
+                throw new DllNotFoundException($"No dll found which implements type '{type}'");
+            });
+
+            return (T)Activator.CreateInstance(foundType, args);
+        }
+
+        private static Type GetImplementationTypeByInterface<T>(Assembly assembly)
+        {
+            return assembly.GetTypes().FirstOrDefault(t => typeof(T).IsAssignableFrom(t) && !t.GetTypeInfo().IsInterface);
+        }
+    }
+}

src/WireMock.Net/Properties/AssemblyInfo.cs

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

src/WireMock.Net/Proxy/ProxyHelper.cs

@@ -0,0 +1,111 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Net.Http;
+using System.Threading.Tasks;
+using HandlebarsDotNet.Helpers.Validation;
+using JetBrains.Annotations;
+using WireMock.Http;
+using WireMock.Matchers;
+using WireMock.RequestBuilders;
+using WireMock.ResponseBuilders;
+using WireMock.Settings;
+using WireMock.Types;
+using WireMock.Util;
+
+namespace WireMock.Proxy
+{
+    internal class ProxyHelper
+    {
+        private readonly IWireMockServerSettings _settings;
+
+        public ProxyHelper([NotNull] IWireMockServerSettings settings)
+        {
+            Guard.NotNull(settings, nameof(settings));
+            _settings = settings;
+        }
+
+        public async Task<(ResponseMessage ResponseMessage, IMapping Mapping)> SendAsync(
+            [NotNull] IProxyAndRecordSettings proxyAndRecordSettings,
+            [NotNull] HttpClient client,
+            [NotNull] RequestMessage requestMessage,
+            [NotNull] string url)
+        {
+            Guard.NotNull(client, nameof(client));
+            Guard.NotNull(requestMessage, nameof(requestMessage));
+            Guard.NotNull(url, nameof(url));
+
+            var originalUri = new Uri(requestMessage.Url);
+            var requiredUri = new Uri(url);
+
+            // Create HttpRequestMessage
+            var httpRequestMessage = HttpRequestMessageHelper.Create(requestMessage, url);
+
+            // Call the URL
+            var httpResponseMessage = await client.SendAsync(httpRequestMessage, HttpCompletionOption.ResponseContentRead);
+
+            // Create ResponseMessage
+            bool deserializeJson = !_settings.DisableJsonBodyParsing.GetValueOrDefault(false);
+            bool decompressGzipAndDeflate = !_settings.DisableRequestBodyDecompressing.GetValueOrDefault(false);
+
+            var responseMessage = await HttpResponseMessageHelper.CreateAsync(httpResponseMessage, requiredUri, originalUri, deserializeJson, decompressGzipAndDeflate);
+
+            IMapping mapping = null;
+            if (HttpStatusRangeParser.IsMatch(proxyAndRecordSettings.SaveMappingForStatusCodePattern, responseMessage.StatusCode) &&
+                (proxyAndRecordSettings.SaveMapping || proxyAndRecordSettings.SaveMappingToFile))
+            {
+                mapping = ToMapping(proxyAndRecordSettings, requestMessage, responseMessage);
+            }
+
+            return (responseMessage, mapping);
+        }
+
+        private IMapping ToMapping(IProxyAndRecordSettings proxyAndRecordSettings, RequestMessage requestMessage, ResponseMessage responseMessage)
+        {
+            string[] excludedHeaders = proxyAndRecordSettings.ExcludedHeaders ?? new string[] { };
+            string[] excludedCookies = proxyAndRecordSettings.ExcludedCookies ?? new string[] { };
+
+            var request = Request.Create();
+            request.WithPath(requestMessage.Path);
+            request.UsingMethod(requestMessage.Method);
+
+            requestMessage.Query.Loop((key, value) => request.WithParam(key, false, value.ToArray()));
+            requestMessage.Cookies.Loop((key, value) =>
+            {
+                if (!excludedCookies.Contains(key, StringComparer.OrdinalIgnoreCase))
+                {
+                    request.WithCookie(key, value);
+                }
+            });
+
+            var allExcludedHeaders = new List<string>(excludedHeaders) { "Cookie" };
+            requestMessage.Headers.Loop((key, value) =>
+            {
+                if (!allExcludedHeaders.Contains(key, StringComparer.OrdinalIgnoreCase))
+                {
+                    request.WithHeader(key, value.ToArray());
+                }
+            });
+
+            bool throwExceptionWhenMatcherFails = _settings.ThrowExceptionWhenMatcherFails == true;
+            switch (requestMessage.BodyData?.DetectedBodyType)
+            {
+                case BodyType.Json:
+                    request.WithBody(new JsonMatcher(MatchBehaviour.AcceptOnMatch, requestMessage.BodyData.BodyAsJson, true, throwExceptionWhenMatcherFails));
+                    break;
+
+                case BodyType.String:
+                    request.WithBody(new ExactMatcher(MatchBehaviour.AcceptOnMatch, throwExceptionWhenMatcherFails, requestMessage.BodyData.BodyAsString));
+                    break;
+
+                case BodyType.Bytes:
+                    request.WithBody(new ExactObjectMatcher(MatchBehaviour.AcceptOnMatch, requestMessage.BodyData.BodyAsBytes, throwExceptionWhenMatcherFails));
+                    break;
+            }
+
+            var response = Response.Create(responseMessage);
+
+            return new Mapping(Guid.NewGuid(), string.Empty, null, _settings, request, response, 0, null, null, null, null);
+        }
+    }
+}

src/WireMock.Net/RequestBuilders/Request.cs

@@ -55,6 +55,16 @@ namespace WireMock.RequestBuilders
             return _requestMatchers.OfType<T>().FirstOrDefault();
         }
 
+        /// <summary>
+        /// Gets the request message matcher.
+        /// </summary>
+        /// <typeparam name="T">Type of IRequestMatcher</typeparam>
+        /// <returns>A RequestMatcher</returns>
+        public T GetRequestMessageMatcher<T>(Func<T, bool> func) where T : IRequestMatcher
+        {
+            return _requestMatchers.OfType<T>().FirstOrDefault(func);
+        }
+
         /// <inheritdoc cref="IClientIPRequestBuilder.WithClientIP(IStringMatcher[])"/>
         public IRequestBuilder WithClientIP(params IStringMatcher[] matchers)
         {

src/WireMock.Net/ResponseBuilders/ITransformResponseBuilder.cs

@@ -1,4 +1,6 @@
-namespace WireMock.ResponseBuilders
+using WireMock.Types;
+
+namespace WireMock.ResponseBuilders
 {
     /// <summary>
     /// The TransformResponseBuilder interface.
@@ -6,11 +8,19 @@
     public interface ITransformResponseBuilder : IDelayResponseBuilder
     {
         /// <summary>
-        /// The with transformer.
+        /// Use the Handlebars.Net ResponseMessage transformer.
         /// </summary>
         /// <returns>
         /// The <see cref="IResponseBuilder"/>.
         /// </returns>
         IResponseBuilder WithTransformer(bool transformContentFromBodyAsFile = false);
+
+        /// <summary>
+        /// Use a specific ResponseMessage transformer.
+        /// </summary>
+        /// <returns>
+        /// The <see cref="IResponseBuilder"/>.
+        /// </returns>
+        IResponseBuilder WithTransformer(TransformerType transformerType, bool transformContentFromBodyAsFile = false);
     }
 }

src/WireMock.Net/ResponseBuilders/Response.WithProxy.cs

@@ -9,15 +9,10 @@ namespace WireMock.ResponseBuilders
     {
         private HttpClient _httpClientForProxy;
 
-        /// <summary>
-        /// The Proxy URL to use.
-        /// </summary>
-        public string ProxyUrl { get; private set; }
-
         /// <summary>
         /// The WebProxy settings.
         /// </summary>
-        public IWebProxySettings WebProxySettings { get; private set; }
+        public IProxyAndRecordSettings ProxyAndRecordSettings { get; private set; }
 
         /// <inheritdoc cref="IProxyResponseBuilder.WithProxy(string, string)"/>
         public IResponseBuilder WithProxy(string proxyUrl, string clientX509Certificate2ThumbprintOrSubjectName = null)
@@ -38,10 +33,9 @@ namespace WireMock.ResponseBuilders
         {
             Check.NotNull(settings, nameof(settings));
 
-            ProxyUrl = settings.Url;
-            WebProxySettings = settings.WebProxySettings;
+            ProxyAndRecordSettings = settings;
 
-            _httpClientForProxy = HttpClientHelper.CreateHttpClient(settings);
+            _httpClientForProxy = HttpClientBuilder.Build(settings);
             return this;
         }
     }

src/WireMock.Net/ResponseBuilders/Response.cs

@@ -7,10 +7,12 @@ using System.Net;
 using System.Text;
 using System.Threading.Tasks;
 using JetBrains.Annotations;
-using WireMock.Http;
+using WireMock.Proxy;
 using WireMock.ResponseProviders;
 using WireMock.Settings;
 using WireMock.Transformers;
+using WireMock.Transformers.Handlebars;
+using WireMock.Transformers.Scriban;
 using WireMock.Types;
 using WireMock.Util;
 using WireMock.Validation;
@@ -32,6 +34,11 @@ namespace WireMock.ResponseBuilders
         /// </summary>
         public bool UseTransformer { get; private set; }
 
+        /// <summary>
+        /// Gets the type of the transformer.
+        /// </summary>
+        public TransformerType TransformerType { get; private set; }
+
         /// <summary>
         /// Gets a value indicating whether to use the Handlerbars transformer for the content from the referenced BodyAsFile.
         /// </summary>
@@ -282,6 +289,16 @@ namespace WireMock.ResponseBuilders
         public IResponseBuilder WithTransformer(bool transformContentFromBodyAsFile = false)
         {
             UseTransformer = true;
+            TransformerType = TransformerType.Handlebars;
+            UseTransformerForBodyAsFile = transformContentFromBodyAsFile;
+            return this;
+        }
+
+        /// <inheritdoc cref="ITransformResponseBuilder.WithTransformer(TransformerType, bool)"/>
+        public IResponseBuilder WithTransformer(TransformerType transformerType, bool transformContentFromBodyAsFile = false)
+        {
+            UseTransformer = true;
+            TransformerType = transformerType;
             UseTransformerForBodyAsFile = transformContentFromBodyAsFile;
             return this;
         }
@@ -312,7 +329,7 @@ namespace WireMock.ResponseBuilders
                 await Task.Delay(Delay.Value);
             }
 
-            if (ProxyUrl != null && _httpClientForProxy != null)
+            if (ProxyAndRecordSettings != null && _httpClientForProxy != null)
             {
                 string RemoveFirstOccurrence(string source, string find)
                 {
@@ -323,16 +340,19 @@ namespace WireMock.ResponseBuilders
                 var requestUri = new Uri(requestMessage.Url);
 
                 // Build the proxy url and skip duplicates
-                string extra = RemoveFirstOccurrence(requestUri.LocalPath.TrimEnd('/'), new Uri(ProxyUrl).LocalPath.TrimEnd('/'));
-                requestMessage.ProxyUrl = ProxyUrl + extra + requestUri.Query;
+                string extra = RemoveFirstOccurrence(requestUri.LocalPath.TrimEnd('/'), new Uri(ProxyAndRecordSettings.Url).LocalPath.TrimEnd('/'));
+                requestMessage.ProxyUrl = ProxyAndRecordSettings.Url + extra + requestUri.Query;
 
-                return await HttpClientHelper.SendAsync(
+                var proxyHelper = new ProxyHelper(settings);
+
+                var (proxyResponseMessage, _) = await proxyHelper.SendAsync(
+                    ProxyAndRecordSettings,
                     _httpClientForProxy,
                     requestMessage,
-                    requestMessage.ProxyUrl,
-                    !settings.DisableJsonBodyParsing.GetValueOrDefault(false),
-                    !settings.DisableRequestBodyDecompressing.GetValueOrDefault(false)
+                    requestMessage.ProxyUrl
                 );
+
+                return proxyResponseMessage;
             }
 
             ResponseMessage responseMessage;
@@ -366,8 +386,24 @@ namespace WireMock.ResponseBuilders
 
             if (UseTransformer)
             {
-                var factory = new HandlebarsContextFactory(settings.FileSystemHandler, settings.HandlebarsRegistrationCallback);
-                var responseMessageTransformer = new ResponseMessageTransformer(factory);
+                ITransformer responseMessageTransformer;
+                switch (TransformerType)
+                {
+                    case TransformerType.Handlebars:
+                        var factoryHandlebars = new HandlebarsContextFactory(settings.FileSystemHandler, settings.HandlebarsRegistrationCallback);
+                        responseMessageTransformer = new Transformer(factoryHandlebars);
+                        break;
+
+                    case TransformerType.Scriban:
+                    case TransformerType.ScribanDotLiquid:
+                        var factoryDotLiquid = new ScribanContextFactory(settings.FileSystemHandler, TransformerType);
+                        responseMessageTransformer = new Transformer(factoryDotLiquid);
+                        break;
+
+                    default:
+                        throw new NotImplementedException($"TransformerType '{TransformerType}' is not supported.");
+                }
+
                 return responseMessageTransformer.Transform(requestMessage, responseMessage, UseTransformerForBodyAsFile);
             }
 

src/WireMock.Net/ResponseProviders/IResponseProvider.cs

@@ -1,7 +1,7 @@
 // This source file is based on mock4net by Alexandre Victoor which is licensed under the Apache 2.0 License.
 // For more details see 'mock4net/LICENSE.txt' and 'mock4net/readme.md' in this project root.
-using JetBrains.Annotations;
 using System.Threading.Tasks;
+using JetBrains.Annotations;
 using WireMock.Settings;
 
 namespace WireMock.ResponseProviders

src/WireMock.Net/Serialization/JsonSerializationConstants.cs

@@ -0,0 +1,19 @@
+using Newtonsoft.Json;
+
+namespace WireMock.Serialization
+{
+    internal static class JsonSerializationConstants
+    {
+        public static readonly JsonSerializerSettings JsonSerializerSettingsDefault = new JsonSerializerSettings
+        {
+            Formatting = Formatting.Indented,
+            NullValueHandling = NullValueHandling.Ignore
+        };
+
+        public static readonly JsonSerializerSettings JsonSerializerSettingsIncludeNullValues = new JsonSerializerSettings
+        {
+            Formatting = Formatting.Indented,
+            NullValueHandling = NullValueHandling.Include
+        };
+    }
+}

src/WireMock.Net/Serialization/MappingConverter.cs

@@ -101,7 +101,7 @@ namespace WireMock.Serialization
                 }
             }
 
-            if (!string.IsNullOrEmpty(response.ProxyUrl))
+            if (response.ProxyAndRecordSettings != null)
             {
                 mappingModel.Response.StatusCode = null;
                 mappingModel.Response.Headers = null;
@@ -113,11 +113,12 @@ namespace WireMock.Serialization
                 mappingModel.Response.BodyAsFile = null;
                 mappingModel.Response.BodyAsFileIsCached = null;
                 mappingModel.Response.UseTransformer = null;
+                mappingModel.Response.TransformerType = null;
                 mappingModel.Response.UseTransformerForBodyAsFile = null;
                 mappingModel.Response.BodyEncoding = null;
-                mappingModel.Response.ProxyUrl = response.ProxyUrl;
+                mappingModel.Response.ProxyUrl = response.ProxyAndRecordSettings.Url;
                 mappingModel.Response.Fault = null;
-                mappingModel.Response.WebProxy = MapWebProxy(response.WebProxySettings);
+                mappingModel.Response.WebProxy = MapWebProxy(response.ProxyAndRecordSettings.WebProxySettings);
             }
             else
             {
@@ -133,6 +134,7 @@ namespace WireMock.Serialization
                 if (response.UseTransformer)
                 {
                     mappingModel.Response.UseTransformer = response.UseTransformer;
+                    mappingModel.Response.TransformerType = response.TransformerType.ToString();
                 }
 
                 if (response.UseTransformerForBodyAsFile)

src/WireMock.Net/Serialization/MappingToFileSaver.cs

@@ -0,0 +1,49 @@
+using System.IO;
+using System.Linq;
+using Newtonsoft.Json;
+using WireMock.Settings;
+using WireMock.Validation;
+
+namespace WireMock.Serialization
+{
+    internal class MappingToFileSaver
+    {
+        private readonly IWireMockServerSettings _settings;
+        private readonly MappingConverter _mappingConverter;
+
+        public MappingToFileSaver(IWireMockServerSettings settings, MappingConverter mappingConverter)
+        {
+            Check.NotNull(settings, nameof(settings));
+
+            _settings = settings;
+            _mappingConverter = mappingConverter;
+        }
+
+        public void SaveMappingToFile(IMapping mapping, string folder = null)
+        {
+            if (folder == null)
+            {
+                folder = _settings.FileSystemHandler.GetMappingFolder();
+            }
+
+            if (!_settings.FileSystemHandler.FolderExists(folder))
+            {
+                _settings.FileSystemHandler.CreateFolder(folder);
+            }
+
+            var model = _mappingConverter.ToMappingModel(mapping);
+            string filename = (!string.IsNullOrEmpty(mapping.Title) ? SanitizeFileName(mapping.Title) : mapping.Guid.ToString()) + ".json";
+
+            string path = Path.Combine(folder, filename);
+
+            _settings.Logger.Info("Saving Mapping file {0}", filename);
+
+            _settings.FileSystemHandler.WriteMappingFile(path, JsonConvert.SerializeObject(model, JsonSerializationConstants.JsonSerializerSettingsDefault));
+        }
+
+        private static string SanitizeFileName(string name, char replaceChar = '_')
+        {
+            return Path.GetInvalidFileNameChars().Aggregate(name, (current, c) => current.Replace(c, replaceChar));
+        }
+    }
+}

src/WireMock.Net/Serialization/MatcherMapper.cs

@@ -5,6 +5,7 @@ using JetBrains.Annotations;
 using SimMetrics.Net;
 using WireMock.Admin.Mappings;
 using WireMock.Matchers;
+using WireMock.Plugin;
 using WireMock.Settings;
 using WireMock.Validation;
 
@@ -46,7 +47,7 @@ namespace WireMock.Serialization
                 case "CSharpCodeMatcher":
                     if (_settings.AllowCSharpCodeMatcher == true)
                     {
-                        return new CSharpCodeMatcher(matchBehaviour, stringPatterns);
+                        return PluginLoader.Load<ICSharpCodeMatcher>(matchBehaviour, stringPatterns);
                     }
 
                     throw new NotSupportedException("It's not allowed to use the 'CSharpCodeMatcher' because IWireMockServerSettings.AllowCSharpCodeMatcher is not set to 'true'.");

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

@@ -16,6 +16,7 @@ using WireMock.Http;
 using WireMock.Logging;
 using WireMock.Matchers;
 using WireMock.Matchers.Request;
+using WireMock.Proxy;
 using WireMock.RequestBuilders;
 using WireMock.ResponseBuilders;
 using WireMock.ResponseProviders;
@@ -47,18 +48,6 @@ namespace WireMock.Server
         private readonly RegexMatcher _adminMappingsGuidPathMatcher = new RegexMatcher(@"^\/__admin\/mappings\/([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})$");
         private readonly RegexMatcher _adminRequestsGuidPathMatcher = new RegexMatcher(@"^\/__admin\/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})$");
 
-        private readonly JsonSerializerSettings _jsonSerializerSettings = new JsonSerializerSettings
-        {
-            Formatting = Formatting.Indented,
-            NullValueHandling = NullValueHandling.Ignore
-        };
-
-        private readonly JsonSerializerSettings _settingsIncludeNullValues = new JsonSerializerSettings
-        {
-            Formatting = Formatting.Indented,
-            NullValueHandling = NullValueHandling.Include
-        };
-
         #region InitAdmin
         private void InitAdmin()
         {
@@ -119,7 +108,7 @@ namespace WireMock.Server
         {
             foreach (var mapping in Mappings.Where(m => !m.IsAdminInterface))
             {
-                SaveMappingToFile(mapping, folder);
+                _mappingToFileSaver.SaveMappingToFile(mapping, folder);
             }
         }
 
@@ -246,7 +235,7 @@ namespace WireMock.Server
 
         private void InitProxyAndRecord(IWireMockServerSettings settings)
         {
-            _httpClientForProxy = HttpClientHelper.CreateHttpClient(settings.ProxyAndRecordSettings);
+            _httpClientForProxy = HttpClientBuilder.Build(settings.ProxyAndRecordSettings);
 
             var respondProvider = Given(Request.Create().WithPath("/*").UsingAnyMethod());
             if (settings.StartAdminInterface == true)
@@ -263,82 +252,27 @@ namespace WireMock.Server
             var proxyUri = new Uri(settings.ProxyAndRecordSettings.Url);
             var proxyUriWithRequestPathAndQuery = new Uri(proxyUri, requestUri.PathAndQuery);
 
-            var responseMessage = await HttpClientHelper.SendAsync(
+            var proxyHelper = new ProxyHelper(settings);
+
+            var (responseMessage, mapping) = await proxyHelper.SendAsync(
+                _settings.ProxyAndRecordSettings,
                 _httpClientForProxy,
                 requestMessage,
-                proxyUriWithRequestPathAndQuery.AbsoluteUri,
-                !settings.DisableJsonBodyParsing.GetValueOrDefault(false),
-                !settings.DisableRequestBodyDecompressing.GetValueOrDefault(false)
+                proxyUriWithRequestPathAndQuery.AbsoluteUri
             );
 
-            if (HttpStatusRangeParser.IsMatch(settings.ProxyAndRecordSettings.SaveMappingForStatusCodePattern, responseMessage.StatusCode) &&
-                (settings.ProxyAndRecordSettings.SaveMapping || settings.ProxyAndRecordSettings.SaveMappingToFile))
+            if (settings.ProxyAndRecordSettings.SaveMapping)
             {
-                var mapping = ToMapping(
-                    requestMessage,
-                    responseMessage,
-                    settings.ProxyAndRecordSettings.ExcludedHeaders ?? new string[] { },
-                    settings.ProxyAndRecordSettings.ExcludedCookies ?? new string[] { }
-                );
+                _options.Mappings.TryAdd(mapping.Guid, mapping);
+            }
 
-                if (settings.ProxyAndRecordSettings.SaveMapping)
-                {
-                    _options.Mappings.TryAdd(mapping.Guid, mapping);
-                }
-
-                if (settings.ProxyAndRecordSettings.SaveMappingToFile)
-                {
-                    SaveMappingToFile(mapping);
-                }
+            if (settings.ProxyAndRecordSettings.SaveMappingToFile)
+            {
+                _mappingToFileSaver.SaveMappingToFile(mapping);
             }
 
             return responseMessage;
         }
-
-        private IMapping ToMapping(RequestMessage requestMessage, ResponseMessage responseMessage, string[] excludedHeaders, string[] excludedCookies)
-        {
-            var request = Request.Create();
-            request.WithPath(requestMessage.Path);
-            request.UsingMethod(requestMessage.Method);
-
-            requestMessage.Query.Loop((key, value) => request.WithParam(key, false, value.ToArray()));
-            requestMessage.Cookies.Loop((key, value) =>
-            {
-                if (!excludedCookies.Contains(key, StringComparer.OrdinalIgnoreCase))
-                {
-                    request.WithCookie(key, value);
-                }
-            });
-
-            var allExcludedHeaders = new List<string>(excludedHeaders) { "Cookie" };
-            requestMessage.Headers.Loop((key, value) =>
-            {
-                if (!allExcludedHeaders.Contains(key, StringComparer.OrdinalIgnoreCase))
-                {
-                    request.WithHeader(key, value.ToArray());
-                }
-            });
-
-            bool throwExceptionWhenMatcherFails = _settings.ThrowExceptionWhenMatcherFails == true;
-            switch (requestMessage.BodyData?.DetectedBodyType)
-            {
-                case BodyType.Json:
-                    request.WithBody(new JsonMatcher(MatchBehaviour.AcceptOnMatch, requestMessage.BodyData.BodyAsJson, true, throwExceptionWhenMatcherFails));
-                    break;
-
-                case BodyType.String:
-                    request.WithBody(new ExactMatcher(MatchBehaviour.AcceptOnMatch, throwExceptionWhenMatcherFails, requestMessage.BodyData.BodyAsString));
-                    break;
-
-                case BodyType.Bytes:
-                    request.WithBody(new ExactObjectMatcher(MatchBehaviour.AcceptOnMatch, requestMessage.BodyData.BodyAsBytes, throwExceptionWhenMatcherFails));
-                    break;
-            }
-
-            var response = Response.Create(responseMessage);
-
-            return new Mapping(Guid.NewGuid(), string.Empty, null, _settings, request, response, 0, null, null, null, null);
-        }
         #endregion
 
         #region Settings
@@ -446,33 +380,6 @@ namespace WireMock.Server
             return ResponseMessageBuilder.Create("Mappings saved to disk");
         }
 
-        private void SaveMappingToFile(IMapping mapping, string folder = null)
-        {
-            if (folder == null)
-            {
-                folder = _settings.FileSystemHandler.GetMappingFolder();
-            }
-
-            if (!_settings.FileSystemHandler.FolderExists(folder))
-            {
-                _settings.FileSystemHandler.CreateFolder(folder);
-            }
-
-            var model = _mappingConverter.ToMappingModel(mapping);
-            string filename = (!string.IsNullOrEmpty(mapping.Title) ? SanitizeFileName(mapping.Title) : mapping.Guid.ToString()) + ".json";
-
-            string path = Path.Combine(folder, filename);
-
-            _settings.Logger.Info("Saving Mapping file {0}", filename);
-
-            _settings.FileSystemHandler.WriteMappingFile(path, JsonConvert.SerializeObject(model, _jsonSerializerSettings));
-        }
-
-        private static string SanitizeFileName(string name, char replaceChar = '_')
-        {
-            return Path.GetInvalidFileNameChars().Aggregate(name, (current, c) => current.Replace(c, replaceChar));
-        }
-
         private IEnumerable<MappingModel> ToMappingModels()
         {
             return Mappings.Where(m => !m.IsAdminInterface).Select(_mappingConverter.ToMappingModel);
@@ -863,7 +770,11 @@ namespace WireMock.Server
 
             if (responseModel.UseTransformer == true)
             {
-                responseBuilder = responseBuilder.WithTransformer(responseModel.UseTransformerForBodyAsFile == true);
+                if (!Enum.TryParse<TransformerType>(responseModel.TransformerType, out var transformerType))
+                {
+                    transformerType = TransformerType.Handlebars;
+                }
+                responseBuilder = responseBuilder.WithTransformer(transformerType, responseModel.UseTransformerForBodyAsFile == true);
             }
 
             if (!string.IsNullOrEmpty(responseModel.ProxyUrl))
@@ -945,7 +856,7 @@ namespace WireMock.Server
                 BodyData = new BodyData
                 {
                     DetectedBodyType = BodyType.String,
-                    BodyAsString = JsonConvert.SerializeObject(result, keepNullValues ? _settingsIncludeNullValues : _jsonSerializerSettings)
+                    BodyAsString = JsonConvert.SerializeObject(result, keepNullValues ? JsonSerializationConstants.JsonSerializerSettingsIncludeNullValues : JsonSerializationConstants.JsonSerializerSettingsDefault)
                 },
                 StatusCode = (int)HttpStatusCode.OK,
                 Headers = new Dictionary<string, WireMockList<string>> { { HttpKnownHeaderNames.ContentType, new WireMockList<string>(ContentTypeJson) } }

src/WireMock.Net/Server/WireMockServer.cs

@@ -35,6 +35,7 @@ namespace WireMock.Server
         private readonly IWireMockMiddlewareOptions _options = new WireMockMiddlewareOptions();
         private readonly MappingConverter _mappingConverter;
         private readonly MatcherMapper _matcherMapper;
+        private readonly MappingToFileSaver _mappingToFileSaver;
 
         /// <inheritdoc cref="IWireMockServer.IsStarted" />
         [PublicAPI]
@@ -238,6 +239,7 @@ namespace WireMock.Server
 
             _matcherMapper = new MatcherMapper(_settings);
             _mappingConverter = new MappingConverter(_matcherMapper);
+            _mappingToFileSaver = new MappingToFileSaver(_settings, _mappingConverter);
 
 #if USE_ASPNETCORE
             _httpServer = new AspNetCoreSelfHost(_options, urlOptions);
@@ -491,7 +493,7 @@ namespace WireMock.Server
 
             if (saveToFile)
             {
-                SaveMappingToFile(mapping);
+                _mappingToFileSaver.SaveMappingToFile(mapping);
             }
         }
     }

src/WireMock.Net/Settings/IProxyAndRecordSettings.cs

@@ -25,7 +25,7 @@ namespace WireMock.Settings
         string SaveMappingForStatusCodePattern { get; set; }
 
         /// <summary>
-        /// Save the mapping for each request/response also to a file. (Note that SaveMapping must also be set to true.)
+        /// Save the mapping for each request/response to a .json mapping file.
         /// </summary>
         bool SaveMappingToFile { get; set; }
 

src/WireMock.Net/Settings/ProxyAndRecordSettings.cs

@@ -17,13 +17,13 @@ namespace WireMock.Settings
         /// Save the mapping for each request/response to the internal Mappings.
         /// </summary>
         [PublicAPI]
-        public bool SaveMapping { get; set; } = true;
+        public bool SaveMapping { get; set; }
 
         /// <summary>
         /// Save the mapping for each request/response also to a file. (Note that SaveMapping must also be set to true.)
         /// </summary>
         [PublicAPI]
-        public bool SaveMappingToFile { get; set; } = true;
+        public bool SaveMappingToFile { get; set; }
 
         /// <summary>
         /// Only save request/response to the internal Mappings if the status code is included in this pattern. (Note that SaveMapping must also be set to true.)

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

@@ -1,11 +1,19 @@
 using HandlebarsDotNet;
 using WireMock.Handlers;
 
-namespace WireMock.Transformers
+namespace WireMock.Transformers.Handlebars
 {
     internal class HandlebarsContext : IHandlebarsContext
     {
         public IHandlebars Handlebars { get; set; }
+
         public IFileSystemHandler FileSystemHandler { get; set; }
+
+        public string ParseAndRender(string text, object model)
+        {
+            var template = Handlebars.Compile(text);
+
+            return template(model);
+        }
     }
 }

src/WireMock.Net/Transformers/Handlebars/HandlebarsContextFactory.cs

@@ -1,10 +1,11 @@
 using System;
 using HandlebarsDotNet;
+using JetBrains.Annotations;
 using WireMock.Handlers;
 
-namespace WireMock.Transformers
+namespace WireMock.Transformers.Handlebars
 {
-    internal class HandlebarsContextFactory : IHandlebarsContextFactory
+    internal class HandlebarsContextFactory : ITransformerContextFactory
     {
         private static readonly HandlebarsConfiguration HandlebarsConfiguration = new HandlebarsConfiguration
         {
@@ -14,15 +15,15 @@ namespace WireMock.Transformers
         private readonly IFileSystemHandler _fileSystemHandler;
         private readonly Action<IHandlebars, IFileSystemHandler> _action;
 
-        public HandlebarsContextFactory(IFileSystemHandler fileSystemHandler, Action<IHandlebars, IFileSystemHandler> action)
+        public HandlebarsContextFactory([NotNull] IFileSystemHandler fileSystemHandler, [CanBeNull] Action<IHandlebars, IFileSystemHandler> action)
         {
-            _fileSystemHandler = fileSystemHandler;
+            _fileSystemHandler = fileSystemHandler ?? throw new ArgumentNullException(nameof(fileSystemHandler));
             _action = action;
         }
 
-        public IHandlebarsContext Create()
+        public ITransformerContext Create()
         {
-            var handlebars = Handlebars.Create(HandlebarsConfiguration);
+            var handlebars = HandlebarsDotNet.Handlebars.Create(HandlebarsConfiguration);
 
             WireMockHandlebarsHelpers.Register(handlebars, _fileSystemHandler);
 

src/WireMock.Net/Transformers/Handlebars/HandlebarsFile.cs

@@ -3,7 +3,7 @@ using System;
 using WireMock.Handlers;
 using WireMock.Validation;
 
-namespace WireMock.Transformers
+namespace WireMock.Transformers.Handlebars
 {
     internal static class HandlebarsFile
     {

src/WireMock.Net/Transformers/Handlebars/HandlebarsJsonPath.cs

@@ -7,7 +7,7 @@ using System.Linq;
 using WireMock.Util;
 using WireMock.Validation;
 
-namespace WireMock.Transformers
+namespace WireMock.Transformers.Handlebars
 {
     internal static class HandlebarsJsonPath
     {

src/WireMock.Net/Transformers/Handlebars/HandlebarsLinq.cs

@@ -7,7 +7,7 @@ using Newtonsoft.Json.Linq;
 using WireMock.Util;
 using WireMock.Validation;
 
-namespace WireMock.Transformers
+namespace WireMock.Transformers.Handlebars
 {
     internal static class HandlebarsLinq
     {

src/WireMock.Net/Transformers/Handlebars/HandlebarsRandom.cs

@@ -9,7 +9,7 @@ using RandomDataGenerator.FieldOptions;
 using RandomDataGenerator.Randomizers;
 using WireMock.Validation;
 
-namespace WireMock.Transformers
+namespace WireMock.Transformers.Handlebars
 {
     internal static class HandlebarsRandom
     {

src/WireMock.Net/Transformers/Handlebars/HandlebarsRegex.cs

@@ -5,7 +5,7 @@ using HandlebarsDotNet;
 using WireMock.Util;
 using WireMock.Validation;
 
-namespace WireMock.Transformers
+namespace WireMock.Transformers.Handlebars
 {
     internal static class HandlebarsRegex
     {

src/WireMock.Net/Transformers/Handlebars/HandlebarsXPath.cs

@@ -8,7 +8,7 @@ using WireMock.Validation;
 using Wmhelp.XPath2;
 #endif
 
-namespace WireMock.Transformers
+namespace WireMock.Transformers.Handlebars
 {
     internal static class HandlebarsXPath
     {

src/WireMock.Net/Transformers/Handlebars/HandlebarsXeger.cs

@@ -3,7 +3,7 @@ using Fare;
 using HandlebarsDotNet;
 using WireMock.Validation;
 
-namespace WireMock.Transformers
+namespace WireMock.Transformers.Handlebars
 {
     internal static class HandlebarsXeger
     {

src/WireMock.Net/Transformers/Handlebars/IHandlebarsContext.cs

@@ -0,0 +1,9 @@
+using HandlebarsDotNet;
+
+namespace WireMock.Transformers.Handlebars
+{
+    interface IHandlebarsContext : ITransformerContext
+    {
+        IHandlebars Handlebars { get; set; }
+    }
+}

src/WireMock.Net/Transformers/Handlebars/WireMockHandlebarsHelpers.cs

@@ -2,7 +2,7 @@
 using HandlebarsDotNet.Helpers;
 using WireMock.Handlers;
 
-namespace WireMock.Transformers
+namespace WireMock.Transformers.Handlebars
 {
     internal static class WireMockHandlebarsHelpers
     {

src/WireMock.Net/Transformers/IHandlebarsContext.cs

@@ -1,12 +0,0 @@
-using HandlebarsDotNet;
-using WireMock.Handlers;
-
-namespace WireMock.Transformers
-{
-    interface IHandlebarsContext
-    {
-        IHandlebars Handlebars { get; set; }
-
-        IFileSystemHandler FileSystemHandler { get; set; }
-    }
-}

src/WireMock.Net/Transformers/IHandlebarsContextFactory.cs

@@ -1,7 +0,0 @@
-namespace WireMock.Transformers
-{
-    interface IHandlebarsContextFactory
-    {
-        IHandlebarsContext Create();
-    }
-}

src/WireMock.Net/Transformers/ITransformer.cs

@@ -0,0 +1,7 @@
+namespace WireMock.Transformers
+{
+    interface ITransformer
+    {
+        ResponseMessage Transform(RequestMessage requestMessage, ResponseMessage original, bool useTransformerForBodyAsFile);
+    }
+}

src/WireMock.Net/Transformers/ITransformerContext.cs

@@ -0,0 +1,11 @@
+using WireMock.Handlers;
+
+namespace WireMock.Transformers
+{
+    interface ITransformerContext
+    {
+        IFileSystemHandler FileSystemHandler { get; set; }
+
+        string ParseAndRender(string text, object model);
+    }
+}

src/WireMock.Net/Transformers/ITransformerContextFactory.cs

@@ -0,0 +1,7 @@
+namespace WireMock.Transformers
+{
+    interface ITransformerContextFactory
+    {
+        ITransformerContext Create();
+    }
+}

src/WireMock.Net/Transformers/Scriban/ScribanContext.cs

@@ -0,0 +1,27 @@
+using System;
+using Scriban;
+using WireMock.Handlers;
+using WireMock.Types;
+
+namespace WireMock.Transformers.Scriban
+{
+    internal class ScribanContext : ITransformerContext
+    {
+        private readonly TransformerType _transformerType;
+
+        public IFileSystemHandler FileSystemHandler { get; set; }
+
+        public ScribanContext(IFileSystemHandler fileSystemHandler, TransformerType transformerType)
+        {
+            FileSystemHandler = fileSystemHandler ?? throw new ArgumentNullException(nameof(fileSystemHandler));
+            _transformerType = transformerType;
+        }
+
+        public string ParseAndRender(string text, object model)
+        {
+            var template = _transformerType == TransformerType.ScribanDotLiquid ? Template.ParseLiquid(text) : Template.Parse(text);
+
+            return template.Render(model, member => member.Name);
+        }
+    }
+}

src/WireMock.Net/Transformers/Scriban/ScribanContextFactory.cs

@@ -0,0 +1,26 @@
+using WireMock.Handlers;
+using WireMock.Types;
+using WireMock.Validation;
+
+namespace WireMock.Transformers.Scriban
+{
+    internal class ScribanContextFactory : ITransformerContextFactory
+    {
+        private readonly IFileSystemHandler _fileSystemHandler;
+        private readonly TransformerType _transformerType;
+
+        public ScribanContextFactory(IFileSystemHandler fileSystemHandler, TransformerType transformerType)
+        {
+            Check.NotNull(fileSystemHandler, nameof(fileSystemHandler));
+            Check.Condition(transformerType, t => t == TransformerType.Scriban || t == TransformerType.ScribanDotLiquid, nameof(transformerType));
+
+            _fileSystemHandler = fileSystemHandler;
+            _transformerType = transformerType;
+        }
+
+        public ITransformerContext Create()
+        {
+            return new ScribanContext(_fileSystemHandler, _transformerType);
+        }
+    }
+}

src/WireMock.Net/Transformers/Scriban/WireMockListAccessor.cs

@@ -0,0 +1,55 @@
+using System;
+using System.Collections.Generic;
+using Scriban;
+using Scriban.Parsing;
+using Scriban.Runtime;
+
+namespace WireMock.Transformers.Scriban
+{
+    internal class WireMockListAccessor : IListAccessor, IObjectAccessor
+    {
+        #region IListAccessor
+        public int GetLength(TemplateContext context, SourceSpan span, object target)
+        {
+            throw new NotImplementedException();
+        }
+
+        public object GetValue(TemplateContext context, SourceSpan span, object target, int index)
+        {
+            return target.ToString();
+        }
+
+        public void SetValue(TemplateContext context, SourceSpan span, object target, int index, object value)
+        {
+            throw new NotImplementedException();
+        }
+        #endregion
+
+        #region IObjectAccessor
+        public int GetMemberCount(TemplateContext context, SourceSpan span, object target)
+        {
+            throw new NotImplementedException();
+        }
+
+        public IEnumerable<string> GetMembers(TemplateContext context, SourceSpan span, object target)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool HasMember(TemplateContext context, SourceSpan span, object target, string member)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool TryGetValue(TemplateContext context, SourceSpan span, object target, string member, out object value)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool TrySetValue(TemplateContext context, SourceSpan span, object target, string member, object value)
+        {
+            throw new NotImplementedException();
+        }
+        #endregion
+    }
+}

src/WireMock.Net/Transformers/Scriban/WireMockTemplateContext.cs

@@ -0,0 +1,19 @@
+using Scriban;
+using Scriban.Runtime;
+using WireMock.Types;
+
+namespace WireMock.Transformers.Scriban
+{
+    internal class WireMockTemplateContext: TemplateContext
+    {
+        protected override IObjectAccessor GetMemberAccessorImpl(object target)
+        {
+            if (target?.GetType().GetGenericTypeDefinition() == typeof(WireMockList<>))
+            {
+                return new WireMockListAccessor();
+            }
+
+            return base.GetMemberAccessorImpl(target);
+        }
+    }
+}

src/WireMock.Net/Transformers/Transformer.cs

@@ -1,235 +1,227 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using HandlebarsDotNet;
-using JetBrains.Annotations;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
-using WireMock.Types;
-using WireMock.Util;
-using WireMock.Validation;
-
-namespace WireMock.Transformers
-{
-    internal class ResponseMessageTransformer
-    {
-        private readonly IHandlebarsContextFactory _factory;
-
-        public ResponseMessageTransformer([NotNull] IHandlebarsContextFactory factory)
-        {
-            Check.NotNull(factory, nameof(factory));
-
-            _factory = factory;
-        }
-
-        public ResponseMessage Transform(RequestMessage requestMessage, ResponseMessage original, bool useTransformerForBodyAsFile)
-        {
-            var handlebarsContext = _factory.Create();
-
-            var responseMessage = new ResponseMessage();
-
-            var template = new { request = requestMessage };
-
-            switch (original.BodyData?.DetectedBodyType)
-            {
-                case BodyType.Json:
-                    TransformBodyAsJson(handlebarsContext.Handlebars, template, original, responseMessage);
-                    break;
-
-                case BodyType.File:
-                    TransformBodyAsFile(handlebarsContext, template, original, responseMessage, useTransformerForBodyAsFile);
-                    break;
-
-                case BodyType.String:
-                    responseMessage.BodyOriginal = original.BodyData.BodyAsString;
-                    TransformBodyAsString(handlebarsContext.Handlebars, template, original, responseMessage);
-                    break;
-            }
-
-            responseMessage.FaultType = original.FaultType;
-            responseMessage.FaultPercentage = original.FaultPercentage;
-
-            // Headers
-            var newHeaders = new Dictionary<string, WireMockList<string>>();
-            foreach (var header in original.Headers)
-            {
-                var templateHeaderKey = handlebarsContext.Handlebars.Compile(header.Key);
-                var templateHeaderValues = header.Value
-                    .Select(handlebarsContext.Handlebars.Compile)
-                    .Select(func => func(template))
-                    .ToArray();
-
-                newHeaders.Add(templateHeaderKey(template), new WireMockList<string>(templateHeaderValues));
-            }
-
-            responseMessage.Headers = newHeaders;
-
-            switch (original.StatusCode)
-            {
-                case int statusCodeAsInteger:
-                    responseMessage.StatusCode = statusCodeAsInteger;
-                    break;
-
-                case string statusCodeAsString:
-                    var templateForStatusCode = handlebarsContext.Handlebars.Compile(statusCodeAsString);
-                    responseMessage.StatusCode = templateForStatusCode(template);
-                    break;
-            }
-
-            return responseMessage;
-        }
-
-        private static void TransformBodyAsJson(IHandlebars handlebarsContext, object template, ResponseMessage original, ResponseMessage responseMessage)
-        {
-            JToken jToken;
-            switch (original.BodyData.BodyAsJson)
-            {
-                case JObject bodyAsJObject:
-                    jToken = bodyAsJObject.DeepClone();
-                    WalkNode(handlebarsContext, jToken, template);
-                    break;
-
-                case Array bodyAsArray:
-                    jToken = JArray.FromObject(bodyAsArray);
-                    WalkNode(handlebarsContext, jToken, template);
-                    break;
-
-                case string bodyAsString:
-                    jToken = ReplaceSingleNode(handlebarsContext, bodyAsString, template);
-                    break;
-
-                default:
-                    jToken = JObject.FromObject(original.BodyData.BodyAsJson);
-                    WalkNode(handlebarsContext, jToken, template);
-                    break;
-            }
-
-            responseMessage.BodyData = new BodyData
-            {
-                Encoding = original.BodyData.Encoding,
-                DetectedBodyType = original.BodyData.DetectedBodyType,
-                DetectedBodyTypeFromContentType = original.BodyData.DetectedBodyTypeFromContentType,
-                BodyAsJson = jToken
-            };
-        }
-
-        private static JToken ReplaceSingleNode(IHandlebars handlebarsContext, string stringValue, object context)
-        {
-            var templateForStringValue = handlebarsContext.Compile(stringValue);
-            string transformedString = templateForStringValue(context);
-            if (!string.Equals(stringValue, transformedString))
-            {
-                const string property = "_";
-                JObject dummy = JObject.Parse($"{{ \"{property}\": null }}");
-                JToken node = dummy[property];
-
-                ReplaceNodeValue(node, transformedString);
-
-                return dummy[property];
-            }
-
-            return stringValue;
-        }
-
-        private static void WalkNode(IHandlebars handlebarsContext, 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(handlebarsContext, child.Value, context);
-                }
-            }
-            else if (node.Type == JTokenType.Array)
-            {
-                // In case of Array, loop all items. Do a ToArray() to avoid `Collection was modified` exceptions.
-                foreach (JToken child in node.Children().ToArray())
-                {
-                    WalkNode(handlebarsContext, child, context);
-                }
-            }
-            else if (node.Type == JTokenType.String)
-            {
-                // In case of string, try to transform the value.
-                string stringValue = node.Value<string>();
-                if (string.IsNullOrEmpty(stringValue))
-                {
-                    return;
-                }
-
-                var templateForStringValue = handlebarsContext.Compile(stringValue);
-                string transformedString = templateForStringValue(context);
-                if (!string.Equals(stringValue, transformedString))
-                {
-                    ReplaceNodeValue(node, transformedString);
-                }
-            }
-        }
-
-        private static void ReplaceNodeValue(JToken node, string stringValue)
-        {
-            if (bool.TryParse(stringValue, out bool valueAsBoolean))
-            {
-                node.Replace(valueAsBoolean);
-                return;
-            }
-
-            JToken value;
-            try
-            {
-                // Try to convert this string into a JsonObject
-                value = JToken.Parse(stringValue);
-            }
-            catch (JsonException)
-            {
-                // Ignore JsonException and just keep string value and convert to JToken
-                value = stringValue;
-            }
-
-            node.Replace(value);
-        }
-
-        private static void TransformBodyAsString(IHandlebars handlebarsContext, object template, ResponseMessage original, ResponseMessage responseMessage)
-        {
-            var templateBodyAsString = handlebarsContext.Compile(original.BodyData.BodyAsString);
-
-            responseMessage.BodyData = new BodyData
-            {
-                Encoding = original.BodyData.Encoding,
-                DetectedBodyType = original.BodyData.DetectedBodyType,
-                DetectedBodyTypeFromContentType = original.BodyData.DetectedBodyTypeFromContentType,
-                BodyAsString = templateBodyAsString(template)
-            };
-        }
-
-        private void TransformBodyAsFile(IHandlebarsContext handlebarsContext, object template, ResponseMessage original, ResponseMessage responseMessage, bool useTransformerForBodyAsFile)
-        {
-            var templateBodyAsFile = handlebarsContext.Handlebars.Compile(original.BodyData.BodyAsFile);
-            string transformedBodyAsFilename = templateBodyAsFile(template);
-
-            if (!useTransformerForBodyAsFile)
-            {
-                responseMessage.BodyData = new BodyData
-                {
-                    DetectedBodyType = original.BodyData.DetectedBodyType,
-                    DetectedBodyTypeFromContentType = original.BodyData.DetectedBodyTypeFromContentType,
-                    BodyAsFile = transformedBodyAsFilename
-                };
-            }
-            else
-            {
-                string text = handlebarsContext.FileSystemHandler.ReadResponseBodyAsString(transformedBodyAsFilename);
-                var templateBodyAsString = handlebarsContext.Handlebars.Compile(text);
-
-                responseMessage.BodyData = new BodyData
-                {
-                    DetectedBodyType = BodyType.String,
-                    DetectedBodyTypeFromContentType = original.BodyData.DetectedBodyTypeFromContentType,
-                    BodyAsString = templateBodyAsString(template),
-                    BodyAsFile = transformedBodyAsFilename
-                };
-            }
-        }
-    }
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using JetBrains.Annotations;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Linq;
+using WireMock.Types;
+using WireMock.Util;
+using WireMock.Validation;
+
+namespace WireMock.Transformers.Handlebars
+{
+    internal class Transformer : ITransformer
+    {
+        private readonly ITransformerContextFactory _factory;
+
+        public Transformer([NotNull] ITransformerContextFactory factory)
+        {
+            Check.NotNull(factory, nameof(factory));
+
+            _factory = factory;
+        }
+
+        public ResponseMessage Transform(RequestMessage requestMessage, ResponseMessage original, bool useTransformerForBodyAsFile)
+        {
+            var handlebarsContext = _factory.Create();
+
+            var responseMessage = new ResponseMessage();
+
+            var model = new { request = requestMessage };
+
+            switch (original.BodyData?.DetectedBodyType)
+            {
+                case BodyType.Json:
+                    TransformBodyAsJson(handlebarsContext, model, original, responseMessage);
+                    break;
+
+                case BodyType.File:
+                    TransformBodyAsFile(handlebarsContext, model, original, responseMessage, useTransformerForBodyAsFile);
+                    break;
+
+                case BodyType.String:
+                    responseMessage.BodyOriginal = original.BodyData.BodyAsString;
+                    TransformBodyAsString(handlebarsContext, model, original, responseMessage);
+                    break;
+            }
+
+            responseMessage.FaultType = original.FaultType;
+            responseMessage.FaultPercentage = original.FaultPercentage;
+
+            // Headers
+            var newHeaders = new Dictionary<string, WireMockList<string>>();
+            foreach (var header in original.Headers)
+            {
+                var headerKey = handlebarsContext.ParseAndRender(header.Key, model);
+                var templateHeaderValues = header.Value
+                    .Select(text => handlebarsContext.ParseAndRender(text, model))
+                    .ToArray();
+
+                newHeaders.Add(headerKey, new WireMockList<string>(templateHeaderValues));
+            }
+
+            responseMessage.Headers = newHeaders;
+
+            switch (original.StatusCode)
+            {
+                case int statusCodeAsInteger:
+                    responseMessage.StatusCode = statusCodeAsInteger;
+                    break;
+
+                case string statusCodeAsString:
+                    responseMessage.StatusCode = handlebarsContext.ParseAndRender(statusCodeAsString, model);
+                    break;
+            }
+
+            return responseMessage;
+        }
+
+        private static void TransformBodyAsJson(ITransformerContext handlebarsContext, object model, ResponseMessage original, ResponseMessage responseMessage)
+        {
+            JToken jToken;
+            switch (original.BodyData.BodyAsJson)
+            {
+                case JObject bodyAsJObject:
+                    jToken = bodyAsJObject.DeepClone();
+                    WalkNode(handlebarsContext, jToken, model);
+                    break;
+
+                case Array bodyAsArray:
+                    jToken = JArray.FromObject(bodyAsArray);
+                    WalkNode(handlebarsContext, jToken, model);
+                    break;
+
+                case string bodyAsString:
+                    jToken = ReplaceSingleNode(handlebarsContext, bodyAsString, model);
+                    break;
+
+                default:
+                    jToken = JObject.FromObject(original.BodyData.BodyAsJson);
+                    WalkNode(handlebarsContext, jToken, model);
+                    break;
+            }
+
+            responseMessage.BodyData = new BodyData
+            {
+                Encoding = original.BodyData.Encoding,
+                DetectedBodyType = original.BodyData.DetectedBodyType,
+                DetectedBodyTypeFromContentType = original.BodyData.DetectedBodyTypeFromContentType,
+                BodyAsJson = jToken
+            };
+        }
+
+        private static JToken ReplaceSingleNode(ITransformerContext handlebarsContext, string stringValue, object model)
+        {
+            string transformedString = handlebarsContext.ParseAndRender(stringValue, model);
+
+            if (!string.Equals(stringValue, transformedString))
+            {
+                const string property = "_";
+                JObject dummy = JObject.Parse($"{{ \"{property}\": null }}");
+                JToken node = dummy[property];
+
+                ReplaceNodeValue(node, transformedString);
+
+                return dummy[property];
+            }
+
+            return stringValue;
+        }
+
+        private static void WalkNode(ITransformerContext handlebarsContext, JToken node, object model)
+        {
+            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(handlebarsContext, child.Value, model);
+                }
+            }
+            else if (node.Type == JTokenType.Array)
+            {
+                // In case of Array, loop all items. Do a ToArray() to avoid `Collection was modified` exceptions.
+                foreach (JToken child in node.Children().ToArray())
+                {
+                    WalkNode(handlebarsContext, child, model);
+                }
+            }
+            else if (node.Type == JTokenType.String)
+            {
+                // In case of string, try to transform the value.
+                string stringValue = node.Value<string>();
+                if (string.IsNullOrEmpty(stringValue))
+                {
+                    return;
+                }
+
+                string transformedString = handlebarsContext.ParseAndRender(stringValue, model);
+                if (!string.Equals(stringValue, transformedString))
+                {
+                    ReplaceNodeValue(node, transformedString);
+                }
+            }
+        }
+
+        private static void ReplaceNodeValue(JToken node, string stringValue)
+        {
+            if (bool.TryParse(stringValue, out bool valueAsBoolean))
+            {
+                node.Replace(valueAsBoolean);
+                return;
+            }
+
+            JToken value;
+            try
+            {
+                // Try to convert this string into a JsonObject
+                value = JToken.Parse(stringValue);
+            }
+            catch (JsonException)
+            {
+                // Ignore JsonException and just keep string value and convert to JToken
+                value = stringValue;
+            }
+
+            node.Replace(value);
+        }
+
+        private static void TransformBodyAsString(ITransformerContext handlebarsContext, object model, ResponseMessage original, ResponseMessage responseMessage)
+        {
+            responseMessage.BodyData = new BodyData
+            {
+                Encoding = original.BodyData.Encoding,
+                DetectedBodyType = original.BodyData.DetectedBodyType,
+                DetectedBodyTypeFromContentType = original.BodyData.DetectedBodyTypeFromContentType,
+                BodyAsString = handlebarsContext.ParseAndRender(original.BodyData.BodyAsString, model)
+            };
+        }
+
+        private void TransformBodyAsFile(ITransformerContext handlebarsContext, object model, ResponseMessage original, ResponseMessage responseMessage, bool useTransformerForBodyAsFile)
+        {
+            string transformedBodyAsFilename = handlebarsContext.ParseAndRender(original.BodyData.BodyAsFile, model);
+
+            if (!useTransformerForBodyAsFile)
+            {
+                responseMessage.BodyData = new BodyData
+                {
+                    DetectedBodyType = original.BodyData.DetectedBodyType,
+                    DetectedBodyTypeFromContentType = original.BodyData.DetectedBodyTypeFromContentType,
+                    BodyAsFile = transformedBodyAsFilename
+                };
+            }
+            else
+            {
+                string text = handlebarsContext.FileSystemHandler.ReadResponseBodyAsString(transformedBodyAsFilename);
+
+                responseMessage.BodyData = new BodyData
+                {
+                    DetectedBodyType = BodyType.String,
+                    DetectedBodyTypeFromContentType = original.BodyData.DetectedBodyTypeFromContentType,
+                    BodyAsString = handlebarsContext.ParseAndRender(text, model),
+                    BodyAsFile = transformedBodyAsFilename
+                };
+            }
+        }
+    }
 }

src/WireMock.Net/WireMock.Net.csproj

@@ -27,7 +27,7 @@
 
   <!-- https://github.com/aspnet/RoslynCodeDomProvider/issues/51 -->
   <!-- This is needed else we cannot build net452 in Azure DevOps Pipeline -->
-  <Target Name="CheckIfShouldKillVBCSCompiler" />
+  <!--<Target Name="CheckIfShouldKillVBCSCompiler" />-->
 
   <PropertyGroup Condition="'$(Configuration)' == 'Release'">
     <!--<PathMap>$(MSBuildProjectDirectory)=/</PathMap>-->
@@ -50,6 +50,12 @@
     <DefineConstants>USE_ASPNETCORE;NET46</DefineConstants>
   </PropertyGroup>
 
+  <ItemGroup>
+    <Compile Remove="Transformers\Scriban\ScribanTransformer.cs" />
+    <Compile Remove="Transformers\Scriban\WireMockListAccessor.cs" />
+    <Compile Remove="Transformers\Scriban\WireMockTemplateContext.cs" />
+  </ItemGroup>
+
   <ItemGroup>
     <PackageReference Include="JetBrains.Annotations" Version="2020.1.0" PrivateAssets="All" />
     <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="All" />
@@ -59,6 +65,7 @@
     <PackageReference Include="RandomDataGenerator.Net" Version="1.0.12" />
     <PackageReference Include="JmesPath.Net" Version="1.0.125" />
     <PackageReference Include="Handlebars.Net.Helpers" Version="1.1.0" />
+	  <!--<PackageReference Include="DotLiquid" Version="2.0.366" />-->
   </ItemGroup>
 
   <ItemGroup Condition="'$(Configuration)' == 'Debug - Sonar'">
@@ -72,22 +79,13 @@
     <PackageReference Include="XPath2.Extensions" Version="1.1.0" />
   </ItemGroup>
 
-  <ItemGroup Condition=" '$(TargetFramework)' == 'net451' ">
+  <ItemGroup Condition=" '$(TargetFramework)' == 'net451' or '$(TargetFramework)' == 'net452' ">
     <!-- Required for WebRequestHandler -->
     <Reference Include="System.Net.Http.WebRequest" />
 
     <PackageReference Include="Microsoft.AspNet.WebApi.OwinSelfHost" Version="5.2.6" />
     <PackageReference Include="System.ValueTuple" Version="4.5.0" />
-    <PackageReference Include="Microsoft.CodeDom.Providers.DotNetCompilerPlatform" Version="2.0.1" />
-  </ItemGroup>
-
-  <ItemGroup Condition=" '$(TargetFramework)' == 'net452' ">
-    <!-- Required for WebRequestHandler -->
-    <Reference Include="System.Net.Http.WebRequest" />
-
-    <PackageReference Include="Microsoft.AspNet.WebApi.OwinSelfHost" Version="5.2.6" />
-    <PackageReference Include="System.ValueTuple" Version="4.5.0" />
-    <PackageReference Include="Microsoft.CodeDom.Providers.DotNetCompilerPlatform" Version="2.0.1" />
+    <PackageReference Include="Scriban.Signed" Version="2.1.4" />
   </ItemGroup>
 
   <ItemGroup Condition=" '$(TargetFramework)' == 'net46' ">
@@ -97,16 +95,15 @@
     <PackageReference Include="Microsoft.Owin.Hosting" Version="4.0.0" />
     <PackageReference Include="System.Net.Http" Version="4.3.3" />
     <PackageReference Include="System.ValueTuple" Version="4.5.0" />
-    <PackageReference Include="CS-Script" Version="3.29.0" />
+    <PackageReference Include="Scriban.Signed" Version="2.1.4" />
   </ItemGroup>
 
   <ItemGroup Condition=" '$(TargetFramework)' == 'net461' ">
+    <PackageReference Include="Scriban.Signed" Version="2.1.4" />
     <PackageReference Include="Microsoft.AspNetCore" Version="2.2.0" />
 
     <!-- https://github.com/WireMock-Net/WireMock.Net/issues/507 -->
     <PackageReference Include="Microsoft.AspNetCore.Server.IIS" Version="2.2.6" />
-
-    <PackageReference Include="CS-Script" Version="3.29.0" />
   </ItemGroup>
 
   <ItemGroup Condition=" '$(TargetFramework)' == 'netstandard1.3' ">
@@ -115,36 +112,20 @@
     <PackageReference Include="System.Xml.XmlDocument" Version="4.3.0" />
     <PackageReference Include="System.Xml.XPath.XmlDocument" Version="4.3.0" />
     <PackageReference Include="System.ValueTuple" Version="4.5.0" />
+    <PackageReference Include="Scriban.Signed" Version="2.1.4" />
   </ItemGroup>
 
-  <ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0'">
+  <ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.0' or '$(TargetFramework)' == 'netstandard2.1' ">
+    <PackageReference Include="Scriban.Signed" Version="3.3.2" />
     <PackageReference Include="Microsoft.AspNetCore" Version="2.2.0" />
 
     <!-- https://github.com/WireMock-Net/WireMock.Net/issues/507 -->
     <PackageReference Include="Microsoft.AspNetCore.Server.IIS" Version="2.2.6" />
-    <PackageReference Include="CS-Script.Core" Version="1.1.1" />
   </ItemGroup>
 
-  <ItemGroup Condition=" '$(TargetFramework)' == 'netstandard2.1'">
-    <PackageReference Include="Microsoft.AspNetCore" Version="2.2.0" />
-
-    <!-- https://github.com/WireMock-Net/WireMock.Net/issues/507 -->
-    <PackageReference Include="Microsoft.AspNetCore.Server.IIS" Version="2.2.6" />
-
-    <!-- https://github.com/WireMock-Net/WireMock.Net/issues/448 -->
-    <PackageReference Include="CS-Script.Core" Version="1.3.1" />
-  </ItemGroup>
-
-  <ItemGroup Condition=" '$(TargetFramework)' == 'netcoreapp3.1'">
+  <ItemGroup Condition=" '$(TargetFramework)' == 'netcoreapp3.1' or '$(TargetFramework)' == 'net5.0'">
     <FrameworkReference Include="Microsoft.AspNetCore.App" />
-    <!-- https://github.com/WireMock-Net/WireMock.Net/issues/448 -->
-    <PackageReference Include="CS-Script.Core" Version="1.4.0" />
-  </ItemGroup>
-
-  <ItemGroup Condition=" '$(TargetFramework)' == 'net5.0'">
-    <FrameworkReference Include="Microsoft.AspNetCore.App" />
-    <!-- https://github.com/WireMock-Net/WireMock.Net/issues/448 -->
-    <PackageReference Include="CS-Script.Core" Version="1.4.0" />
+    <PackageReference Include="Scriban.Signed" Version="3.3.2" />
   </ItemGroup>
 
   <ItemGroup>

test/WireMock.Net.Tests/Owin/WireMockMiddlewareTests.cs

@@ -1,141 +1,250 @@
-using System;
-using System.Collections.Concurrent;
-using System.Linq.Expressions;
-using System.Threading.Tasks;
-using Moq;
-using Xunit;
-using WireMock.Models;
-using WireMock.Owin;
-using WireMock.Owin.Mappers;
-using WireMock.Util;
-using WireMock.Logging;
-using WireMock.Matchers;
-using System.Collections.Generic;
-using WireMock.Admin.Mappings;
-using WireMock.Admin.Requests;
-#if NET452
-using Microsoft.Owin;
-using IContext = Microsoft.Owin.IOwinContext;
-using IRequest = Microsoft.Owin.IOwinRequest;
-using IResponse = Microsoft.Owin.IOwinResponse;
-#else
-using Microsoft.AspNetCore.Http;
-using IContext = Microsoft.AspNetCore.Http.HttpContext;
-using IRequest = Microsoft.AspNetCore.Http.HttpRequest;
-using IResponse = Microsoft.AspNetCore.Http.HttpResponse;
-#endif
-
-namespace WireMock.Net.Tests.Owin
-{
-    public class WireMockMiddlewareTests
-    {
-        private readonly WireMockMiddleware _sut;
-
-        private readonly Mock<IWireMockMiddlewareOptions> _optionsMock;
-        private readonly Mock<IOwinRequestMapper> _requestMapperMock;
-        private readonly Mock<IOwinResponseMapper> _responseMapperMock;
-        private readonly Mock<IMappingMatcher> _matcherMock;
-        private readonly Mock<IMapping> _mappingMock;
-        private readonly Mock<IContext> _contextMock;
-
-        public WireMockMiddlewareTests()
-        {
-            _optionsMock = new Mock<IWireMockMiddlewareOptions>();
-            _optionsMock.SetupAllProperties();
-            _optionsMock.Setup(o => o.Mappings).Returns(new ConcurrentDictionary<Guid, IMapping>());
-            _optionsMock.Setup(o => o.LogEntries).Returns(new ConcurrentObservableCollection<LogEntry>());
-            _optionsMock.Setup(o => o.Scenarios).Returns(new ConcurrentDictionary<string, ScenarioState>());
-            _optionsMock.Setup(o => o.Logger.Warn(It.IsAny<string>(), It.IsAny<object[]>()));
-            _optionsMock.Setup(o => o.Logger.Error(It.IsAny<string>(), It.IsAny<object[]>()));
-            _optionsMock.Setup(o => o.Logger.DebugRequestResponse(It.IsAny<LogEntryModel>(), It.IsAny<bool>()));
-
-            _requestMapperMock = new Mock<IOwinRequestMapper>();
-            _requestMapperMock.SetupAllProperties();
-            var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "GET", "::1");
-            _requestMapperMock.Setup(m => m.MapAsync(It.IsAny<IRequest>(), It.IsAny<IWireMockMiddlewareOptions>())).ReturnsAsync(request);
-
-            _responseMapperMock = new Mock<IOwinResponseMapper>();
-            _responseMapperMock.SetupAllProperties();
-            _responseMapperMock.Setup(m => m.MapAsync(It.IsAny<ResponseMessage>(), It.IsAny<IResponse>())).Returns(Task.FromResult(true));
-
-            _matcherMock = new Mock<IMappingMatcher>();
-            _matcherMock.SetupAllProperties();
-            _matcherMock.Setup(m => m.FindBestMatch(It.IsAny<RequestMessage>())).Returns((new MappingMatcherResult(), new MappingMatcherResult()));
-
-            _contextMock = new Mock<IContext>();
-
-            _mappingMock = new Mock<IMapping>();
-
-            _sut = new WireMockMiddleware(null, _optionsMock.Object, _requestMapperMock.Object, _responseMapperMock.Object, _matcherMock.Object);
-        }
-
-        [Fact]
-        public async void WireMockMiddleware_Invoke_NoMatch()
-        {
-            // Act
-            await _sut.Invoke(_contextMock.Object);
-
-            // Assert and Verify
-            _optionsMock.Verify(o => o.Logger.Warn(It.IsAny<string>(), It.IsAny<object[]>()), Times.Once);
-
-            Expression<Func<ResponseMessage, bool>> match = r => (int)r.StatusCode == 404 && ((StatusModel)r.BodyData.BodyAsJson).Status == "No matching mapping found";
-            _responseMapperMock.Verify(m => m.MapAsync(It.Is(match), It.IsAny<IResponse>()), Times.Once);
-        }
-
-        [Fact]
-        public async void WireMockMiddleware_Invoke_IsAdminInterface_EmptyHeaders_401()
-        {
-            // Assign
-            var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "GET", "::1", null, new Dictionary<string, string[]>());
-            _requestMapperMock.Setup(m => m.MapAsync(It.IsAny<IRequest>(), It.IsAny<IWireMockMiddlewareOptions>())).ReturnsAsync(request);
-
-            _optionsMock.SetupGet(o => o.AuthorizationMatcher).Returns(new ExactMatcher());
-            _mappingMock.SetupGet(m => m.IsAdminInterface).Returns(true);
-
-            var result = new MappingMatcherResult { Mapping = _mappingMock.Object };
-            _matcherMock.Setup(m => m.FindBestMatch(It.IsAny<RequestMessage>())).Returns((result, result));
-
-            // Act
-            await _sut.Invoke(_contextMock.Object);
-
-            // Assert and Verify
-            _optionsMock.Verify(o => o.Logger.Error(It.IsAny<string>(), It.IsAny<object[]>()), Times.Once);
-
-            Expression<Func<ResponseMessage, bool>> match = r => (int)r.StatusCode == 401;
-            _responseMapperMock.Verify(m => m.MapAsync(It.Is(match), It.IsAny<IResponse>()), Times.Once);
-        }
-
-        [Fact]
-        public async void WireMockMiddleware_Invoke_IsAdminInterface_MissingHeader_401()
-        {
-            // Assign
-            var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "GET", "::1", null, new Dictionary<string, string[]> { { "h", new[] { "x" } } });
-            _requestMapperMock.Setup(m => m.MapAsync(It.IsAny<IRequest>(), It.IsAny<IWireMockMiddlewareOptions>())).ReturnsAsync(request);
-
-            _optionsMock.SetupGet(o => o.AuthorizationMatcher).Returns(new ExactMatcher());
-            _mappingMock.SetupGet(m => m.IsAdminInterface).Returns(true);
-
-            var result = new MappingMatcherResult { Mapping = _mappingMock.Object };
-            _matcherMock.Setup(m => m.FindBestMatch(It.IsAny<RequestMessage>())).Returns((result, result));
-
-            // Act
-            await _sut.Invoke(_contextMock.Object);
-
-            // Assert and Verify
-            _optionsMock.Verify(o => o.Logger.Error(It.IsAny<string>(), It.IsAny<object[]>()), Times.Once);
-
-            Expression<Func<ResponseMessage, bool>> match = r => (int)r.StatusCode == 401;
-            _responseMapperMock.Verify(m => m.MapAsync(It.Is(match), It.IsAny<IResponse>()), Times.Once);
-        }
-
-        [Fact]
-        public async void WireMockMiddleware_Invoke_RequestLogExpirationDurationIsDefined()
-        {
-            // Assign
-            _optionsMock.SetupGet(o => o.RequestLogExpirationDuration).Returns(1);
-
-            // Act
-            await _sut.Invoke(_contextMock.Object);
-        }
-    }
+using System;
+using System.Collections.Concurrent;
+using System.Linq.Expressions;
+using System.Threading.Tasks;
+using Moq;
+using Xunit;
+using WireMock.Models;
+using WireMock.Owin;
+using WireMock.Owin.Mappers;
+using WireMock.Util;
+using WireMock.Logging;
+using WireMock.Matchers;
+using System.Collections.Generic;
+using WireMock.Admin.Mappings;
+using WireMock.Admin.Requests;
+using WireMock.ResponseProviders;
+using WireMock.Settings;
+using FluentAssertions;
+using WireMock.Handlers;
+using WireMock.ResponseBuilders;
+using WireMock.RequestBuilders;
+#if NET452
+using Microsoft.Owin;
+using IContext = Microsoft.Owin.IOwinContext;
+using IRequest = Microsoft.Owin.IOwinRequest;
+using IResponse = Microsoft.Owin.IOwinResponse;
+#else
+using Microsoft.AspNetCore.Http;
+using IContext = Microsoft.AspNetCore.Http.HttpContext;
+using IRequest = Microsoft.AspNetCore.Http.HttpRequest;
+using IResponse = Microsoft.AspNetCore.Http.HttpResponse;
+#endif
+
+namespace WireMock.Net.Tests.Owin
+{
+    public class WireMockMiddlewareTests
+    {
+        private readonly WireMockMiddleware _sut;
+
+        private readonly Mock<IWireMockMiddlewareOptions> _optionsMock;
+        private readonly Mock<IOwinRequestMapper> _requestMapperMock;
+        private readonly Mock<IOwinResponseMapper> _responseMapperMock;
+        private readonly Mock<IMappingMatcher> _matcherMock;
+        private readonly Mock<IMapping> _mappingMock;
+        private readonly Mock<IContext> _contextMock;
+
+        private readonly ConcurrentDictionary<Guid, IMapping> _mappings = new ConcurrentDictionary<Guid, IMapping>();
+
+        public WireMockMiddlewareTests()
+        {
+            _optionsMock = new Mock<IWireMockMiddlewareOptions>();
+            _optionsMock.SetupAllProperties();
+            _optionsMock.Setup(o => o.Mappings).Returns(_mappings);
+            _optionsMock.Setup(o => o.LogEntries).Returns(new ConcurrentObservableCollection<LogEntry>());
+            _optionsMock.Setup(o => o.Scenarios).Returns(new ConcurrentDictionary<string, ScenarioState>());
+            _optionsMock.Setup(o => o.Logger.Warn(It.IsAny<string>(), It.IsAny<object[]>()));
+            _optionsMock.Setup(o => o.Logger.Error(It.IsAny<string>(), It.IsAny<object[]>()));
+            _optionsMock.Setup(o => o.Logger.DebugRequestResponse(It.IsAny<LogEntryModel>(), It.IsAny<bool>()));
+
+            _requestMapperMock = new Mock<IOwinRequestMapper>();
+            _requestMapperMock.SetupAllProperties();
+            var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "GET", "::1");
+            _requestMapperMock.Setup(m => m.MapAsync(It.IsAny<IRequest>(), It.IsAny<IWireMockMiddlewareOptions>())).ReturnsAsync(request);
+
+            _responseMapperMock = new Mock<IOwinResponseMapper>();
+            _responseMapperMock.SetupAllProperties();
+            _responseMapperMock.Setup(m => m.MapAsync(It.IsAny<ResponseMessage>(), It.IsAny<IResponse>())).Returns(Task.FromResult(true));
+
+            _matcherMock = new Mock<IMappingMatcher>();
+            _matcherMock.SetupAllProperties();
+            _matcherMock.Setup(m => m.FindBestMatch(It.IsAny<RequestMessage>())).Returns((new MappingMatcherResult(), new MappingMatcherResult()));
+
+            _contextMock = new Mock<IContext>();
+
+            _mappingMock = new Mock<IMapping>();
+
+            _sut = new WireMockMiddleware(null, _optionsMock.Object, _requestMapperMock.Object, _responseMapperMock.Object, _matcherMock.Object);
+        }
+
+        [Fact]
+        public async void WireMockMiddleware_Invoke_NoMatch()
+        {
+            // Act
+            await _sut.Invoke(_contextMock.Object);
+
+            // Assert and Verify
+            _optionsMock.Verify(o => o.Logger.Warn(It.IsAny<string>(), It.IsAny<object[]>()), Times.Once);
+
+            Expression<Func<ResponseMessage, bool>> match = r => (int)r.StatusCode == 404 && ((StatusModel)r.BodyData.BodyAsJson).Status == "No matching mapping found";
+            _responseMapperMock.Verify(m => m.MapAsync(It.Is(match), It.IsAny<IResponse>()), Times.Once);
+        }
+
+        [Fact]
+        public async void WireMockMiddleware_Invoke_IsAdminInterface_EmptyHeaders_401()
+        {
+            // Assign
+            var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "GET", "::1", null, new Dictionary<string, string[]>());
+            _requestMapperMock.Setup(m => m.MapAsync(It.IsAny<IRequest>(), It.IsAny<IWireMockMiddlewareOptions>())).ReturnsAsync(request);
+
+            _optionsMock.SetupGet(o => o.AuthorizationMatcher).Returns(new ExactMatcher());
+            _mappingMock.SetupGet(m => m.IsAdminInterface).Returns(true);
+
+            var result = new MappingMatcherResult { Mapping = _mappingMock.Object };
+            _matcherMock.Setup(m => m.FindBestMatch(It.IsAny<RequestMessage>())).Returns((result, result));
+
+            // Act
+            await _sut.Invoke(_contextMock.Object);
+
+            // Assert and Verify
+            _optionsMock.Verify(o => o.Logger.Error(It.IsAny<string>(), It.IsAny<object[]>()), Times.Once);
+
+            Expression<Func<ResponseMessage, bool>> match = r => (int)r.StatusCode == 401;
+            _responseMapperMock.Verify(m => m.MapAsync(It.Is(match), It.IsAny<IResponse>()), Times.Once);
+        }
+
+        [Fact]
+        public async void WireMockMiddleware_Invoke_IsAdminInterface_MissingHeader_401()
+        {
+            // Assign
+            var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "GET", "::1", null, new Dictionary<string, string[]> { { "h", new[] { "x" } } });
+            _requestMapperMock.Setup(m => m.MapAsync(It.IsAny<IRequest>(), It.IsAny<IWireMockMiddlewareOptions>())).ReturnsAsync(request);
+
+            _optionsMock.SetupGet(o => o.AuthorizationMatcher).Returns(new ExactMatcher());
+            _mappingMock.SetupGet(m => m.IsAdminInterface).Returns(true);
+
+            var result = new MappingMatcherResult { Mapping = _mappingMock.Object };
+            _matcherMock.Setup(m => m.FindBestMatch(It.IsAny<RequestMessage>())).Returns((result, result));
+
+            // Act
+            await _sut.Invoke(_contextMock.Object);
+
+            // Assert and Verify
+            _optionsMock.Verify(o => o.Logger.Error(It.IsAny<string>(), It.IsAny<object[]>()), Times.Once);
+
+            Expression<Func<ResponseMessage, bool>> match = r => (int)r.StatusCode == 401;
+            _responseMapperMock.Verify(m => m.MapAsync(It.Is(match), It.IsAny<IResponse>()), Times.Once);
+        }
+
+        [Fact]
+        public async void WireMockMiddleware_Invoke_RequestLogExpirationDurationIsDefined()
+        {
+            // Assign
+            _optionsMock.SetupGet(o => o.RequestLogExpirationDuration).Returns(1);
+
+            // Act
+            await _sut.Invoke(_contextMock.Object);
+        }
+
+        [Fact]
+        public async void WireMockMiddleware_Invoke_Mapping_Has_ProxyAndRecordSettings_And_SaveMapping_Is_True()
+        {
+            // Assign
+            var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "GET", "::1", null, new Dictionary<string, string[]>());
+            _requestMapperMock.Setup(m => m.MapAsync(It.IsAny<IRequest>(), It.IsAny<IWireMockMiddlewareOptions>())).ReturnsAsync(request);
+
+            _optionsMock.SetupGet(o => o.AuthorizationMatcher).Returns(new ExactMatcher());
+
+            var fileSystemHandlerMock = new Mock<IFileSystemHandler>();
+            fileSystemHandlerMock.Setup(f => f.GetMappingFolder()).Returns("m");
+
+            var logger = new Mock<IWireMockLogger>();
+
+            var proxyAndRecordSettings = new ProxyAndRecordSettings
+            {
+                SaveMapping = true,
+                SaveMappingToFile = true
+            };
+
+            var settings = new WireMockServerSettings
+            {
+                FileSystemHandler = fileSystemHandlerMock.Object,
+                Logger = logger.Object
+            };
+
+            var responseBuilder = Response.Create().WithProxy(proxyAndRecordSettings);
+
+            _mappingMock.SetupGet(m => m.Provider).Returns(responseBuilder);
+            _mappingMock.SetupGet(m => m.Settings).Returns(settings);
+
+            _mappingMock.Setup(m => m.ProvideResponseAsync(It.IsAny<RequestMessage>())).ReturnsAsync(new ResponseMessage());
+
+            var requestBuilder = Request.Create().UsingAnyMethod();
+            _mappingMock.SetupGet(m => m.RequestMatcher).Returns(requestBuilder);
+
+            var result = new MappingMatcherResult { Mapping = _mappingMock.Object };
+            _matcherMock.Setup(m => m.FindBestMatch(It.IsAny<RequestMessage>())).Returns((result, result));
+
+            // Act
+            await _sut.Invoke(_contextMock.Object);
+
+            // Assert and Verify
+            fileSystemHandlerMock.Verify(f => f.WriteMappingFile(It.IsAny<string>(), It.IsAny<string>()), Times.Once);
+
+            _mappings.Count.Should().Be(1);
+        }
+
+        [Fact]
+        public async void WireMockMiddleware_Invoke_Mapping_Has_ProxyAndRecordSettings_And_SaveMapping_Is_False_But_WireMockServerSettings_SaveMapping_Is_True()
+        {
+            // Assign
+            var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "GET", "::1", null, new Dictionary<string, string[]>());
+            _requestMapperMock.Setup(m => m.MapAsync(It.IsAny<IRequest>(), It.IsAny<IWireMockMiddlewareOptions>())).ReturnsAsync(request);
+
+            _optionsMock.SetupGet(o => o.AuthorizationMatcher).Returns(new ExactMatcher());
+
+            var fileSystemHandlerMock = new Mock<IFileSystemHandler>();
+            fileSystemHandlerMock.Setup(f => f.GetMappingFolder()).Returns("m");
+
+            var logger = new Mock<IWireMockLogger>();
+
+            var proxyAndRecordSettings = new ProxyAndRecordSettings
+            {
+                SaveMapping = false,
+                SaveMappingToFile = false
+            };
+
+            var settings = new WireMockServerSettings
+            {
+                FileSystemHandler = fileSystemHandlerMock.Object,
+                Logger = logger.Object,
+                ProxyAndRecordSettings = new ProxyAndRecordSettings
+                {
+                    SaveMapping = true,
+                    SaveMappingToFile = true
+                }
+            };
+
+            var responseBuilder = Response.Create().WithProxy(proxyAndRecordSettings);
+
+            _mappingMock.SetupGet(m => m.Provider).Returns(responseBuilder);
+            _mappingMock.SetupGet(m => m.Settings).Returns(settings);
+
+            _mappingMock.Setup(m => m.ProvideResponseAsync(It.IsAny<RequestMessage>())).ReturnsAsync(new ResponseMessage());
+
+            var requestBuilder = Request.Create().UsingAnyMethod();
+            _mappingMock.SetupGet(m => m.RequestMatcher).Returns(requestBuilder);
+
+            var result = new MappingMatcherResult { Mapping = _mappingMock.Object };
+            _matcherMock.Setup(m => m.FindBestMatch(It.IsAny<RequestMessage>())).Returns((result, result));
+
+            // Act
+            await _sut.Invoke(_contextMock.Object);
+
+            // Assert and Verify
+            fileSystemHandlerMock.Verify(f => f.WriteMappingFile(It.IsAny<string>(), It.IsAny<string>()), Times.Once);
+
+            _mappings.Count.Should().Be(1);
+        }
+    }
 }

test/WireMock.Net.Tests/Plugin/PluginLoaderTests.cs

@@ -0,0 +1,35 @@
+using System;
+using FluentAssertions;
+using WireMock.Matchers;
+using WireMock.Plugin;
+using Xunit;
+
+namespace WireMock.Net.Tests.Plugin
+{
+    public class PluginLoaderTests
+    {
+        public interface IDummy
+        {
+        }
+
+        [Fact]
+        public void Load_Valid()
+        {
+            // Act
+            var result = PluginLoader.Load<ICSharpCodeMatcher>(MatchBehaviour.AcceptOnMatch, "x");
+
+            // Assert
+            result.Should().NotBeNull();
+        }
+
+        [Fact]
+        public void Load_Invalid_ThrowsException()
+        {
+            // Act
+            Action a = () => PluginLoader.Load<IDummy>();
+
+            // Assert
+            a.Should().Throw<DllNotFoundException>();
+        }
+    }
+}

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

@@ -1,8 +1,10 @@
 using System;
 using System.Text;
 using System.Threading.Tasks;
+using Moq;
 using Newtonsoft.Json.Linq;
 using NFluent;
+using WireMock.Handlers;
 using WireMock.Models;
 using WireMock.ResponseBuilders;
 using WireMock.Settings;
@@ -14,9 +16,19 @@ namespace WireMock.Net.Tests.ResponseBuilders
 {
     public class ResponseWithBodyTests
     {
-        private readonly WireMockServerSettings _settings = new WireMockServerSettings();
         private const string ClientIp = "::1";
 
+        private readonly Mock<IFileSystemHandler> _filesystemHandlerMock;
+        private readonly WireMockServerSettings _settings = new WireMockServerSettings();
+
+        public ResponseWithBodyTests()
+        {
+            _filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
+            _filesystemHandlerMock.Setup(fs => fs.ReadResponseBodyAsString(It.IsAny<string>())).Returns("abc");
+
+            _settings.FileSystemHandler = _filesystemHandlerMock.Object;
+        }
+
         [Fact]
         public async Task Response_ProvideResponse_WithBody_Bytes_Encoding_Destination_String()
         {

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

@@ -1,5 +1,7 @@
 using System.Threading.Tasks;
 using FluentAssertions;
+using Moq;
+using WireMock.Handlers;
 using WireMock.Models;
 using WireMock.ResponseBuilders;
 using WireMock.Settings;
@@ -11,8 +13,19 @@ namespace WireMock.Net.Tests.ResponseBuilders
 {
     public class ResponseWithCallbackTests
     {
+        private const string ClientIp = "::1";
+
+        private readonly Mock<IFileSystemHandler> _filesystemHandlerMock;
         private readonly WireMockServerSettings _settings = new WireMockServerSettings();
 
+        public ResponseWithCallbackTests()
+        {
+            _filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
+            _filesystemHandlerMock.Setup(fs => fs.ReadResponseBodyAsString(It.IsAny<string>())).Returns("abc");
+
+            _settings.FileSystemHandler = _filesystemHandlerMock.Object;
+        }
+
         [Fact]
         public async Task Response_WithCallbackAsync()
         {

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

@@ -1,6 +1,5 @@
-using FluentAssertions;
-using Moq;
-using System.Threading.Tasks;
+using System.Threading.Tasks;
+using FluentAssertions;
 using WireMock.Models;
 using WireMock.ResponseBuilders;
 using WireMock.Settings;

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

@@ -1,5 +1,7 @@
 using System.Threading.Tasks;
+using Moq;
 using NFluent;
+using WireMock.Handlers;
 using WireMock.Models;
 using WireMock.ResponseBuilders;
 using WireMock.Settings;
@@ -11,9 +13,19 @@ namespace WireMock.Net.Tests.ResponseBuilders
 {
     public class ResponseWithHandlebarsHelpersTests
     {
-        private readonly WireMockServerSettings _settings = new WireMockServerSettings();
         private const string ClientIp = "::1";
 
+        private readonly Mock<IFileSystemHandler> _filesystemHandlerMock;
+        private readonly WireMockServerSettings _settings = new WireMockServerSettings();
+
+        public ResponseWithHandlebarsHelpersTests()
+        {
+            _filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
+            _filesystemHandlerMock.Setup(fs => fs.ReadResponseBodyAsString(It.IsAny<string>())).Returns("abc");
+
+            _settings.FileSystemHandler = _filesystemHandlerMock.Object;
+        }
+
         [Fact]
         public async Task Response_ProvideResponseAsync_HandlebarsHelpers_String_Uppercase()
         {

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

@@ -1,7 +1,11 @@
 using System;
+using System.Text;
 using System.Threading.Tasks;
+using Moq;
+using Newtonsoft.Json;
 using Newtonsoft.Json.Linq;
 using NFluent;
+using WireMock.Handlers;
 using WireMock.Models;
 using WireMock.ResponseBuilders;
 using WireMock.Settings;
@@ -13,9 +17,19 @@ namespace WireMock.Net.Tests.ResponseBuilders
 {
     public class ResponseWithHandlebarsJsonPathTests
     {
-        private readonly WireMockServerSettings _settings = new WireMockServerSettings();
         private const string ClientIp = "::1";
 
+        private readonly Mock<IFileSystemHandler> _filesystemHandlerMock;
+        private readonly WireMockServerSettings _settings = new WireMockServerSettings();
+
+        public ResponseWithHandlebarsJsonPathTests()
+        {
+            _filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
+            _filesystemHandlerMock.Setup(fs => fs.ReadResponseBodyAsString(It.IsAny<string>())).Returns("abc");
+
+            _settings.FileSystemHandler = _filesystemHandlerMock.Object;
+        }
+
         [Fact]
         public async Task Response_ProvideResponse_Handlebars_JsonPath_SelectToken_Object_ResponseBodyAsJson()
         {
@@ -333,5 +347,32 @@ namespace WireMock.Net.Tests.ResponseBuilders
             // Act
             Check.ThatAsyncCode(() => response.ProvideResponseAsync(request, _settings)).Throws<ArgumentNullException>();
         }
+
+        [Fact]
+        public async Task Response_ProvideResponse_Transformer_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, _settings);
+
+            // Assert
+            Check.That(responseMessage.BodyData.BodyAsFile).Equals(@"c:\1\test.json");
+        }
     }
 }

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

@@ -1,7 +1,9 @@
 using System;
 using System.Threading.Tasks;
+using Moq;
 using Newtonsoft.Json.Linq;
 using NFluent;
+using WireMock.Handlers;
 using WireMock.Models;
 using WireMock.ResponseBuilders;
 using WireMock.Settings;
@@ -13,8 +15,17 @@ namespace WireMock.Net.Tests.ResponseBuilders
 {
     public class ResponseWithHandlebarsLinqTests
     {
+        private readonly Mock<IFileSystemHandler> _filesystemHandlerMock;
         private readonly WireMockServerSettings _settings = new WireMockServerSettings();
 
+        public ResponseWithHandlebarsLinqTests()
+        {
+            _filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
+            _filesystemHandlerMock.Setup(fs => fs.ReadResponseBodyAsString(It.IsAny<string>())).Returns("abc");
+
+            _settings.FileSystemHandler = _filesystemHandlerMock.Object;
+        }
+
         [Fact]
         public async Task Response_ProvideResponse_Handlebars_Linq1_String0()
         {

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

@@ -1,7 +1,9 @@
 using System.Linq;
 using System.Threading.Tasks;
+using Moq;
 using Newtonsoft.Json.Linq;
 using NFluent;
+using WireMock.Handlers;
 using WireMock.Models;
 using WireMock.ResponseBuilders;
 using WireMock.Settings;
@@ -11,9 +13,19 @@ namespace WireMock.Net.Tests.ResponseBuilders
 {
     public class ResponseWithHandlebarsRandomTests
     {
-        private readonly WireMockServerSettings _settings = new WireMockServerSettings();
         private const string ClientIp = "::1";
 
+        private readonly Mock<IFileSystemHandler> _filesystemHandlerMock;
+        private readonly WireMockServerSettings _settings = new WireMockServerSettings();
+
+        public ResponseWithHandlebarsRandomTests()
+        {
+            _filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
+            _filesystemHandlerMock.Setup(fs => fs.ReadResponseBodyAsString(It.IsAny<string>())).Returns("abc");
+
+            _settings.FileSystemHandler = _filesystemHandlerMock.Object;
+        }
+
         [Fact]
         public async Task Response_ProvideResponseAsync_Handlebars_Random1()
         {

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

@@ -1,6 +1,8 @@
 using System;
 using System.Threading.Tasks;
+using Moq;
 using NFluent;
+using WireMock.Handlers;
 using WireMock.Models;
 using WireMock.ResponseBuilders;
 using WireMock.Settings;
@@ -12,9 +14,19 @@ namespace WireMock.Net.Tests.ResponseBuilders
 {
     public class ResponseWithHandlebarsRegexTests
     {
-        private readonly WireMockServerSettings _settings = new WireMockServerSettings();
         private const string ClientIp = "::1";
 
+        private readonly Mock<IFileSystemHandler> _filesystemHandlerMock;
+        private readonly WireMockServerSettings _settings = new WireMockServerSettings();
+
+        public ResponseWithHandlebarsRegexTests()
+        {
+            _filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
+            _filesystemHandlerMock.Setup(fs => fs.ReadResponseBodyAsString(It.IsAny<string>())).Returns("abc");
+
+            _settings.FileSystemHandler = _filesystemHandlerMock.Object;
+        }
+
         [Fact]
         public async Task Response_ProvideResponseAsync_Handlebars_RegexMatch()
         {

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

@@ -7,6 +7,8 @@ using WireMock.Settings;
 using WireMock.Types;
 using WireMock.Util;
 using Xunit;
+using Moq;
+using WireMock.Handlers;
 #if !NETSTANDARD1_3
 using Wmhelp.XPath2;
 #endif
@@ -15,9 +17,19 @@ namespace WireMock.Net.Tests.ResponseBuilders
 {
     public class ResponseWithHandlebarsXPathTests
     {
-        private readonly WireMockServerSettings _settings = new WireMockServerSettings();
         private const string ClientIp = "::1";
 
+        private readonly Mock<IFileSystemHandler> _filesystemHandlerMock;
+        private readonly WireMockServerSettings _settings = new WireMockServerSettings();
+
+        public ResponseWithHandlebarsXPathTests()
+        {
+            _filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
+            _filesystemHandlerMock.Setup(fs => fs.ReadResponseBodyAsString(It.IsAny<string>())).Returns("abc");
+
+            _settings.FileSystemHandler = _filesystemHandlerMock.Object;
+        }
+
         [Fact]
         public async Task Response_ProvideResponse_Handlebars_XPath_SelectSingleNode_Request_BodyAsString()
         {

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

@@ -2,6 +2,7 @@
 using Newtonsoft.Json.Linq;
 using NFluent;
 using System.Threading.Tasks;
+using WireMock.Handlers;
 using WireMock.Models;
 using WireMock.ResponseBuilders;
 using WireMock.Settings;
@@ -11,9 +12,19 @@ namespace WireMock.Net.Tests.ResponseBuilders
 {
     public class ResponseWithHandlebarsXegerTests
     {
-        private readonly WireMockServerSettings _settings = new WireMockServerSettings();
         private const string ClientIp = "::1";
 
+        private readonly Mock<IFileSystemHandler> _filesystemHandlerMock;
+        private readonly WireMockServerSettings _settings = new WireMockServerSettings();
+
+        public ResponseWithHandlebarsXegerTests()
+        {
+            _filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
+            _filesystemHandlerMock.Setup(fs => fs.ReadResponseBodyAsString(It.IsAny<string>())).Returns("abc");
+
+            _settings.FileSystemHandler = _filesystemHandlerMock.Object;
+        }
+
         [Fact]
         public async Task Response_ProvideResponseAsync_Handlebars_Xeger1()
         {

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

@@ -0,0 +1,74 @@
+using System;
+using System.Threading.Tasks;
+using FluentAssertions;
+using NFluent;
+using WireMock.Models;
+using WireMock.ResponseBuilders;
+using WireMock.Settings;
+using WireMock.Types;
+using WireMock.Util;
+using Xunit;
+using WireMock.Handlers;
+using Moq;
+#if NET452
+using Microsoft.Owin;
+#else
+using Microsoft.AspNetCore.Http;
+#endif
+
+namespace WireMock.Net.Tests.ResponseBuilders
+{
+    public class ResponseWithScribanTests
+    {
+        private const string ClientIp = "::1";
+
+        private readonly Mock<IFileSystemHandler> _filesystemHandlerMock;
+        private readonly WireMockServerSettings _settings = new WireMockServerSettings();
+
+        public ResponseWithScribanTests()
+        {
+            _filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
+            _filesystemHandlerMock.Setup(fs => fs.ReadResponseBodyAsString(It.IsAny<string>())).Returns("abc");
+
+            _settings.FileSystemHandler = _filesystemHandlerMock.Object;
+        }
+
+        [Fact]
+        public async Task Response_ProvideResponse_DotLiquid_WithNullBody_ShouldNotThrowException()
+        {
+            // Assign
+            var urlDetails = UrlUtils.Parse(new Uri("http://localhost/wiremock/a/b"), new PathString("/wiremock"));
+            var request = new RequestMessage(urlDetails, "GET", ClientIp);
+
+            var response = Response.Create().WithTransformer(TransformerType.ScribanDotLiquid);
+
+            // Act
+            var responseMessage = await response.ProvideResponseAsync(request, _settings);
+
+            // Assert
+            responseMessage.BodyData.Should().BeNull();
+        }
+
+        [Fact]
+        public async Task Response_ProvideResponse_DotLiquid_UrlPathVerb()
+        {
+            // Assign
+            var body = new BodyData
+            {
+                BodyAsString = "whatever",
+                DetectedBodyType = BodyType.String
+            };
+            var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "POSt", ClientIp, body);
+
+            var response = Response.Create()
+                .WithBody("test {{request.Url}} {{request.Path}} {{request.Method}}")
+                .WithTransformer(TransformerType.Scriban);
+
+            // Act
+            var responseMessage = await response.ProvideResponseAsync(request, _settings);
+
+            // Assert
+            Check.That(responseMessage.BodyData.BodyAsString).Equals("test http://localhost/foo /foo POSt");
+        }
+    }
+}

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

@@ -20,6 +20,50 @@ namespace WireMock.Net.Tests.Serialization
             _sut = new MatcherMapper(_settings);
         }
 
+        [Fact]
+        public void MatcherModelMapper_Map_CSharpCodeMatcher()
+        {
+            // Assign
+            var model = new MatcherModel
+            {
+                Name = "CSharpCodeMatcher",
+                Patterns = new[] { "return it == \"x\";" }
+            };
+            var sut = new MatcherMapper(new WireMockServerSettings { AllowCSharpCodeMatcher = true });
+
+            // Act 1
+            var matcher1 = (ICSharpCodeMatcher)sut.Map(model);
+
+            // Assert 1
+            matcher1.Should().NotBeNull();
+            matcher1.IsMatch("x").Should().Be(1.0d);
+
+            // Act 2
+            var matcher2 = (ICSharpCodeMatcher)sut.Map(model);
+
+            // Assert 2
+            matcher2.Should().NotBeNull();
+            matcher2.IsMatch("x").Should().Be(1.0d);
+        }
+
+        [Fact]
+        public void MatcherModelMapper_Map_CSharpCodeMatcher_NotAllowed_ThrowsException()
+        {
+            // Assign
+            var model = new MatcherModel
+            {
+                Name = "CSharpCodeMatcher",
+                Patterns = new[] { "x" }
+            };
+            var sut = new MatcherMapper(new WireMockServerSettings { AllowCSharpCodeMatcher = false });
+
+            // Act
+            Action action = () => sut.Map(model);
+
+            // Assert
+            action.Should().Throw<NotSupportedException>();
+        }
+
         [Fact]
         public void MatcherModelMapper_Map_Null()
         {

test/WireMock.Net.Tests/Transformers/Handlebars/HandlebarsContextFactoryTests.cs

@@ -1,52 +1,52 @@
-using FluentAssertions;
-using HandlebarsDotNet;
-using Moq;
-using System;
-using WireMock.Handlers;
-using WireMock.Transformers;
-using Xunit;
-
-namespace WireMock.Net.Tests.Transformers
-{
-    public class HandlebarsContextFactoryTests
-    {
-        private readonly Mock<IFileSystemHandler> _fileSystemHandlerMock = new Mock<IFileSystemHandler>();
-
-        [Fact]
-        public void Create_WithNullAction_DoesNotInvokeAction()
-        {
-            // Arrange
-            var sut = new HandlebarsContextFactory(_fileSystemHandlerMock.Object, null);
-
-            // Act
-            var result = sut.Create();
-
-            // Assert
-            result.Should().NotBeNull();
-        }
-
-        [Fact]
-        public void Create_WithAction_InvokesAction()
-        {
-            // Arrange
-            int num = 0;
-            Action<IHandlebars, IFileSystemHandler> action = (ctx, fs) =>
-            {
-                ctx.Should().NotBeNull();
-                fs.Should().NotBeNull();
-
-                num++;
-            };
-            var sut = new HandlebarsContextFactory(_fileSystemHandlerMock.Object, action);
-
-            // Act
-            var result = sut.Create();
-
-            // Assert
-            result.Should().NotBeNull();
-
-            // Verify
-            num.Should().Be(1);
-        }
-    }
-}
+using FluentAssertions;
+using HandlebarsDotNet;
+using Moq;
+using System;
+using WireMock.Handlers;
+using WireMock.Transformers.Handlebars;
+using Xunit;
+
+namespace WireMock.Net.Tests.Transformers.Handlebars
+{
+    public class HandlebarsContextFactoryTests
+    {
+        private readonly Mock<IFileSystemHandler> _fileSystemHandlerMock = new Mock<IFileSystemHandler>();
+
+        [Fact]
+        public void Create_WithNullAction_DoesNotInvokeAction()
+        {
+            // Arrange
+            var sut = new HandlebarsContextFactory(_fileSystemHandlerMock.Object, null);
+
+            // Act
+            var result = sut.Create();
+
+            // Assert
+            result.Should().NotBeNull();
+        }
+
+        [Fact]
+        public void Create_WithAction_InvokesAction()
+        {
+            // Arrange
+            int num = 0;
+            Action<IHandlebars, IFileSystemHandler> action = (ctx, fs) =>
+            {
+                ctx.Should().NotBeNull();
+                fs.Should().NotBeNull();
+
+                num++;
+            };
+            var sut = new HandlebarsContextFactory(_fileSystemHandlerMock.Object, action);
+
+            // Act
+            var result = sut.Create();
+
+            // Assert
+            result.Should().NotBeNull();
+
+            // Verify
+            num.Should().Be(1);
+        }
+    }
+}

test/WireMock.Net.Tests/Transformers/Scriban/ScribanContextFactoryTests.cs

@@ -0,0 +1,40 @@
+using System;
+using FluentAssertions;
+using Moq;
+using WireMock.Handlers;
+using WireMock.Transformers.Scriban;
+using WireMock.Types;
+using Xunit;
+
+namespace WireMock.Net.Tests.Transformers.Scriban
+{
+    public class ScribanContextFactoryTests
+    {
+        private readonly Mock<IFileSystemHandler> _fileSystemHandlerMock = new Mock<IFileSystemHandler>();
+
+        [Theory]
+        [InlineData(TransformerType.Scriban)]
+        [InlineData(TransformerType.ScribanDotLiquid)]
+        public void Create_With_Scriban_TransformerType_Creates_ITransformerContext(TransformerType transformerType)
+        {
+            // Arrange
+            var sut = new ScribanContextFactory(_fileSystemHandlerMock.Object, transformerType);
+
+            // Act
+            var result = sut.Create();
+
+            // Assert
+            result.Should().NotBeNull();
+        }
+
+        [Fact]
+        public void Create_With_Invalid_TransformerType_Throws_Exception()
+        {
+            // Act
+            Action action = () => new ScribanContextFactory(_fileSystemHandlerMock.Object, TransformerType.Handlebars);
+
+            // Assert
+            action.Should().Throw<Exception>();
+        }
+    }
+}

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

@@ -2,7 +2,7 @@
 
   <PropertyGroup>
     <Authors>Stef Heyenrath</Authors>
-    <TargetFrameworks>net452;netcoreapp3.1;net5.0</TargetFrameworks>
+    <TargetFrameworks>net452;net461;netcoreapp3.1;net5.0</TargetFrameworks>
     <IsPackable>false</IsPackable>
     <DebugType>full</DebugType>
     <AssemblyName>WireMock.Net.Tests</AssemblyName>
@@ -26,6 +26,7 @@
   <ItemGroup>
     <ProjectReference Include="..\..\src\WireMock.Net.Abstractions\WireMock.Net.Abstractions.csproj" />
     <ProjectReference Include="..\..\src\WireMock.Net.FluentAssertions\WireMock.Net.FluentAssertions.csproj" />
+    <ProjectReference Include="..\..\src\WireMock.Net.Matchers.CSharpCode\WireMock.Net.Matchers.CSharpCode.csproj" />
     <ProjectReference Include="..\..\src\WireMock.Net.RestClient\WireMock.Net.RestClient.csproj" />
     <ProjectReference Include="..\..\src\WireMock.Net\WireMock.Net.csproj" />
   </ItemGroup>

test/WireMock.Net.Tests/WireMockAdminApiTests.cs

@@ -1,4 +1,5 @@
-using System;
+#if !NET452 && !NET461
+using System;
 using System.Linq;
 using System.Net.Http;
 using System.Net.Http.Headers;
@@ -552,4 +553,5 @@ namespace WireMock.Net.Tests
             server.Stop();
         }
     }
-}
+}
+#endif

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

@@ -6,13 +6,16 @@ using System.Net.Http.Headers;
 using System.Text;
 using System.Threading.Tasks;
 using FluentAssertions;
+using Moq;
 using NFluent;
 using WireMock.Admin.Mappings;
+using WireMock.Handlers;
 using WireMock.Matchers.Request;
 using WireMock.RequestBuilders;
 using WireMock.ResponseBuilders;
 using WireMock.Server;
 using WireMock.Settings;
+using WireMock.Util;
 using Xunit;
 
 namespace WireMock.Net.Tests
@@ -50,6 +53,69 @@ namespace WireMock.Net.Tests
             Check.That(server.LogEntries).HasSize(1);
         }
 
+        [Fact]
+        public async Task WireMockServer_Proxy_With_SaveMapping_Is_True_And_SaveMappingToFile_Is_False_Should_AddInternalMappingOnly()
+        {
+            // Assign
+            var settings = new WireMockServerSettings
+            {
+                ProxyAndRecordSettings = new ProxyAndRecordSettings
+                {
+                    Url = "http://www.google.com",
+                    SaveMapping = true,
+                    SaveMappingToFile = false
+                }
+            };
+            var server = WireMockServer.Start(settings);
+
+            // Act
+            var requestMessage = new HttpRequestMessage
+            {
+                Method = HttpMethod.Get,
+                RequestUri = new Uri(server.Urls[0])
+            };
+            var httpClientHandler = new HttpClientHandler { AllowAutoRedirect = false };
+            await new HttpClient(httpClientHandler).SendAsync(requestMessage);
+
+            // Assert
+            server.Mappings.Should().HaveCount(2);
+        }
+
+        [Fact]
+        public async Task WireMockServer_Proxy_With_SaveMapping_Is_False_And_SaveMappingToFile_Is_True_ShouldSaveMappingToFile()
+        {
+            // Assign
+            var fileSystemHandlerMock = new Mock<IFileSystemHandler>();
+            fileSystemHandlerMock.Setup(f => f.GetMappingFolder()).Returns("m");
+
+            var settings = new WireMockServerSettings
+            {
+                ProxyAndRecordSettings = new ProxyAndRecordSettings
+                {
+                    Url = "http://www.google.com",
+                    SaveMapping = false,
+                    SaveMappingToFile = true
+                },
+                FileSystemHandler = fileSystemHandlerMock.Object
+            };
+            var server = WireMockServer.Start(settings);
+
+            // Act
+            var requestMessage = new HttpRequestMessage
+            {
+                Method = HttpMethod.Get,
+                RequestUri = new Uri(server.Urls[0])
+            };
+            var httpClientHandler = new HttpClientHandler { AllowAutoRedirect = false };
+            await new HttpClient(httpClientHandler).SendAsync(requestMessage);
+
+            // Assert
+            server.Mappings.Should().HaveCount(1);
+
+            // Verify
+            fileSystemHandlerMock.Verify(f => f.WriteMappingFile(It.IsAny<string>(), It.IsAny<string>()), Times.Once);
+        }
+
         [Fact]
         public async Task WireMockServer_Proxy_Should_log_proxied_requests()
         {
@@ -75,8 +141,8 @@ namespace WireMock.Net.Tests
             await new HttpClient(httpClientHandler).SendAsync(requestMessage);
 
             // Assert
-            Check.That(server.Mappings).HasSize(2);
-            Check.That(server.LogEntries).HasSize(1);
+            server.Mappings.Should().HaveCount(2);
+            server.LogEntries.Should().HaveCount(1);
         }
 
         [Fact]
@@ -148,10 +214,56 @@ namespace WireMock.Net.Tests
 
             // check that new proxied mapping is added
             Check.That(server.Mappings).HasSize(2);
+        }
 
-            //var newMapping = _server.Mappings.First(m => m.Guid != guid);
-            //var matcher = ((Request)newMapping.RequestMatcher).GetRequestMessageMatchers<RequestMessageHeaderMatcher>().FirstOrDefault(m => m.Name == "bbb");
-            //Check.That(matcher).IsNotNull();
+        [Fact]
+        public async Task WireMockServer_Proxy_Should_preserve_Authorization_header_in_proxied_request()
+        {
+            // Assign
+            string path = $"/prx_{Guid.NewGuid()}";
+            var serverForProxyForwarding = WireMockServer.Start();
+            serverForProxyForwarding
+                .Given(Request.Create().WithPath(path))
+                .RespondWith(Response.Create().WithCallback(x => new ResponseMessage
+                {
+                    BodyData = new BodyData
+                    {
+                        BodyAsString = x.Headers["Authorization"].ToString(),
+                        DetectedBodyType = Types.BodyType.String
+                    }
+                }));
+
+            var settings = new WireMockServerSettings
+            {
+                ProxyAndRecordSettings = new ProxyAndRecordSettings
+                {
+                    Url = serverForProxyForwarding.Urls[0],
+                    SaveMapping = true,
+                    SaveMappingToFile = false
+                }
+            };
+            var server = WireMockServer.Start(settings);
+
+            // Act
+            var requestMessage = new HttpRequestMessage
+            {
+                Method = HttpMethod.Post,
+                RequestUri = new Uri($"{server.Urls[0]}{path}"),
+                Content = new StringContent("stringContent", Encoding.ASCII)
+            };
+            requestMessage.Headers.Authorization = new AuthenticationHeaderValue("BASIC", "test-A");
+            var result = await new HttpClient().SendAsync(requestMessage);
+
+            // Assert
+            (await result.Content.ReadAsStringAsync()).Should().Be("BASIC test-A");
+
+            var receivedRequest = serverForProxyForwarding.LogEntries.First().RequestMessage;
+            var authorizationHeader = receivedRequest.Headers["Authorization"].ToString().Should().Be("BASIC test-A");
+
+            server.Mappings.Should().HaveCount(2);
+            var authorizationRequestMessageHeaderMatcher = ((Request)server.Mappings.Single(m => !m.IsAdminInterface).RequestMatcher)
+                .GetRequestMessageMatcher<RequestMessageHeaderMatcher>(x => x.Matchers.Any(m => m.GetPatterns().Contains("BASIC test-A")));
+            authorizationRequestMessageHeaderMatcher.Should().NotBeNull();
         }
 
         [Fact]

test/WireMock.Net.Tests/WireMockServerTests.cs

@@ -175,7 +175,7 @@ namespace WireMock.Net.Tests
             server.Stop();
         }
 
-#if !NET452
+#if !NET452 && !NET461
         [Theory]
         [InlineData("TRACE")]
         [InlineData("GET")]