1.0.1.3

README.md

@@ -2,7 +2,7 @@
 A C# .NET version based on [mock4net](https://github.com/alexvictoor/mock4net) which mimics the functionality from the JAVA based http://WireMock.org
 
 [![Build status](https://ci.appveyor.com/api/projects/status/b3n6q3ygbww4lyls?svg=true)](https://ci.appveyor.com/project/StefH/wiremock-net)
-
+[![codecov](https://codecov.io/gh/StefH/WireMock.Net/branch/master/graph/badge.svg)](https://codecov.io/gh/StefH/WireMock.Net)
 [![NuGet Badge](https://buildstats.info/nuget/WireMock.Net)](https://www.nuget.org/packages/WireMock.Net)
 
 ## Stubbing

WireMock.Net Solution.sln

@@ -9,6 +9,7 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution
 	ProjectSection(SolutionItems) = preProject
 		.runsettings = .runsettings
 		appveyor.yml = appveyor.yml
+		global.json = global.json
 		README.md = README.md
 	EndProjectSection
 EndProject
@@ -23,16 +24,13 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WireMock.Net.ConsoleApplica
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "test", "test", "{890A1DED-C229-4FA1-969E-AAC3BBFC05E5}"
 EndProject
-Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WireMock.Net.Tests", "test\WireMock.Net.Tests\WireMock.Net.Tests.csproj", "{D8B56D28-33CE-4BEF-97D4-7DD546E37F25}"
-	ProjectSection(ProjectDependencies) = postProject
-		{D3804228-91F4-4502-9595-39584E5A01AD} = {D3804228-91F4-4502-9595-39584E5A01AD}
-	EndProjectSection
-EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "WireMock.Net.StandAlone", "src\WireMock.Net.StandAlone\WireMock.Net.StandAlone.csproj", "{668F689E-57B4-422E-8846-C0FF643CA999}"
 	ProjectSection(ProjectDependencies) = postProject
 		{D3804228-91F4-4502-9595-39584E5A01AD} = {D3804228-91F4-4502-9595-39584E5A01AD}
 	EndProjectSection
 EndProject
+Project("{8BB2217D-0F2D-49D1-97BC-3654ED321F3B}") = "WireMock.Net.Tests", "test\WireMock.Net.Tests\WireMock.Net.Tests.xproj", "{31DC2EF8-C3FE-467D-84BE-FB5D956E612E}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -47,14 +45,14 @@ Global
 		{668F689E-57B4-422E-8846-C0FF643CA268}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{668F689E-57B4-422E-8846-C0FF643CA268}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{668F689E-57B4-422E-8846-C0FF643CA268}.Release|Any CPU.Build.0 = Release|Any CPU
-		{D8B56D28-33CE-4BEF-97D4-7DD546E37F25}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{D8B56D28-33CE-4BEF-97D4-7DD546E37F25}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{D8B56D28-33CE-4BEF-97D4-7DD546E37F25}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{D8B56D28-33CE-4BEF-97D4-7DD546E37F25}.Release|Any CPU.Build.0 = Release|Any CPU
 		{668F689E-57B4-422E-8846-C0FF643CA999}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{668F689E-57B4-422E-8846-C0FF643CA999}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{668F689E-57B4-422E-8846-C0FF643CA999}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{668F689E-57B4-422E-8846-C0FF643CA999}.Release|Any CPU.Build.0 = Release|Any CPU
+		{31DC2EF8-C3FE-467D-84BE-FB5D956E612E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{31DC2EF8-C3FE-467D-84BE-FB5D956E612E}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{31DC2EF8-C3FE-467D-84BE-FB5D956E612E}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{31DC2EF8-C3FE-467D-84BE-FB5D956E612E}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -62,7 +60,7 @@ Global
 	GlobalSection(NestedProjects) = preSolution
 		{D3804228-91F4-4502-9595-39584E5A01AD} = {EF242EDF-7133-4277-9A0C-18744DE08707}
 		{668F689E-57B4-422E-8846-C0FF643CA268} = {F0C22C47-DF71-463C-9B04-B4E0F3B8708A}
-		{D8B56D28-33CE-4BEF-97D4-7DD546E37F25} = {890A1DED-C229-4FA1-969E-AAC3BBFC05E5}
 		{668F689E-57B4-422E-8846-C0FF643CA999} = {EF242EDF-7133-4277-9A0C-18744DE08707}
+		{31DC2EF8-C3FE-467D-84BE-FB5D956E612E} = {890A1DED-C229-4FA1-969E-AAC3BBFC05E5}
 	EndGlobalSection
 EndGlobal

appveyor.yml

@@ -4,7 +4,6 @@ version: 1.0.0.{build}
 
 configuration:
 - Debug
-- Release
 
 platform: Any CPU
 
@@ -17,20 +16,40 @@ install:
 
 environment:
   PATH: $(PATH);$(PROGRAMFILES)\dotnet\
+  COVERALLS_REPO_TOKEN:
+    secure: Eq/3VV5DVAeQAlQhe6hvy21IYPo5uY4fWKxvC4pxdq3giJzcwFp1QxBvRpXJ8Wkw
 
 before_build:
+- appveyor-retry dotnet restore .\src\WireMock.Net -v Minimal
 - nuget restore .\examples\WireMock.Net.ConsoleApplication\WireMock.Net.ConsoleApplication.csproj -PackagesDirectory packages
-- nuget restore .\test\WireMock.Net.Tests\WireMock.Net.Tests.csproj -PackagesDirectory packages
 
 build_script:
-- appveyor-retry dotnet restore .\src\WireMock.Net -v Minimal
-
+# build WireMock.Net
 - dotnet build .\src\WireMock.Net\project.json -c %CONFIGURATION%
+
+# restore and build WireMock.Net.Tests
+- appveyor-retry dotnet restore .\test\WireMock.Net.Tests -v Minimal
+- dotnet build .\test\WireMock.Net.Tests\project.json -c %CONFIGURATION%
+
+# build WireMock.Net.ConsoleApplication
 - cmd: msbuild .\examples\WireMock.Net.ConsoleApplication\WireMock.Net.ConsoleApplication.csproj /p:Configuration=%CONFIGURATION% /p:Platform=AnyCPU
-- cmd: msbuild .\test\WireMock.Net.Tests\WireMock.Net.Tests.csproj /p:Configuration=%CONFIGURATION% /p:Platform=AnyCPU
 
 - dotnet pack -c %CONFIGURATION% --no-build --version-suffix %LABEL% -o .\artifacts .\src\WireMock.Net\project.json
 
+test_script:
+# test WireMock.Net.Tests
+- cd .\test\WireMock.Net.Tests
+- dotnet test -c %CONFIGURATION% --no-build
+
+after_test:
+  - nuget.exe install OpenCover -ExcludeVersion
+  - nuget.exe install coveralls.net -ExcludeVersion
+  - OpenCover\tools\OpenCover.Console.exe -register:user -target:"nunit3-console.exe" -targetargs:"\".\test\WireMock.Net.Tests\bin\%CONFIGURATION%\net452\win7-x64\WireMock.Net.Tests.dll\" --result=myresults.xml;format=AppVeyor" -returntargetcode -filter:"+[WireMock.Net]*" -excludebyattribute:*.ExcludeFromCodeCoverage* -hideskipped:All -output:coverage.xml
+  - "SET PATH=C:\\Python34;C:\\Python34\\Scripts;%PATH%"
+  - pip install codecov
+  - codecov -f "coverage.xml"
+  - coveralls.net\tools\csmacnz.Coveralls.exe --opencover -i .\coverage.xml
+
 artifacts:
 - path: artifacts\**\*.*
 

examples/WireMock.Net.ConsoleApplication/Program.cs

@@ -16,7 +16,12 @@ namespace WireMock.Net.ConsoleApplication
             string url2 = "http://localhost:9091/";
             string url3 = "https://localhost:9443/";
 
-            var server = FluentMockServer.StartWithAdminInterface(url1, url2, url3);
+            var server = FluentMockServer.Start(new FluentMockServerSettings
+            {
+                Urls = new [] { url1, url2, url3 },
+                StartAdminInterface = true,
+                ReadStaticMappings = true
+            });
             Console.WriteLine("FluentMockServer listening at {0}", string.Join(" and ", server.Urls));
 
             server.SetBasicAuthentication("a", "b");

global.json

@@ -0,0 +1,3 @@
+{
+    "projects": [ "src", "test" ]
+}

src/WireMock.Net.StandAlone/Program.cs

@@ -16,6 +16,12 @@ namespace WireMock.Net.StandAlone
 
             [SwitchArgument('p', "AllowPartialMapping", true, Description = "Allow Partial Mapping (default set to true).", Optional = true)]
             public bool AllowPartialMapping { get; set; }
+
+            [SwitchArgument('s', "StartAdminInterface", true, Description = "Start the AdminInterface (default set to true).", Optional = true)]
+            public bool StartAdminInterface { get; set; }
+
+            [SwitchArgument('r', "ReadStaticMappings", true, Description = "Read StaticMappings from ./__admin/mappings (default set to true).", Optional = true)]
+            public bool ReadStaticMappings { get; set; }
         }
 
         static void Main(params string[] args)
@@ -31,7 +37,12 @@ namespace WireMock.Net.StandAlone
                 if (!options.Urls.Any())
                     options.Urls.Add("http://localhost:9090/");
 
-                var server = FluentMockServer.StartWithAdminInterface(options.Urls.ToArray());
+                var server = FluentMockServer.Start(new FluentMockServerSettings
+                {
+                    Urls = options.Urls.ToArray(),
+                    StartAdminInterface = options.StartAdminInterface,
+                    ReadStaticMappings = options.ReadStaticMappings
+                });
 
                 if (options.AllowPartialMapping)
                     server.AllowPartialMapping();

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

@@ -15,6 +15,14 @@ namespace WireMock.Admin.Mappings
         /// </value>
         public Guid? Guid { get; set; }
 
+        /// <summary>
+        /// Gets or sets the unique title.
+        /// </summary>
+        /// <value>
+        /// The unique title.
+        /// </value>
+        public string Title { get; set; }
+
         /// <summary>
         /// Gets or sets the priority.
         /// </summary>

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

@@ -63,6 +63,14 @@ namespace WireMock.Admin.Mappings
         /// </value>
         public IDictionary<string, string> Headers { get; set; }
 
+        /// <summary>
+        /// Gets or sets the Headers (Raw).
+        /// </summary>
+        /// <value>
+        /// The Headers (Raw).
+        /// </value>
+        public string HeadersRaw { get; set; }
+
         /// <summary>
         /// Gets or sets the delay in milliseconds.
         /// </summary>

src/WireMock.Net/Admin/Requests/LogEntryModel.cs

@@ -39,6 +39,14 @@ namespace WireMock.Admin.Requests
         /// </value>
         public Guid? MappingGuid { get; set; }
 
+        /// <summary>
+        /// Gets or sets the mapping unique title.
+        /// </summary>
+        /// <value>
+        /// The mapping unique title.
+        /// </value>
+        public string MappingTitle { get; set; }
+
         /// <summary>
         /// Gets or sets the request match result.
         /// </summary>

src/WireMock.Net/Logging/LogEntry.cs

@@ -47,5 +47,13 @@ namespace WireMock.Logging
         /// The mapping unique identifier.
         /// </value>
         public Guid? MappingGuid { get; set; }
+
+        /// <summary>
+        /// Gets or sets the mapping unique title.
+        /// </summary>
+        /// <value>
+        /// The mapping unique title.
+        /// </value>
+        public string MappingTitle { get; set; }
     }
 }

src/WireMock.Net/Mapping.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Threading.Tasks;
+using JetBrains.Annotations;
 using WireMock.Matchers.Request;
 
 namespace WireMock
@@ -9,14 +10,6 @@ namespace WireMock
     /// </summary>
     public class Mapping
     {
-        /// <summary>
-        /// Gets the priority.
-        /// </summary>
-        /// <value>
-        /// The priority.
-        /// </value>
-        public int Priority { get; }
-
         /// <summary>
         /// Gets the unique identifier.
         /// </summary>
@@ -25,6 +18,22 @@ namespace WireMock
         /// </value>
         public Guid Guid { get; }
 
+        /// <summary>
+        /// Gets the unique title.
+        /// </summary>
+        /// <value>
+        /// The unique title.
+        /// </value>
+        public string Title { get; }
+
+        /// <summary>
+        /// Gets the priority.
+        /// </summary>
+        /// <value>
+        /// The priority.
+        /// </value>
+        public int Priority { get; }
+
         /// <summary>
         /// The Request matcher.
         /// </summary>
@@ -38,14 +47,16 @@ namespace WireMock
         /// <summary>
         /// Initializes a new instance of the <see cref="Mapping"/> class.
         /// </summary>
-        /// <param name="guid">The the unique identifier.</param>
+        /// <param name="guid">The unique identifier.</param>
+        /// <param name="title">The unique title (can be null_.</param>
         /// <param name="requestMatcher">The request matcher.</param>
         /// <param name="provider">The provider.</param>
         /// <param name="priority">The priority for this mapping.</param>
-        public Mapping(Guid guid, IRequestMatcher requestMatcher, IResponseProvider provider, int priority)
+        public Mapping(Guid guid, [CanBeNull] string title, IRequestMatcher requestMatcher, IResponseProvider provider, int priority)
         {
             Priority = priority;
             Guid = guid;
+            Title = title;
             RequestMatcher = requestMatcher;
             Provider = provider;
         }

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

@@ -24,7 +24,7 @@ namespace WireMock.Server
     /// </summary>
     public partial class FluentMockServer
     {
-        private const string AdminMappingsFolder = @"\__admin\mappings\";
+        private static readonly string AdminMappingsFolder = Path.Combine("__admin", "mappings");
         private const string AdminMappings = "/__admin/mappings";
         private const string AdminRequests = "/__admin/requests";
         private const string AdminSettings = "/__admin/settings";
@@ -37,15 +37,44 @@ namespace WireMock.Server
             NullValueHandling = NullValueHandling.Ignore,
         };
 
-        private void ReadStaticMappings()
+        /// <summary>
+        /// Reads the static mappings from a folder.
+        /// </summary>
+        /// <param name="folder">The optional folder. If not defined, use \__admin\mappings\</param>
+        [PublicAPI]
+        public void ReadStaticMappings([CanBeNull] string folder = null)
         {
-            if (!Directory.Exists(Directory.GetCurrentDirectory() + AdminMappingsFolder))
+            if (folder == null)
+                folder = Path.Combine(Directory.GetCurrentDirectory(), AdminMappingsFolder);
+
+            if (!Directory.Exists(folder))
                 return;
 
-            foreach (string filename in Directory.EnumerateFiles(Directory.GetCurrentDirectory() + AdminMappingsFolder))
+            foreach (string filename in Directory.EnumerateFiles(folder).OrderBy(f => f))
             {
-                var json = File.ReadAllText(filename);
-                DeserializeAndAddMapping(json, Guid.Parse(Path.GetFileNameWithoutExtension(filename)));
+                ReadStaticMapping(filename);
+            }
+        }
+
+        /// <summary>
+        /// Reads the static mapping.
+        /// </summary>
+        /// <param name="filename">The filename.</param>
+        [PublicAPI]
+        public void ReadStaticMapping([NotNull] string filename)
+        {
+            Check.NotNull(filename, nameof(filename));
+
+            string filenameWithoutExtension = Path.GetFileNameWithoutExtension(filename);
+            Guid guidFromFilename;
+
+            if (Guid.TryParse(filenameWithoutExtension, out guidFromFilename))
+            {
+                DeserializeAndAddMapping(File.ReadAllText(filename), guidFromFilename);
+            }
+            else
+            {
+                DeserializeAndAddMapping(File.ReadAllText(filename));
             }
         }
 
@@ -142,9 +171,12 @@ namespace WireMock.Server
             var requestBuilder = InitRequestBuilder(mappingModel.Request);
             var responseBuilder = InitResponseBuilder(mappingModel.Response);
 
-            Given(requestBuilder)
-                .WithGuid(guid)
-                .RespondWith(responseBuilder);
+            IRespondWithAProvider respondProvider = Given(requestBuilder).WithGuid(guid);
+
+            if (!string.IsNullOrEmpty(mappingModel.Title))
+                respondProvider = respondProvider.WithTitle(mappingModel.Title);
+
+            respondProvider.RespondWith(responseBuilder);
 
             return new ResponseMessage { Body = "Mapping added or updated" };
         }
@@ -171,13 +203,19 @@ namespace WireMock.Server
             {
                 var model = ToMappingModel(mapping);
                 string json = JsonConvert.SerializeObject(model, _settings);
+                string filename = !string.IsNullOrEmpty(mapping.Title) ? SanitizeFileName(mapping.Title) : mapping.Guid.ToString();
 
-                File.WriteAllText(Path.Combine(folder, mapping.Guid + ".json"), json);
+                File.WriteAllText(Path.Combine(folder, filename + ".json"), json);
             }
 
             return new ResponseMessage { Body = "Mappings saved to disk" };
         }
 
+        private static string SanitizeFileName(string name, char replaceChar = '_')
+        {
+            return Path.GetInvalidFileNameChars().Aggregate(name, (current, c) => current.Replace(c, replaceChar));
+        }
+
         private ResponseMessage MappingsGet(RequestMessage requestMessage)
         {
             var result = new List<MappingModel>();
@@ -230,6 +268,9 @@ namespace WireMock.Server
                 respondProvider = respondProvider.WithGuid(mappingModel.Guid.Value);
             }
 
+            if (!string.IsNullOrEmpty(mappingModel.Title))
+                respondProvider = respondProvider.WithTitle(mappingModel.Title);
+
             if (mappingModel.Priority != null)
                 respondProvider = respondProvider.AtPriority(mappingModel.Priority.Value);
 
@@ -315,6 +356,7 @@ namespace WireMock.Server
                     } : null
                 },
                 MappingGuid = logEntry.MappingGuid,
+                MappingTitle = logEntry.MappingTitle,
                 RequestMatchResult = logEntry.RequestMatchResult != null ? new LogRequestMatchModel
                 {
                     TotalScore = logEntry.RequestMatchResult.TotalScore,
@@ -429,6 +471,16 @@ namespace WireMock.Server
 
             if (responseModel.Headers != null)
                 responseBuilder = responseBuilder.WithHeaders(responseModel.Headers);
+            else if (responseModel.HeadersRaw != null)
+            {
+                foreach (string headerLine in responseModel.HeadersRaw.Split(new[] { "\n", "\r\n" }, StringSplitOptions.RemoveEmptyEntries))
+                {
+                    int indexColon = headerLine.IndexOf(":", StringComparison.Ordinal);
+                    string key = headerLine.Substring(0, indexColon).TrimStart(' ', '\t');
+                    string value = headerLine.Substring(indexColon + 1).TrimStart(' ', '\t');
+                    responseBuilder = responseBuilder.WithHeader(key, value);
+                }
+            }
 
             if (responseModel.Body != null)
                 responseBuilder = responseBuilder.WithBody(responseModel.Body, ToEncoding(responseModel.BodyEncoding));
@@ -462,6 +514,7 @@ namespace WireMock.Server
             return new MappingModel
             {
                 Guid = mapping.Guid,
+                Title = mapping.Title,
                 Priority = mapping.Priority,
                 Request = new RequestModel
                 {
@@ -493,7 +546,7 @@ namespace WireMock.Server
                         Funcs = Map(cm.Funcs)
                     }).ToList() : null,
 
-                    Params = paramsMatchers != null && paramsMatchers.Any() ? paramsMatchers?.Select(pm => new ParamModel
+                    Params = paramsMatchers != null && paramsMatchers.Any() ? paramsMatchers.Select(pm => new ParamModel
                     {
                         Name = pm.Key,
                         Values = pm.Values?.ToList(),

src/WireMock.Net/Server/FluentMockServer.cs

@@ -19,7 +19,7 @@ namespace WireMock.Server
     /// <summary>
     /// The fluent mock server.
     /// </summary>
-    public partial class FluentMockServer
+    public partial class FluentMockServer : IDisposable
     {
         private readonly TinyHttpServer _httpServer;
 
@@ -112,6 +112,19 @@ namespace WireMock.Server
             }
         }
 
+        /// <summary>
+        /// Starts the specified settings.
+        /// </summary>
+        /// <param name="settings">The FluentMockServerSettings.</param>
+        /// <returns>The <see cref="FluentMockServer"/>.</returns>
+        [PublicAPI]
+        public static FluentMockServer Start(FluentMockServerSettings settings)
+        {
+            Check.NotNull(settings, nameof(settings));
+
+            return new FluentMockServer(settings);
+        }
+
         /// <summary>
         /// Start this FluentMockServer.
         /// </summary>
@@ -119,14 +132,13 @@ namespace WireMock.Server
         /// <param name="ssl">The SSL support.</param>
         /// <returns>The <see cref="FluentMockServer"/>.</returns>
         [PublicAPI]
-        public static FluentMockServer Start(int port = 0, bool ssl = false)
+        public static FluentMockServer Start([CanBeNull] int? port = 0, bool ssl = false)
         {
-            Check.Condition(port, p => p >= 0, nameof(port));
-
-            if (port == 0)
-                port = PortUtil.FindFreeTcpPort();
-
-            return new FluentMockServer(false, port, ssl);
+            return new FluentMockServer(new FluentMockServerSettings
+            {
+                Port = port,
+                UseSSL = ssl
+            });
         }
 
         /// <summary>
@@ -139,7 +151,10 @@ namespace WireMock.Server
         {
             Check.NotEmpty(urls, nameof(urls));
 
-            return new FluentMockServer(false, urls);
+            return new FluentMockServer(new FluentMockServerSettings
+            {
+                Urls = urls
+            });
         }
 
         /// <summary>
@@ -149,14 +164,14 @@ namespace WireMock.Server
         /// <param name="ssl">The SSL support.</param>
         /// <returns>The <see cref="FluentMockServer"/>.</returns>
         [PublicAPI]
-        public static FluentMockServer StartWithAdminInterface(int port = 0, bool ssl = false)
+        public static FluentMockServer StartWithAdminInterface(int? port = 0, bool ssl = false)
         {
-            Check.Condition(port, p => p >= 0, nameof(port));
-
-            if (port == 0)
-                port = PortUtil.FindFreeTcpPort();
-
-            return new FluentMockServer(true, port, ssl);
+            return new FluentMockServer(new FluentMockServerSettings
+            {
+                Port = port,
+                UseSSL = ssl,
+                StartAdminInterface = true
+            });
         }
 
         /// <summary>
@@ -169,7 +184,57 @@ namespace WireMock.Server
         {
             Check.NotEmpty(urls, nameof(urls));
 
-            return new FluentMockServer(true, urls);
+            return new FluentMockServer(new FluentMockServerSettings
+            {
+                Urls = urls,
+                StartAdminInterface = true
+            });
+        }
+
+        /// <summary>
+        /// Start this FluentMockServer with the admin interface and read static mappings.
+        /// </summary>
+        /// <param name="urls">The urls.</param>
+        /// <returns>The <see cref="FluentMockServer"/>.</returns>
+        [PublicAPI]
+        public static FluentMockServer StartWithAdminInterfaceAndReadStaticMappings(params string[] urls)
+        {
+            Check.NotEmpty(urls, nameof(urls));
+
+            return new FluentMockServer(new FluentMockServerSettings
+            {
+                Urls = urls,
+                StartAdminInterface = true,
+                ReadStaticMappings = true
+            });
+        }
+
+        private FluentMockServer(FluentMockServerSettings settings)
+        {
+            if (settings.Urls != null)
+            {
+                Urls = settings.Urls;
+            }
+            else
+            {
+                int port = settings.Port > 0 ? settings.Port.Value : PortUtil.FindFreeTcpPort();
+                Urls = new[] { (settings.UseSSL == true ? "https" : "http") + "://localhost:" + port + "/" };
+            }
+
+            _httpServer = new TinyHttpServer(HandleRequestAsync, Urls);
+            Ports = _httpServer.Ports;
+
+            _httpServer.Start();
+
+            if (settings.StartAdminInterface == true)
+            {
+                InitAdmin();
+            }
+
+            if (settings.ReadStaticMappings == true)
+            {
+                ReadStaticMappings();
+            }
         }
 
         /// <summary>
@@ -184,27 +249,6 @@ namespace WireMock.Server
                 .RespondWith(new DynamicResponseProvider(request => new ResponseMessage { StatusCode = 404, Body = "No matching mapping found" }));
         }
 
-        private FluentMockServer(bool startAdminInterface, int port, bool ssl) : this(startAdminInterface, (ssl ? "https" : "http") + "://localhost:" + port + "/")
-        {
-        }
-
-        private FluentMockServer(bool startAdminInterface, params string[] urls)
-        {
-            Urls = urls;
-
-            _httpServer = new TinyHttpServer(HandleRequestAsync, urls);
-            Ports = _httpServer.Ports;
-
-            _httpServer.Start();
-
-            if (startAdminInterface)
-            {
-                InitAdmin();
-            }
-
-            ReadStaticMappings();
-        }
-
         /// <summary>
         /// Stop this server.
         /// </summary>
@@ -214,6 +258,17 @@ namespace WireMock.Server
             _httpServer.Stop();
         }
 
+        /// <summary>
+        /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
+        /// </summary>
+        public void Dispose()
+        {
+            if (_httpServer != null && _httpServer.IsStarted)
+            {
+                _httpServer.Stop();
+            }
+        }
+
         /// <summary>
         /// Resets LogEntries and Mappings.
         /// </summary>
@@ -452,6 +507,7 @@ namespace WireMock.Server
                     RequestMessage = request,
                     ResponseMessage = response,
                     MappingGuid = targetMapping?.Guid,
+                    MappingTitle = targetMapping?.Title,
                     RequestMatchResult = requestMatchResult
                 };
 

src/WireMock.Net/Server/FluentMockServerSettings.cs

@@ -0,0 +1,48 @@
+namespace WireMock.Server
+{
+    /// <summary>
+    /// FluentMockServerSettings
+    /// </summary>
+    public class FluentMockServerSettings
+    {
+        /// <summary>
+        /// Gets or sets the port.
+        /// </summary>
+        /// <value>
+        /// The port.
+        /// </value>
+        public int? Port { get; set; }
+
+        /// <summary>
+        /// Gets or sets the use SSL.
+        /// </summary>
+        /// <value>
+        /// The use SSL.
+        /// </value>
+        public bool? UseSSL { get; set; }
+
+        /// <summary>
+        /// Gets or sets the start admin interface.
+        /// </summary>
+        /// <value>
+        /// The start admin interface.
+        /// </value>
+        public bool? StartAdminInterface { get; set; }
+
+        /// <summary>
+        /// Gets or sets the read static mappings.
+        /// </summary>
+        /// <value>
+        /// The read static mappings.
+        /// </value>
+        public bool? ReadStaticMappings { get; set; }
+
+        /// <summary>
+        /// Gets or sets the urls.
+        /// </summary>
+        /// <value>
+        /// The urls.
+        /// </value>
+        public string[] Urls { get; set; }
+    }
+}

src/WireMock.Net/Server/IRespondWithAProvider.cs

@@ -14,6 +14,13 @@ namespace WireMock.Server
         /// <returns>The <see cref="IRespondWithAProvider"/>.</returns>
         IRespondWithAProvider WithGuid(Guid guid);
 
+        /// <summary>
+        /// Define a unique title for this mapping.
+        /// </summary>
+        /// <param name="title">The unique title.</param>
+        /// <returns>The <see cref="IRespondWithAProvider"/>.</returns>
+        IRespondWithAProvider WithTitle(string title);
+
         /// <summary>
         /// Define a unique identifier for this mapping.
         /// </summary>

src/WireMock.Net/Server/RespondWithAProvider.cs

@@ -10,6 +10,7 @@ namespace WireMock.Server
     {
         private int _priority;
         private Guid? _guid;
+        private string _title;
 
         /// <summary>
         /// The _registration callback.
@@ -41,7 +42,7 @@ namespace WireMock.Server
         public void RespondWith(IResponseProvider provider)
         {
             var mappingGuid = _guid ?? Guid.NewGuid();
-            _registrationCallback(new Mapping(mappingGuid, _requestMatcher, provider, _priority));
+            _registrationCallback(new Mapping(mappingGuid, _title, _requestMatcher, provider, _priority));
         }
 
         /// <summary>
@@ -66,6 +67,18 @@ namespace WireMock.Server
             return this;
         }
 
+        /// <summary>
+        /// Define a unique identifier for this mapping.
+        /// </summary>
+        /// <param name="title">The unique identifier.</param>
+        /// <returns>The <see cref="IRespondWithAProvider"/>.</returns>
+        public IRespondWithAProvider WithTitle(string title)
+        {
+            _title = title;
+
+            return this;
+        }
+
         /// <summary>
         /// Define the priority for this mapping.
         /// </summary>

src/WireMock.Net/project.json

@@ -1,5 +1,5 @@
 {
-    "version": "1.0.1.2",
+    "version": "1.0.1.3",
     "title": "WireMock.Net",
     "description": "Lightweight Http Mocking Server for .Net, inspired by WireMock from the Java landscape.",
     "authors": [ "Alexandre Victoor", "Stef Heyenrath" ],
@@ -15,7 +15,7 @@
         "projectUrl": "https://github.com/StefH/WireMock.Net",
         "iconUrl": "https://raw.githubusercontent.com/StefH/WireMock.Net/master/WireMock.Net-Logo.png",
         "licenseUrl": "https://raw.githubusercontent.com/StefH/WireMock.Net/master/LICENSE",
-        "releaseNotes": "Added more Admin-Interface commands (save/find/reset/settings) and added support for body encoding."
+        "releaseNotes": "Updated Start() method and added ReadStaticMapping."
     },
 
     "buildOptions": {

test/WireMock.Net.Tests.old/FluentMockServerTests.cs

@@ -0,0 +1,291 @@
+using System;
+using System.Diagnostics;
+using System.Linq;
+using System.Net;
+using System.Net.Http;
+using System.Threading.Tasks;
+using NFluent;
+using NUnit.Framework;
+using WireMock.Matchers;
+using WireMock.RequestBuilders;
+using WireMock.ResponseBuilders;
+using WireMock.Server;
+
+namespace WireMock.Net.Tests
+{
+    [TestFixture]
+    [Timeout(5000)]
+    public class FluentMockServerTests
+    {
+        private FluentMockServer _server;
+
+        [Test]
+        public void FluentMockServer_Admin_Mappings_Get()
+        {
+            var guid = Guid.Parse("90356dba-b36c-469a-a17e-669cd84f1f05");
+            _server = FluentMockServer.Start();
+
+            _server.Given(Request.Create().WithPath("/foo1").UsingGet())
+                .WithGuid(guid)
+                .RespondWith(Response.Create().WithStatusCode(201).WithBody("1"));
+
+            _server.Given(Request.Create().WithPath("/foo2").UsingGet())
+                .RespondWith(Response.Create().WithStatusCode(202).WithBody("2"));
+
+            var mappings = _server.Mappings.ToArray();
+            Check.That(mappings).HasSize(2);
+
+            Check.That(mappings.First().RequestMatcher).IsNotNull();
+            Check.That(mappings.First().Provider).IsNotNull();
+            Check.That(mappings.First().Guid).Equals(guid);
+
+            Check.That(mappings[1].Guid).Not.Equals(guid);
+        }
+
+        [Test]
+        public void FluentMockServer_Admin_Mappings_Add_SameGuid()
+        {
+            var guid = Guid.Parse("90356dba-b36c-469a-a17e-669cd84f1f05");
+            _server = FluentMockServer.Start();
+
+            _server.Given(Request.Create().WithPath("/1").UsingGet())
+                .WithGuid(guid)
+                .RespondWith(Response.Create().WithStatusCode(500));
+
+            var mappings = _server.Mappings.ToArray();
+            Check.That(mappings).HasSize(1);
+            Check.That(mappings.First().Guid).Equals(guid);
+
+            _server.Given(Request.Create().WithPath("/2").UsingGet())
+                .WithGuid(guid)
+                .RespondWith(Response.Create().WithStatusCode(500));
+
+            Check.That(mappings).HasSize(1);
+            Check.That(mappings.First().Guid).Equals(guid);
+        }
+
+        [Test]
+        public async Task FluentMockServer_Admin_Mappings_AtPriority()
+        {
+            _server = FluentMockServer.Start();
+
+            // given
+            _server.Given(Request.Create().WithPath("/1").UsingGet())
+                .AtPriority(2)
+                .RespondWith(Response.Create().WithStatusCode(200));
+
+            _server.Given(Request.Create().WithPath("/1").UsingGet())
+                .AtPriority(1)
+                .RespondWith(Response.Create().WithStatusCode(400));
+
+            var mappings = _server.Mappings.ToArray();
+            Check.That(mappings).HasSize(2);
+            Check.That(mappings[0].Priority).Equals(2);
+            Check.That(mappings[1].Priority).Equals(1);
+
+            // when
+            var response = await new HttpClient().GetAsync("http://localhost:" + _server.Ports[0] + "/1");
+
+            // then
+            Check.That((int)response.StatusCode).IsEqualTo(400);
+        }
+
+        [Test]
+        public async Task FluentMockServer_Admin_Requests_Get()
+        {
+            // given
+            _server = FluentMockServer.Start();
+
+            // when
+            await new HttpClient().GetAsync("http://localhost:" + _server.Ports[0] + "/foo");
+
+            // then
+            Check.That(_server.LogEntries).HasSize(1);
+            var requestLogged = _server.LogEntries.First();
+            Check.That(requestLogged.RequestMessage.Method).IsEqualTo("get");
+            Check.That(requestLogged.RequestMessage.BodyAsBytes).IsNull();
+        }
+
+        [Test]
+        public async Task Should_respond_to_request()
+        {
+            // given
+            _server = FluentMockServer.Start();
+
+            _server
+                .Given(Request.Create()
+                    .WithPath("/foo")
+                    .UsingGet())
+                .RespondWith(Response.Create()
+                    .WithStatusCode(200)
+                    .WithBody(@"{ msg: ""Hello world!""}"));
+
+            // when
+            var response = await new HttpClient().GetStringAsync("http://localhost:" + _server.Ports[0] + "/foo");
+
+            // then
+            Check.That(response).IsEqualTo(@"{ msg: ""Hello world!""}");
+        }
+
+        [Test]
+        public async Task Should_respond_to_request_bodyAsBase64()
+        {
+            // given
+            _server = FluentMockServer.Start();
+
+            _server.Given(Request.Create().WithPath("/foo").UsingGet()).RespondWith(Response.Create().WithBodyAsBase64("SGVsbG8gV29ybGQ/"));
+
+            // when
+            var response = await new HttpClient().GetStringAsync("http://localhost:" + _server.Ports[0] + "/foo");
+
+            // then
+            Check.That(response).IsEqualTo("Hello World?");
+        }
+
+        [Test]
+        public async Task Should_respond_404_for_unexpected_request()
+        {
+            // given
+            _server = FluentMockServer.Start();
+
+            // when
+            var response = await new HttpClient().GetAsync("http://localhost:" + _server.Ports[0] + "/foo");
+
+            // then
+            Check.That(response.StatusCode).IsEqualTo(HttpStatusCode.NotFound);
+            Check.That((int)response.StatusCode).IsEqualTo(404);
+        }
+
+        [Test]
+        public async Task Should_find_a_request_satisfying_a_request_spec()
+        {
+            // given
+            _server = FluentMockServer.Start();
+
+            // when
+            await new HttpClient().GetAsync("http://localhost:" + _server.Ports[0] + "/foo");
+            await new HttpClient().GetAsync("http://localhost:" + _server.Ports[0] + "/bar");
+
+            // then
+            var result = _server.FindLogEntries(Request.Create().WithPath(new RegexMatcher("^/b.*"))).ToList();
+            Check.That(result).HasSize(1);
+
+            var requestLogged = result.First();
+            Check.That(requestLogged.RequestMessage.Path).IsEqualTo("/bar");
+            Check.That(requestLogged.RequestMessage.Url).IsEqualTo("http://localhost:" + _server.Ports[0] + "/bar");
+        }
+
+        [Test]
+        public async Task Should_reset_requestlogs()
+        {
+            // given
+            _server = FluentMockServer.Start();
+
+            // when
+            await new HttpClient().GetAsync("http://localhost:" + _server.Ports[0] + "/foo");
+            _server.ResetLogEntries();
+
+            // then
+            Check.That(_server.LogEntries).IsEmpty();
+        }
+
+        [Test]
+        public void Should_reset_mappings()
+        {
+            // given
+            _server = FluentMockServer.Start();
+
+            _server
+                .Given(Request.Create()
+                    .WithPath("/foo")
+                    .UsingGet())
+                .RespondWith(Response.Create()
+                    .WithBody(@"{ msg: ""Hello world!""}"));
+
+            // when
+            _server.ResetMappings();
+
+            // then
+            Check.That(_server.Mappings).IsEmpty();
+            Check.ThatAsyncCode(() => new HttpClient().GetStringAsync("http://localhost:" + _server.Ports[0] + "/foo"))
+                .ThrowsAny();
+        }
+
+        [Test]
+        public async Task Should_respond_a_redirect_without_body()
+        {
+            // given
+            _server = FluentMockServer.Start();
+
+            _server
+                .Given(Request.Create()
+                    .WithPath("/foo")
+                    .UsingGet())
+                .RespondWith(Response.Create()
+                    .WithStatusCode(307)
+                    .WithHeader("Location", "/bar"));
+            _server
+                .Given(Request.Create()
+                    .WithPath("/bar")
+                    .UsingGet())
+                .RespondWith(Response.Create()
+                    .WithStatusCode(200)
+                    .WithBody("REDIRECT SUCCESSFUL"));
+
+            // when
+            var response = await new HttpClient().GetStringAsync("http://localhost:" + _server.Ports[0] + "/foo");
+
+            // then
+            Check.That(response).IsEqualTo("REDIRECT SUCCESSFUL");
+        }
+
+        [Test]
+        public async Task Should_delay_responses_for_a_given_route()
+        {
+            // given
+            _server = FluentMockServer.Start();
+
+            _server
+                .Given(Request.Create()
+                    .WithPath("/*"))
+                .RespondWith(Response.Create()
+                    .WithBody(@"{ msg: ""Hello world!""}")
+                    .WithDelay(TimeSpan.FromMilliseconds(200)));
+
+            // when
+            var watch = new Stopwatch();
+            watch.Start();
+            await new HttpClient().GetStringAsync("http://localhost:" + _server.Ports[0] + "/foo");
+            watch.Stop();
+
+            // then
+            Check.That(watch.ElapsedMilliseconds).IsGreaterThan(200);
+        }
+
+        [Test]
+        public async Task Should_delay_responses()
+        {
+            // given
+            _server = FluentMockServer.Start();
+            _server.AddGlobalProcessingDelay(TimeSpan.FromMilliseconds(200));
+            _server
+                .Given(Request.Create().WithPath("/*"))
+                .RespondWith(Response.Create().WithBody(@"{ msg: ""Hello world!""}"));
+
+            // when
+            var watch = new Stopwatch();
+            watch.Start();
+            await new HttpClient().GetStringAsync("http://localhost:" + _server.Ports[0] + "/foo");
+            watch.Stop();
+
+            // then
+            Check.That(watch.ElapsedMilliseconds).IsGreaterThan(200);
+        }
+
+        [TearDown]
+        public void ShutdownServer()
+        {
+            _server.Stop();
+        }
+    }
+}

test/WireMock.Net.Tests.old/Http/TinyHttpServerTests.cs

@@ -0,0 +1,39 @@
+using System.Diagnostics.CodeAnalysis;
+using System.Net.Http;
+using NFluent;
+using NUnit.Framework;
+using WireMock.Http;
+
+[module:
+    SuppressMessage("StyleCop.CSharp.DocumentationRules", 
+        "SA1600:ElementsMustBeDocumented", 
+        Justification = "Reviewed. Suppression is OK here, as it's a tests class.")]
+[module:
+    SuppressMessage("StyleCop.CSharp.DocumentationRules", 
+        "SA1633:FileMustHaveHeader", 
+        Justification = "Reviewed. Suppression is OK here, as unknown copyright and company.")]
+
+namespace WireMock.Net.Tests.Http
+{
+    [TestFixture]
+    public class TinyHttpServerTests
+    {
+        [Test]
+        public void Should_call_handler_on_request()
+        {
+            // given
+            var port = PortUtil.FindFreeTcpPort();
+            bool called = false;
+            var urlPrefix = "http://localhost:" + port + "/";
+            var server = new TinyHttpServer(ctx => called = true, urlPrefix);
+            server.Start();
+
+            // when
+            var httpClient = new HttpClient();
+            httpClient.GetAsync(urlPrefix).Wait(3000);
+
+            // then
+            Check.That(called).IsTrue();
+        }
+    }
+}

test/WireMock.Net.Tests.old/HttpListenerRequestMapperTests.cs

@@ -0,0 +1,147 @@
+using System;
+using System.Collections.Generic;
+using System.Net;
+using System.Net.Http;
+using System.Threading.Tasks;
+using NFluent;
+using NUnit.Framework;
+using WireMock.Http;
+
+namespace WireMock.Net.Tests
+{
+    [TestFixture]
+    public class HttpListenerRequestMapperTests
+    {
+        private MapperServer _server;
+
+        [SetUp]
+        public void StartListenerServer()
+        {
+            _server = MapperServer.Start();
+        }
+
+        [Test]
+        public async Task Should_map_uri_from_listener_request()
+        {
+            // given
+            var client = new HttpClient();
+
+            // when 
+            await client.GetAsync(MapperServer.UrlPrefix + "toto");
+
+            // then
+            Check.That(MapperServer.LastRequestMessage).IsNotNull();
+            Check.That(MapperServer.LastRequestMessage.Path).IsEqualTo("/toto");
+        }
+
+        [Test]
+        public async Task Should_map_verb_from_listener_request()
+        {
+            // given
+            var client = new HttpClient();
+
+            // when 
+            await client.PutAsync(MapperServer.UrlPrefix, new StringContent("Hello!"));
+
+            // then
+            Check.That(MapperServer.LastRequestMessage).IsNotNull();
+            Check.That(MapperServer.LastRequestMessage.Method).IsEqualTo("put");
+        }
+
+        [Test]
+        public async Task Should_map_body_from_listener_request()
+        {
+            // given
+            var client = new HttpClient();
+
+            // when 
+            await client.PutAsync(MapperServer.UrlPrefix, new StringContent("Hello!"));
+
+            // then
+            Check.That(MapperServer.LastRequestMessage).IsNotNull();
+            Check.That(MapperServer.LastRequestMessage.Body).IsEqualTo("Hello!");
+        }
+
+        [Test]
+        public async Task Should_map_headers_from_listener_request()
+        {
+            // given
+            var client = new HttpClient();
+            client.DefaultRequestHeaders.Add("X-Alex", "1706");
+
+            // when 
+            await client.GetAsync(MapperServer.UrlPrefix);
+
+            // then
+            Check.That(MapperServer.LastRequestMessage).IsNotNull();
+            Check.That(MapperServer.LastRequestMessage.Headers).Not.IsNullOrEmpty();
+            Check.That(MapperServer.LastRequestMessage.Headers.Contains(new KeyValuePair<string, string>("X-Alex", "1706"))).IsTrue();
+        }
+
+        [Test]
+        public async Task Should_map_params_from_listener_request()
+        {
+            // given
+            var client = new HttpClient();
+
+            // when 
+            await client.GetAsync(MapperServer.UrlPrefix + "index.html?id=toto");
+
+            // then
+            Check.That(MapperServer.LastRequestMessage).IsNotNull();
+            Check.That(MapperServer.LastRequestMessage.Path).EndsWith("/index.html");
+            Check.That(MapperServer.LastRequestMessage.GetParameter("id")).HasSize(1);
+        }
+
+        [TearDown]
+        public void StopListenerServer()
+        {
+            _server.Stop();
+        }
+
+        private class MapperServer : TinyHttpServer
+        {
+            private static volatile RequestMessage _lastRequestMessage;
+
+            private MapperServer(Action<HttpListenerContext> httpHandler, string urlPrefix) : base(httpHandler, urlPrefix)
+            {
+            }
+
+            public static RequestMessage LastRequestMessage
+            {
+                get
+                {
+                    return _lastRequestMessage;
+                }
+
+                private set
+                {
+                    _lastRequestMessage = value;
+                }
+            }
+
+            public static string UrlPrefix { get; private set; }
+
+            public new static MapperServer Start()
+            {
+                int port = PortUtil.FindFreeTcpPort();
+                UrlPrefix = "http://localhost:" + port + "/";
+                var server = new MapperServer(
+                    context =>
+                        {
+                            LastRequestMessage = new HttpListenerRequestMapper().Map(context.Request);
+                            context.Response.Close();
+                        }, UrlPrefix);
+                ((TinyHttpServer)server).Start();
+
+                return server;
+            }
+
+            public new void Stop()
+            {
+                base.Stop();
+                LastRequestMessage = null;
+            }
+        }
+    }
+}

test/WireMock.Net.Tests.old/HttpListenerResponseMapperTests.cs

@@ -0,0 +1,133 @@
+using System.Net;
+using System.Net.Http;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+using NFluent;
+using NUnit.Framework;
+using WireMock.Http;
+
+namespace WireMock.Net.Tests
+{
+    [TestFixture]
+    public class HttpListenerResponseMapperTests
+    {
+        private TinyHttpServer _server;
+        private Task<HttpResponseMessage> _responseMsgTask;
+
+        [Test]
+        public void Should_map_status_code_from_original_response()
+        {
+            // given
+            var response = new ResponseMessage { StatusCode = 404 };
+            var httpListenerResponse = CreateHttpListenerResponse();
+
+            // when
+            new HttpListenerResponseMapper().Map(response, httpListenerResponse);
+
+            // then
+            Check.That(httpListenerResponse.StatusCode).IsEqualTo(404);
+        }
+
+        [Test]
+        public void Should_map_headers_from_original_response()
+        {
+            // given
+            var response = new ResponseMessage();
+            response.AddHeader("cache-control", "no-cache");
+            var httpListenerResponse = CreateHttpListenerResponse();
+
+            // when
+            new HttpListenerResponseMapper().Map(response, httpListenerResponse);
+
+            // then
+            Check.That(httpListenerResponse.Headers).HasSize(1);
+            Check.That(httpListenerResponse.Headers.Keys).Contains("cache-control");
+            Check.That(httpListenerResponse.Headers.Get("cache-control")).Contains("no-cache");
+        }
+
+        [Test]
+        public void Should_map_body_from_original_response()
+        {
+            // given
+            var response = new ResponseMessage
+            {
+                Body = "Hello !!!"
+            };
+
+            var httpListenerResponse = CreateHttpListenerResponse();
+
+            // when
+            new HttpListenerResponseMapper().Map(response, httpListenerResponse);
+
+            // then
+            var responseMessage = ToResponseMessage(httpListenerResponse);
+            Check.That(responseMessage).IsNotNull();
+
+            var contentTask = responseMessage.Content.ReadAsStringAsync();
+            Check.That(contentTask.Result).IsEqualTo("Hello !!!");
+        }
+
+        [Test]
+        public void Should_map_encoded_body_from_original_response()
+        {
+            // given
+            var response = new ResponseMessage
+            {
+                Body = "Hello !!!",
+                BodyEncoding = Encoding.ASCII
+            };
+
+            var httpListenerResponse = CreateHttpListenerResponse();
+
+            // when
+            new HttpListenerResponseMapper().Map(response, httpListenerResponse);
+
+            // then
+            Check.That(httpListenerResponse.ContentEncoding).Equals(Encoding.ASCII);
+
+            var responseMessage = ToResponseMessage(httpListenerResponse);
+            Check.That(responseMessage).IsNotNull();
+
+            var contentTask = responseMessage.Content.ReadAsStringAsync();
+            Check.That(contentTask.Result).IsEqualTo("Hello !!!");
+        }
+
+        [TearDown]
+        public void StopServer()
+        {
+            _server?.Stop();
+        }
+
+        /// <summary>
+        /// Dirty HACK to get HttpListenerResponse instances
+        /// </summary>
+        /// <returns>
+        /// The <see cref="HttpListenerResponse"/>.
+        /// </returns>
+        public HttpListenerResponse CreateHttpListenerResponse()
+        {
+            var port = PortUtil.FindFreeTcpPort();
+            var urlPrefix = "http://localhost:" + port + "/";
+            var responseReady = new AutoResetEvent(false);
+            HttpListenerResponse response = null;
+            _server = new TinyHttpServer(
+                context =>
+                    {
+                        response = context.Response;
+                        responseReady.Set();
+                    }, urlPrefix);
+            _server.Start();
+            _responseMsgTask = new HttpClient().GetAsync(urlPrefix);
+            responseReady.WaitOne();
+            return response;
+        }
+
+        public HttpResponseMessage ToResponseMessage(HttpListenerResponse listenerResponse)
+        {
+            listenerResponse.Close();
+            _responseMsgTask.Wait();
+            return _responseMsgTask.Result;
+        }
+    }
+}

test/WireMock.Net.Tests.old/RequestMessageTests.cs

@@ -0,0 +1,35 @@
+using System;
+using System.Text;
+using NFluent;
+using NUnit.Framework;
+
+namespace WireMock.Net.Tests
+{
+    [TestFixture]
+    public class RequestMessageTests
+    {
+        [Test]
+        public void Should_handle_empty_query()
+        {
+            // given
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "POST");
+
+            // then
+            Check.That(request.GetParameter("not_there")).IsNull();
+        }
+
+        [Test]
+        public void Should_parse_query_params()
+        {
+            // given
+            string bodyAsString = "whatever";
+            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
+            var request = new RequestMessage(new Uri("http://localhost?foo=bar&multi=1&multi=2"), "POST", body, bodyAsString, Encoding.UTF8);
+
+            // then
+            Check.That(request.GetParameter("foo")).Contains("bar");
+            Check.That(request.GetParameter("multi")).Contains("1");
+            Check.That(request.GetParameter("multi")).Contains("2");
+        }
+    }
+}

test/WireMock.Net.Tests.old/RequestTests.cs

@@ -0,0 +1,550 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using NFluent;
+using NUnit.Framework;
+using WireMock.RequestBuilders;
+using WireMock.Matchers;
+using WireMock.Matchers.Request;
+
+namespace WireMock.Net.Tests
+{
+    [TestFixture]
+    public class RequestTests
+    {
+        [Test]
+        public void Should_specify_requests_matching_given_path()
+        {
+            // given
+            var spec = Request.Create().WithPath("/foo");
+
+            // when
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "blabla");
+
+            // then
+            var requestMatchResult = new RequestMatchResult();
+            Check.That(spec.GetMatchingScore(request, requestMatchResult)).IsEqualTo(1.0);
+        }
+
+        [Test]
+        public void Should_specify_requests_matching_given_paths()
+        {
+            var requestBuilder = Request.Create().WithPath("/x1", "/x2");
+
+            var request1 = new RequestMessage(new Uri("http://localhost/x1"), "blabla");
+            var request2 = new RequestMessage(new Uri("http://localhost/x2"), "blabla");
+
+            var requestMatchResult = new RequestMatchResult();
+            Check.That(requestBuilder.GetMatchingScore(request1, requestMatchResult)).IsEqualTo(1.0);
+            Check.That(requestBuilder.GetMatchingScore(request2, requestMatchResult)).IsEqualTo(1.0);
+        }
+
+        [Test]
+        public void Should_specify_requests_matching_given_pathFuncs()
+        {
+            // given
+            var spec = Request.Create().WithPath(url => url.EndsWith("/foo"));
+
+            // when
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "blabla");
+
+            // then
+            var requestMatchResult = new RequestMatchResult();
+            Check.That(spec.GetMatchingScore(request, requestMatchResult)).IsEqualTo(1.0);
+        }
+
+        [Test]
+        public void Should_specify_requests_matching_given_path_prefix()
+        {
+            // given
+            var spec = Request.Create().WithPath(new RegexMatcher("^/foo"));
+
+            // when
+            var request = new RequestMessage(new Uri("http://localhost/foo/bar"), "blabla");
+
+            // then
+            var requestMatchResult = new RequestMatchResult();
+            Check.That(spec.GetMatchingScore(request, requestMatchResult)).IsEqualTo(1.0);
+        }
+
+        [Test]
+        public void Should_exclude_requests_not_matching_given_path()
+        {
+            // given
+            var spec = Request.Create().WithPath("/foo");
+
+            // when
+            var request = new RequestMessage(new Uri("http://localhost/bar"), "blabla");
+
+            // then
+            var requestMatchResult = new RequestMatchResult();
+            Check.That(spec.GetMatchingScore(request, requestMatchResult)).IsNotEqualTo(1.0);
+        }
+
+        [Test]
+        public void Should_specify_requests_matching_given_url()
+        {
+            // given
+            var spec = Request.Create().WithUrl("*/foo");
+
+            // when
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "blabla");
+
+            // then
+            var requestMatchResult = new RequestMatchResult();
+            Check.That(spec.GetMatchingScore(request, requestMatchResult)).IsEqualTo(1.0);
+        }
+
+        [Test]
+        public void Should_specify_requests_matching_given_path_and_method_put()
+        {
+            // given
+            var spec = Request.Create().WithPath("/foo").UsingPut();
+
+            // when
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "PUT");
+
+            // then
+            var requestMatchResult = new RequestMatchResult();
+            Check.That(spec.GetMatchingScore(request, requestMatchResult)).IsEqualTo(1.0);
+        }
+
+        [Test]
+        public void Should_specify_requests_matching_given_path_and_method_post()
+        {
+            // given
+            var spec = Request.Create().WithPath("/foo").UsingPost();
+
+            // when
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "POST");
+
+            // then
+            var requestMatchResult = new RequestMatchResult();
+            Check.That(spec.GetMatchingScore(request, requestMatchResult)).IsEqualTo(1.0);
+        }
+
+        [Test]
+        public void Should_specify_requests_matching_given_path_and_method_get()
+        {
+            // given
+            var spec = Request.Create().WithPath("/foo").UsingGet();
+
+            // when
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "GET");
+
+            // then
+            var requestMatchResult = new RequestMatchResult();
+            Check.That(spec.GetMatchingScore(request, requestMatchResult)).IsEqualTo(1.0);
+        }
+
+        [Test]
+        public void Should_specify_requests_matching_given_path_and_method_delete()
+        {
+            // given
+            var spec = Request.Create().WithPath("/foo").UsingDelete();
+
+            // when
+            string bodyAsString = "whatever";
+            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "Delete", body, bodyAsString, Encoding.UTF8);
+
+            // then
+            var requestMatchResult = new RequestMatchResult();
+            Check.That(spec.GetMatchingScore(request, requestMatchResult)).IsEqualTo(1.0);
+        }
+
+        [Test]
+        public void Should_specify_requests_matching_given_path_and_method_head()
+        {
+            // given
+            var spec = Request.Create().WithPath("/foo").UsingHead();
+
+            // when
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "HEAD");
+
+            // then
+            var requestMatchResult = new RequestMatchResult();
+            Check.That(spec.GetMatchingScore(request, requestMatchResult)).IsEqualTo(1.0);
+        }
+
+        [Test]
+        public void Should_exclude_requests_matching_given_path_but_not_http_method()
+        {
+            // given
+            var spec = Request.Create().WithPath("/foo").UsingPut();
+
+            // when
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "HEAD");
+
+            // then
+            var requestMatchResult = new RequestMatchResult();
+            Check.That(spec.GetMatchingScore(request, requestMatchResult)).IsNotEqualTo(1.0);
+        }
+
+        [Test]
+        public void Should_exclude_requests_matching_given_http_method_but_not_url()
+        {
+            // given
+            var spec = Request.Create().WithPath("/bar").UsingPut();
+
+            // when
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "PUT");
+
+            // then
+            var requestMatchResult = new RequestMatchResult();
+            Check.That(spec.GetMatchingScore(request, requestMatchResult)).IsNotEqualTo(1.0);
+        }
+
+        [Test]
+        public void Should_specify_requests_matching_given_path_and_headers()
+        {
+            // given
+            var spec = Request.Create().WithPath("/foo").UsingAnyVerb().WithHeader("X-toto", "tata");
+
+            // when
+            string bodyAsString = "whatever";
+            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "PUT", body, bodyAsString, Encoding.UTF8, new Dictionary <string, string> { { "X-toto", "tata" } });
+
+            // then
+            var requestMatchResult = new RequestMatchResult();
+            Check.That(spec.GetMatchingScore(request, requestMatchResult)).IsEqualTo(1.0);
+        }
+
+        [Test]
+        public void Should_exclude_requests_not_matching_given_headers()
+        {
+            // given
+            var spec = Request.Create().UsingAnyVerb().WithHeader("X-toto", "tatata");
+
+            // when
+            string bodyAsString = "whatever";
+            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "PUT", body, bodyAsString, Encoding.UTF8, new Dictionary <string, string> { { "X-toto", "tata" } });
+
+            // then
+            var requestMatchResult = new RequestMatchResult();
+            Check.That(spec.GetMatchingScore(request, requestMatchResult)).IsNotEqualTo(1.0);
+        }
+
+        [Test]
+        public void Should_exclude_requests_not_matching_given_headers_ignorecase()
+        {
+            // given
+            var spec = Request.Create().UsingAnyVerb().WithHeader("X-toto", "abc", false);
+
+            // when
+            string bodyAsString = "whatever";
+            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "PUT", body, bodyAsString, Encoding.UTF8, new Dictionary <string, string> { { "X-toto", "ABC" } });
+
+            // then
+            var requestMatchResult = new RequestMatchResult();
+            Check.That(spec.GetMatchingScore(request, requestMatchResult)).IsNotEqualTo(1.0);
+        }
+
+        [Test]
+        public void Should_specify_requests_matching_given_header_prefix()
+        {
+            // given
+            var spec = Request.Create().UsingAnyVerb().WithHeader("X-toto", "tata*");
+
+            // when
+            string bodyAsString = "whatever";
+            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "PUT", body, bodyAsString, Encoding.UTF8, new Dictionary<string, string> { { "X-toto", "TaTa" } });
+
+            // then
+            var requestMatchResult = new RequestMatchResult();
+            Check.That(spec.GetMatchingScore(request, requestMatchResult)).IsEqualTo(1.0);
+        }
+
+        [Test]
+        public void Should_specify_requests_matching_given_cookies()
+        {
+            // given
+            var spec = Request.Create().UsingAnyVerb().WithCookie("session", "a*");
+
+            // when
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "PUT", null, null, null, null, new Dictionary<string, string> { { "session", "abc" } });
+
+            // then
+            var requestMatchResult = new RequestMatchResult();
+            Check.That(spec.GetMatchingScore(request, requestMatchResult)).IsEqualTo(1.0);
+        }
+
+        [Test]
+        public void Should_specify_requests_matching_given_body()
+        {
+            // given
+            var spec = Request.Create().UsingAnyVerb().WithBody("Hello world!");
+
+            // when
+            string bodyAsString = "Hello world!";
+            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "PUT", body, bodyAsString, Encoding.UTF8);
+
+            // then
+            var requestMatchResult = new RequestMatchResult();
+            Check.That(spec.GetMatchingScore(request, requestMatchResult)).IsEqualTo(1.0);
+        }
+
+        [Test]
+        public void Should_specify_requests_matching_given_body_using_ExactMatcher_true()
+        {
+            // given
+            var requestBuilder = Request.Create().UsingAnyVerb().WithBody(new ExactMatcher("cat"));
+
+            // when
+            string bodyAsString = "cat";
+            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "POST", body, bodyAsString, Encoding.UTF8);
+
+            // then
+            var requestMatchResult = new RequestMatchResult();
+            Check.That(requestBuilder.GetMatchingScore(request, requestMatchResult)).IsEqualTo(1.0);
+        }
+
+        [Test]
+        public void Should_specify_requests_matching_given_body_using_ExactMatcher_multiplePatterns()
+        {
+            // given
+            var requestBuilder = Request.Create().UsingAnyVerb().WithBody(new ExactMatcher("cat", "dog"));
+
+            // when
+            string bodyAsString = "cat";
+            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "POST", body, bodyAsString, Encoding.UTF8);
+
+            // then
+            var requestMatchResult = new RequestMatchResult();
+            Check.That(requestBuilder.GetMatchingScore(request, requestMatchResult)).IsEqualTo(0.5);
+        }
+
+        [Test]
+        public void Should_specify_requests_matching_given_body_using_ExactMatcher_false()
+        {
+            // given
+            var requestBuilder = Request.Create().UsingAnyVerb().WithBody(new ExactMatcher("cat"));
+
+            // when
+            string bodyAsString = "caR";
+            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "POST", body, bodyAsString, Encoding.UTF8);
+
+            // then
+            var requestMatchResult = new RequestMatchResult();
+            Check.That(requestBuilder.GetMatchingScore(request, requestMatchResult)).IsLessThan(1.0);
+        }
+
+        [Test]
+        public void Should_specify_requests_matching_given_body_using_SimMetricsMatcher1()
+        {
+            // given
+            var requestBuilder = Request.Create().UsingAnyVerb().WithBody(new SimMetricsMatcher("The cat walks in the street."));
+
+            // when
+            string bodyAsString = "The car drives in the street.";
+            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "POST", body, bodyAsString, Encoding.UTF8);
+
+            // then
+            var requestMatchResult = new RequestMatchResult();
+            Check.That(requestBuilder.GetMatchingScore(request, requestMatchResult)).IsLessThan(1.0).And.IsGreaterThan(0.5);
+        }
+
+        [Test]
+        public void Should_specify_requests_matching_given_body_using_SimMetricsMatcher2()
+        {
+            // given
+            var requestBuilder = Request.Create().UsingAnyVerb().WithBody(new SimMetricsMatcher("The cat walks in the street."));
+
+            // when
+            string bodyAsString = "Hello";
+            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "POST", body, bodyAsString, Encoding.UTF8);
+
+            // then
+            var requestMatchResult = new RequestMatchResult();
+            Check.That(requestBuilder.GetMatchingScore(request, requestMatchResult)).IsLessThan(0.1).And.IsGreaterThan(0.05);
+        }
+
+        [Test]
+        public void Should_specify_requests_matching_given_body_using_WildcardMatcher()
+        {
+            // given
+            var spec = Request.Create().WithPath("/foo").UsingAnyVerb().WithBody(new WildcardMatcher("H*o*"));
+
+            // when
+            string bodyAsString = "Hello world!";
+            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "PUT", body, bodyAsString, Encoding.UTF8, new Dictionary<string, string> { { "X-toto", "tatata" } });
+
+            // then
+            var requestMatchResult = new RequestMatchResult();
+            Check.That(spec.GetMatchingScore(request, requestMatchResult)).IsEqualTo(1.0);
+        }
+
+        [Test]
+        public void Should_specify_requests_matching_given_body_using_RegexMatcher()
+        {
+            // given
+            var spec = Request.Create().UsingAnyVerb().WithBody(new RegexMatcher("H.*o"));
+
+            // when
+            string bodyAsString = "Hello world!";
+            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "PUT", body, bodyAsString, Encoding.UTF8);
+
+            // then
+            var requestMatchResult = new RequestMatchResult();
+            Check.That(spec.GetMatchingScore(request, requestMatchResult)).IsEqualTo(1.0);
+        }
+
+        [Test]
+        public void Should_specify_requests_matching_given_body_using_XPathMatcher_true()
+        {
+            // given
+            var spec = Request.Create().UsingAnyVerb().WithBody(new XPathMatcher("/todo-list[count(todo-item) = 3]"));
+
+            // when
+            string xmlBodyAsString = @"
+                    <todo-list>
+                        <todo-item id='a1'>abc</todo-item>
+                        <todo-item id='a2'>def</todo-item>
+                        <todo-item id='a3'>xyz</todo-item>
+                    </todo-list>";
+            byte[] body = Encoding.UTF8.GetBytes(xmlBodyAsString);
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "PUT", body, xmlBodyAsString, Encoding.UTF8);
+
+            // then
+            var requestMatchResult = new RequestMatchResult();
+            Check.That(spec.GetMatchingScore(request, requestMatchResult)).IsEqualTo(1.0);
+        }
+
+        [Test]
+        public void Should_specify_requests_matching_given_body_using_XPathMatcher_false()
+        {
+            // given
+            var spec = Request.Create().UsingAnyVerb().WithBody(new XPathMatcher("/todo-list[count(todo-item) = 99]"));
+
+            // when
+            string xmlBodyAsString = @"
+                    <todo-list>
+                        <todo-item id='a1'>abc</todo-item>
+                        <todo-item id='a2'>def</todo-item>
+                        <todo-item id='a3'>xyz</todo-item>
+                    </todo-list>";
+            byte[] body = Encoding.UTF8.GetBytes(xmlBodyAsString);
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "PUT", body, xmlBodyAsString, Encoding.UTF8);
+
+            // then
+            var requestMatchResult = new RequestMatchResult();
+            Check.That(spec.GetMatchingScore(request, requestMatchResult)).IsNotEqualTo(1.0);
+        }
+
+        [Test]
+        public void Should_specify_requests_matching_given_body_using_JsonPathMatcher_true()
+        {
+            // given
+            var spec = Request.Create().UsingAnyVerb().WithBody(new JsonPathMatcher("$.things[?(@.name == 'RequiredThing')]"));
+
+            // when
+            string bodyAsString = "{ \"things\": [ { \"name\": \"RequiredThing\" }, { \"name\": \"Wiremock\" } ] }";
+            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "PUT", body, bodyAsString, Encoding.UTF8);
+
+            // then
+            var requestMatchResult = new RequestMatchResult();
+            Check.That(spec.GetMatchingScore(request, requestMatchResult)).IsEqualTo(1.0);
+        }
+
+        [Test]
+        public void Should_specify_requests_matching_given_body_using_JsonPathMatcher_false()
+        {
+            // given
+            var spec = Request.Create().UsingAnyVerb().WithBody(new JsonPathMatcher("$.things[?(@.name == 'RequiredThing')]"));
+
+            // when
+            string bodyAsString = "{ \"things\": { \"name\": \"Wiremock\" } }";
+            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "PUT", body, bodyAsString, Encoding.UTF8);
+
+            // then
+            var requestMatchResult = new RequestMatchResult();
+            Check.That(spec.GetMatchingScore(request, requestMatchResult)).IsNotEqualTo(1.0);
+        }
+
+        [Test]
+        public void Should_exclude_requests_not_matching_given_body()
+        {
+            // given
+            var spec = Request.Create().UsingAnyVerb().WithBody("      Hello world!   ");
+
+            // when
+            string bodyAsString = "xxx";
+            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "PUT", body, bodyAsString, Encoding.UTF8, new Dictionary<string, string> { { "X-toto", "tatata" } });
+
+            // then
+            var requestMatchResult = new RequestMatchResult();
+            Check.That(spec.GetMatchingScore(request, requestMatchResult)).IsNotEqualTo(1.0);
+        }
+
+        [Test]
+        public void Should_specify_requests_matching_given_param()
+        {
+            // given
+            var spec = Request.Create().WithParam("bar", "1", "2");
+
+            // when
+            var request = new RequestMessage(new Uri("http://localhost/foo?bar=1&bar=2"), "PUT");
+
+            // then
+            var requestMatchResult = new RequestMatchResult();
+            Check.That(spec.GetMatchingScore(request, requestMatchResult)).IsEqualTo(1.0);
+        }
+
+        [Test]
+        public void Should_specify_requests_matching_given_paramNoValue()
+        {
+            // given
+            var spec = Request.Create().WithParam("bar");
+
+            // when
+            var request = new RequestMessage(new Uri("http://localhost/foo?bar"), "PUT");
+
+            // then
+            var requestMatchResult = new RequestMatchResult();
+            Check.That(spec.GetMatchingScore(request, requestMatchResult)).IsEqualTo(1.0);
+        }
+
+        [Test]
+        public void Should_specify_requests_matching_given_param_func()
+        {
+            // given
+            var spec = Request.Create().UsingAnyVerb().WithParam(p => p.ContainsKey("bar"));
+
+            // when
+            var request = new RequestMessage(new Uri("http://localhost/foo?bar=1&bar=2"), "PUT");
+
+            // then
+            var requestMatchResult = new RequestMatchResult();
+            Check.That(spec.GetMatchingScore(request, requestMatchResult)).IsEqualTo(1.0);
+        }
+
+        [Test]
+        public void Should_exclude_requests_not_matching_given_params()
+        {
+            // given
+            var spec = Request.Create().WithParam("bar", "1");
+
+            // when
+            var request = new RequestMessage(new Uri("http://localhost/test=7"), "PUT");
+
+            // then
+            var requestMatchResult = new RequestMatchResult();
+            Check.That(spec.GetMatchingScore(request, requestMatchResult)).IsNotEqualTo(1.0);
+        }
+    }
+}

