Stef negate matcher

GitReleaseNotes.txt

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

examples/WireMock.Net.ConsoleApplication/MainApp.cs

@@ -150,6 +150,15 @@ public static void Run()
                     .WithHeader("Content-Type", "application/json")
                     .WithBody(@"{ ""result"": ""data deleted with 200""}"));
 
+            server
+                .Given(Request.Create()
+                    .WithPath("/reject")
+                    .UsingGet()
+                    .WithHeader("x", "1", MatchBehaviour.RejectOnMatch)
+                    .UsingAnyMethod())
+                .RespondWith(Response.Create()
+                    .WithBody(@"{ ""result"": ""reject""}"));
+
             server
                 .Given(Request.Create().WithPath("/nobody").UsingGet())
                 .RespondWith(Response.Create().WithDelay(TimeSpan.FromSeconds(1))

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

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

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

@@ -24,5 +24,10 @@ public class MatcherModel
         /// Gets or sets the ignore case.
         /// </summary>
         public bool? IgnoreCase { get; set; }
+
+        /// <summary>
+        /// Reject on match.
+        /// </summary>
+        public bool? RejectOnMatch { get; set; }
     }
 }

src/WireMock.Net/Matchers/ExactMatcher.cs

@@ -12,21 +12,34 @@ public class ExactMatcher : IStringMatcher
     {
         private readonly string[] _values;
 
+        /// <inheritdoc cref="IMatcher.MatchBehaviour"/>
+        public MatchBehaviour MatchBehaviour { get; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ExactMatcher"/> class.
+        /// </summary>
+        /// <param name="values">The values.</param>
+        public ExactMatcher([NotNull] params string[] values) : this(MatchBehaviour.AcceptOnMatch, values)
+        {
+        }
+
         /// <summary>
         /// Initializes a new instance of the <see cref="ExactMatcher"/> class.
         /// </summary>
+        /// <param name="matchBehaviour">The match behaviour.</param>
         /// <param name="values">The values.</param>
-        public ExactMatcher([NotNull] params string[] values)
+        public ExactMatcher(MatchBehaviour matchBehaviour, [NotNull] params string[] values)
         {
             Check.HasNoNulls(values, nameof(values));
 
             _values = values;
+            MatchBehaviour = matchBehaviour;
         }
 
         /// <inheritdoc cref="IStringMatcher.IsMatch"/>
         public double IsMatch(string input)
         {
-            return MatchScores.ToScore(_values.Select(value => value.Equals(input)));
+            return MatchBehaviourHelper.Convert(MatchBehaviour, MatchScores.ToScore(_values.Select(value => value.Equals(input))));
         }
 
         /// <inheritdoc cref="IStringMatcher.GetPatterns"/>
@@ -35,10 +48,7 @@ public string[] GetPatterns()
             return _values;
         }
 
-        /// <inheritdoc cref="IMatcher.GetName"/>
-        public string GetName()
-        {
-            return "ExactMatcher";
-        }
+        /// <inheritdoc cref="IMatcher.Name"/>
+        public string Name => "ExactMatcher";
     }
 }

src/WireMock.Net/Matchers/ExactObjectMatcher.cs

@@ -1,5 +1,6 @@
 using System.Linq;
 using JetBrains.Annotations;
