1.0.4.14

* LinqMatcher

* LinqMatcher : revert

* LinqMatcher

CHANGELOG.md

@@ -1,3 +1,28 @@
+# 1.0.4.14 (02 September 2018)
+
+ - [#197](https://github.com/WireMock-Net/WireMock.Net/pull/197) - Set IsStarted = true in a IApplicationLifetime.ApplicationStarted listener contributed by ([davide-romanini](https://github.com/davide-romanini)) +fix
+ - [#196](https://github.com/WireMock-Net/WireMock.Net/issues/196) - Issue: AspNetCoreSelfHost.IsStarted set before the server actually started for real +fix
+
+Commits: 077b3c0891...5ccb992201
+
+
+# 1.0.4.13 (31 August 2018)
+
+ - [#195](https://github.com/WireMock-Net/WireMock.Net/pull/195) - Add LinqMatcher contributed by Stef Heyenrath ([StefH](https://github.com/StefH))
+
+Commits: 9f17948e9f...9f17948e9f
+
+
+# 1.0.4.12 (23 August 2018)
+
+ - [#191](https://github.com/WireMock-Net/WireMock.Net/pull/191) - Fix ignore case logic for header-name and cookie-name contributed by Stef Heyenrath ([StefH](https://github.com/StefH))
+ - [#190](https://github.com/WireMock-Net/WireMock.Net/pull/190) - Fix ResponseMessageTransformer (#188) contributed by Stef Heyenrath ([StefH](https://github.com/StefH))
+ - [#189](https://github.com/WireMock-Net/WireMock.Net/issues/189) - Issue: Case of header key/name not ignored in RequestBuilder when ignoreCase == true
+ - [#188](https://github.com/WireMock-Net/WireMock.Net/issues/188) - Bug: ResponseMessageTransformer : 
+
+Commits: e6ecf5cc84...f8d22d4c47
+
+
 # 1.0.4.11 (20 August 2018)
 
  - [#187](https://github.com/WireMock-Net/WireMock.Net/issues/187) - Bug: Admin GetRequestAsync does not populate request body for JsonApi ("application/vnd.api+json") content

GitReleaseNotes.txt

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

README.md

@@ -30,26 +30,21 @@ A C# .NET version based on [mock4net](https://github.com/alexvictoor/mock4net) w
 |   **WireMock.Net** | [![NuGet Badge WireMock.Net](https://buildstats.info/nuget/WireMock.Net)](https://www.nuget.org/packages/WireMock.Net) |
 |   **WireMock.Net.StandAlone** | [![NuGet Badge WireMock.Net.StandAlone](https://buildstats.info/nuget/WireMock.Net.StandAlone)](https://www.nuget.org/packages/WireMock.Net.StandAlone) |
 
-### Frameworks
-The following frameworks are supported:
-- net 4.5.1 and up (Microsoft.AspNet.WebApi.OwinSelfHost version 5.2.6)
-- net 4.6.1 and up (Microsoft.AspNetCore version 2.1.2)
-- netstandard 1.3 (Microsoft.AspNetCore version 1.1.7)
-- netstandard 2.0 (Microsoft.AspNetCore version 2.1.2)
-
-### Build info
-To build you need:
-- Microsoft .NET Framework [4.5.1 Developer Pack](https://www.microsoft.com/en-us/download/details.aspx?id=40772)
-- Microsoft .NET Framework [4.5.2 Developer Pack](https://www.microsoft.com/en-us/download/details.aspx?id=42637)
-- Microsoft .NET Framework [4.6 Targeting Pack](https://www.microsoft.com/en-us/download/confirmation.aspx?id=48136)
-- Microsoft .NET Framework [4.6.2 Developer Pack](https://www.microsoft.com/en-us/download/confirmation.aspx?id=53321)
-- .NET Core 2.0 (https://www.microsoft.com/net/download)
+## Development
+For the supported frameworks and build information, see [this](https://github.com/WireMock-Net/WireMock.Net/wiki/Development-Information) page.
 
 ## Stubbing
-A core feature of WireMock.Net is the ability to return canned/predefined HTTP responses for requests matching criteria, see [Wiki : Stubbing & Request Matching](https://github.com/WireMock-Net/WireMock.Net/wiki/Stubbing-and-Request-Matching).
+A core feature of WireMock.Net is the ability to return predefined HTTP responses for requests matching criteria.
+See [Wiki : Stubbing](https://github.com/WireMock-Net/WireMock.Net/wiki/Stubbing).
+
+## Request Matching
+WireMock.Net support advanced request-matching logic, see [Wiki : Request Matching](https://github.com/WireMock-Net/WireMock.Net/wiki/Request-Matching).
+
+## Response Templating
+The response which is returned WireMock.Net can be changed using templating. This is described here [Wiki : Response Templating](https://github.com/WireMock-Net/WireMock.Net/wiki/Response-Templating).
 
 ## Admin API Reference
-The WireMock admin API provides functionality to define the mappings via a http interface, see [Wiki : Admin API Reference](https://github.com/StefH/WireMock.Net/wiki/Admin-API-Reference).
+The WireMock admin API provides functionality to define the mappings via a http interface see [Wiki : Admin API Reference](https://github.com/StefH/WireMock.Net/wiki/Admin-API-Reference).
 
 ## Using
 WireMock.Net can be used in several ways:

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

@@ -350,6 +350,14 @@ namespace WireMock.Net.ConsoleApplication
                     .WithTransformer()
                 );
 
+            // https://stackoverflow.com/questions/51985089/wiremock-request-matching-with-comparison-between-two-query-parameters
+            server
+                .Given(Request.Create().WithPath("/linq")
+                    .WithParam("from", new LinqMatcher("DateTime.Parse(it) > \"2018-03-01 00:00:00\"")))
+                .RespondWith(Response.Create()
+                    .WithBody("linq match !!!")
+                );
+
             System.Console.WriteLine("Press any key to stop the server");
             System.Console.ReadKey();
             server.Stop();

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

@@ -1,9 +1,8 @@
 <Project Sdk="Microsoft.NET.Sdk">
-
   <PropertyGroup>
     <Description>Lightweight StandAlone Http Mocking Server for .Net.</Description>
     <AssemblyTitle>WireMock.Net.StandAlone</AssemblyTitle>
-    <Version>1.0.4.11</Version>
+    <Version>1.0.4.14</Version>
     <Authors>Stef Heyenrath</Authors>
     <TargetFrameworks>net451;net452;net46;netstandard1.3;netstandard2.0</TargetFrameworks>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
@@ -46,5 +45,4 @@
   <ItemGroup>
     <ProjectReference Include="..\WireMock.Net\WireMock.Net.csproj" />
   </ItemGroup>
-
 </Project>

src/WireMock.Net/Matchers/LinqMatcher.cs

@@ -0,0 +1,99 @@
+using System.Linq;
+using System.Linq.Dynamic.Core;
+using JetBrains.Annotations;
+
+namespace WireMock.Matchers
+{
+    /// <summary>
+    /// System.Linq.Dynamic.Core Expression Matcher
+    /// </summary>
+    /// <inheritdoc cref="IStringMatcher"/>
+    public class LinqMatcher : IStringMatcher
+    {
+        private readonly string[] _patterns;
+
+        /// <inheritdoc cref="IMatcher.MatchBehaviour"/>
+        public MatchBehaviour MatchBehaviour { get; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="LinqMatcher"/> class.
+        /// </summary>
+        /// <param name="pattern">The pattern.</param>
+        public LinqMatcher([NotNull] string pattern) : this(new[] { pattern })
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="LinqMatcher"/> class.
+        /// </summary>
+        /// <param name="patterns">The patterns.</param>
+        public LinqMatcher([NotNull] string[] patterns) : this(MatchBehaviour.AcceptOnMatch, patterns)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="LinqMatcher"/> class.
+        /// </summary>
+        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// <param name="pattern">The pattern.</param>
+        public LinqMatcher(MatchBehaviour matchBehaviour, [NotNull] string pattern) : this(matchBehaviour, new[] { pattern })
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="LinqMatcher"/> class.
+        /// </summary>
+        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// <param name="patterns">The patterns.</param>
+        public LinqMatcher(MatchBehaviour matchBehaviour, [NotNull] string[] patterns)
+        {
+            MatchBehaviour = matchBehaviour;
+            _patterns = patterns;
+        }
+
+        /// <inheritdoc cref="IStringMatcher.IsMatch"/>
+        public double IsMatch(string input)
+        {
+            // Convert a single input string to a Queryable string-list with 1 entry.
+            IQueryable queryable = new[] { input }.AsQueryable();
+
+            // Use the Any(...) method to check if the result matches
+            double match = MatchScores.ToScore(_patterns.Select(pattern => queryable.Any(pattern)));
+
+            return MatchBehaviourHelper.Convert(MatchBehaviour, match);
+        }
+
+        ///// <inheritdoc cref="IObjectMatcher.IsMatch"/>
+        //public double IsMatch(object input)
+        //{
+        //    object value;
+        //    switch (input)
+        //    {
+        //        case JObject valueAsJObject:
+        //            value = valueAsJObject.ToObject<object>();
+        //            break;
+
+        //        default:
+        //            value = input;
+        //            break;
+        //    }
+
+        //    // Convert a single object to a Queryable object-list with 1 entry.
+        //    IQueryable queryable = new[] { value }.AsQueryable().Select("new (it as x)");
+
+        //    // Use the Any(...) method to check if the result matches
+        //    double match = MatchScores.ToScore(_patterns.Select(pattern => queryable.Any(pattern)));
+
+        //    return MatchBehaviourHelper.Convert(MatchBehaviour, match);
+        //}
+
+        /// <inheritdoc cref="IStringMatcher.GetPatterns"/>
+        public string[] GetPatterns()
+        {
+            return _patterns;
+        }
+
+        /// <inheritdoc cref="IMatcher.Name"/>
+        public string Name => "LinqMatcher";
+    }
+}

src/WireMock.Net/Matchers/Request/RequestMessageCookieMatcher.cs

@@ -12,6 +12,7 @@ namespace WireMock.Matchers.Request
     public class RequestMessageCookieMatcher : IRequestMatcher
     {
         private readonly MatchBehaviour _matchBehaviour;
+        private readonly bool _ignoreCase;
 
         /// <value>
         /// The funcs.
@@ -41,6 +42,7 @@ namespace WireMock.Matchers.Request
             Check.NotNull(pattern, nameof(pattern));
 
             _matchBehaviour = matchBehaviour;
+            _ignoreCase = ignoreCase;
             Name = name;
             Matchers = new IStringMatcher[] { new WildcardMatcher(matchBehaviour, pattern, ignoreCase) };
         }
@@ -84,9 +86,12 @@ namespace WireMock.Matchers.Request
                 return MatchBehaviourHelper.Convert(_matchBehaviour, MatchScores.Mismatch);
             }
 
+            // Check if we want to use IgnoreCase to compare the Cookie-Name and Cookie-Value
+            var cookies = !_ignoreCase ? requestMessage.Cookies : new Dictionary<string, string>(requestMessage.Cookies, StringComparer.OrdinalIgnoreCase);
+
             if (Funcs != null)
             {
-                return MatchScores.ToScore(Funcs.Any(f => f(requestMessage.Cookies)));
+                return MatchScores.ToScore(Funcs.Any(f => f(cookies)));
             }
 
             if (Matchers == null)
@@ -94,12 +99,12 @@ namespace WireMock.Matchers.Request
                 return MatchScores.Mismatch;
             }
 
-            if (!requestMessage.Cookies.ContainsKey(Name))
+            if (!cookies.ContainsKey(Name))
             {
                 return MatchBehaviourHelper.Convert(_matchBehaviour, MatchScores.Mismatch);
             }
 
-            string value = requestMessage.Cookies[Name];
+            string value = cookies[Name];
             return Matchers.Max(m => m.IsMatch(value));
         }
     }

src/WireMock.Net/Matchers/Request/RequestMessageHeaderMatcher.cs

@@ -14,6 +14,7 @@ namespace WireMock.Matchers.Request
     public class RequestMessageHeaderMatcher : IRequestMatcher
     {
         private readonly MatchBehaviour _matchBehaviour;
+        private readonly bool _ignoreCase;
 
         /// <summary>
         /// The functions
@@ -43,6 +44,7 @@ namespace WireMock.Matchers.Request
             Check.NotNull(pattern, nameof(pattern));
 
             _matchBehaviour = matchBehaviour;
+            _ignoreCase = ignoreCase;
             Name = name;
             Matchers = new IStringMatcher[] { new WildcardMatcher(matchBehaviour, pattern, ignoreCase) };
         }
@@ -60,6 +62,7 @@ namespace WireMock.Matchers.Request
             Check.NotNull(patterns, nameof(patterns));
 
             _matchBehaviour = matchBehaviour;
+            _ignoreCase = ignoreCase;
             Name = name;
             Matchers = patterns.Select(pattern => new WildcardMatcher(matchBehaviour, pattern, ignoreCase)).Cast<IStringMatcher>().ToArray();
         }
@@ -103,9 +106,12 @@ namespace WireMock.Matchers.Request
                 return MatchBehaviourHelper.Convert(_matchBehaviour, MatchScores.Mismatch);
             }
 
+            // Check if we want to use IgnoreCase to compare the Header-Name and Header-Value(s)
+            var headers = !_ignoreCase ? requestMessage.Headers : new Dictionary<string, WireMockList<string>>(requestMessage.Headers, StringComparer.OrdinalIgnoreCase);
+
             if (Funcs != null)
             {
-                return MatchScores.ToScore(Funcs.Any(f => f(requestMessage.Headers.ToDictionary(entry => entry.Key, entry => entry.Value.ToArray()))));
+                return MatchScores.ToScore(Funcs.Any(f => f(headers.ToDictionary(entry => entry.Key, entry => entry.Value.ToArray()))));
             }
 
             if (Matchers == null)
@@ -113,12 +119,12 @@ namespace WireMock.Matchers.Request
                 return MatchScores.Mismatch;
             }
 
-            if (!requestMessage.Headers.ContainsKey(Name))
+            if (!headers.ContainsKey(Name))
             {
                 return MatchBehaviourHelper.Convert(_matchBehaviour, MatchScores.Mismatch);
             }
 
-            WireMockList<string> list = requestMessage.Headers[Name];
+            WireMockList<string> list = headers[Name];
             return Matchers.Max(m => list.Max(value => m.IsMatch(value))); // TODO : is this correct ?
         }
     }

src/WireMock.Net/Owin/AspNetCoreSelfHost.cs

@@ -104,7 +104,9 @@ namespace WireMock.Owin
         {
             try
             {
-                IsStarted = true;
+                var appLifetime = (IApplicationLifetime) _host.Services.GetService(typeof(IApplicationLifetime));
+                appLifetime.ApplicationStarted.Register(() => IsStarted = true);
+
 #if NETSTANDARD1_3
                 _logger.Info("WireMock.Net server using netstandard1.3");
 #elif NETSTANDARD2_0

src/WireMock.Net/Serialization/MatcherMapper.cs

@@ -26,6 +26,9 @@ namespace WireMock.Serialization
 
             switch (matcherName)
             {
+                case "LinqMatcher":
+                    return new LinqMatcher(matchBehaviour, stringPatterns);
+
                 case "ExactMatcher":
                     return new ExactMatcher(matchBehaviour, stringPatterns);
 

src/WireMock.Net/Transformers/ResponseMessageTransformer.cs

@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.Linq;
 using HandlebarsDotNet;
 using Newtonsoft.Json;
@@ -55,37 +56,41 @@ namespace WireMock.Transformers
 
         private static void TransformBodyAsJson(object template, ResponseMessage original, ResponseMessage responseMessage)
         {
-            JObject jobject;
+            JToken jToken;
             switch (original.BodyAsJson)
             {
                 case JObject bodyAsJObject:
-                    jobject = bodyAsJObject;
+                    jToken = bodyAsJObject;
+                    break;
+
+                case Array bodyAsArray:
+                    jToken = JArray.FromObject(bodyAsArray);
                     break;
 
                 default:
-                    jobject = JObject.FromObject(original.BodyAsJson);
+                    jToken = JObject.FromObject(original.BodyAsJson);
                     break;
             }
 
-            WalkNode(jobject, template);
+            WalkNode(jToken, template);
 
-            responseMessage.BodyAsJson = jobject;
+            responseMessage.BodyAsJson = jToken;
         }
 
         private static void WalkNode(JToken node, object template)
         {
             if (node.Type == JTokenType.Object)
             {
-                // In case of Object, loop all children.
-                foreach (JProperty child in node.Children<JProperty>())
+                // In case of Object, loop all children. Do a ToArray() to avoid `Collection was modified` exceptions.
+                foreach (JProperty child in node.Children<JProperty>().ToArray())
                 {
                     WalkNode(child.Value, template);
                 }
             }
             else if (node.Type == JTokenType.Array)
             {
-                // In case of Array, loop all items.
-                foreach (JToken child in node.Children())
+                // In case of Array, loop all items. Do a ToArray() to avoid `Collection was modified` exceptions.
+                foreach (JToken child in node.Children().ToArray())
                 {
                     WalkNode(child, template);
                 }

src/WireMock.Net/WireMock.Net.csproj

@@ -1,9 +1,8 @@
 <Project Sdk="Microsoft.NET.Sdk">
-
   <PropertyGroup>
     <Description>Lightweight Http Mocking Server for .Net, inspired by WireMock from the Java landscape.</Description>
     <AssemblyTitle>WireMock.Net</AssemblyTitle>
-    <Version>1.0.4.11</Version>
+    <Version>1.0.4.14</Version>
     <Authors>Stef Heyenrath</Authors>
     <TargetFrameworks>net451;net452;net46;net461;netstandard1.3;netstandard2.0</TargetFrameworks>
     <GenerateDocumentationFile>true</GenerateDocumentationFile>
@@ -50,6 +49,7 @@
     <PackageReference Include="System.Net.Http" Version="4.3.3" />
     <PackageReference Include="RestEase" Version="1.4.4" />
     <PackageReference Include="MimeKitLite" Version="2.0.1" />
+    <PackageReference Include="System.Linq.Dynamic.Core" Version="1.0.8.17" />
   </ItemGroup>
 
   <ItemGroup Condition=" '$(TargetFramework)' == 'net451' ">
@@ -99,5 +99,4 @@
     <PackageReference Include="Microsoft.AspNetCore" Version="2.1.2" />
     <PackageReference Include="XPath2" Version="1.0.5.1" />
   </ItemGroup>
-
 </Project>

test/WireMock.Net.Tests/MatcherMapperTests.cs

@@ -0,0 +1,97 @@
+using System;
+using NFluent;
+using WireMock.Admin.Mappings;
+using WireMock.Matchers;
+using WireMock.Serialization;
+using Xunit;
+
+namespace WireMock.Net.Tests
+{
+    public class MatcherMapperTests
+    {
+        [Fact]
+        public void MatcherMapper_Map_MatcherModel_Null()
+        {
+            // Act
+            var result = MatcherMapper.Map((MatcherModel)null);
+
+            // Assert
+            Check.That(result).IsNull();
+        }
+
+        [Fact]
+        public void MatcherMapper_Map_MatcherModel_Exception()
+        {
+            // Assign
+            var model = new MatcherModel { Name = "test" };
+
+            // Act and Assert
+            Check.ThatCode(() => MatcherMapper.Map(model)).Throws<NotSupportedException>();
+        }
+
+        [Fact]
+        public void MatcherMapper_Map_MatcherModel_LinqMatcher_Pattern()
+        {
+            // Assign
+            var model = new MatcherModel
+            {
+                Name = "LinqMatcher",
+                Pattern = "p"
+            };
+
+            // Act
+            var matcher = MatcherMapper.Map(model) as LinqMatcher;
+
+            // Assert
+            Check.That(matcher).IsNotNull();
+            Check.That(matcher.MatchBehaviour).IsEqualTo(MatchBehaviour.AcceptOnMatch);
+            Check.That(matcher.GetPatterns()).ContainsExactly("p");
+        }
+
+        [Fact]
+        public void MatcherMapper_Map_MatcherModel_LinqMatcher_Patterns()
+        {
+            // Assign
+            var model = new MatcherModel
+            {
+                Name = "LinqMatcher",
+                Patterns = new[] { "p1", "p2" }
+            };
+
+            // Act
+            var matcher = MatcherMapper.Map(model) as LinqMatcher;
+
+            // Assert
+            Check.That(matcher).IsNotNull();
+            Check.That(matcher.MatchBehaviour).IsEqualTo(MatchBehaviour.AcceptOnMatch);
+            Check.That(matcher.GetPatterns()).Contains(new[] { "p1", "p2" });
+        }
+
+        [Fact]
+        public void MatcherMapper_Map_IMatcher_Null()
+        {
+            // Act
+            var result = MatcherMapper.Map((IMatcher)null);
+
+            // Assert
+            Check.That(result).IsNull();
+        }
+
+        [Fact]
+        public void MatcherMapper_Map_IMatcher_LinqMatcher_Pattern()
+        {
+            // Assign
+            var matcher = new LinqMatcher(MatchBehaviour.AcceptOnMatch, "p");
+
+            // Act
+            var result = MatcherMapper.Map(matcher);
+
+            // Assert
+            Check.That(result).IsNotNull();
+            Check.That(result.Name).IsEqualTo("LinqMatcher");
+            Check.That(result.IgnoreCase).IsNull();
+            Check.That(result.Pattern).IsEqualTo("p");
+            Check.That(result.Patterns).IsNull();
+        }
+    }
+}

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

@@ -0,0 +1,112 @@
+using NFluent;
+using WireMock.Matchers;
+using Xunit;
+
+namespace WireMock.Net.Tests.Matchers
+{
+    public class LinqMatcherTests
+    {
+        [Fact]
+        public void LinqMatcher_For_String_SinglePattern_IsMatch_Positive()
+        {
+            // Assign
+            string input = "2018-08-31 13:59:59";
+
+            // Act
+            var matcher = new LinqMatcher("DateTime.Parse(it) > \"2018-08-01 13:50:00\"");
+
+            // Assert
+            Check.That(matcher.IsMatch(input)).IsEqualTo(1.0d);
+        }
+
+        [Fact]
+        public void LinqMatcher_For_String_IsMatch_Negative()
+        {
+            // Assign
+            string input = "2018-08-31 13:59:59";
+
+            // Act
+            var matcher = new LinqMatcher("DateTime.Parse(it) > \"2019-01-01 00:00:00\"");
+
+            // Assert
+            Check.That(matcher.IsMatch(input)).IsEqualTo(0.0d);
+        }
+
+        [Fact]
+        public void LinqMatcher_For_String_IsMatch_RejectOnMatch()
+        {
+            // Assign
+            string input = "2018-08-31 13:59:59";
+
+            // Act
+            var matcher = new LinqMatcher(MatchBehaviour.RejectOnMatch, "DateTime.Parse(it) > \"2018-08-01 13:50:00\"");
+
+            // Assert
+            Check.That(matcher.IsMatch(input)).IsEqualTo(0.0d);
+        }
+
+        //[Fact]
+        //public void LinqMatcher_For_Object_IsMatch()
+        //{
+        //    // Assign
+        //    var input = new
+        //    {
+        //        Id = 9,
+        //        Name = "Test"
+        //    };
+
+        //    // Act
+        //    var matcher = new LinqMatcher("Id > 1 AND Name == \"Test\"");
+
+        //    double match = matcher.IsMatch(input);
+
+        //    // Assert
+        //    Assert.Equal(1.0, match);
+        //}
+
+        //[Fact]
+        //public void LinqMatcher_For_JObject_IsMatch()
+        //{
+        //    // Assign
+        //    var input = new JObject
+        //    {
+        //        { "Id", new JValue(9) },
+        //        { "Name", new JValue("Test") }
+        //    };
+
+        //    // Act
+        //    var matcher = new LinqMatcher("it.Id > 1 AND it.Name == \"Test\"");
+
+        //    double match = matcher.IsMatch(input);
+
+        //    // Assert
+        //    Assert.Equal(1.0, match);
+        //}
+
+        [Fact]
+        public void LinqMatcher_GetName()
+        {
+            // Assign
+            var matcher = new LinqMatcher("x");
+
+            // Act
+            string name = matcher.Name;
+
+            // Assert
+            Check.That(name).Equals("LinqMatcher");
+        }
+
+        [Fact]
+        public void LinqMatcher_GetPatterns()
+        {
+            // Assign
+            var matcher = new LinqMatcher("x");
+
+            // Act
+            string[] patterns = matcher.GetPatterns();
+
+            // Assert
+            Check.That(patterns).ContainsExactly("x");
+        }
+    }
+}

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

@@ -1,5 +1,4 @@
-using System;
-using Moq;
+using Moq;
 using NFluent;
 using WireMock.Matchers;
 using WireMock.Matchers.Request;

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

@@ -1,5 +1,4 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using NFluent;
 using WireMock.Matchers;
 using WireMock.Matchers.Request;
@@ -134,5 +133,37 @@ namespace WireMock.Net.Tests.RequestMatchers
             // Assert
             Check.That(score).IsEqualTo(1.0d);
         }
+
+        [Fact]
+        public void RequestMessageCookieMatcher_GetMatchingScore_CaseIgnoreForCookieValue()
+        {
+            // Assign
+            var cookies = new Dictionary<string, string> { { "cook", "teST" } };
+            var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", null, null, cookies);
+            var matcher = new RequestMessageCookieMatcher(MatchBehaviour.AcceptOnMatch, "cook", "test", true);
+
+            // Act
+            var result = new RequestMatchResult();
+            double score = matcher.GetMatchingScore(requestMessage, result);
+
+            // Assert
+            Check.That(score).IsEqualTo(1.0d);
+        }
+
+        [Fact]
+        public void RequestMessageCookieMatcher_GetMatchingScore_CaseIgnoreForCookieName()
+        {
+            // Assign
+            var cookies = new Dictionary<string, string> { { "cook", "teST" } };
+            var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", null, null, cookies);
+            var matcher = new RequestMessageCookieMatcher(MatchBehaviour.AcceptOnMatch, "CooK", "test", true);
+
+            // Act
+            var result = new RequestMatchResult();
+            double score = matcher.GetMatchingScore(requestMessage, result);
+
+            // Assert
+            Check.That(score).IsEqualTo(1.0d);
+        }
     }
 }

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

@@ -1,5 +1,4 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using NFluent;
 using WireMock.Matchers;
 using WireMock.Matchers.Request;
@@ -134,5 +133,37 @@ namespace WireMock.Net.Tests.RequestMatchers
             // Assert
             Check.That(score).IsEqualTo(1.0d);
         }
+
+        [Fact]
+        public void RequestMessageHeaderMatcher_GetMatchingScore_CaseIgnoreForHeaderValue()
+        {
+            // Assign
+            var headers = new Dictionary<string, string[]> { { "h", new[] { "teST" } } };
+            var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", null, headers);
+            var matcher = new RequestMessageHeaderMatcher(MatchBehaviour.AcceptOnMatch, "h", "test", true);
+
+            // Act
+            var result = new RequestMatchResult();
+            double score = matcher.GetMatchingScore(requestMessage, result);
+
+            // Assert
+            Check.That(score).IsEqualTo(1.0d);
+        }
+
+        [Fact]
+        public void RequestMessageHeaderMatcher_GetMatchingScore_CaseIgnoreForHeaderName()
+        {
+            // Assign
+            var headers = new Dictionary<string, string[]> { { "teST", new[] { "x" } } };
+            var requestMessage = new RequestMessage(new UrlDetails("http://localhost"), "GET", "127.0.0.1", null, headers);
+            var matcher = new RequestMessageHeaderMatcher(MatchBehaviour.AcceptOnMatch, "TEST", "x", true);
+
+            // Act
+            var result = new RequestMatchResult();
+            double score = matcher.GetMatchingScore(requestMessage, result);
+
+            // Assert
+            Check.That(score).IsEqualTo(1.0d);
+        }
     }
 }

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

@@ -493,5 +493,28 @@ namespace WireMock.Net.Tests.ResponseBuilderTests
             // Act
             Check.ThatAsyncCode(() => response.ProvideResponseAsync(request)).Throws<ArgumentNullException>();
         }
+
+        [Fact]
+        public async Task Response_ProvideResponse_Handlebars_WithBodyAsJson_ResultAsArray()
+        {
+            // Assign
+            string jsonString = "{ \"a\": \"test 1\", \"b\": \"test 2\" }";
+            var bodyData = new BodyData
+            {
+                BodyAsJson = JsonConvert.DeserializeObject(jsonString),
+                Encoding = Encoding.UTF8
+            };
+            var request = new RequestMessage(new UrlDetails("http://localhost/foo_array"), "POST", ClientIp, bodyData);
+
+            var response = Response.Create()
+                .WithBodyAsJson(new[] { "first", "{{request.path}}", "{{request.bodyAsJson.a}}", "{{request.bodyAsJson.b}}", "last" })
+                .WithTransformer();
+
+            // Act
+            var responseMessage = await response.ProvideResponseAsync(request);
+
+            // Assert
+            Check.That(JsonConvert.SerializeObject(responseMessage.BodyAsJson)).Equals("[\"first\",\"/foo_array\",\"test 1\",\"test 2\",\"last\"]");
+        }
     }
 }