test/WireMock.Net.Tests.old/ResponseTests.cs

@@ -0,0 +1,106 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+using NFluent;
+using NUnit.Framework;
+using WireMock.ResponseBuilders;
+
+namespace WireMock.Net.Tests
+{
+    [TestFixture]
+    public class ResponseTests
+    {
+        [Test]
+        public async Task Response_ProvideResponse_Handlebars_UrlPathVerb()
+        {
+            // given
+            string bodyAsString = "abc";
+            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "POST", body, bodyAsString, Encoding.UTF8);
+
+            var response = Response.Create()
+                .WithBody("test {{request.url}} {{request.path}} {{request.method}}")
+                .WithTransformer();
+            
+            // act
+            var responseMessage = await response.ProvideResponse(request);
+
+            // then
+            Check.That(responseMessage.Body).Equals("test http://localhost/foo /foo post");
+        }
+
+        [Test]
+        public async Task Response_ProvideResponse_Handlebars_Query()
+        {
+            // given
+            string bodyAsString = "abc";
+            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
+            var request = new RequestMessage(new Uri("http://localhost/foo?a=1&a=2&b=5"), "POST", body, bodyAsString, Encoding.UTF8);
+
+            var response = Response.Create()
+                .WithBody("test keya={{request.query.a}} idx={{request.query.a.[0]}} idx={{request.query.a.[1]}} keyb={{request.query.b}}")
+                .WithTransformer();
+
+            // act
+            var responseMessage = await response.ProvideResponse(request);
+
+            // then
+            Check.That(responseMessage.Body).Equals("test keya=1 idx=1 idx=2 keyb=5");
+        }
+
+        [Test]
+        public async Task Response_ProvideResponse_Handlebars_Headers()
+        {
+            // given
+            string bodyAsString = "abc";
+            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "POST", body, bodyAsString, Encoding.UTF8, new Dictionary<string, string> { { "Content-Type", "text/plain" } });
+
+            var response = Response.Create().WithHeader("x", "{{request.headers.Content-Type}}").WithBody("test").WithTransformer();
+
+            // act
+            var responseMessage = await response.ProvideResponse(request);
+
+            // then
+            Check.That(responseMessage.Body).Equals("test");
+            Check.That(responseMessage.Headers).Contains(new KeyValuePair<string,string>("x", "text/plain"));
+        }
+
+        [Test]
+        public async Task Response_ProvideResponse_Encoding_Body()
+        {
+            // given
+            string bodyAsString = "abc";
+            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "POST", body, bodyAsString, Encoding.UTF8);
+
+            var response = Response.Create().WithBody("test", Encoding.ASCII);
+
+            // act
+            var responseMessage = await response.ProvideResponse(request);
+
+            // then
+            Check.That(responseMessage.Body).Equals("test");
+            Check.That(responseMessage.BodyEncoding).Equals(Encoding.ASCII);
+        }
+
+        [Test]
+        public async Task Response_ProvideResponse_Encoding_JsonBody()
+        {
+            // given
+            string bodyAsString = "abc";
+            byte[] body = Encoding.UTF8.GetBytes(bodyAsString);
+            var request = new RequestMessage(new Uri("http://localhost/foo"), "POST", body, bodyAsString, Encoding.UTF8);
+
+            var response = Response.Create().WithBodyAsJson(new { value = "test" }, Encoding.ASCII);
+
+            // act
+            var responseMessage = await response.ProvideResponse(request);
+
+            // then
+            Check.That(responseMessage.Body).Equals("{\"value\":\"test\"}");
+            Check.That(responseMessage.BodyEncoding).Equals(Encoding.ASCII);
+        }
+    }
+}

