1.0.21.0

* wip

* HandlebarsRegistrationCallback

* HandlebarsContextFactoryTests

* 1.0.21.0

* fix sonar

* LocalFileSystemHandler

* readme

* Fix System.IO.IOException

CHANGELOG.md

@@ -1,3 +1,16 @@
+# 1.0.21.0 (03 July 2019)
+- [#286](https://github.com/WireMock-Net/WireMock.Net/pull/286) - Handlebars Extension [feature] contributed by [StefH](https://github.com/StefH)
+- [#293](https://github.com/WireMock-Net/WireMock.Net/pull/293) - workaround for AppContext.BaseDirectory being null on some platforms contributed by [eli-darkly](https://github.com/eli-darkly)
+- [#294](https://github.com/WireMock-Net/WireMock.Net/pull/294) - don't strip request body if we don't recognize the request method contributed by [eli-darkly](https://github.com/eli-darkly)
+- [#275](https://github.com/WireMock-Net/WireMock.Net/issues/275) - Server not starting up with 1.0.15 code [invalid, question]
+- [#280](https://github.com/WireMock-Net/WireMock.Net/issues/280) - Static Mapping Not work [question]
+- [#285](https://github.com/WireMock-Net/WireMock.Net/issues/285) - Need ability to add custom ResponseMessageTransformers [feature, question]
+- [#288](https://github.com/WireMock-Net/WireMock.Net/issues/288) - Allow setting root folder in LocalFileSystemHandler [feature, question]
+- [#289](https://github.com/WireMock-Net/WireMock.Net/issues/289) - Bug:  When WatchStaticMappings=true throws exceptions on updating the mapping files [bug]
+- [#290](https://github.com/WireMock-Net/WireMock.Net/issues/290) - Request body is dropped if verb is REPORT [bug]
+- [#291](https://github.com/WireMock-Net/WireMock.Net/issues/291) - Define multiple scenarios for the same url path and switch to it at run-time? [question]
+- [#292](https://github.com/WireMock-Net/WireMock.Net/issues/292) - Can't start server in Xamarin Android [bug]
+
 # 1.0.20.0 (17 June 2019)
 - [#284](https://github.com/WireMock-Net/WireMock.Net/pull/284) - Add SaveToFile in the mapping [feature] contributed by [StefH](https://github.com/StefH)
 

Directory.Build.props

@@ -4,7 +4,7 @@
   </PropertyGroup>
 
   <PropertyGroup>
-    <VersionPrefix>1.0.20</VersionPrefix>
+    <VersionPrefix>1.0.21</VersionPrefix>
   </PropertyGroup>
 
   <Choose>

GitHubReleaseNotes.txt

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

README.md

@@ -3,12 +3,14 @@ A C# .NET version based on [mock4net](https://github.com/alexvictoor/mock4net) w
 
 ## Key Features
 * HTTP response stubbing, matchable on URL/Path, headers, cookies and body content patterns
-* Runs in unit tests, as a standalone process, as windows service, as Azure or IIS or as docker
+* Library can be used in unit tests and integration tests
+* Runs as a standalone process, as windows service, as Azure/IIS or as docker
 * Configurable via a fluent DotNet API, JSON files and JSON over HTTP
 * Record/playback of stubs (proxying)
 * Per-request conditional proxying
 * Stateful behaviour simulation
 * Response templating / transformation using Handlebars and extensions
+* Can be used locally or in CI/CD scenarios.
 
 ## Info
 | | |

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

@@ -33,7 +33,8 @@ namespace WireMock.Net.ConsoleApplication
                 PostWireMockMiddlewareInit = app => { System.Console.WriteLine($"PostWireMockMiddlewareInit : {app.GetType()}"); },
                 Logger = new WireMockConsoleLogger(),
 
-                FileSystemHandler = new CustomFileSystemFileHandler()
+                // Uncomment below if you want to use the CustomFileSystemFileHandler
+                // FileSystemHandler = new CustomFileSystemFileHandler()
             });
             System.Console.WriteLine("FluentMockServer listening at {0}", string.Join(",", server.Urls));
 

src/WireMock.Net/Handlers/LocalFileSystemHandler.cs

@@ -11,6 +11,24 @@ namespace WireMock.Handlers
     {
         private static readonly string AdminMappingsFolder = Path.Combine("__admin", "mappings");
 
+        private readonly string _rootFolder;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="LocalFileSystemHandler"/> class.
+        /// </summary>
+        public LocalFileSystemHandler() : this(Directory.GetCurrentDirectory())
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="LocalFileSystemHandler"/> class.
+        /// </summary>
+        /// <param name="rootFolder">The root folder.</param>
+        public LocalFileSystemHandler(string rootFolder)
+        {
+            _rootFolder = rootFolder;
+        }
+
         /// <inheritdoc cref="IFileSystemHandler.FolderExists"/>
         public bool FolderExists(string path)
         {
@@ -38,7 +56,7 @@ namespace WireMock.Handlers
         /// <inheritdoc cref="IFileSystemHandler.GetMappingFolder"/>
         public string GetMappingFolder()
         {
-            return Path.Combine(Directory.GetCurrentDirectory(), AdminMappingsFolder);
+            return Path.Combine(_rootFolder, AdminMappingsFolder);
         }
 
         /// <inheritdoc cref="IFileSystemHandler.ReadMappingFile"/>

src/WireMock.Net/IMapping.cs

@@ -1,9 +1,9 @@
 using JetBrains.Annotations;
 using System;
 using System.Threading.Tasks;
-using WireMock.Handlers;
 using WireMock.Matchers.Request;
 using WireMock.ResponseProviders;
+using WireMock.Settings;
 
 namespace WireMock
 {
@@ -62,9 +62,9 @@ namespace WireMock
         IResponseProvider Provider { get; }
 
         /// <summary>
-        /// The FileSystemHandler.
+        /// The FluentMockServerSettings.
         /// </summary>
-        IFileSystemHandler FileSystemHandler { get; }
+        IFluentMockServerSettings Settings { get; }
 
         /// <summary>
         /// Is State started ?

src/WireMock.Net/Mapping.cs

@@ -1,9 +1,9 @@
 using JetBrains.Annotations;
 using System;
 using System.Threading.Tasks;
-using WireMock.Handlers;
 using WireMock.Matchers.Request;
 using WireMock.ResponseProviders;
+using WireMock.Settings;
 
 namespace WireMock
 {
@@ -39,8 +39,8 @@ namespace WireMock
         /// <inheritdoc cref="IMapping.Provider" />
         public IResponseProvider Provider { get; }
 
-        /// <inheritdoc cref="IMapping.FileSystemHandler" />
-        public IFileSystemHandler FileSystemHandler { get; }
+        /// <inheritdoc cref="IMapping.Settings" />
+        public IFluentMockServerSettings Settings { get; }
 
         /// <inheritdoc cref="IMapping.IsStartState" />
         public bool IsStartState => Scenario == null || Scenario != null && NextState != null && ExecutionConditionState == null;
@@ -54,7 +54,7 @@ namespace WireMock
         /// <param name="guid">The unique identifier.</param>
         /// <param name="title">The unique title (can be null).</param>
         /// <param name="path">The full file path from this mapping title (can be null).</param>
-        /// <param name="fileSystemHandler">The fileSystemHandler.</param>
+        /// <param name="settings">The FluentMockServerSettings.</param>
         /// <param name="requestMatcher">The request matcher.</param>
         /// <param name="provider">The provider.</param>
         /// <param name="priority">The priority for this mapping.</param>
@@ -62,13 +62,13 @@ 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>
         public Mapping(Guid guid, [CanBeNull] string title, [CanBeNull] string path,
-            [NotNull] IFileSystemHandler fileSystemHandler, [NotNull] IRequestMatcher requestMatcher, [NotNull] IResponseProvider provider,
+            [NotNull] IFluentMockServerSettings settings, [NotNull] IRequestMatcher requestMatcher, [NotNull] IResponseProvider provider,
             int priority, [CanBeNull] string scenario, [CanBeNull] string executionConditionState, [CanBeNull] string nextState)
         {
             Guid = guid;
             Title = title;
             Path = path;
-            FileSystemHandler = fileSystemHandler;
+            Settings = settings;
             RequestMatcher = requestMatcher;
             Provider = provider;
             Priority = priority;
@@ -80,7 +80,7 @@ namespace WireMock
         /// <inheritdoc cref="IMapping.ResponseToAsync" />
         public async Task<ResponseMessage> ResponseToAsync(RequestMessage requestMessage)
         {
-            return await Provider.ProvideResponseAsync(requestMessage, FileSystemHandler);
+            return await Provider.ProvideResponseAsync(requestMessage, Settings);
         }
 
         /// <inheritdoc cref="IMapping.GetRequestMatchResult" />

src/WireMock.Net/Matchers/ExactObjectMatcher.cs

@@ -10,8 +10,14 @@ namespace WireMock.Matchers
     /// <seealso cref="IObjectMatcher" />
     public class ExactObjectMatcher : IObjectMatcher
     {
+        /// <summary>
+        /// Gets the value as object.
+        /// </summary>
         public object ValueAsObject { get; }
 
+        /// <summary>
+        /// Gets the value as byte[].
+        /// </summary>
         public byte[] ValueAsBytes { get; }
 
         /// <inheritdoc cref="IMatcher.MatchBehaviour"/>

src/WireMock.Net/Owin/AspNetCoreSelfHost.cs

@@ -56,7 +56,18 @@ namespace WireMock.Owin
 
         public Task StartAsync()
         {
-            _host = new WebHostBuilder()
+            var builder = new WebHostBuilder();
+
+            // Workaround for https://github.com/WireMock-Net/WireMock.Net/issues/292
+            // On some platforms, AppContext.BaseDirectory is null, which causes WebHostBuilder to fail if ContentRoot is not
+            // specified (even though we don't actually use that base path mechanism, since we have our own way of configuring
+            // a filesystem handler).
+            if (string.IsNullOrEmpty(AppContext.BaseDirectory))
+            {
+                builder.UseContentRoot(System.IO.Directory.GetCurrentDirectory());
+            }
+
+            _host = builder
                 .ConfigureServices(services =>
                 {
                     services.AddSingleton(_options.FileSystemHandler);

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

@@ -63,6 +63,7 @@ namespace WireMock.RequestBuilders
             return this;
         }
 
+        /// <inheritdoc cref="IParamsRequestBuilder.WithParam(string, MatchBehaviour, IStringMatcher[])"/>
         public IRequestBuilder WithParam(string key, MatchBehaviour matchBehaviour, params IStringMatcher[] matchers)
         {
             return WithParam(key, matchBehaviour, false, matchers);
@@ -77,7 +78,7 @@ namespace WireMock.RequestBuilders
             return this;
         }
 
-        /// <inheritdoc cref="IParamsRequestBuilder.WithParam(Func{IDictionary{string, WireMockList{T}}, bool}[])"/>
+        /// <inheritdoc cref="IParamsRequestBuilder.WithParam(Func{IDictionary{string, WireMockList{string}}, bool}[])"/>
         public IRequestBuilder WithParam(params Func<IDictionary<string, WireMockList<string>>, bool>[] funcs)
         {
             Check.NotNullOrEmpty(funcs, nameof(funcs));

src/WireMock.Net/ResponseBuilders/Response.cs

@@ -7,8 +7,8 @@ using System.Net;
 using System.Net.Http;
 using System.Text;
 using System.Threading.Tasks;
-using WireMock.Handlers;
 using WireMock.Http;
+using WireMock.ResponseProviders;
 using WireMock.Settings;
 using WireMock.Transformers;
 using WireMock.Util;
@@ -371,7 +371,8 @@ namespace WireMock.ResponseBuilders
             return this;
         }
 
-        public async Task<ResponseMessage> ProvideResponseAsync(RequestMessage requestMessage, IFileSystemHandler fileSystemHandler)
+        /// <inheritdoc cref="IResponseProvider.ProvideResponseAsync(RequestMessage, IFluentMockServerSettings)"/>
+        public async Task<ResponseMessage> ProvideResponseAsync(RequestMessage requestMessage, IFluentMockServerSettings settings)
         {
             Check.NotNull(requestMessage, nameof(requestMessage));
 
@@ -410,13 +411,14 @@ namespace WireMock.ResponseBuilders
 
             if (UseTransformer)
             {
-                var responseMessageTransformer = new ResponseMessageTransformer(fileSystemHandler);
+                var factory = new HandlebarsContextFactory(settings.FileSystemHandler, settings.HandlebarsRegistrationCallback);
+                var responseMessageTransformer = new ResponseMessageTransformer(factory);
                 return responseMessageTransformer.Transform(requestMessage, ResponseMessage);
             }
 
             if (!UseTransformer && ResponseMessage.BodyData?.BodyAsFileIsCached == true)
             {
-                ResponseMessage.BodyData.BodyAsBytes = fileSystemHandler.ReadResponseBodyAsFile(ResponseMessage.BodyData.BodyAsFile);
+                ResponseMessage.BodyData.BodyAsBytes = settings.FileSystemHandler.ReadResponseBodyAsFile(ResponseMessage.BodyData.BodyAsFile);
                 ResponseMessage.BodyData.BodyAsFile = null;
             }
 

src/WireMock.Net/ResponseProviders/DynamicAsyncResponseProvider.cs

@@ -1,6 +1,6 @@
 using System;
 using System.Threading.Tasks;
-using WireMock.Handlers;
+using WireMock.Settings;
 
 namespace WireMock.ResponseProviders
 {
@@ -13,7 +13,7 @@ namespace WireMock.ResponseProviders
             _responseMessageFunc = responseMessageFunc;
         }
 
-        public Task<ResponseMessage> ProvideResponseAsync(RequestMessage requestMessage, IFileSystemHandler fileSystemHandler)
+        public Task<ResponseMessage> ProvideResponseAsync(RequestMessage requestMessage, IFluentMockServerSettings settings)
         {
             return _responseMessageFunc(requestMessage);
         }

src/WireMock.Net/ResponseProviders/DynamicResponseProvider.cs

@@ -1,6 +1,6 @@
 using System;
 using System.Threading.Tasks;
-using WireMock.Handlers;
+using WireMock.Settings;
 
 namespace WireMock.ResponseProviders
 {
@@ -13,7 +13,7 @@ namespace WireMock.ResponseProviders
             _responseMessageFunc = responseMessageFunc;
         }
 
-        public Task<ResponseMessage> ProvideResponseAsync(RequestMessage requestMessage, IFileSystemHandler fileSystemHandler)
+        public Task<ResponseMessage> ProvideResponseAsync(RequestMessage requestMessage, IFluentMockServerSettings settings)
         {
             return Task.FromResult(_responseMessageFunc(requestMessage));
         }

src/WireMock.Net/ResponseProviders/IResponseProvider.cs

@@ -1,6 +1,6 @@
-using System.Threading.Tasks;
-using JetBrains.Annotations;
-using WireMock.Handlers;
+using JetBrains.Annotations;
+using System.Threading.Tasks;
+using WireMock.Settings;
 
 namespace WireMock.ResponseProviders
 {
@@ -13,8 +13,8 @@ namespace WireMock.ResponseProviders
         /// The provide response.
         /// </summary>
         /// <param name="requestMessage">The request.</param>
-        /// <param name="fileSystemHandler">The fileSystemHandler.</param>
+        /// <param name="settings">The FluentMockServerSettings.</param>
         /// <returns>The <see cref="ResponseMessage"/>.</returns>
-        Task<ResponseMessage> ProvideResponseAsync([NotNull] RequestMessage requestMessage, [NotNull] IFileSystemHandler fileSystemHandler);
+        Task<ResponseMessage> ProvideResponseAsync([NotNull] RequestMessage requestMessage, [NotNull] IFluentMockServerSettings settings);
     }
 }

src/WireMock.Net/ResponseProviders/ProxyAsyncResponseProvider.cs

@@ -1,6 +1,5 @@
 using System;
 using System.Threading.Tasks;
-using WireMock.Handlers;
 using WireMock.Settings;
 
 namespace WireMock.ResponseProviders
@@ -16,7 +15,7 @@ namespace WireMock.ResponseProviders
             _settings = settings;
         }
 
-        public Task<ResponseMessage> ProvideResponseAsync(RequestMessage requestMessage, IFileSystemHandler fileSystemHandler)
+        public Task<ResponseMessage> ProvideResponseAsync(RequestMessage requestMessage, IFluentMockServerSettings settings)
         {
             return _responseMessageFunc(requestMessage, _settings);
         }

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

@@ -164,10 +164,10 @@ namespace WireMock.Server
         {
             if (folder == null)
             {
-                folder = _fileSystemHandler.GetMappingFolder();
+                folder = _settings.FileSystemHandler.GetMappingFolder();
             }
 
-            if (!_fileSystemHandler.FolderExists(folder))
+            if (!_settings.FileSystemHandler.FolderExists(folder))
             {
                 return;
             }
@@ -177,17 +177,23 @@ namespace WireMock.Server
             var watcher = new EnhancedFileSystemWatcher(folder, "*.json", EnhancedFileSystemWatcherTimeoutMs);
             watcher.Created += (sender, args) =>
             {
-                _logger.Info("New MappingFile created : '{0}'", args.FullPath);
-                ReadStaticMappingAndAddOrUpdate(args.FullPath);
+                _logger.Info("MappingFile created : '{0}', reading file.", args.FullPath);
+                if (!ReadStaticMappingAndAddOrUpdate(args.FullPath))
+                {
+                    _logger.Error("Unable to read MappingFile '{0}'.", args.FullPath);
+                }
             };
             watcher.Changed += (sender, args) =>
             {
-                _logger.Info("New MappingFile updated : '{0}'", args.FullPath);
-                ReadStaticMappingAndAddOrUpdate(args.FullPath);
+                _logger.Info("MappingFile updated : '{0}', reading file.", args.FullPath);
+                if (!ReadStaticMappingAndAddOrUpdate(args.FullPath))
+                {
+                    _logger.Error("Unable to read MappingFile '{0}'.", args.FullPath);
+                }
             };
             watcher.Deleted += (sender, args) =>
             {
-                _logger.Info("New MappingFile deleted : '{0}'", args.FullPath);
+                _logger.Info("MappingFile deleted : '{0}'", args.FullPath);
                 string filenameWithoutExtension = Path.GetFileNameWithoutExtension(args.FullPath);
 
                 if (Guid.TryParse(filenameWithoutExtension, out Guid guidFromFilename))
@@ -208,24 +214,31 @@ namespace WireMock.Server
         /// </summary>
         /// <param name="path">The path.</param>
         [PublicAPI]
-        public void ReadStaticMappingAndAddOrUpdate([NotNull] string path)
+        public bool ReadStaticMappingAndAddOrUpdate([NotNull] string path)
         {
             Check.NotNull(path, nameof(path));
 
             string filenameWithoutExtension = Path.GetFileNameWithoutExtension(path);
 
-            var mappingModels = DeserializeObjectToArray<MappingModel>(JsonConvert.DeserializeObject(_fileSystemHandler.ReadMappingFile(path)));
-            foreach (var mappingModel in mappingModels)
+            if (FileHelper.TryReadMappingFileWithRetryAndDelay(_fileSystemHandler, path, out string value))
             {
-                if (mappingModels.Length == 1 && Guid.TryParse(filenameWithoutExtension, out Guid guidFromFilename))
+                var mappingModels = DeserializeObjectToArray<MappingModel>(JsonConvert.DeserializeObject(value));
+                foreach (var mappingModel in mappingModels)
                 {
-                    DeserializeAndAddOrUpdateMapping(mappingModel, guidFromFilename, path);
-                }
-                else
-                {
-                    DeserializeAndAddOrUpdateMapping(mappingModel, null, path);
+                    if (mappingModels.Length == 1 && Guid.TryParse(filenameWithoutExtension, out Guid guidFromFilename))
+                    {
+                        DeserializeAndAddOrUpdateMapping(mappingModel, guidFromFilename, path);
+                    }
+                    else
+                    {
+                        DeserializeAndAddOrUpdateMapping(mappingModel, null, path);
+                    }
                 }
+
+                return true;
             }
+
+            return false;
         }
         #endregion
 
@@ -302,7 +315,7 @@ namespace WireMock.Server
 
             var response = Response.Create(responseMessage);
 
-            return new Mapping(Guid.NewGuid(), string.Empty, null, _fileSystemHandler, request, response, 0, null, null, null);
+            return new Mapping(Guid.NewGuid(), string.Empty, null, _settings, request, response, 0, null, null, null);
         }
         #endregion
 

src/WireMock.Net/Server/FluentMockServer.cs

@@ -29,6 +29,7 @@ namespace WireMock.Server
 
         private readonly IWireMockLogger _logger;
         private readonly IFileSystemHandler _fileSystemHandler;
+        private readonly IFluentMockServerSettings _settings;
         private readonly IOwinSelfHost _httpServer;
         private readonly IWireMockMiddlewareOptions _options = new WireMockMiddlewareOptions();
 
@@ -92,7 +93,7 @@ namespace WireMock.Server
         /// <param name="settings">The FluentMockServerSettings.</param>
         /// <returns>The <see cref="FluentMockServer"/>.</returns>
         [PublicAPI]
-        public static FluentMockServer Start(IFluentMockServerSettings settings)
+        public static FluentMockServer Start([NotNull] IFluentMockServerSettings settings)
         {
             Check.NotNull(settings, nameof(settings));
 
@@ -185,6 +186,7 @@ namespace WireMock.Server
 
         private FluentMockServer(IFluentMockServerSettings settings)
         {
+            _settings = settings;
             settings.Logger = settings.Logger ?? new WireMockNullLogger();
 
             _logger = settings.Logger;
@@ -435,7 +437,7 @@ namespace WireMock.Server
         [PublicAPI]
         public IRespondWithAProvider Given(IRequestMatcher requestMatcher, bool saveToFile = false)
         {
-            return new RespondWithAProvider(RegisterMapping, requestMatcher, _fileSystemHandler, saveToFile);
+            return new RespondWithAProvider(RegisterMapping, requestMatcher, _settings, saveToFile);
         }
 
         private void RegisterMapping(IMapping mapping, bool saveToFile)

src/WireMock.Net/Server/RespondWithAProvider.cs

@@ -1,7 +1,7 @@
 using System;
-using WireMock.Handlers;
 using WireMock.Matchers.Request;
 using WireMock.ResponseProviders;
+using WireMock.Settings;
 
 namespace WireMock.Server
 {
@@ -18,7 +18,7 @@ namespace WireMock.Server
         private string _scenario;
         private readonly RegistrationCallback _registrationCallback;
         private readonly IRequestMatcher _requestMatcher;
-        private readonly IFileSystemHandler _fileSystemHandler;
+        private readonly IFluentMockServerSettings _settings;
         private readonly bool _saveToFile;
 
         public Guid Guid { get; private set; } = Guid.NewGuid();
@@ -28,13 +28,13 @@ namespace WireMock.Server
         /// </summary>
         /// <param name="registrationCallback">The registration callback.</param>
         /// <param name="requestMatcher">The request matcher.</param>
-        /// <param name="fileSystemHandler">The fileSystemHandler.</param>
+        /// <param name="settings">The FluentMockServerSettings.</param>
         /// <param name="saveToFile">Optional boolean to indicate if this mapping should be saved as static mapping file.</param>
-        public RespondWithAProvider(RegistrationCallback registrationCallback, IRequestMatcher requestMatcher, IFileSystemHandler fileSystemHandler, bool saveToFile = false)
+        public RespondWithAProvider(RegistrationCallback registrationCallback, IRequestMatcher requestMatcher, IFluentMockServerSettings settings, bool saveToFile = false)
         {
             _registrationCallback = registrationCallback;
             _requestMatcher = requestMatcher;
-            _fileSystemHandler = fileSystemHandler;
+            _settings = settings;
             _saveToFile = saveToFile;
         }
 
@@ -44,7 +44,7 @@ namespace WireMock.Server
         /// <param name="provider">The provider.</param>
         public void RespondWith(IResponseProvider provider)
         {
-            _registrationCallback(new Mapping(Guid, _title, _path, _fileSystemHandler, _requestMatcher, provider, _priority, _scenario, _executionConditionState, _nextState), _saveToFile);
+            _registrationCallback(new Mapping(Guid, _title, _path, _settings, _requestMatcher, provider, _priority, _scenario, _executionConditionState, _nextState), _saveToFile);
         }
 
         /// <see cref="IRespondWithAProvider.WithGuid(string)"/>

src/WireMock.Net/Settings/FluentMockServerSettings.cs

@@ -1,4 +1,5 @@
-using JetBrains.Annotations;
+using HandlebarsDotNet;
+using JetBrains.Annotations;
 using Newtonsoft.Json;
 using System;
 using WireMock.Handlers;
@@ -83,5 +84,10 @@ namespace WireMock.Settings
         [PublicAPI]
         [JsonIgnore]
         public IFileSystemHandler FileSystemHandler { get; set; }
+
+        /// <inheritdoc cref="IFluentMockServerSettings.HandlebarsRegistrationCallback"/>
+        [PublicAPI]
+        [JsonIgnore]
+        public Action<IHandlebars, IFileSystemHandler> HandlebarsRegistrationCallback { get; set; }
     }
 }

src/WireMock.Net/Settings/IFluentMockServerSettings.cs

@@ -1,5 +1,6 @@
-using System;
+using HandlebarsDotNet;
 using JetBrains.Annotations;
+using System;
 using WireMock.Handlers;
 using WireMock.Logging;
 
@@ -112,5 +113,11 @@ namespace WireMock.Settings
         /// </summary>
         [PublicAPI]
         IFileSystemHandler FileSystemHandler { get; set; }
+
+        /// <summary>
+        /// Action which can be used to add additional is Handlebar registrations. [Optional]
+        /// </summary>
+        [PublicAPI]
+        Action<IHandlebars, IFileSystemHandler> HandlebarsRegistrationCallback { get; set; }
     }
 }

src/WireMock.Net/Transformers/HandlebarsContextFactory.cs

@@ -0,0 +1,34 @@
+using HandlebarsDotNet;
+using System;
+using WireMock.Handlers;
+
+namespace WireMock.Transformers
+{
+    internal class HandlebarsContextFactory : IHandlebarsContextFactory
+    {
+        private static readonly HandlebarsConfiguration HandlebarsConfiguration = new HandlebarsConfiguration
+        {
+            UnresolvedBindingFormatter = "{0}"
+        };
+
+        private readonly IFileSystemHandler _fileSystemHandler;
+        private readonly Action<IHandlebars, IFileSystemHandler> _action;
+
+        public HandlebarsContextFactory(IFileSystemHandler fileSystemHandler, Action<IHandlebars, IFileSystemHandler> action)
+        {
+            _fileSystemHandler = fileSystemHandler;
+            _action = action;
+        }
+
+        public IHandlebars Create()
+        {
+            var handlebarsContext = Handlebars.Create(HandlebarsConfiguration);
+
+            HandlebarsHelpers.Register(handlebarsContext, _fileSystemHandler);
+
+            _action?.Invoke(handlebarsContext, _fileSystemHandler);
+
+            return handlebarsContext;
+        }
+    }
+}

src/WireMock.Net/Transformers/IHandlebarsContextFactory.cs

@@ -0,0 +1,9 @@
+using HandlebarsDotNet;
+
+namespace WireMock.Transformers
+{
+    interface IHandlebarsContextFactory
+    {
+        IHandlebars Create();
+    }
+}

src/WireMock.Net/Transformers/ResponseMessageTransformer.cs

@@ -5,7 +5,6 @@ using Newtonsoft.Json.Linq;
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using WireMock.Handlers;
 using WireMock.Util;
 using WireMock.Validation;
 
@@ -13,22 +12,19 @@ namespace WireMock.Transformers
 {
     internal class ResponseMessageTransformer
     {
-        private static readonly HandlebarsConfiguration HandlebarsConfiguration = new HandlebarsConfiguration
+        private readonly IHandlebarsContextFactory _factory;
+
+        public ResponseMessageTransformer([NotNull] IHandlebarsContextFactory factory)
         {
-            UnresolvedBindingFormatter = "{0}"
-        };
+            Check.NotNull(factory, nameof(factory));
 
-        private static readonly IHandlebars HandlebarsContext = Handlebars.Create(HandlebarsConfiguration);
-
-        public ResponseMessageTransformer([NotNull] IFileSystemHandler fileSystemHandler)
-        {
-            Check.NotNull(fileSystemHandler, nameof(fileSystemHandler));
-
-            HandlebarsHelpers.Register(HandlebarsContext, fileSystemHandler);
+            _factory = factory;
         }
 
         public ResponseMessage Transform(RequestMessage requestMessage, ResponseMessage original)
         {
+            var handlebarsContext = _factory.Create();
+
             var responseMessage = new ResponseMessage { StatusCode = original.StatusCode };
 
             var template = new { request = requestMessage };
@@ -36,16 +32,16 @@ namespace WireMock.Transformers
             switch (original.BodyData.DetectedBodyType)
             {
                 case BodyType.Json:
-                    TransformBodyAsJson(template, original, responseMessage);
+                    TransformBodyAsJson(handlebarsContext, template, original, responseMessage);
                     break;
 
                 case BodyType.File:
-                    TransformBodyAsFile(template, original, responseMessage);
+                    TransformBodyAsFile(handlebarsContext, template, original, responseMessage);
                     break;
 
                 case BodyType.String:
                     responseMessage.BodyOriginal = original.BodyData.BodyAsString;
-                    TransformBodyAsString(template, original, responseMessage);
+                    TransformBodyAsString(handlebarsContext, template, original, responseMessage);
                     break;
             }
 
@@ -53,9 +49,9 @@ namespace WireMock.Transformers
             var newHeaders = new Dictionary<string, WireMockList<string>>();
             foreach (var header in original.Headers)
             {
-                var templateHeaderKey = HandlebarsContext.Compile(header.Key);
+                var templateHeaderKey = handlebarsContext.Compile(header.Key);
                 var templateHeaderValues = header.Value
-                    .Select(HandlebarsContext.Compile)
+                    .Select(handlebarsContext.Compile)
                     .Select(func => func(template))
                     .ToArray();
 
@@ -67,7 +63,7 @@ namespace WireMock.Transformers
             return responseMessage;
         }
 
-        private static void TransformBodyAsJson(object template, ResponseMessage original, ResponseMessage responseMessage)
+        private static void TransformBodyAsJson(IHandlebars handlebarsContext, object template, ResponseMessage original, ResponseMessage responseMessage)
         {
             JToken jToken;
             switch (original.BodyData.BodyAsJson)
@@ -85,7 +81,7 @@ namespace WireMock.Transformers
                     break;
             }
 
-            WalkNode(jToken, template);
+            WalkNode(handlebarsContext, jToken, template);
 
             responseMessage.BodyData = new BodyData
             {
@@ -95,14 +91,14 @@ namespace WireMock.Transformers
             };
         }
 
-        private static void WalkNode(JToken node, object context)
+        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(child.Value, context);
+                    WalkNode(handlebarsContext, child.Value, context);
                 }
             }
             else if (node.Type == JTokenType.Array)
@@ -110,7 +106,7 @@ namespace WireMock.Transformers
                 // In case of Array, loop all items. Do a ToArray() to avoid `Collection was modified` exceptions.
                 foreach (JToken child in node.Children().ToArray())
                 {
-                    WalkNode(child, context);
+                    WalkNode(handlebarsContext, child, context);
                 }
             }
             else if (node.Type == JTokenType.String)
@@ -122,7 +118,7 @@ namespace WireMock.Transformers
                     return;
                 }
 
-                var templateForStringValue = HandlebarsContext.Compile(stringValue);
+                var templateForStringValue = handlebarsContext.Compile(stringValue);
                 string transformedString = templateForStringValue(context);
                 if (!string.Equals(stringValue, transformedString))
                 {
@@ -154,9 +150,9 @@ namespace WireMock.Transformers
             node.Replace(value);
         }
 
-        private static void TransformBodyAsString(object template, ResponseMessage original, ResponseMessage responseMessage)
+        private static void TransformBodyAsString(IHandlebars handlebarsContext, object template, ResponseMessage original, ResponseMessage responseMessage)
         {
-            var templateBodyAsString = HandlebarsContext.Compile(original.BodyData.BodyAsString);
+            var templateBodyAsString = handlebarsContext.Compile(original.BodyData.BodyAsString);
 
             responseMessage.BodyData = new BodyData
             {
@@ -166,9 +162,9 @@ namespace WireMock.Transformers
             };
         }
 
-        private static void TransformBodyAsFile(object template, ResponseMessage original, ResponseMessage responseMessage)
+        private static void TransformBodyAsFile(IHandlebars handlebarsContext, object template, ResponseMessage original, ResponseMessage responseMessage)
         {
-            var templateBodyAsFile = HandlebarsContext.Compile(original.BodyData.BodyAsFile);
+            var templateBodyAsFile = handlebarsContext.Compile(original.BodyData.BodyAsFile);
 
             responseMessage.BodyData = new BodyData
             {

src/WireMock.Net/Util/BodyParser.cs

@@ -2,6 +2,7 @@
 using MimeKit;
 using Newtonsoft.Json;
 using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Text;
@@ -27,7 +28,18 @@ namespace WireMock.Util
             CONNECT - No defined body semantics
             PATCH - Body supported.
         */
-        private static readonly string[] AllowedBodyParseMethods = { "PUT", "POST", "OPTIONS", "PATCH" };
+        private static readonly IDictionary<string, bool> BodyAllowedForMethods = new Dictionary<string, bool>
+        {
+            { "HEAD", false },
+            { "GET", false },
+            { "PUT", true },
+            { "POST", true },
+            { "DELETE", false },
+            { "TRACE", false },
+            { "OPTIONS", true },
+            { "CONNECT", false },
+            { "PATCH", true }
+        };
 
         private static readonly IStringMatcher[] MultipartContentTypesMatchers = {
             new WildcardMatcher("multipart/*", true)
@@ -53,7 +65,19 @@ namespace WireMock.Util
 
         public static bool ShouldParseBody([CanBeNull] string method)
         {
-            return AllowedBodyParseMethods.Contains(method, StringComparer.OrdinalIgnoreCase);
+            if (String.IsNullOrEmpty(method))
+            {
+                return false;
+            }
+            if (BodyAllowedForMethods.TryGetValue(method.ToUpper(), out var allowed))
+            {
+                return allowed;
+            }
+            // If we don't have any knowledge of this method, we should assume that a body *may*
+            // be present, so we should parse it if it is. Therefore, if a new method is added to
+            // the HTTP Method Registry, we only really need to add it to BodyAllowedForMethods if
+            // we want to make it clear that a body is *not* allowed.
+            return true;
         }
 
         public static BodyType DetectBodyTypeFromContentType([CanBeNull] string contentTypeValue)

src/WireMock.Net/Util/FileHelper.cs

@@ -1,6 +1,5 @@
-using System.IO;
+using JetBrains.Annotations;
 using System.Threading;
-using JetBrains.Annotations;
 using WireMock.Handlers;
 using WireMock.Validation;
 
@@ -11,16 +10,19 @@ namespace WireMock.Util
         private const int NumberOfRetries = 3;
         private const int DelayOnRetry = 500;
 
-        public static string ReadAllTextWithRetryAndDelay([NotNull] IFileSystemHandler handler, [NotNull] string path)
+        public static bool TryReadMappingFileWithRetryAndDelay([NotNull] IFileSystemHandler handler, [NotNull] string path, out string value)
         {
             Check.NotNull(handler, nameof(handler));
             Check.NotNullOrEmpty(path, nameof(path));
 
+            value = null;
+
             for (int i = 1; i <= NumberOfRetries; ++i)
             {
                 try
                 {
-                    return handler.ReadMappingFile(path);
+                    value = handler.ReadMappingFile(path);
+                    return true;
                 }
                 catch
                 {
@@ -28,7 +30,7 @@ namespace WireMock.Util
                 }
             }
 
-            throw new IOException();
+            return false;
         }
     }
 }

test/WireMock.Net.Tests/FluentMockServerTests.cs

@@ -1,6 +1,7 @@
 using NFluent;
 using System;
 using System.Diagnostics;
+using System.Net;
 using System.Net.Http;
 using System.Threading.Tasks;
 using WireMock.RequestBuilders;
@@ -172,5 +173,63 @@ namespace WireMock.Net.Tests
             Check.That(response.Headers.Contains("test")).IsTrue();
             Check.That(response.Headers.Contains("Transfer-Encoding")).IsFalse();
         }
+
+        [Theory]
+        [InlineData("GET")]
+        [InlineData("TRACE")]
+        [InlineData("DELETE")]
+        public async Task FluentMockServer_Should_exclude_body_for_methods_where_body_is_definitely_disallowed(string method)
+        {
+            // Assign
+            string content = "hello";
+            var server = FluentMockServer.Start();
+
+            server
+                .Given(Request.Create().WithBody(b => true))
+                .AtPriority(0)
+                .RespondWith(Response.Create().WithStatusCode(400));
+            server
+                .Given(Request.Create())
+                .AtPriority(1)
+                .RespondWith(Response.Create().WithStatusCode(200));
+
+            // Act
+            var request = new HttpRequestMessage(new HttpMethod(method), "http://localhost:" + server.Ports[0] + "/");
+            request.Content = new StringContent(content);
+            var response = await new HttpClient().SendAsync(request);
+
+            // Assert
+            Check.That(response.StatusCode).Equals(HttpStatusCode.OK);
+        }
+    
+        [Theory]
+        [InlineData("POST")]
+        [InlineData("PUT")]
+        [InlineData("OPTIONS")]
+        [InlineData("REPORT")]
+        [InlineData("SOME-UNKNOWN-METHOD")] // default behavior for unknown methods is to allow a body (see BodyParser.ShouldParseBody)
+        public async Task FluentMockServer_Should_not_exclude_body_for_supported_methods(string method)
+        {
+            // Assign
+            string content = "hello";
+            var server = FluentMockServer.Start();
+
+            server
+                .Given(Request.Create().WithBody(content))
+                .AtPriority(0)
+                .RespondWith(Response.Create().WithStatusCode(200));
+            server
+                .Given(Request.Create())
+                .AtPriority(1)
+                .RespondWith(Response.Create().WithStatusCode(400));
+
+            // Act
+            var request = new HttpRequestMessage(new HttpMethod(method), "http://localhost:" + server.Ports[0] + "/");
+            request.Content = new StringContent(content);
+            var response = await new HttpClient().SendAsync(request);
+
+            // Assert
+            Check.That(response.StatusCode).Equals(HttpStatusCode.OK);
+        }
     }
 }

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

@@ -1,16 +1,16 @@
-using System.Threading.Tasks;
-using Moq;
+using Moq;
 using NFluent;
-using WireMock.Handlers;
+using System.Threading.Tasks;
 using WireMock.Models;
 using WireMock.ResponseBuilders;
+using WireMock.Settings;
 using Xunit;
 
 namespace WireMock.Net.Tests.ResponseBuilders
 {
     public class ResponseCreateTests
     {
-        private readonly Mock<IFileSystemHandler> _fileSystemHandlerMock = new Mock<IFileSystemHandler>();
+        private readonly Mock<IFluentMockServerSettings> _settingsMock = new Mock<IFluentMockServerSettings>();
 
         [Fact]
         public async Task Response_Create_Func()
@@ -22,7 +22,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
             var response = Response.Create(() => responseMessage);
 
             // Act
-            var providedResponse = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var providedResponse = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // Assert
             Check.That(providedResponse).Equals(responseMessage);

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

@@ -4,9 +4,9 @@ using NFluent;
 using System;
 using System.Text;
 using System.Threading.Tasks;
-using WireMock.Handlers;
 using WireMock.Models;
 using WireMock.ResponseBuilders;
+using WireMock.Settings;
 using WireMock.Util;
 using Xunit;
 
@@ -14,7 +14,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
 {
     public class ResponseWithBodyTests
     {
-        private readonly Mock<IFileSystemHandler> _fileSystemHandlerMock = new Mock<IFileSystemHandler>();
+        private readonly Mock<IFluentMockServerSettings> _settingsMock = new Mock<IFluentMockServerSettings>();
         private const string ClientIp = "::1";
 
         [Fact]
@@ -31,7 +31,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
             var response = Response.Create().WithBody(new byte[] { 48, 49 }, BodyDestinationFormat.String, Encoding.ASCII);
 
             // act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // then
             Check.That(responseMessage.BodyData.BodyAsString).Equals("01");
@@ -53,7 +53,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
             var response = Response.Create().WithBody(new byte[] { 48, 49 }, BodyDestinationFormat.SameAsSource, Encoding.ASCII);
 
             // act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // then
             Check.That(responseMessage.BodyData.BodyAsBytes).ContainsExactly(new byte[] { 48, 49 });
@@ -75,7 +75,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
             var response = Response.Create().WithBody("test", null, Encoding.ASCII);
 
             // act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // then
             Check.That(responseMessage.BodyData.BodyAsString).Equals("test");
@@ -97,7 +97,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
             var response = Response.Create().WithBodyAsJson(x, Encoding.ASCII);
 
             // act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // then
             Check.That(responseMessage.BodyData.BodyAsJson).Equals(x);
@@ -119,7 +119,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
             var response = Response.Create().WithBodyAsJson(x, true);
 
             // act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // then
             Check.That(responseMessage.BodyData.BodyAsJson).Equals(x);
@@ -135,7 +135,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
             var response = Response.Create().WithBody("r", BodyDestinationFormat.SameAsSource, Encoding.ASCII);
 
             // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // Assert
             Check.That(responseMessage.BodyData.BodyAsBytes).IsNull();
@@ -153,7 +153,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
             var response = Response.Create().WithBody("r", BodyDestinationFormat.Bytes, Encoding.ASCII);
 
             // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // Assert
             Check.That(responseMessage.BodyData.BodyAsString).IsNull();
@@ -171,7 +171,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
             var response = Response.Create().WithBody("{ \"value\": 42 }", BodyDestinationFormat.Json, Encoding.ASCII);
 
             // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // Assert
             Check.That(responseMessage.BodyData.BodyAsString).IsNull();
@@ -193,7 +193,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
                 .WithBody(req => $"path: {req.Path}");
 
             // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // Assert
             Check.That(responseMessage.BodyData.BodyAsString).IsEqualTo("path: /test");
@@ -221,8 +221,8 @@ namespace WireMock.Net.Tests.ResponseBuilders
                 .WithTransformer();
 
             // Act
-            var response1Message = await response.ProvideResponseAsync(request1, _fileSystemHandlerMock.Object);
-            var response2Message = await response.ProvideResponseAsync(request2, _fileSystemHandlerMock.Object);
+            var response1Message = await response.ProvideResponseAsync(request1, _settingsMock.Object);
+            var response2Message = await response.ProvideResponseAsync(request2, _settingsMock.Object);
 
             // Assert
             Check.That(((JToken)response1Message.BodyData.BodyAsJson).SelectToken("id")?.Value<int>()).IsEqualTo(request1Id);
@@ -246,7 +246,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
 
             var response = Response.Create().WithStatusCode(200).WithBody(fileContents);
 
-            var provideResponseAsync = await response.ProvideResponseAsync(request1, _fileSystemHandlerMock.Object);
+            var provideResponseAsync = await response.ProvideResponseAsync(request1, _settingsMock.Object);
 
             Check.That(provideResponseAsync.StatusCode).IsEqualTo(200);
             Check.That(provideResponseAsync.BodyData.BodyAsString).Contains(fileContents);
@@ -262,7 +262,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
 
             var response = Response.Create().WithStatusCode(200).WithBody(fileContents);
 
-            var provideResponseAsync = await response.ProvideResponseAsync(request1, _fileSystemHandlerMock.Object);
+            var provideResponseAsync = await response.ProvideResponseAsync(request1, _settingsMock.Object);
 
             Check.That(provideResponseAsync.StatusCode).IsEqualTo(200);
             Check.That(provideResponseAsync.BodyData.BodyAsString).Contains(fileContents);
@@ -278,7 +278,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
 
             var response = Response.Create().WithStatusCode(200).WithBody("File deleted.");
 
-            var provideResponseAsync = await response.ProvideResponseAsync(request1, _fileSystemHandlerMock.Object);
+            var provideResponseAsync = await response.ProvideResponseAsync(request1, _settingsMock.Object);
 
             Check.That(provideResponseAsync.StatusCode).IsEqualTo(200);
             Check.That(provideResponseAsync.BodyData.BodyAsString).Contains("File deleted.");

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

@@ -1,9 +1,9 @@
 using Moq;
 using NFluent;
 using System.Threading.Tasks;
-using WireMock.Handlers;
 using WireMock.Models;
 using WireMock.ResponseBuilders;
+using WireMock.Settings;
 using WireMock.Util;
 using Xunit;
 
@@ -11,7 +11,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
 {
     public class ResponseWithCallbackTests
     {
-        private readonly Mock<IFileSystemHandler> _fileSystemHandlerMock = new Mock<IFileSystemHandler>();
+        private readonly Mock<IFluentMockServerSettings> _settingsMock = new Mock<IFluentMockServerSettings>();
 
         [Fact]
         public async Task Response_WithCallback()
@@ -21,7 +21,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
             var response = Response.Create().WithCallback(req => new ResponseMessage { BodyData = new BodyData { DetectedBodyType = BodyType.String, BodyAsString = req.Path + "Bar" }, StatusCode = 302 });
 
             // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // Assert
             Check.That(responseMessage.BodyData.BodyAsString).IsEqualTo("/fooBar");

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

@@ -6,6 +6,7 @@ using System.Threading.Tasks;
 using WireMock.Handlers;
 using WireMock.Models;
 using WireMock.ResponseBuilders;
+using WireMock.Settings;
 using Xunit;
 
 namespace WireMock.Net.Tests.ResponseBuilders
@@ -13,12 +14,16 @@ namespace WireMock.Net.Tests.ResponseBuilders
     public class ResponseWithHandlebarsFileTests
     {
         private readonly Mock<IFileSystemHandler> _filesystemHandlerMock;
+        private readonly Mock<IFluentMockServerSettings> _settingsMock;
         private const string ClientIp = "::1";
 
         public ResponseWithHandlebarsFileTests()
         {
             _filesystemHandlerMock = new Mock<IFileSystemHandler>(MockBehavior.Strict);
             _filesystemHandlerMock.Setup(fs => fs.ReadResponseBodyAsString(It.IsAny<string>())).Returns("abc");
+
+            _settingsMock = new Mock<IFluentMockServerSettings>();
+            _settingsMock.SetupGet(s => s.FileSystemHandler).Returns(_filesystemHandlerMock.Object);
         }
 
         [Fact]
@@ -35,7 +40,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
                 .WithTransformer();
 
             // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _filesystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // Assert
             JObject j = JObject.FromObject(responseMessage.BodyData.BodyAsJson);
@@ -60,7 +65,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
                 .WithTransformer();
 
             // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _filesystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // Assert
             JObject j = JObject.FromObject(responseMessage.BodyData.BodyAsJson);
@@ -85,7 +90,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
                 .WithTransformer();
 
             // Act
-            Check.ThatAsyncCode(() => response.ProvideResponseAsync(request, _filesystemHandlerMock.Object)).Throws<ArgumentOutOfRangeException>();
+            Check.ThatAsyncCode(() => response.ProvideResponseAsync(request, _settingsMock.Object)).Throws<ArgumentOutOfRangeException>();
 
             // Verify
             _filesystemHandlerMock.Verify(fs => fs.ReadResponseBodyAsString(It.IsAny<string>()), Times.Never);

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

@@ -1,11 +1,11 @@
-using System;
-using System.Threading.Tasks;
-using Moq;
+using Moq;
 using Newtonsoft.Json.Linq;
 using NFluent;
-using WireMock.Handlers;
+using System;
+using System.Threading.Tasks;
 using WireMock.Models;
 using WireMock.ResponseBuilders;
+using WireMock.Settings;
 using WireMock.Util;
 using Xunit;
 
@@ -13,7 +13,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
 {
     public class ResponseWithHandlebarsJsonPathTests
     {
-        private readonly Mock<IFileSystemHandler> _fileSystemHandlerMock = new Mock<IFileSystemHandler>();
+        private readonly Mock<IFluentMockServerSettings> _settingsMock = new Mock<IFluentMockServerSettings>();
         private const string ClientIp = "::1";
 
         [Fact]
@@ -63,7 +63,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
                 .WithTransformer();
 
             // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // Assert
             JObject j = JObject.FromObject(responseMessage.BodyData.BodyAsJson);
@@ -89,7 +89,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
                 .WithTransformer();
 
             // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // Assert
             JObject j = JObject.FromObject(responseMessage.BodyData.BodyAsJson);
@@ -143,7 +143,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
                 .WithTransformer();
 
             // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // Assert
             Check.That(responseMessage.BodyData.BodyAsString).Equals($"{{{Environment.NewLine}  \"Name\": \"Acme Co\",{Environment.NewLine}  \"Products\": [{Environment.NewLine}    {{{Environment.NewLine}      \"Name\": \"Anvil\",{Environment.NewLine}      \"Price\": 50{Environment.NewLine}    }}{Environment.NewLine}  ]{Environment.NewLine}}}");
@@ -196,7 +196,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
                 .WithTransformer();
 
             // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // Assert
             Check.That(responseMessage.BodyData.BodyAsString).Equals($"{{{Environment.NewLine}  \"Name\": \"Acme Co\",{Environment.NewLine}  \"Products\": [{Environment.NewLine}    {{{Environment.NewLine}      \"Name\": \"Anvil\",{Environment.NewLine}      \"Price\": 50{Environment.NewLine}    }}{Environment.NewLine}  ]{Environment.NewLine}}}");
@@ -249,7 +249,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
                 .WithTransformer();
 
             // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // Assert
             Check.That(responseMessage.BodyData.BodyAsString).Equals("%0:Anvil%%1:Elbow Grease%");
@@ -302,7 +302,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
                 .WithTransformer();
 
             // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // Assert
             Check.That(responseMessage.BodyData.BodyAsString).Equals("%0:Anvil%%1:Elbow Grease%");
@@ -331,7 +331,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
                 .WithTransformer();
 
             // Act
-            Check.ThatAsyncCode(() => response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object)).Throws<ArgumentNullException>();
+            Check.ThatAsyncCode(() => response.ProvideResponseAsync(request, _settingsMock.Object)).Throws<ArgumentNullException>();
         }
     }
 }

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

@@ -3,9 +3,9 @@ using Newtonsoft.Json.Linq;
 using NFluent;
 using System;
 using System.Threading.Tasks;
-using WireMock.Handlers;
 using WireMock.Models;
 using WireMock.ResponseBuilders;
+using WireMock.Settings;
 using WireMock.Util;
 using Xunit;
 
@@ -13,7 +13,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
 {
     public class ResponseWithHandlebarsLinqTests
     {
-        private readonly Mock<IFileSystemHandler> _fileSystemHandlerMock = new Mock<IFileSystemHandler>();
+        private readonly Mock<IFluentMockServerSettings> _settingsMock = new Mock<IFluentMockServerSettings>();
 
         [Fact]
         public async Task Response_ProvideResponse_Handlebars_Linq1_String0()
@@ -29,7 +29,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
                 .WithTransformer();
 
             // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // Assert
             JObject j = JObject.FromObject(responseMessage.BodyData.BodyAsJson);
@@ -59,7 +59,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
                 .WithTransformer();
 
             // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // Assert
             JObject j = JObject.FromObject(responseMessage.BodyData.BodyAsJson);
@@ -89,7 +89,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
                 .WithTransformer();
 
             // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // Assert
             JObject j = JObject.FromObject(responseMessage.BodyData.BodyAsJson);
@@ -119,7 +119,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
                 .WithTransformer();
 
             // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // Assert
             JObject j = JObject.FromObject(responseMessage.BodyData.BodyAsJson);
@@ -144,7 +144,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
                 .WithTransformer();
 
             // Act
-            Check.ThatAsyncCode(() => response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object)).Throws<NotSupportedException>();
+            Check.ThatAsyncCode(() => response.ProvideResponseAsync(request, _settingsMock.Object)).Throws<NotSupportedException>();
         }
 
         [Fact]
@@ -160,7 +160,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
                 .WithTransformer();
 
             // Act
-            Check.ThatAsyncCode(() => response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object)).Throws<ArgumentNullException>();
+            Check.ThatAsyncCode(() => response.ProvideResponseAsync(request, _settingsMock.Object)).Throws<ArgumentNullException>();
         }
 
         [Fact]
@@ -176,7 +176,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
                 .WithTransformer();
 
             // Act
-            Check.ThatAsyncCode(() => response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object)).Throws<ArgumentException>();
+            Check.ThatAsyncCode(() => response.ProvideResponseAsync(request, _settingsMock.Object)).Throws<ArgumentException>();
         }
 
         [Fact]
@@ -200,7 +200,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
                 .WithTransformer();
 
             // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // Assert
             JObject j = JObject.FromObject(responseMessage.BodyData.BodyAsJson);
@@ -228,7 +228,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
                 .WithTransformer();
 
             // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // Assert
             JObject j = JObject.FromObject(responseMessage.BodyData.BodyAsJson);

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

@@ -1,18 +1,18 @@
-using System.Linq;
-using System.Threading.Tasks;
-using Moq;
+using Moq;
 using Newtonsoft.Json.Linq;
 using NFluent;
-using WireMock.Handlers;
+using System.Linq;
+using System.Threading.Tasks;
 using WireMock.Models;
 using WireMock.ResponseBuilders;
+using WireMock.Settings;
 using Xunit;
 
 namespace WireMock.Net.Tests.ResponseBuilders
 {
     public class ResponseWithHandlebarsRandomTests
     {
-        private readonly Mock<IFileSystemHandler> _fileSystemHandlerMock = new Mock<IFileSystemHandler>();
+        private readonly Mock<IFluentMockServerSettings> _settingsMock = new Mock<IFluentMockServerSettings>();
         private const string ClientIp = "::1";
 
         [Fact]
@@ -32,7 +32,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
                 .WithTransformer();
 
             // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // Assert
             JObject j = JObject.FromObject(responseMessage.BodyData.BodyAsJson);
@@ -55,7 +55,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
                 .WithTransformer();
 
             // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // Assert
             JObject j = JObject.FromObject(responseMessage.BodyData.BodyAsJson);
@@ -77,7 +77,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
                 .WithTransformer();
 
             // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // Assert
             JObject j = JObject.FromObject(responseMessage.BodyData.BodyAsJson);
@@ -101,7 +101,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
                 .WithTransformer();
 
             // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // Assert
             JObject j = JObject.FromObject(responseMessage.BodyData.BodyAsJson);
@@ -123,7 +123,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
                 .WithTransformer();
 
             // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // Assert
             JObject j = JObject.FromObject(responseMessage.BodyData.BodyAsJson);

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

@@ -1,10 +1,10 @@
-using System;
-using System.Threading.Tasks;
-using Moq;
+using Moq;
 using NFluent;
-using WireMock.Handlers;
+using System;
+using System.Threading.Tasks;
 using WireMock.Models;
 using WireMock.ResponseBuilders;
+using WireMock.Settings;
 using WireMock.Util;
 using Xunit;
 
@@ -12,7 +12,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
 {
     public class ResponseWithHandlebarsRegexTests
     {
-        private readonly Mock<IFileSystemHandler> _fileSystemHandlerMock = new Mock<IFileSystemHandler>();
+        private readonly Mock<IFluentMockServerSettings> _settingsMock = new Mock<IFluentMockServerSettings>();
         private const string ClientIp = "::1";
 
         [Fact]
@@ -28,7 +28,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
                 .WithTransformer();
 
             // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // assert
             Check.That(responseMessage.BodyData.BodyAsString).Equals("abc");
@@ -47,7 +47,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
                 .WithTransformer();
 
             // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // assert
             Check.That(responseMessage.BodyData.BodyAsString).Equals("");
@@ -66,7 +66,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
                 .WithTransformer();
 
             // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // assert
             Check.That(responseMessage.BodyData.BodyAsString).Equals("d");
@@ -85,7 +85,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
                 .WithTransformer();
 
             // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // assert
             Check.That(responseMessage.BodyData.BodyAsString).Equals("5000-https");
@@ -104,7 +104,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
                 .WithTransformer();
 
             // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // assert
             Check.That(responseMessage.BodyData.BodyAsString).Equals("");
@@ -123,7 +123,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
                 .WithTransformer();
 
             // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // assert
             Check.That(responseMessage.BodyData.BodyAsString).Equals("x");
@@ -142,7 +142,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
                 .WithTransformer();
 
             // Act and Assert
-            Check.ThatAsyncCode(() => response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object)).Throws<NotSupportedException>();
+            Check.ThatAsyncCode(() => response.ProvideResponseAsync(request, _settingsMock.Object)).Throws<NotSupportedException>();
         }
     }
 }

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

@@ -5,9 +5,9 @@ using System.Threading.Tasks;
 using Moq;
 using Newtonsoft.Json;
 using NFluent;
-using WireMock.Handlers;
 using WireMock.Models;
 using WireMock.ResponseBuilders;
+using WireMock.Settings;
 using WireMock.Util;
 using Xunit;
 #if NET452
@@ -20,7 +20,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
 {
     public class ResponseWithHandlebarsTests
     {
-        private readonly Mock<IFileSystemHandler> _fileSystemHandlerMock = new Mock<IFileSystemHandler>();
+        private readonly Mock<IFluentMockServerSettings> _settingsMock = new Mock<IFluentMockServerSettings>();
         private const string ClientIp = "::1";
 
         [Fact]
@@ -41,7 +41,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
                 .WithTransformer();
 
             // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // Assert
             Check.That(JsonConvert.SerializeObject(responseMessage.BodyData.BodyAsJson)).Equals("{\"x\":\"test /foo_object\"}");
@@ -63,7 +63,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
                 .WithTransformer();
 
             // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // Assert
             Check.That(responseMessage.BodyData.BodyAsString).Equals("test http://localhost/foo /foo POSt");
@@ -81,7 +81,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
                 .WithTransformer();
 
             // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // Assert
             Check.That(responseMessage.BodyData.BodyAsString).Equals("http://localhost/a/b http://localhost/wiremock/a/b /a/b /wiremock/a/b");
@@ -99,7 +99,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
                 .WithTransformer();
 
             // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // Assert
             Check.That(responseMessage.BodyData.BodyAsString).Equals("a wiremock");
@@ -121,7 +121,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
                 .WithTransformer();
 
             // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // Assert
             Check.That(responseMessage.BodyData.BodyAsString).Equals("test keya=1 idx=1 idx=2 keyb=5");
@@ -141,7 +141,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
             var response = Response.Create().WithHeader("x", "{{request.headers.Content-Type}}").WithBody("test").WithTransformer();
 
             // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // Assert
             Check.That(responseMessage.BodyData.BodyAsString).Equals("test");
@@ -163,7 +163,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
             var response = Response.Create().WithHeader("x", "{{request.headers.Content-Type}}", "{{request.url}}").WithBody("test").WithTransformer();
 
             // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // Assert
             Check.That(responseMessage.BodyData.BodyAsString).Equals("test");
@@ -188,7 +188,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
                 .WithTransformer();
 
             // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // Assert
             Check.That(responseMessage.BodyData.BodyAsString).Equals("test http://localhost:1234 1234 http localhost");
@@ -212,7 +212,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
                 .WithTransformer();
 
             // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // Assert
             Check.That(JsonConvert.SerializeObject(responseMessage.BodyData.BodyAsJson)).Equals("[\"first\",\"/foo_array\",\"test 1\",\"test 2\",\"last\"]");
@@ -229,7 +229,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
                 .WithBodyFromFile(@"c:\\{{request.query.MyUniqueNumber}}\test.xml"); // why use a \\ here ?
 
             // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // Assert
             Check.That(responseMessage.BodyData.BodyAsFile).Equals(@"c:\1\test.xml");
@@ -256,7 +256,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
                 .WithBodyFromFile(@"c:\\{{JsonPath.SelectToken request.body " + jsonPath + "}}\\test.json"); // why use a \\ here ?
 
             // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // Assert
             Check.That(responseMessage.BodyData.BodyAsFile).Equals(@"c:\1\test.json");

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

@@ -1,17 +1,17 @@
-using System.Threading.Tasks;
-using Moq;
+using Moq;
 using Newtonsoft.Json.Linq;
 using NFluent;
-using WireMock.Handlers;
+using System.Threading.Tasks;
 using WireMock.Models;
 using WireMock.ResponseBuilders;
+using WireMock.Settings;
 using Xunit;
 
 namespace WireMock.Net.Tests.ResponseBuilders
 {
     public class ResponseWithHandlebarsXegerTests
     {
-        private readonly Mock<IFileSystemHandler> _fileSystemHandlerMock = new Mock<IFileSystemHandler>();
+        private readonly Mock<IFluentMockServerSettings> _settingsMock = new Mock<IFluentMockServerSettings>();
         private const string ClientIp = "::1";
 
         [Fact]
@@ -29,7 +29,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
                 .WithTransformer();
 
             // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // Assert
             JObject j = JObject.FromObject(responseMessage.BodyData.BodyAsJson);
@@ -52,7 +52,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
                 .WithTransformer();
 
             // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // Assert
             JObject j = JObject.FromObject(responseMessage.BodyData.BodyAsJson);

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

@@ -1,10 +1,10 @@
-using System.Collections.Generic;
-using System.Threading.Tasks;
-using Moq;
+using Moq;
 using NFluent;
-using WireMock.Handlers;
+using System.Collections.Generic;
+using System.Threading.Tasks;
 using WireMock.Models;
 using WireMock.ResponseBuilders;
+using WireMock.Settings;
 using WireMock.Util;
 using Xunit;
 
@@ -12,7 +12,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
 {
     public class ResponseWithHeadersTests
     {
-        private readonly Mock<IFileSystemHandler> _fileSystemHandlerMock = new Mock<IFileSystemHandler>();
+        private readonly Mock<IFluentMockServerSettings> _settingsMock = new Mock<IFluentMockServerSettings>();
         private const string ClientIp = "::1";
 
         [Theory]
@@ -26,7 +26,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
             IResponseBuilder builder = Response.Create().WithHeader(headerName, headerValue);
 
             // Act
-            var response = await builder.ProvideResponseAsync(requestMock, _fileSystemHandlerMock.Object);
+            var response = await builder.ProvideResponseAsync(requestMock, _settingsMock.Object);
 
             // Assert
             Check.That(response.Headers[headerName].ToString()).Equals(headerValue);
@@ -42,7 +42,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
             IResponseBuilder builder = Response.Create().WithHeader(headerName, headerValues);
 
             // Act
-            var response = await builder.ProvideResponseAsync(requestMock, _fileSystemHandlerMock.Object);
+            var response = await builder.ProvideResponseAsync(requestMock, _settingsMock.Object);
 
             // Assert
             Check.That(response.Headers[headerName].ToArray()).Equals(headerValues);
@@ -57,7 +57,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
             var response = Response.Create().WithHeaders(headers);
 
             // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // Assert
             Check.That(responseMessage.Headers["h"]).ContainsExactly("x");
@@ -72,7 +72,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
             var response = Response.Create().WithHeaders(headers);
 
             // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // Assert
             Check.That(responseMessage.Headers["h"]).ContainsExactly("x");
@@ -87,7 +87,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
             var response = Response.Create().WithHeaders(headers);
 
             // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // Assert
             Check.That(responseMessage.Headers["h"]).ContainsExactly("x");

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

@@ -1,13 +1,13 @@
-using System;
+using Moq;
+using NFluent;
+using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
-using Moq;
-using NFluent;
-using WireMock.Handlers;
 using WireMock.Models;
 using WireMock.RequestBuilders;
 using WireMock.ResponseBuilders;
 using WireMock.Server;
+using WireMock.Settings;
 using WireMock.Util;
 using Xunit;
 
@@ -15,7 +15,7 @@ namespace WireMock.Net.Tests.ResponseBuilders
 {
     public class ResponseWithProxyTests : IDisposable
     {
-        private readonly Mock<IFileSystemHandler> _fileSystemHandlerMock = new Mock<IFileSystemHandler>();
+        private readonly Mock<IFluentMockServerSettings> _settingsMock = new Mock<IFluentMockServerSettings>();
         private readonly FluentMockServer _server;
         private readonly Guid _guid;
 
@@ -33,11 +33,11 @@ namespace WireMock.Net.Tests.ResponseBuilders
         {
             // Assign
             var headers = new Dictionary<string, string[]> { { "Content-Type", new[] { "application/xml" } } };
-            var request = new RequestMessage(new UrlDetails($"{_server.Urls[0]}/{_guid}"), "POST", "::1", new BodyData { DetectedBodyType = BodyType.Json,  BodyAsJson = new { a = 1 } }, headers);
+            var request = new RequestMessage(new UrlDetails($"{_server.Urls[0]}/{_guid}"), "POST", "::1", new BodyData { DetectedBodyType = BodyType.Json, BodyAsJson = new { a = 1 } }, headers);
             var response = Response.Create().WithProxy(_server.Urls[0]);
 
             // Act
-            var responseMessage = await response.ProvideResponseAsync(request, _fileSystemHandlerMock.Object);
+            var responseMessage = await response.ProvideResponseAsync(request, _settingsMock.Object);
 
             // Assert
             Check.That(responseMessage.BodyData.BodyAsString).IsEqualTo("{\"p\":42}");

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

@@ -1,17 +1,17 @@
 using FluentAssertions;
 using Moq;
 using System;
-using WireMock.Handlers;
 using WireMock.RequestBuilders;
 using WireMock.ResponseBuilders;
 using WireMock.Serialization;
+using WireMock.Settings;
 using Xunit;
 
 namespace WireMock.Net.Tests.Serialization
 {
     public class MappingConverterTests
     {
-        private readonly Mock<IFileSystemHandler> _fileSystemHandlerMock = new Mock<IFileSystemHandler>();
+        private readonly Mock<IFluentMockServerSettings> _settingsMock = new Mock<IFluentMockServerSettings>();
 
         [Fact]
         public void ToMappingModel()
@@ -19,7 +19,7 @@ namespace WireMock.Net.Tests.Serialization
             // Assign
             var request = Request.Create();
             var response = Response.Create();
-            var mapping = new Mapping(Guid.NewGuid(), "", null, _fileSystemHandlerMock.Object, request, response, 0, null, null, null);
+            var mapping = new Mapping(Guid.NewGuid(), "", null, _settingsMock.Object, request, response, 0, null, null, null);
 
             // Act
             var model = MappingConverter.ToMappingModel(mapping);
@@ -37,7 +37,7 @@ namespace WireMock.Net.Tests.Serialization
             // Assign
             var request = Request.Create();
             var response = Response.Create().WithBodyAsJson(new { x = "x" }).WithTransformer();
-            var mapping = new Mapping(Guid.NewGuid(), "", null, _fileSystemHandlerMock.Object, request, response, 42, null, null, null);
+            var mapping = new Mapping(Guid.NewGuid(), "", null, _settingsMock.Object, request, response, 42, null, null, null);
 
             // Act
             var model = MappingConverter.ToMappingModel(mapping);

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

@@ -0,0 +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);
+        }
+    }
+}

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

@@ -125,5 +125,28 @@ Content-Type: text/html
             Check.That(body.DetectedBodyType).IsEqualTo(detectedBodyType);
             Check.That(body.DetectedBodyTypeFromContentType).IsEqualTo(detectedBodyTypeFromContentType);
         }
+
+        [Theory]
+        [InlineData("HEAD", false)]
+        [InlineData("GET", false)]
+        [InlineData("PUT", true)]
+        [InlineData("POST", true)]
+        [InlineData("DELETE", false)]
+        [InlineData("TRACE", false)]
+        [InlineData("OPTIONS", true)]
+        [InlineData("CONNECT", false)]
+        [InlineData("PATCH", true)]
+        public void BodyParser_ShouldParseBody_ExpectedResultForKnownMethods(string method, bool resultShouldBe)
+        {
+            Check.That(BodyParser.ShouldParseBody(method)).Equals(resultShouldBe);
+        }
+
+        [Theory]
+        [InlineData("REPORT")]
+        [InlineData("SOME-UNKNOWN-METHOD")]
+        public void BodyParser_ShouldParseBody_DefaultIsTrueForUnknownMethods(string method)
+        {
+            Check.That(BodyParser.ShouldParseBody(method)).IsTrue();
+        }
     }
 }

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

@@ -1,7 +1,6 @@
-using System;
-using System.IO;
+using FluentAssertions;
 using Moq;
-using NFluent;
+using System;
 using WireMock.Handlers;
 using WireMock.Util;
 using Xunit;
@@ -11,31 +10,36 @@ namespace WireMock.Net.Tests.Util
     public class FileHelperTests
     {
         [Fact]
-        public void FileHelper_ReadAllTextWithRetryAndDelay()
+        public void TryReadMappingFileWithRetryAndDelay_WithIFileSystemHandlerOk_ReturnsTrue()
         {
             // Assign
             var staticMappingHandlerMock = new Mock<IFileSystemHandler>();
             staticMappingHandlerMock.Setup(m => m.ReadMappingFile(It.IsAny<string>())).Returns("text");
 
             // Act
-            string result = FileHelper.ReadAllTextWithRetryAndDelay(staticMappingHandlerMock.Object, @"c:\temp");
+            bool result = FileHelper.TryReadMappingFileWithRetryAndDelay(staticMappingHandlerMock.Object, @"c:\temp", out string value);
 
             // Assert
-            Check.That(result).Equals("text");
+            result.Should().BeTrue();
+            value.Should().Be("text");
 
             // Verify
             staticMappingHandlerMock.Verify(m => m.ReadMappingFile(@"c:\temp"), Times.Once);
         }
 
         [Fact]
-        public void FileHelper_ReadAllTextWithRetryAndDelay_Throws()
+        public void TryReadMappingFileWithRetryAndDelay_WithIFileSystemHandlerThrows_ReturnsFalse()
         {
             // Assign
             var staticMappingHandlerMock = new Mock<IFileSystemHandler>();
             staticMappingHandlerMock.Setup(m => m.ReadMappingFile(It.IsAny<string>())).Throws<NotSupportedException>();
 
             // Act
-            Check.ThatCode(() => FileHelper.ReadAllTextWithRetryAndDelay(staticMappingHandlerMock.Object, @"c:\temp")).Throws<IOException>();
+            bool result = FileHelper.TryReadMappingFileWithRetryAndDelay(staticMappingHandlerMock.Object, @"c:\temp", out string value);
+
+            // Assert
+            result.Should().BeFalse();
+            value.Should().BeNull();
 
             // Verify
             staticMappingHandlerMock.Verify(m => m.ReadMappingFile(@"c:\temp"), Times.Exactly(3));