Restricted ResponseHeaders (#126)

* Fix for issue #118

* Adding test cases for fix #118

* Moved the namespace in using block for fix #118

CHANGELOG.md

@@ -1,3 +1,28 @@
+# 1.0.3.16 (15 April 2018)
+
+ - [#125](https://github.com/WireMock-Net/WireMock.Net/pull/125) - Change listen from loopback to any ip address for dotnetcore2.0 apps contributed by ([SubjectiveReality](https://github.com/SubjectiveReality))
+ - [#124](https://github.com/WireMock-Net/WireMock.Net/issues/124) - Issue: Unable to get host to listen on ips other than 127.0.0.1 using StandAloneApp
+ - [#121](https://github.com/WireMock-Net/WireMock.Net/pull/121) - Fix for issue #118 contributed by ([raghavendrabankapur](https://github.com/raghavendrabankapur)) +fix
+ - [#118](https://github.com/WireMock-Net/WireMock.Net/issues/118) - Not reading the response from a file when mappings are placed in json file
+
+Commits: 7bd63a0baf...1bcdfe31ab
+
+
+# 1.0.3.15 (05 April 2018)
+
+ - [#117](https://github.com/WireMock-Net/WireMock.Net/pull/117) - Respect start timeout setting and expose exception from server startup contributed by Evan Liang ([evanlwj](https://github.com/evanlwj))
+
+Commits: 2d2a2dd6fc...4f294baff2
+
+
+# 1.0.3.14 (01 April 2018)
+
+ - [#114](https://github.com/WireMock-Net/WireMock.Net/issues/114) - Feature: Add PathSegments in Transform +feature
+ - [#113](https://github.com/WireMock-Net/WireMock.Net/issues/113) - Feature: Add BodyAsJsonIndented for response message +feature
+
+Commits: bdb79aec95...e87f970057
+
+
 # 1.0.3.12 (24 March 2018)
 
  - [#100](https://github.com/WireMock-Net/WireMock.Net/issues/100) - Issue: JsonPathMatcher - not working for rootless jsons?

GitReleaseNotes.txt

@@ -1,5 +1,5 @@
 https://github.com/GitTools/GitReleaseNotes
 
-GitReleaseNotes.exe . /OutputFile CHANGELOG.md /Version 1.0.3.11
+GitReleaseNotes.exe . /OutputFile CHANGELOG.md /Version 1.0.3.16
 
 GitReleaseNotes.exe . /OutputFile CHANGELOG.md /allTags

WireMock.Net Solution.sln

@@ -14,6 +14,7 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution
 		GitReleaseNotes.txt = GitReleaseNotes.txt
 		README.md = README.md
 		ReSharper_WireMock.DotSettings = ReSharper_WireMock.DotSettings
+		WireMock.Net Solution.sln.DotSettings = WireMock.Net Solution.sln.DotSettings
 	EndProjectSection
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "examples", "examples", "{F0C22C47-DF71-463C-9B04-B4E0F3B8708A}"

WireMock.Net Solution.sln.DotSettings

@@ -1,3 +1,11 @@
 <wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=ID/@EntryIndexedValue">ID</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=IP/@EntryIndexedValue">IP</s:String>
-	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=SSL/@EntryIndexedValue">SSL</s:String></wpf:ResourceDictionary>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=MD/@EntryIndexedValue">MD5</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=SSL/@EntryIndexedValue">SSL</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=TE/@EntryIndexedValue">TE</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=TSV/@EntryIndexedValue">TSV</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=WWW/@EntryIndexedValue">WWW</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=XMS/@EntryIndexedValue">XMS</s:String>
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=XUA/@EntryIndexedValue">XUA</s:String>
+</wpf:ResourceDictionary>

examples/WireMock.Net.ConsoleApplication/MainApp.cs

@@ -160,18 +160,17 @@ namespace WireMock.Net.ConsoleApplication
                 .RespondWith(Response.Create().WithStatusCode(200).WithBody("partial = 200"));
 
             // http://localhost:8080/any/any?start=1000&stop=1&stop=2
-            //server
-            //    .Given(Request.Create().WithPath("/*").UsingGet())
-            //    .WithGuid("90356dba-b36c-469a-a17e-669cd84f1f05")
-            //    .AtPriority(server.Mappings.Count() + 1)
-            //    .RespondWith(Response.Create()
-            //        .WithStatusCode(200)
-            //        .WithHeader("Content-Type", "application/json")
-            //        .WithHeader("Transformed-Postman-Token", "token is {{request.headers.Postman-Token}}")
-            //        .WithBody(@"{""msg"": ""Hello world CATCH-ALL on /*, {{request.path}}, bykey={{request.query.start}}, bykey={{request.query.stop}}, byidx0={{request.query.stop.[0]}}, byidx1={{request.query.stop.[1]}}"" }")
-            //        .WithTransformer()
-            //        .WithDelay(TimeSpan.FromMilliseconds(100))
-            //    );
+            server
+                .Given(Request.Create().WithPath("/trans").UsingGet())
+                .WithGuid("90356dba-b36c-469a-a17e-669cd84f1f05")
+                .RespondWith(Response.Create()
+                    .WithStatusCode(200)
+                    .WithHeader("Content-Type", "application/json")
+                    .WithHeader("Transformed-Postman-Token", "token is {{request.headers.Postman-Token}}")
+                    .WithBody(@"{""msg"": ""Hello world CATCH-ALL on /*, {{request.path}}, bykey={{request.query.start}}, bykey={{request.query.stop}}, byidx0={{request.query.stop.[0]}}, byidx1={{request.query.stop.[1]}}"" }")
+                    .WithTransformer()
+                    .WithDelay(TimeSpan.FromMilliseconds(100))
+                );
 
             server
                 .Given(Request.Create()

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

@@ -3,7 +3,7 @@
   <PropertyGroup>
     <Description>Lightweight StandAlone Http Mocking Server for .Net.</Description>
     <AssemblyTitle>WireMock.Net.StandAlone</AssemblyTitle>
-    <Version>1.0.3.13</Version>
+    <Version>1.0.3.16</Version>
     <Authors>Stef Heyenrath</Authors>
     <TargetFrameworks>net452;net46;netstandard1.3;netstandard2.0</TargetFrameworks>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>

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

@@ -32,6 +32,11 @@ namespace WireMock.Admin.Mappings
         /// </summary>
         public object BodyAsJson { get; set; }
 
+        /// <summary>
+        /// Gets or sets a value indicating whether child objects to be indented according to the Newtonsoft.Json.JsonTextWriter.Indentation and Newtonsoft.Json.JsonTextWriter.IndentChar settings.
+        /// </summary>
+        public bool? BodyAsJsonIndented { get; set; }
+
         /// <summary>
         /// Gets or sets the body (as bytearray).
         /// </summary>

src/WireMock.Net/Owin/AspNetCoreSelfHost.cs

@@ -9,6 +9,7 @@ using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Hosting;
 using WireMock.Http;
 using WireMock.HttpsCertificate;
+using WireMock.Logging;
 using WireMock.Validation;
 
 namespace WireMock.Owin
@@ -18,6 +19,8 @@ namespace WireMock.Owin
         private readonly CancellationTokenSource _cts = new CancellationTokenSource();
         private readonly WireMockMiddlewareOptions _options;
         private readonly string[] _urls;
+        private readonly IWireMockLogger _logger;
+        private Exception _runningException;
 
         private IWebHost _host;
 
@@ -27,11 +30,15 @@ namespace WireMock.Owin
 
         public List<int> Ports { get; } = new List<int>();
 
+        public Exception RunningException => _runningException;
+
         public AspNetCoreSelfHost([NotNull] WireMockMiddlewareOptions options, [NotNull] params string[] uriPrefixes)
         {
             Check.NotNull(options, nameof(options));
             Check.NotNullOrEmpty(uriPrefixes, nameof(uriPrefixes));
 
+            _logger = options.Logger ?? new WireMockConsoleLogger();
+
             foreach (string uriPrefix in uriPrefixes)
             {
                 Urls.Add(uriPrefix);
@@ -69,13 +76,13 @@ namespace WireMock.Owin
                     foreach (string url in _urls.Where(u => u.StartsWith("http://", StringComparison.OrdinalIgnoreCase)))
                     {
                         PortUtil.TryExtractProtocolAndPort(url, out string host, out int port);
-                        options.Listen(System.Net.IPAddress.Loopback, port);
+                        options.Listen(System.Net.IPAddress.Any, port);
                     }
 
                     foreach (string url in _urls.Where(u => u.StartsWith("https://", StringComparison.OrdinalIgnoreCase)))
                     {
                         PortUtil.TryExtractProtocolAndPort(url, out string host, out int port);
-                        options.Listen(System.Net.IPAddress.Loopback, port, listenOptions =>
+                        options.Listen(System.Net.IPAddress.Any, port, listenOptions =>
                         {
                             listenOptions.UseHttps(PublicCertificateHelper.GetX509Certificate2());
                         });
@@ -89,20 +96,34 @@ namespace WireMock.Owin
 
             IsStarted = true;
 
-#if NETSTANDARD1_3
-            Console.WriteLine("WireMock.Net server using netstandard1.3");
             return Task.Run(() =>
             {
-                _host.Run(_cts.Token);
+                StartServers();
             }, _cts.Token);
-#else
-            System.Console.WriteLine("WireMock.Net server using netstandard2.0");
+        }
 
-            return Task.Run(() =>
+        private void StartServers()
+        {
+            try
             {
+                IsStarted = true;
+#if NETSTANDARD1_3
+                _logger.Info("WireMock.Net server using netstandard1.3");
+                _host.Run(_cts.Token);
+#else
+                _logger.Info("WireMock.Net server using netstandard2.0");
                 _host.Run();
-            }, _cts.Token);
 #endif
+            }
+            catch (Exception e)
+            {
+                _runningException = e;
+                _logger.Error(e.ToString());
+            }
+            finally
+            {
+                IsStarted = false;
+            }
         }
 
         public Task StopAsync()

src/WireMock.Net/Owin/IOwinSelfHost.cs

@@ -1,5 +1,6 @@
 using System.Collections.Generic;
 using System.Threading.Tasks;
+using System;
 
 namespace WireMock.Owin
 {
@@ -16,19 +17,18 @@ namespace WireMock.Owin
         /// <summary>
         /// Gets the urls.
         /// </summary>
-        /// <value>
-        /// The urls.
-        /// </value>
         List<string> Urls { get; }
 
         /// <summary>
         /// Gets the ports.
         /// </summary>
-        /// <value>
-        /// The ports.
-        /// </value>
         List<int> Ports { get; }
 
+        /// <summary>
+        /// The exception occurred when the host is running
+        /// </summary>
+        Exception RunningException { get; }
+
         Task StartAsync();
 
         Task StopAsync();

src/WireMock.Net/Owin/OwinRequestMapper.cs

@@ -1,8 +1,6 @@
 using System;
 using System.Collections.Generic;
-// using System.IO;
 using System.Linq;
-// using System.Text;
 using System.Threading.Tasks;
 using WireMock.Util;
 #if !NETSTANDARD

src/WireMock.Net/Owin/OwinResponseMapper.cs

@@ -5,6 +5,7 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 using Newtonsoft.Json;
+using WireMock.Http;
 using WireMock.Util;
 #if !NETSTANDARD
 using Microsoft.Owin;
@@ -21,17 +22,27 @@ namespace WireMock.Owin
     {
         private readonly Encoding _utf8NoBom = new UTF8Encoding(false);
 
-        // https://stackoverflow.com/questions/239725/cannot-set-some-http-headers-when-using-system-net-webrequest
+        // https://msdn.microsoft.com/en-us/library/78h415ay(v=vs.110).aspx
 #if !NETSTANDARD
         private static readonly IDictionary<string, Action<IOwinResponse, WireMockList<string>>> RestrictedResponseHeaders = new Dictionary<string, Action<IOwinResponse, WireMockList<string>>>(StringComparer.OrdinalIgnoreCase) {
 #else
         private static readonly IDictionary<string, Action<HttpResponse, WireMockList<string>>> RestrictedResponseHeaders = new Dictionary<string, Action<HttpResponse, WireMockList<string>>>(StringComparer.OrdinalIgnoreCase) {
 #endif
-            { "Content-Length", null },
-            { "Content-Type", (r, v) => r.ContentType = v.FirstOrDefault() },
-            { "Keep-Alive", null },
-            { "Transfer-Encoding", null },
-            { "WWW-Authenticate", null }
+            { HttpKnownHeaderNames.Accept, null },
+            { HttpKnownHeaderNames.Connection, null },
+            { HttpKnownHeaderNames.ContentLength, null },
+            { HttpKnownHeaderNames.ContentType, (r, v) => r.ContentType = v.FirstOrDefault() },
+            { HttpKnownHeaderNames.Date, null },
+            { HttpKnownHeaderNames.Expect, null },
+            { HttpKnownHeaderNames.Host, null },
+            { HttpKnownHeaderNames.IfModifiedSince, null },
+            { HttpKnownHeaderNames.KeepAlive, null },
+            { HttpKnownHeaderNames.Range, null },
+            { HttpKnownHeaderNames.Referer, null },
+            { HttpKnownHeaderNames.TransferEncoding, null },
+            { HttpKnownHeaderNames.UserAgent, null },
+            { HttpKnownHeaderNames.ProxyConnection, null },
+            { HttpKnownHeaderNames.WWWAuthenticate, null }
         };
 
         /// <summary>
@@ -87,7 +98,8 @@ namespace WireMock.Owin
 
             if (responseMessage.BodyAsJson != null)
             {
-                string jsonBody = JsonConvert.SerializeObject(responseMessage.BodyAsJson, new JsonSerializerSettings { Formatting = Formatting.None, NullValueHandling = NullValueHandling.Ignore });
+                Formatting formatting = responseMessage.BodyAsJsonIndented == true ? Formatting.Indented : Formatting.None;
+                string jsonBody = JsonConvert.SerializeObject(responseMessage.BodyAsJson, new JsonSerializerSettings { Formatting = formatting, NullValueHandling = NullValueHandling.Ignore });
                 using (var writer = new StreamWriter(response.Body, responseMessage.BodyEncoding ?? _utf8NoBom))
                 {
                     await writer.WriteAsync(jsonBody);

src/WireMock.Net/Owin/OwinSelfHost.cs

@@ -1,13 +1,14 @@
 #if !NETSTANDARD
+using JetBrains.Annotations;
+using Microsoft.Owin.Hosting;
+using Owin;
 using System;
 using System.Collections.Generic;
 using System.Threading;
 using System.Threading.Tasks;
-using JetBrains.Annotations;
-using WireMock.Validation;
-using Owin;
-using Microsoft.Owin.Hosting;
 using WireMock.Http;
+using WireMock.Logging;
+using WireMock.Validation;
 
 namespace WireMock.Owin
 {
@@ -15,12 +16,16 @@ namespace WireMock.Owin
     {
         private readonly WireMockMiddlewareOptions _options;
         private readonly CancellationTokenSource _cts = new CancellationTokenSource();
+        private readonly IWireMockLogger _logger;
+        private Exception _runningException;
 
         public OwinSelfHost([NotNull] WireMockMiddlewareOptions options, [NotNull] params string[] uriPrefixes)
         {
             Check.NotNull(options, nameof(options));
             Check.NotNullOrEmpty(uriPrefixes, nameof(uriPrefixes));
 
+            _logger = options.Logger ?? new WireMockConsoleLogger();
+
             foreach (string uriPrefix in uriPrefixes)
             {
                 Urls.Add(uriPrefix);
@@ -38,6 +43,8 @@ namespace WireMock.Owin
 
         public List<int> Ports { get; } = new List<int>();
 
+        public Exception RunningException => _runningException;
+
         [PublicAPI]
         public Task StartAsync()
         {
@@ -58,37 +65,46 @@ namespace WireMock.Owin
         private void StartServers()
         {
 #if NET46
-            Console.WriteLine("WireMock.Net server using .net 4.6.x or higher");
+            _logger.Info("WireMock.Net server using .net 4.6.x or higher");
 #else
-            Console.WriteLine("WireMock.Net server using .net 4.5.x or higher");
+            _logger.Info("WireMock.Net server using .net 4.5.x or higher");
 #endif
-
-            Action<IAppBuilder> startup = app =>
-            {
-                app.Use<GlobalExceptionMiddleware>(_options);
-                _options.PreWireMockMiddlewareInit?.Invoke(app);
-                app.Use<WireMockMiddleware>(_options);
-                _options.PostWireMockMiddlewareInit?.Invoke(app);
-            };
-
             var servers = new List<IDisposable>();
-            foreach (var url in Urls)
+
+            try
             {
-                servers.Add(WebApp.Start(url, startup));
+                Action<IAppBuilder> startup = app =>
+                {
+                    app.Use<GlobalExceptionMiddleware>(_options);
+                    _options.PreWireMockMiddlewareInit?.Invoke(app);
+                    app.Use<WireMockMiddleware>(_options);
+                    _options.PostWireMockMiddlewareInit?.Invoke(app);
+                };
+
+                foreach (var url in Urls)
+                {
+                    servers.Add(WebApp.Start(url, startup));
+                }
+
+                IsStarted = true;
+
+                // WaitHandle is signaled when the token is cancelled,
+                // which will be more efficent than Thread.Sleep in while loop
+                _cts.Token.WaitHandle.WaitOne();
             }
-
-            IsStarted = true;
-
-            while (!_cts.IsCancellationRequested)
+            catch (Exception e)
             {
-                Thread.Sleep(30000);
+                // Expose exception of starting host, otherwise it's hard to be troubleshooting if keeping quiet
+                // For example, WebApp.Start will fail with System.MissingMemberException if Microsoft.Owin.Host.HttpListener.dll is being located
+                // https://stackoverflow.com/questions/25090211/owin-httplistener-not-located/31369857
+                _runningException = e;
+                _logger.Error(e.ToString());
             }
-
-            IsStarted = false;
-
-            foreach (var server in servers)
+            finally
             {
-                server.Dispose();
+                IsStarted = false;
+                // Dispose all servers in finally block to make sure clean up allocated resource on error happening
+                servers.ForEach(s => s.Dispose());
             }
         }
     }

src/WireMock.Net/RequestMessage.cs

@@ -34,6 +34,11 @@ namespace WireMock
         /// </summary>
         public string Path { get; }
 
+        /// <summary>
+        /// Gets the path segments.
+        /// </summary>
+        public string[] PathSegments { get; }
+
         /// <summary>
         /// Gets the method.
         /// </summary>
@@ -120,6 +125,7 @@ namespace WireMock
             Port = url.Port;
             Origin = $"{url.Scheme}://{url.Host}:{url.Port}";
             Path = WebUtility.UrlDecode(url.AbsolutePath);
+            PathSegments = Path.Split('/').Skip(1).ToArray();
             Method = method.ToLower();
             ClientIP = clientIP;
 
@@ -157,11 +163,14 @@ namespace WireMock
             Port = url.Port;
             Origin = $"{url.Scheme}://{url.Host}:{url.Port}";
             Path = WebUtility.UrlDecode(url.AbsolutePath);
+            PathSegments = Path.Split('/').Skip(1).ToArray();
             Method = method.ToLower();
             ClientIP = clientIP;
+
             BodyAsBytes = bodyAsBytes;
             Body = body;
             BodyEncoding = bodyEncoding;
+
             Headers = headers?.ToDictionary(header => header.Key, header => new WireMockList<string>(header.Value));
             Cookies = cookies;
             RawQuery = WebUtility.UrlDecode(url.Query);

src/WireMock.Net/ResponseBuilders/IBodyResponseBuilder.cs

@@ -18,7 +18,6 @@ namespace WireMock.ResponseBuilders
         /// <returns>A <see cref="IResponseBuilder"/>.</returns>
         IResponseBuilder WithBody([NotNull] string body, [CanBeNull] string destination = BodyDestinationFormat.SameAsSource, [CanBeNull] Encoding encoding = null);
 
-
         /// <summary>
         /// WithBody : Create a ... response based on a callback function.
         /// </summary>
@@ -26,8 +25,7 @@ namespace WireMock.ResponseBuilders
         /// <param name="destination">The Body Destination format (SameAsSource, String or Bytes).</param>
         /// <param name="encoding">The body encoding.</param>
         /// <returns>A <see cref="IResponseBuilder"/>.</returns>
-        IResponseBuilder WithBody([NotNull] Func<RequestMessage,string> bodyFactory, [CanBeNull] string destination = BodyDestinationFormat.SameAsSource, [CanBeNull] Encoding encoding = null);
-
+        IResponseBuilder WithBody([NotNull] Func<RequestMessage, string> bodyFactory, [CanBeNull] string destination = BodyDestinationFormat.SameAsSource, [CanBeNull] Encoding encoding = null);
 
         /// <summary>
         /// WithBody : Create a ... response based on a bytearray.
@@ -43,8 +41,17 @@ namespace WireMock.ResponseBuilders
         /// </summary>
         /// <param name="body">The body.</param>
         /// <param name="encoding">The body encoding.</param>
+        /// <param name="indented">Use JSON indented.</param>
         /// <returns>A <see cref="IResponseBuilder"/>.</returns>
-        IResponseBuilder WithBodyAsJson([NotNull] object body, [CanBeNull] Encoding encoding = null);
+        IResponseBuilder WithBodyAsJson([NotNull] object body, [CanBeNull] Encoding encoding = null, bool? indented = null);
+
+        /// <summary>
+        /// WithBody : Create a string response based on a object (which will be converted to a JSON string).
+        /// </summary>
+        /// <param name="body">The body.</param>
+        /// <param name="indented">Define whether child objects to be indented according to the Newtonsoft.Json.JsonTextWriter.Indentation and Newtonsoft.Json.JsonTextWriter.IndentChar settings.</param>
+        /// <returns>A <see cref="IResponseBuilder"/>.</returns>
+        IResponseBuilder WithBodyAsJson([NotNull] object body, bool indented);
 
         /// <summary>
         /// WithBody : Create a string response based on a Base64 string (which will be decoded to a normal string).

src/WireMock.Net/ResponseBuilders/Response.cs

@@ -31,9 +31,6 @@ namespace WireMock.ResponseBuilders
         /// <summary>
         /// Gets a value indicating whether [use transformer].
         /// </summary>
-        /// <value>
-        ///   <c>true</c> if [use transformer]; otherwise, <c>false</c>.
-        /// </value>
         public bool UseTransformer { get; private set; }
 
         /// <summary>
@@ -258,18 +255,25 @@ namespace WireMock.ResponseBuilders
             return this;
         }
 
-        /// <inheritdoc cref="IBodyResponseBuilder.WithBodyAsJson"/>
-        public IResponseBuilder WithBodyAsJson(object body, Encoding encoding = null)
+        /// <inheritdoc cref="IBodyResponseBuilder.WithBodyAsJson(object, Encoding, bool?)"/>
+        public IResponseBuilder WithBodyAsJson(object body, Encoding encoding = null, bool? indented = null)
         {
             Check.NotNull(body, nameof(body));
 
             ResponseMessage.BodyDestination = null;
             ResponseMessage.BodyAsJson = body;
             ResponseMessage.BodyEncoding = encoding;
+            ResponseMessage.BodyAsJsonIndented = indented;
 
             return this;
         }
 
+        /// <inheritdoc cref="IBodyResponseBuilder.WithBodyAsJson(object, bool)"/>
+        public IResponseBuilder WithBodyAsJson(object body, bool indented)
+        {
+            return WithBodyAsJson(body, null, indented);
+        }
+
         /// <inheritdoc cref="IBodyResponseBuilder.WithBodyFromBase64"/>
         public IResponseBuilder WithBodyFromBase64(string bodyAsbase64, Encoding encoding = null)
         {

src/WireMock.Net/ResponseMessage.cs

@@ -42,6 +42,11 @@ namespace WireMock
         /// </summary>
         public object BodyAsJson { get; set; }
 
+        /// <summary>
+        /// Gets or sets a value indicating whether child objects to be indented according to the Newtonsoft.Json.JsonTextWriter.Indentation and Newtonsoft.Json.JsonTextWriter.IndentChar settings.
+        /// </summary>
+        public bool? BodyAsJsonIndented { get; set; }
+
         /// <summary>
         /// Gets or sets the body as bytes.
         /// </summary>

src/WireMock.Net/Serialization/MappingConverter.cs

@@ -1,7 +1,5 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Linq;
-using JetBrains.Annotations;
 using WireMock.Admin.Mappings;
 using WireMock.Matchers.Request;
 using WireMock.RequestBuilders;
@@ -96,6 +94,7 @@ namespace WireMock.Serialization
                 mappingModel.Response.Headers = null;
                 mappingModel.Response.BodyDestination = null;
                 mappingModel.Response.BodyAsJson = null;
+                mappingModel.Response.BodyAsJsonIndented = null;
                 mappingModel.Response.Body = null;
                 mappingModel.Response.BodyAsBytes = null;
                 mappingModel.Response.BodyAsFile = null;
@@ -110,6 +109,7 @@ namespace WireMock.Serialization
                 mappingModel.Response.StatusCode = response.ResponseMessage.StatusCode;
                 mappingModel.Response.Headers = Map(response.ResponseMessage.Headers);
                 mappingModel.Response.BodyAsJson = response.ResponseMessage.BodyAsJson;
+                mappingModel.Response.BodyAsJsonIndented = response.ResponseMessage.BodyAsJsonIndented;
                 mappingModel.Response.Body = response.ResponseMessage.Body;
                 mappingModel.Response.BodyAsBytes = response.ResponseMessage.BodyAsBytes;
                 mappingModel.Response.BodyAsFile = response.ResponseMessage.BodyAsFile;
@@ -147,16 +147,14 @@ namespace WireMock.Serialization
             return newDictionary;
         }
 
+        //private static string[] Map<T>([CanBeNull] IEnumerable<Func<T, bool>> funcs)
+        //{
+        //    return funcs?.Select(Map).Where(x => x != null).ToArray();
+        //}
 
-
-        private static string[] Map<T>([CanBeNull] IEnumerable<Func<T, bool>> funcs)
-        {
-            return funcs?.Select(Map).Where(x => x != null).ToArray();
-        }
-
-        private static string Map<T>([CanBeNull] Func<T, bool> func)
-        {
-            return func?.ToString();
-        }
+        //private static string Map<T>([CanBeNull] Func<T, bool> func)
+        //{
+        //    return func?.ToString();
+        //}
     }
 }

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

@@ -266,17 +266,19 @@ namespace WireMock.Server
 
         private ResponseMessage SettingsUpdate(RequestMessage requestMessage)
         {
-            var settings = requestMessage.Body != null ? JsonConvert.DeserializeObject<SettingsModel>(requestMessage.Body) : ((JObject)requestMessage.BodyAsJson).ToObject<SettingsModel>();
-
-            if (settings.AllowPartialMapping != null)
-                _options.AllowPartialMapping = settings.AllowPartialMapping.Value;
-
+            var settings = DeserializeObject<SettingsModel>(requestMessage);
             _options.MaxRequestLogCount = settings.MaxRequestLogCount;
-
             _options.RequestLogExpirationDuration = settings.RequestLogExpirationDuration;
 
+            if (settings.AllowPartialMapping != null)
+            {
+                _options.AllowPartialMapping = settings.AllowPartialMapping.Value;
+            }
+
             if (settings.GlobalProcessingDelay != null)
+            {
                 _options.RequestProcessingDelay = TimeSpan.FromMilliseconds(settings.GlobalProcessingDelay.Value);
+            }
 
             return new ResponseMessage { Body = "Settings updated" };
         }
@@ -303,7 +305,7 @@ namespace WireMock.Server
         {
             Guid guid = Guid.Parse(requestMessage.Path.TrimStart(AdminMappings.ToCharArray()));
 
-            MappingModel mappingModel = requestMessage.Body != null ? JsonConvert.DeserializeObject<MappingModel>(requestMessage.Body) : ((JObject)requestMessage.BodyAsJson).ToObject<MappingModel>();
+            var mappingModel = DeserializeObject<MappingModel>(requestMessage);
             DeserializeAndAddOrUpdateMapping(mappingModel, guid);
 
             return new ResponseMessage { Body = "Mapping added or updated" };
@@ -371,7 +373,7 @@ namespace WireMock.Server
         {
             try
             {
-                MappingModel mappingModel = requestMessage.Body != null ? JsonConvert.DeserializeObject<MappingModel>(requestMessage.Body) : ((JObject)requestMessage.BodyAsJson).ToObject<MappingModel>();
+                var mappingModel = DeserializeObject<MappingModel>(requestMessage);
                 DeserializeAndAddOrUpdateMapping(mappingModel);
             }
             catch (ArgumentException a)
@@ -552,7 +554,7 @@ namespace WireMock.Server
         #region Requests/find
         private ResponseMessage RequestsFind(RequestMessage requestMessage)
         {
-            var requestModel = requestMessage.Body != null ? JsonConvert.DeserializeObject<RequestModel>(requestMessage.Body) : ((JObject)requestMessage.BodyAsJson).ToObject<RequestModel>();
+            var requestModel = DeserializeObject<RequestModel>(requestMessage);
 
             var request = (Request)InitRequestBuilder(requestModel);
 
@@ -598,8 +600,7 @@ namespace WireMock.Server
 
             if (requestModel.ClientIP != null)
             {
-                string clientIP = requestModel.ClientIP as string;
-                if (clientIP != null)
+                if (requestModel.ClientIP is string clientIP)
                 {
                     requestBuilder = requestBuilder.WithClientIP(clientIP);
                 }
@@ -615,8 +616,7 @@ namespace WireMock.Server
 
             if (requestModel.Path != null)
             {
-                string path = requestModel.Path as string;
-                if (path != null)
+                if (requestModel.Path is string path)
                 {
                     requestBuilder = requestBuilder.WithPath(path);
                 }
@@ -632,8 +632,7 @@ namespace WireMock.Server
 
             if (requestModel.Url != null)
             {
-                string url = requestModel.Url as string;
-                if (url != null)
+                if (requestModel.Url is string url)
                 {
                     requestBuilder = requestBuilder.WithUrl(url);
                 }
@@ -739,13 +738,18 @@ namespace WireMock.Server
             }
             else if (responseModel.BodyAsJson != null)
             {
-                responseBuilder = responseBuilder.WithBodyAsJson(responseModel.BodyAsJson, ToEncoding(responseModel.BodyEncoding));
+                responseBuilder = responseBuilder.WithBodyAsJson(responseModel.BodyAsJson, ToEncoding(responseModel.BodyEncoding), responseModel.BodyAsJsonIndented == true);
             }
             else if (responseModel.BodyFromBase64 != null)
             {
                 responseBuilder = responseBuilder.WithBodyFromBase64(responseModel.BodyFromBase64, ToEncoding(responseModel.BodyEncoding));
             }
 
+            else if (responseModel.BodyAsFile != null)
+            {
+                responseBuilder = responseBuilder.WithBodyFromFile(responseModel.BodyAsFile);
+            }
+
             if (responseModel.UseTransformer)
             {
                 responseBuilder = responseBuilder.WithTransformer();
@@ -768,5 +772,12 @@ namespace WireMock.Server
         {
             return encodingModel != null ? Encoding.GetEncoding(encodingModel.CodePage) : null;
         }
+
+        private T DeserializeObject<T>(RequestMessage requestMessage)
+        {
+            return requestMessage.Body != null ?
+                JsonConvert.DeserializeObject<T>(requestMessage.Body) :
+                ((JObject)requestMessage.BodyAsJson).ToObject<T>();
+        }
     }
 }

src/WireMock.Net/Server/FluentMockServer.cs

@@ -1,20 +1,20 @@
+using JetBrains.Annotations;
+using Newtonsoft.Json;
 using System;
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
-using System.Threading.Tasks;
-using JetBrains.Annotations;
-using Newtonsoft.Json;
+using System.Threading;
 using WireMock.Http;
 using WireMock.Logging;
 using WireMock.Matchers;
 using WireMock.Matchers.Request;
+using WireMock.Owin;
 using WireMock.RequestBuilders;
+using WireMock.ResponseProviders;
 using WireMock.Settings;
 using WireMock.Validation;
-using WireMock.Owin;
-using WireMock.ResponseProviders;
 
 namespace WireMock.Server
 {
@@ -32,7 +32,7 @@ namespace WireMock.Server
         /// Gets a value indicating whether this server is started.
         /// </summary>
         [PublicAPI]
-        public bool IsStarted { get; }
+        public bool IsStarted => _httpServer != null && _httpServer.IsStarted;
 
         /// <summary>
         /// Gets the ports.
@@ -186,10 +186,23 @@ namespace WireMock.Server
 
             _httpServer.StartAsync();
 
-            // Fix for 'Bug: Server not listening after Start() returns (on macOS)'
-            Task.Delay(ServerStartDelay).Wait();
-
-            IsStarted = _httpServer.IsStarted;
+            using (var ctsStartTimeout = new CancellationTokenSource(settings.StartTimeout))
+            {
+                while (!_httpServer.IsStarted)
+                {
+                    // Throw out exception if service start fails
+                    if (_httpServer.RunningException != null)
+                    {
+                        throw new Exception($"Service start failed with error: {_httpServer.RunningException.Message}", _httpServer.RunningException);
+                    }
+                    // Respect start timeout setting by throwing TimeoutException
+                    if (ctsStartTimeout.IsCancellationRequested)
+                    {
+                        throw new TimeoutException($"Service start timed out after {TimeSpan.FromMilliseconds(settings.StartTimeout)}");
+                    }
+                    ctsStartTimeout.Token.WaitHandle.WaitOne(ServerStartDelay);
+                }
+            }
 
             if (settings.AllowPartialMapping == true)
             {

src/WireMock.Net/Transformers/ResponseMessageTransformer.cs

@@ -21,7 +21,8 @@ namespace WireMock.Transformers
             var template = new { request = requestMessage };
 
             // Body
-            string body = bodyIsJson ? JsonConvert.SerializeObject(original.BodyAsJson) : original.Body;
+            Formatting formatting = original.BodyAsJsonIndented == true ? Formatting.Indented : Formatting.None;
+            string body = bodyIsJson ? JsonConvert.SerializeObject(original.BodyAsJson, formatting) : original.Body;
             if (body != null)
             {
                 var templateBody = Handlebars.Compile(body);

src/WireMock.Net/Util/JsonUtils.cs

@@ -11,8 +11,7 @@ namespace WireMock.Util
                 return default(T);
             }
 
-            var token = value as JToken;
-            return token == null ? default(T) : token.ToObject<T>();
+            return !(value is JToken token) ? default(T) : token.ToObject<T>();
         }
     }
 }

src/WireMock.Net/WireMock.Net.csproj

@@ -3,7 +3,7 @@
   <PropertyGroup>
     <Description>Lightweight Http Mocking Server for .Net, inspired by WireMock from the Java landscape.</Description>
     <AssemblyTitle>WireMock.Net</AssemblyTitle>
-    <Version>1.0.3.13</Version>
+    <Version>1.0.3.16</Version>
     <Authors>Stef Heyenrath</Authors>
     <TargetFrameworks>net452;net46;netstandard1.3;netstandard2.0</TargetFrameworks>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>

test/WireMock.Net.Tests/FluentMockServerTests.cs

@@ -11,6 +11,7 @@ using WireMock.RequestBuilders;
 using WireMock.ResponseBuilders;
 using WireMock.Server;
 using Xunit;
+using Newtonsoft.Json;
 
 namespace WireMock.Net.Tests
 {
@@ -76,6 +77,34 @@ namespace WireMock.Net.Tests
             Check.That(mappings.First().Title).IsNullOrEmpty();
         }
 
+        [Fact]
+        public void FluentMockServer_ReadStaticMapping_WithResponseBodyFromFile()
+        {
+            string guid = "00000002-ee28-4f29-ae63-1ac9b0802d87";
+
+            string folder = Path.Combine(GetCurrentFolder(), "__admin", "mappings", guid + ".json");
+            string json = File.ReadAllText(folder);
+
+            string responseBodyFilePath = Path.Combine(GetCurrentFolder(), "ResponseBodyFiles", "responsebody.json");
+
+            dynamic jsonObj = JsonConvert.DeserializeObject(json);
+            jsonObj["Response"]["BodyAsFile"] = responseBodyFilePath;
+
+            string output = JsonConvert.SerializeObject(jsonObj, Formatting.Indented);
+            File.WriteAllText(folder, output);
+
+            _server = FluentMockServer.Start();
+            _server.ReadStaticMappingAndAddOrUpdate(folder);
+
+            var mappings = _server.Mappings.ToArray();
+            Check.That(mappings).HasSize(1);
+
+            Check.That(mappings.First().RequestMatcher).IsNotNull();
+            Check.That(mappings.First().Provider).IsNotNull();
+            Check.That(mappings.First().Guid).Equals(Guid.Parse(guid));
+            Check.That(mappings.First().Title).IsNullOrEmpty();
+        }
+
         [Fact]
         public void FluentMockServer_ReadStaticMappings()
         {
@@ -85,7 +114,7 @@ namespace WireMock.Net.Tests
             _server.ReadStaticMappings(folder);
 
             var mappings = _server.Mappings.ToArray();
-            Check.That(mappings).HasSize(2);
+            Check.That(mappings).HasSize(3);
         }
 
         [Fact]
@@ -232,6 +261,40 @@ namespace WireMock.Net.Tests
             Check.That(response).IsEqualTo("Hello world!");
         }
 
+        [Fact]
+        public async Task FluentMockServer_Should_respond_to_request_BodyAsJson()
+        {
+            // Assign
+            _server = FluentMockServer.Start();
+
+            _server
+                .Given(Request.Create().UsingAnyVerb())
+                .RespondWith(Response.Create().WithBodyAsJson(new { message = "Hello" }));
+
+            // Act
+            var response = await new HttpClient().GetStringAsync("http://localhost:" + _server.Ports[0]);
+
+            // Assert
+            Check.That(response).IsEqualTo("{\"message\":\"Hello\"}");
+        }
+
+        [Fact]
+        public async Task FluentMockServer_Should_respond_to_request_BodyAsJson_Indented()
+        {
+            // Assign
+            _server = FluentMockServer.Start();
+
+            _server
+                .Given(Request.Create().UsingAnyVerb())
+                .RespondWith(Response.Create().WithBodyAsJson(new { message = "Hello" }, true));
+
+            // Act
+            var response = await new HttpClient().GetStringAsync("http://localhost:" + _server.Ports[0]);
+
+            // Assert
+            Check.That(response).IsEqualTo("{\r\n  \"message\": \"Hello\"\r\n}");
+        }
+
         [Fact]
         public async Task FluentMockServer_Should_respond_to_request_bodyAsCallback()
         {
@@ -482,6 +545,24 @@ namespace WireMock.Net.Tests
             Check.That(response).IsEqualTo("/fooBar");
         }
 
+        [Fact]
+        public async Task FluentMockServer_Should_IgnoreRestrictedHeader()
+        {
+            // Assign
+            _server = FluentMockServer.Start();
+            _server
+                .Given(Request.Create().WithPath("/head").UsingHead())
+                .RespondWith(Response.Create().WithHeader("Content-Length", "1024"));
+
+            var request = new HttpRequestMessage(HttpMethod.Head, "http://localhost:" + _server.Ports[0] + "/head");
+
+            // Act
+            var response = await new HttpClient().SendAsync(request);
+
+            // Assert
+            Check.That(response.Content.Headers.GetValues("Content-Length")).ContainsExactly("0");
+        }
+
         public void Dispose()
         {
             _server?.Stop();

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

@@ -0,0 +1,145 @@
+using System;
+using Moq;
+using NFluent;
+using WireMock.Matchers;
+using WireMock.Matchers.Request;
+using WireMock.Util;
+using Xunit;
+
+namespace WireMock.Net.Tests.RequestMatchers
+{
+    public class RequestMessageBodyMatcherTests
+    {
+        [Fact]
+        public void RequestMessageBodyMatcher_GetMatchingScore_BodyAsString_IStringMatcher()
+        {
+            // Assign
+            var body = new BodyData
+            {
+                BodyAsString = "b"
+            };
+            var stringMatcherMock = new Mock<IStringMatcher>();
+            stringMatcherMock.Setup(m => m.IsMatch(It.IsAny<string>())).Returns(0.5d);
+
+            var requestMessage = new RequestMessage(new Uri("http://localhost"), "GET", "127.0.0.1", body);
+
+            var matcher = new RequestMessageBodyMatcher(stringMatcherMock.Object);
+
+            // Act
+            var result = new RequestMatchResult();
+            double score = matcher.GetMatchingScore(requestMessage, result);
+
+            // Assert
+            Check.That(score).IsEqualTo(0.5d);
+
+            // Verify
+            stringMatcherMock.Verify(m => m.GetPatterns(), Times.Never);
+            stringMatcherMock.Verify(m => m.IsMatch("b"), Times.Once);
+        }
+
+        [Fact]
+        public void RequestMessageBodyMatcher_GetMatchingScore_BodyAsBytes_IStringMatcher()
+        {
+            // Assign
+            var body = new BodyData
+            {
+                BodyAsBytes = new byte[] { 1 }
+            };
+            var stringMatcherMock = new Mock<IStringMatcher>();
+            stringMatcherMock.Setup(m => m.IsMatch(It.IsAny<string>())).Returns(0.5d);
+
+            var requestMessage = new RequestMessage(new Uri("http://localhost"), "GET", "127.0.0.1", body);
+
+            var matcher = new RequestMessageBodyMatcher(stringMatcherMock.Object);
+
+            // Act
+            var result = new RequestMatchResult();
+            double score = matcher.GetMatchingScore(requestMessage, result);
+
+            // Assert
+            Check.That(score).IsEqualTo(0.0d);
+
+            // Verify
+            stringMatcherMock.Verify(m => m.GetPatterns(), Times.Never);
+            stringMatcherMock.Verify(m => m.IsMatch(It.IsAny<string>()), Times.Never);
+        }
+
+        [Fact]
+        public void RequestMessageBodyMatcher_GetMatchingScore_BodyAsJson_IStringMatcher()
+        {
+            // Assign
+            var body = new BodyData
+            {
+                BodyAsJson = new { value = 42 }
+            };
+            var stringMatcherMock = new Mock<IStringMatcher>();
+            stringMatcherMock.Setup(m => m.IsMatch(It.IsAny<string>())).Returns(0.5d);
+
+            var requestMessage = new RequestMessage(new Uri("http://localhost"), "GET", "127.0.0.1", body);
+
+            var matcher = new RequestMessageBodyMatcher(stringMatcherMock.Object);
+
+            // Act
+            var result = new RequestMatchResult();
+            double score = matcher.GetMatchingScore(requestMessage, result);
+
+            // Assert
+            Check.That(score).IsEqualTo(0.0d);
+
+            // Verify
+            stringMatcherMock.Verify(m => m.IsMatch("b"), Times.Never);
+        }
+
+        [Fact]
+        public void RequestMessageBodyMatcher_GetMatchingScore_BodyAsJson_IObjectMatcher()
+        {
+            // Assign
+            var body = new BodyData
+            {
+                BodyAsJson = 42
+            };
+            var objectMatcherMock = new Mock<IObjectMatcher>();
+            objectMatcherMock.Setup(m => m.IsMatch(It.IsAny<object>())).Returns(0.5d);
+
+            var requestMessage = new RequestMessage(new Uri("http://localhost"), "GET", "127.0.0.1", body);
+
+            var matcher = new RequestMessageBodyMatcher(objectMatcherMock.Object);
+
+            // Act
+            var result = new RequestMatchResult();
+            double score = matcher.GetMatchingScore(requestMessage, result);
+
+            // Assert
+            Check.That(score).IsEqualTo(0.5d);
+
+            // Verify
+            objectMatcherMock.Verify(m => m.IsMatch(42), Times.Once);
+        }
+
+        [Fact]
+        public void RequestMessageBodyMatcher_GetMatchingScore_BodyAsBytes_IObjectMatcher()
+        {
+            // Assign
+            var body = new BodyData
+            {
+                BodyAsBytes = new byte[] { 1 }
+            };
+            var objectMatcherMock = new Mock<IObjectMatcher>();
+            objectMatcherMock.Setup(m => m.IsMatch(It.IsAny<object>())).Returns(0.5d);
+
+            var requestMessage = new RequestMessage(new Uri("http://localhost"), "GET", "127.0.0.1", body);
+
+            var matcher = new RequestMessageBodyMatcher(objectMatcherMock.Object);
+
+            // Act
+            var result = new RequestMatchResult();
+            double score = matcher.GetMatchingScore(requestMessage, result);
+
+            // Assert
+            Check.That(score).IsEqualTo(0.5d);
+
+            // Verify
+            objectMatcherMock.Verify(m => m.IsMatch(It.IsAny<byte[]>()), Times.Once);
+        }
+    }
+}

test/WireMock.Net.Tests/RequestMessageTests.cs

@@ -1,5 +1,6 @@
 using System;
 using NFluent;
+using WireMock.Util;
 using Xunit;
 
 namespace WireMock.Net.Tests
@@ -50,5 +51,25 @@ namespace WireMock.Net.Tests
             Check.That(request.GetParameter("key")).Contains("2");
             Check.That(request.GetParameter("key")).Contains("3");
         }
+
+        [Fact]
+        public void RequestMessage_Constructor1_PathSegments()
+        {
+            // Assign
+            var request = new RequestMessage(new Uri("http://localhost/a/b/c"), "POST", ClientIp);
+
+            // Assert
+            Check.That(request.PathSegments).ContainsExactly("a", "b", "c");
+        }
+
+        [Fact]
+        public void RequestMessage_Constructor2_PathSegments()
+        {
+            // Assign
+            var request = new RequestMessage(new Uri("http://localhost/a/b/c"), "POST", ClientIp, new BodyData());
+
+            // Assert
+            Check.That(request.PathSegments).ContainsExactly("a", "b", "c");
+        }
     }
 }

test/WireMock.Net.Tests/ResponseBodyFiles/responsebody.json

@@ -0,0 +1,3 @@
+{
+  "test": "test"
+}

test/WireMock.Net.Tests/ResponseTests.cs

@@ -0,0 +1,26 @@
+using System;
+using NFluent;
+using WireMock.ResponseBuilders;
+using Xunit;
+
+namespace WireMock.Net.Tests
+{
+    public class ResponseTests
+    {
+        private const string ClientIp = "::1";
+
+        [Fact]
+        public async void Response_Create_WithHeader_ContentLength()
+        {
+            // Assign
+            var requestMock = new RequestMessage(new Uri("http://localhost/foo"), "PUT", ClientIp);
+            IResponseBuilder builder = Response.Create().WithHeader("Content-Length", "1024");
+
+            // Act
+            var response = await builder.ProvideResponseAsync(requestMock);
+
+            // Assert
+            Check.That(response.Headers["Content-Length"].ToString()).Equals("1024");
+        }
+    }
+}

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

@@ -31,9 +31,15 @@
   </ItemGroup>
 
   <ItemGroup>
+    <None Update="ResponseBodyFiles\responsebody.json">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
     <None Update="__admin\mappings\00000002-ee28-4f29-ae63-1ac9b0802d86.json">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
+    <None Update="__admin\mappings\00000002-ee28-4f29-ae63-1ac9b0802d87.json">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
     <None Update="__admin\mappings\documentdb_root.json">
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>

test/WireMock.Net.Tests/__admin/mappings/00000002-ee28-4f29-ae63-1ac9b0802d87.json

@@ -0,0 +1,24 @@
+{
+  "Guid": "00000002-ee28-4f29-ae63-1ac9b0802d87",
+  "Priority": 0,
+  "Request": {
+    "Path": {
+      "Matchers": [
+        {
+          "Name": "ExactMatcher",
+          "Pattern": "/response/staticfile"
+        }
+      ]
+    },
+    "Methods": [
+      "get"
+    ]
+  },
+  "Response": {
+    "StatusCode": 200,
+    "BodyAsFile": "responsebody.json",
+    "Headers": {
+      "Content-Type": "application/json"
+    }
+  }
+}