test/WireMock.Net.Tests.old/WildcardMatcherTest.cs

@@ -0,0 +1,59 @@
+using NUnit.Framework;
+using WireMock.Matchers;
+
+namespace WireMock.Net.Tests
+{
+    [TestFixture]
+    public class WildcardMatcherTest
+    {
+        [Test]
+        public void WildcardMatcher_patterns_positive()
+        {
+            var tests = new[]
+            {
+                new { p = "*", i = "" },
+                new { p = "?", i = " " },
+                new { p = "*", i = "a" },
+                new { p = "*", i = "ab" },
+                new { p = "?", i = "a" },
+                new { p = "*?", i = "abc" },
+                new { p = "?*", i = "abc" },
+                new { p = "abc", i = "abc" },
+                new { p = "abc*", i = "abc" },
+                new { p = "abc*", i = "abcd" },
+                new { p = "*abc*", i = "abc" },
+                new { p = "*a*bc*", i = "abc" },
+                new { p = "*a*b?", i = "aXXXbc" }
+            };
+            foreach (var test in tests)
+            {
+                var matcher = new WildcardMatcher(test.p);
+                Assert.AreEqual(1.0, matcher.IsMatch(test.i), "p = " + test.p + ", i = " + test.i);
+            }
+        }
+
+        [Test]
+        public void WildcardMatcher_patterns_negative()
+        {
+            var tests = new[]
+            {
+                new { p = "*a", i = ""},
+                new { p = "a*", i = ""},
+                new { p = "?", i = ""},
+                new { p = "*b*", i = "a"},
+                new { p = "b*a", i = "ab"},
+                new { p = "??", i = "a"},
+                new { p = "*?", i = ""},
+                new { p = "??*", i = "a"},
+                new { p = "*abc", i = "abX"},
+                new { p = "*abc*", i = "Xbc"},
+                new { p = "*a*bc*", i = "ac"}
+            };
+            foreach (var test in tests)
+            {
+                var matcher = new WildcardMatcher(test.p);
+                Assert.AreEqual(0.0, matcher.IsMatch(test.i), "p = " + test.p + ", i = " + test.i);
+            }
+        }
+    }
+}