+using WireMock.Validation;
 
 namespace WireMock.Matchers
 {
@@ -12,35 +13,59 @@ public class ExactObjectMatcher : IObjectMatcher
         private readonly object _object;
         private readonly byte[] _bytes;
 
+        /// <inheritdoc cref="IMatcher.MatchBehaviour"/>
+        public MatchBehaviour MatchBehaviour { get; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ExactMatcher"/> class.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        public ExactObjectMatcher([NotNull] object value) : this(MatchBehaviour.AcceptOnMatch, value)
+        {
+        }
+
         /// <summary>
         /// Initializes a new instance of the <see cref="ExactMatcher"/> class.
         /// </summary>
+        /// <param name="matchBehaviour">The match behaviour.</param>
         /// <param name="value">The value.</param>
-        public ExactObjectMatcher([NotNull] object value)
+        public ExactObjectMatcher(MatchBehaviour matchBehaviour, [NotNull] object value)
         {
+            Check.NotNull(value, nameof(value));
+
             _object = value;
+            MatchBehaviour = matchBehaviour;
         }
 
         /// <summary>
         /// Initializes a new instance of the <see cref="ExactMatcher"/> class.
         /// </summary>
         /// <param name="value">The value.</param>
-        public ExactObjectMatcher([NotNull] byte[] value)
+        public ExactObjectMatcher([NotNull] byte[] value) : this(MatchBehaviour.AcceptOnMatch, value)
         {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ExactMatcher"/> class.
+        /// </summary>
+        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// <param name="value">The value.</param>
+        public ExactObjectMatcher(MatchBehaviour matchBehaviour, [NotNull] byte[] value)
+        {
+            Check.NotNull(value, nameof(value));
+
             _bytes = value;
+            MatchBehaviour = matchBehaviour;
         }
 
         /// <inheritdoc cref="IObjectMatcher.IsMatch"/>
         public double IsMatch(object input)
         {
             bool equals = _object != null ? Equals(_object, input) : _bytes.SequenceEqual((byte[])input);
-            return MatchScores.ToScore(equals);
+            return MatchBehaviourHelper.Convert(MatchBehaviour, MatchScores.ToScore(equals));
         }
 
-        /// <inheritdoc cref="IMatcher.GetName"/>
-        public string GetName()
-        {
-            return "ExactObjectMatcher";
-        }
+        /// <inheritdoc cref="IMatcher.Name"/>
+        public string Name => "ExactObjectMatcher";
     }
 }

src/WireMock.Net/Matchers/IIgnoreCaseMatcher.cs

@@ -3,10 +3,11 @@
     /// <summary>
     /// IIgnoreCaseMatcher
     /// </summary>
+    /// <inheritdoc cref="IMatcher"/>
     public interface IIgnoreCaseMatcher : IMatcher
     {
         /// <summary>
-        /// Ignore the case.
+        /// Ignore the case from the pattern.
         /// </summary>
         bool IgnoreCase { get; }
     }

src/WireMock.Net/Matchers/IMatcher.cs

@@ -8,7 +8,12 @@ public interface IMatcher
         /// <summary>
         /// Gets the name.
         /// </summary>
-        /// <returns>Name</returns>
-        string GetName();
+        string Name { get; }
+
+
+        /// <summary>
+        /// Gets the match behaviour.
+        /// </summary>
+        MatchBehaviour MatchBehaviour { get; }
     }
 }

src/WireMock.Net/Matchers/IStringMatcher.cs

@@ -3,6 +3,7 @@
     /// <summary>
     /// IStringMatcher
     /// </summary>