test/WireMock.Net.Tests/FluentMockServerTests.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Diagnostics;
+using System.IO;
 using System.Linq;
 using System.Net;
 using System.Net.Http;
@@ -19,6 +20,53 @@ namespace WireMock.Net.Tests
     {
         private FluentMockServer _server;
 
+        [Test]
+        public void FluentMockServer_ReadStaticMapping_WithNonGuidFilename()
+        {
+            var guid = Guid.Parse("04ee4872-9efd-4770-90d3-88d445265d0d");
+            string title = "documentdb_root_title";
+
+            _server = FluentMockServer.Start();
+
+            string folder = Path.Combine(Directory.GetCurrentDirectory(), "__admin", "mappings", "documentdb_root.json");
+            _server.ReadStaticMapping(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);
+            Check.That(mappings.First().Title).Equals(title);
+        }
+
+        [Test]
+        public void FluentMockServer_ReadStaticMapping_WithGuidFilename()
+        {
+            string guid = "00000002-ee28-4f29-ae63-1ac9b0802d86";
+
+            _server = FluentMockServer.Start();
+            string folder = Path.Combine(Directory.GetCurrentDirectory(), "__admin", "mappings", guid + ".json");
+            _server.ReadStaticMapping(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();
+        }
+
+        [Test]
+        public void FluentMockServer_ReadStaticMappings()
+        {
+            _server = FluentMockServer.Start(new FluentMockServerSettings { ReadStaticMappings = true });
+
+            var mappings = _server.Mappings.ToArray();
+            Check.That(mappings).HasSize(2);
+        }
+
         [Test]
         public void FluentMockServer_Admin_Mappings_Get()
         {

test/WireMock.Net.Tests/WireMock.Net.Tests.xproj

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="14.0.25420" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <VisualStudioVersion Condition="'$(VisualStudioVersion)' == ''">14.0.25420</VisualStudioVersion>
+    <VSToolsPath Condition="'$(VSToolsPath)' == ''">$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)</VSToolsPath>
+  </PropertyGroup>
+  <Import Project="$(VSToolsPath)\DotNet\Microsoft.DotNet.Props" Condition="'$(VSToolsPath)' != ''" />
+  <PropertyGroup Label="Globals">
+    <ProjectGuid>31dc2ef8-c3fe-467d-84be-fb5d956e612e</ProjectGuid>
+    <RootNamespace>WireMock.Net.Tests</RootNamespace>
+    <BaseIntermediateOutputPath Condition="'$(BaseIntermediateOutputPath)'=='' ">.\obj</BaseIntermediateOutputPath>
+    <OutputPath Condition="'$(OutputPath)'=='' ">.\bin\</OutputPath>
+  </PropertyGroup>
+  <PropertyGroup>
+    <SchemaVersion>2.0</SchemaVersion>
+  </PropertyGroup>
+  <ItemGroup>
+    <Service Include="{82a7f48d-3b50-4b1e-b82e-3ada8210c358}" />
+  </ItemGroup>
+  <Import Project="$(VSToolsPath)\DotNet\Microsoft.DotNet.targets" Condition="'$(VSToolsPath)' != ''" />
+</Project>

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

@@ -0,0 +1,50 @@
+{
+  "Guid": "00000002-ee28-4f29-ae63-1ac9b0802d86",
+  "Priority": 0,
+  "Request": {
+    "Path": {
+      "Matchers": [
+        {
+          "Name": "ExactMatcher",
+          "Pattern": "/dbs"
+        }
+      ]
+    },
+    "Methods": [
+      "post"
+    ],
+    "Body": {
+      "Matcher": {
+        "Name": "WildcardMatcher",
+        "Pattern": "*db-abc*"
+      }
+    }
+  },
+  "Response": {
+    "StatusCode": 200,
+    "Body": "{\"_rid\":\"\",\"Databases\":[{\"id\":\"db-abc\",\"_rid\":\"hBYWAA==\",\"_self\":\"dbs/hBYWAA==/\",\"_etag\":\"\\\"00008e00-0000-0000-0000-58b94f910000\\\"\",\"_colls\":\"colls/\",\"_users\":\"users/\",\"_ts\":1488539514}],\"_count\":1}",
+    "BodyEncoding": {
+      "CodePage": 65001,
+      "EncodingName": "Unicode (UTF-8)",
+      "WebName": "utf-8"
+    },
+    "UseTransformer": false,
+    "Headers": {
+      "x-ms-schemaversion": "1.3",
+      "Date": "Mon, 06 Mar 2017 10:56:43 GMT",
+      "x-ms-activity-id": "5e39429d-7fcc-4b75-93d6-519b7c582772",
+      "x-ms-item-count": "1",
+      "x-ms-resource-usage": "databases=1;",
+      "x-ms-gatewayversion": "version=1.11.164.3",
+      "x-ms-xp-role": "2",
+      "x-ms-session-token": "0:25908",
+      "x-ms-serviceversion": "version=1.11.150.2",
+      "Strict-Transport-Security": "max-age=31536000",
+      "Server": "Microsoft-HTTPAPI/2.0",
+      "x-ms-last-state-change-utc": "Fri, 24 Feb 2017 11:35:16.053 GMT",
+      "Content-Type": "application/json",
+      "x-ms-request-charge": "4.68",
+      "x-ms-resource-quota": "databases=100;"
+    }
+  }
+}

test/WireMock.Net.Tests/__admin/mappings/documentdb_root.json

@@ -0,0 +1,42 @@
+{
+  "Guid": "04ee4872-9efd-4770-90d3-88d445265d0d",
+  "Title": "documentdb_root_title",
+  "Priority": 0,
+  "Request": {
+    "Path": {
+      "Matchers": [
+        {
+          "Name": "ExactMatcher",
+          "Pattern": "/"
+        }
+      ]
+    },
+    "Methods": [
+      "get"
+    ],
+    "Body": {}
+  },
+  "Response": {
+    "StatusCode": 200,
+    "Body": "{\"_self\":\"\",\"id\":\"abc\",\"_rid\":\"abc.documents.azure.com\",\"media\":\"//media/\",\"addresses\":\"//addresses/\",\"_dbs\":\"//dbs/\",\"writableLocations\":[{\"name\":\"West Europe\",\"databaseAccountEndpoint\":\"http://localhost:9090/\"}],\"readableLocations\":[{\"name\":\"West Europe\",\"databaseAccountEndpoint\":\"http://localhost:9090/\"}],\"userReplicationPolicy\":{\"asyncReplication\":false,\"minReplicaSetSize\":3,\"maxReplicasetSize\":4},\"userConsistencyPolicy\":{\"defaultConsistencyLevel\":\"Session\"},\"systemReplicationPolicy\":{\"minReplicaSetSize\":3,\"maxReplicasetSize\":4},\"readPolicy\":{\"primaryReadCoefficient\":1,\"secondaryReadCoefficient\":1},\"queryEngineConfiguration\":\"{\\\"maxSqlQueryInputLength\\\":30720,\\\"maxJoinsPerSqlQuery\\\":5,\\\"maxLogicalAndPerSqlQuery\\\":500,\\\"maxLogicalOrPerSqlQuery\\\":500,\\\"maxUdfRefPerSqlQuery\\\":2,\\\"maxInExpressionItemsCount\\\":8000,\\\"queryMaxInMemorySortDocumentCount\\\":500,\\\"maxQueryRequestTimeoutFraction\\\":0.9,\\\"sqlAllowNonFiniteNumbers\\\":false,\\\"sqlAllowAggregateFunctions\\\":true,\\\"sqlAllowSubQuery\\\":false,\\\"allowNewKeywords\\\":true,\\\"sqlAllowLike\\\":false,\\\"maxSpatialQueryCells\\\":12,\\\"spatialMaxGeometryPointCount\\\":256,\\\"sqlAllowTop\\\":true,\\\"enableSpatialIndexing\\\":true}\"}",
+    "BodyEncoding": {
+      "CodePage": 65001,
+      "EncodingName": "Unicode (UTF-8)",
+      "WebName": "utf-8"
+    },
+    "UseTransformer": false,
+    "Headers": {
+      "x-ms-databaseaccount-reserved-mb": "0",
+      "x-ms-databaseaccount-consumed-mb": "0",
+      "Strict-Transport-Security": "max-age=31536000",
+      "x-ms-max-media-storage-usage-mb": "2048",
+      "x-ms-gatewayversion": "version=1.11.164.3",
+      "x-ms-media-storage-usage-mb": "0",
+      "x-ms-databaseaccount-provisioned-mb": "0",
+      "Content-Location": "http://localhost:9090/",
+      "Date": "Mon, 06 Mar 2017 10:56:40 GMT",
+      "Content-Type": "application/json",
+      "Server": "Microsoft-HTTPAPI/2.0"
+    }
+  }
+}

test/WireMock.Net.Tests/project.json

@@ -0,0 +1,23 @@
+{
+    "version": "1.0.0-*",
+    "authors": [ "Stef Heyenrath" ],
+
+    "frameworks": {
+        "net452": {
+            "frameworkAssemblies": {
+                "System.Net.Http": { "type": "build" }
+            },
+
+            "dependencies": {
+                "dotnet-test-nunit": "3.4.0-beta-3",
+                "Moq": "4.7.0",
+                "NFluent": "1.3.1",
+                "NUnit": "3.6.0",
+                "SimMetrics.Net": "1.0.1.0",
+                "WireMock.Net": { "target": "project" }
+            }
+        }
+    },
+
+    "testRunner": "nunit"
+}