+    /// <inheritdoc cref="IMatcher"/>
     public interface IStringMatcher : IMatcher
     {
         /// <summary>

src/WireMock.Net/Matchers/JSONPathMatcher.cs

@@ -14,54 +14,69 @@ public class JsonPathMatcher : IStringMatcher, IObjectMatcher
     {
         private readonly string[] _patterns;
 
+        /// <inheritdoc cref="IMatcher.MatchBehaviour"/>
+        public MatchBehaviour MatchBehaviour { get; }
+
         /// <summary>
         /// Initializes a new instance of the <see cref="JsonPathMatcher"/> class.
         /// </summary>
         /// <param name="patterns">The patterns.</param>
-        public JsonPathMatcher([NotNull] params string[] patterns)
+        public JsonPathMatcher([NotNull] params string[] patterns) : this(MatchBehaviour.AcceptOnMatch, patterns)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonPathMatcher"/> class.
+        /// </summary>
+        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// <param name="patterns">The patterns.</param>
+        public JsonPathMatcher(MatchBehaviour matchBehaviour, [NotNull] params string[] patterns)
         {
             Check.NotNull(patterns, nameof(patterns));
 
+            MatchBehaviour = matchBehaviour;
             _patterns = patterns;
         }
 
         /// <inheritdoc cref="IStringMatcher.IsMatch"/>
         public double IsMatch(string input)
         {
-            if (input == null)
+            double match = MatchScores.Mismatch;
+            if (input != null)
             {
-                return MatchScores.Mismatch;
+                try
+                {
+                    var jtoken = JToken.Parse(input);
+                    match =  IsMatch(jtoken);
+                }
+                catch (Exception)
+                {
+                    // just ignore exception
+                }
             }
 
-            try
-            {
-                var jtoken = JToken.Parse(input);
-                return IsMatch(jtoken);
-            }
-            catch (Exception)
-            {
-                return MatchScores.Mismatch;
-            }
+            return MatchBehaviourHelper.Convert(MatchBehaviour, match);
         }
 
         /// <inheritdoc cref="IObjectMatcher.IsMatch"/>
         public double IsMatch(object input)
         {
-            if (input == null)
+            double match = MatchScores.Mismatch;
+            if (input != null)
             {
-                return MatchScores.Mismatch;
+                try
+                {
+                    // Check if JToken or object
+                    JToken jtoken = input is JToken token ? token : JObject.FromObject(input);
+                    match = IsMatch(jtoken);
+                }
+                catch (Exception)
+                {
+                    // just ignore exception
+                }
             }
 
-            try
-            {
-                // Check if JToken or object
-                JToken jtoken = input is JToken token ? token : JObject.FromObject(input);
-                return IsMatch(jtoken);
-            }
-            catch (Exception)
-            {
-                return MatchScores.Mismatch;
-            }
+            return MatchBehaviourHelper.Convert(MatchBehaviour, match);
         }
 
         /// <inheritdoc cref="IStringMatcher.GetPatterns"/>
@@ -70,11 +85,8 @@ public string[] GetPatterns()
             return _patterns;
         }
 
-        /// <inheritdoc cref="IMatcher.GetName"/>
-        public string GetName()
-        {
-            return "JsonPathMatcher";
-        }
+        /// <inheritdoc cref="IMatcher.Name"/>
+        public string Name => "JsonPathMatcher";
 
         private double IsMatch(JToken jtoken)
         {

src/WireMock.Net/Matchers/MatchBehaviour.cs

@@ -0,0 +1,18 @@
+namespace WireMock.Matchers
+{
+    /// <summary>
+    /// MatchBehaviour
+    /// </summary>
+    public enum MatchBehaviour
+    {
+        /// <summary>
+        /// Accept on match (default)
+        /// </summary>
+        AcceptOnMatch,
+
+        /// <summary>
+        /// Reject on match
+        /// </summary>
+        RejectOnMatch
+    }
+}

src/WireMock.Net/Matchers/MatchBehaviourHelper.cs

@@ -0,0 +1,28 @@
+
+namespace WireMock.Matchers
+{
+    internal static class MatchBehaviourHelper
+    {
+        /// <summary>
+        /// Converts the specified match behaviour and match value to a new match value.
+        /// 
+        /// if AcceptOnMatch --> return match (default)
+        /// if RejectOnMatch and match = 0.0 --> return 1.0
+        /// if RejectOnMatch and match = 0.? --> return 0.0
+        /// if RejectOnMatch and match = 1.0 --> return 0.0
+        /// </summary>
+        /// 
+        /// <param name="matchBehaviour">The match behaviour.</param>
+        /// <param name="match">The match.</param>
+        /// <returns>match value</returns>
+        internal static double Convert(MatchBehaviour matchBehaviour, double match)
+        {
+            if (matchBehaviour == MatchBehaviour.AcceptOnMatch)
+            {
+                return match;
+            }
+
+            return match <= MatchScores.Tolerance ? MatchScores.Perfect : MatchScores.Mismatch;
+        }
+    }
+}