Rename to WireMock.Net

src/WireMock.Net/Matchers/IMatcher.cs

@@ -0,0 +1,23 @@
+namespace WireMock.Matchers
+{
+    /// <summary>
+    /// IMatcher
+    /// </summary>
+    public interface IMatcher
+    {
+        /// <summary>
+        /// Determines whether the specified input is match.
+        /// </summary>
+        /// <param name="input">The input.</param>
+        /// <returns>
+        ///   <c>true</c> if the specified input is match; otherwise, <c>false</c>.
+        /// </returns>
+        bool IsMatch(string input);
+
+        /// <summary>
+        /// Gets the pattern.
+        /// </summary>
+        /// <returns>Pattern</returns>
+        string GetPattern();
+    }
+}

src/WireMock.Net/Matchers/JSONPathMatcher.cs

@@ -0,0 +1,61 @@
+using System;
+using JetBrains.Annotations;
+using Newtonsoft.Json.Linq;
+using WireMock.Validation;
+
+namespace WireMock.Matchers
+{
+    /// <summary>
+    /// JSONPathMatcher
+    /// </summary>
+    /// <seealso cref="WireMock.Matchers.IMatcher" />
+    public class JsonPathMatcher : IMatcher
+    {
+        private readonly string _pattern;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="JsonPathMatcher"/> class.
+        /// </summary>
+        /// <param name="pattern">The pattern.</param>
+        public JsonPathMatcher([NotNull] string pattern)
+        {
+            Check.NotNull(pattern, nameof(pattern));
+
+            _pattern = pattern;
+        }
+
+        /// <summary>
+        /// Determines whether the specified input is match.
+        /// </summary>
+        /// <param name="input">The input.</param>
+        /// <returns>
+        ///   <c>true</c> if the specified input is match; otherwise, <c>false</c>.
+        /// </returns>
+        public bool IsMatch(string input)
+        {
+            if (input == null)
+                return false;
+
+            try
+            {
+                JObject o = JObject.Parse(input);
+                JToken token = o.SelectToken(_pattern);
+                
+                return token != null;
+            }
+            catch (Exception)
+            {
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Gets the pattern.
+        /// </summary>
+        /// <returns>Pattern</returns>
+        public string GetPattern()
+        {
+            return _pattern;
+        }
+    }
+}

src/WireMock.Net/Matchers/RegexMatcher.cs

@@ -0,0 +1,60 @@
+using System;
+using System.Text.RegularExpressions;
+using JetBrains.Annotations;
+using WireMock.Validation;
+
+namespace WireMock.Matchers
+{
+    /// <summary>
+    /// Regular Expression Matcher
+    /// </summary>
+    /// <seealso cref="WireMock.Matchers.IMatcher" />
+    public class RegexMatcher : IMatcher
+    {
+        private readonly string _pattern;
+        private readonly Regex _expression;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RegexMatcher"/> class.
+        /// </summary>
+        /// <param name="pattern">The pattern.</param>
+        public RegexMatcher([NotNull, RegexPattern] string pattern)
+        {
+            Check.NotNull(pattern, nameof(pattern));
+
+            _pattern = pattern;
+            _expression = new Regex(_pattern, RegexOptions.Compiled);
+        }
+
+        /// <summary>
+        /// Determines whether the specified input is match.
+        /// </summary>
+        /// <param name="input">The input.</param>
+        /// <returns>
+        ///   <c>true</c> if the specified input is match; otherwise, <c>false</c>.
+        /// </returns>
+        public bool IsMatch(string input)
+        {
+            if (input == null)
+                return false;
+
+            try
+            {
+                return _expression.IsMatch(input);
+            }
+            catch (Exception)
+            {
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Gets the pattern.
+        /// </summary>
+        /// <returns>Pattern</returns>
+        public string GetPattern()
+        {
+            return _pattern;
+        }
+    }
+}

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

@@ -0,0 +1,18 @@
+namespace WireMock.Matchers.Request
+{
+    /// <summary>
+    /// CompositeMatcherType
+    /// </summary>
+    public enum CompositeMatcherType
+    {
+        /// <summary>
+        /// And
+        /// </summary>
+        And = 0,
+
+        /// <summary>
+        /// Or
+        /// </summary>
+        Or = 1
+    }
+}

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

@@ -0,0 +1,19 @@
+using JetBrains.Annotations;
+
+namespace WireMock.Matchers.Request
+{
+    /// <summary>
+    /// The RequestMatcher interface.
+    /// </summary>
+    public interface IRequestMatcher
+    {
+        /// <summary>
+        /// Determines whether the specified RequestMessage is match.
+        /// </summary>
+        /// <param name="requestMessage">The RequestMessage.</param>
+        /// <returns>
+        ///   <c>true</c> if the specified RequestMessage is match; otherwise, <c>false</c>.
+        /// </returns>
+        bool IsMatch([NotNull] RequestMessage requestMessage);
+    }
+}

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

@@ -0,0 +1,124 @@
+using System;
+using JetBrains.Annotations;
+using WireMock.Validation;
+
+namespace WireMock.Matchers.Request
+{
+    /// <summary>
+    /// The request body matcher.
+    /// </summary>
+    public class RequestMessageBodyMatcher : IRequestMatcher
+    {
+        /// <summary>
+        /// The body.
+        /// </summary>
+        private readonly string _body;
+
+        /// <summary>
+        /// The body as byte[].
+        /// </summary>
+        private readonly byte[] _bodyData;
+
+        /// <summary>
+        /// The body function
+        /// </summary>
+        private readonly Func<string, bool> _bodyFunc;
+
+        /// <summary>
+        /// The body data function
+        /// </summary>
+        private readonly Func<byte[], bool> _bodyDataFunc;
+
+        /// <summary>
+        /// The matcher.
+        /// </summary>
+        public readonly IMatcher Matcher;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RequestMessageBodyMatcher"/> class.
+        /// </summary>
+        /// <param name="body">
+        /// The body Regex pattern.
+        /// </param>
+        public RequestMessageBodyMatcher([NotNull] string body)
+        {
+            Check.NotNull(body, nameof(body));
+            _body = body;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RequestMessageBodyMatcher"/> class.
+        /// </summary>
+        /// <param name="body">
+        /// The body Regex pattern.
+        /// </param>
+        public RequestMessageBodyMatcher([NotNull] byte[] body)
+        {
+            Check.NotNull(body, nameof(body));
+            _bodyData = body;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RequestMessageBodyMatcher"/> class.
+        /// </summary>
+        /// <param name="func">
+        /// The body func.
+        /// </param>
+        public RequestMessageBodyMatcher([NotNull] Func<string, bool> func)
+        {
+            Check.NotNull(func, nameof(func));
+            _bodyFunc = func;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RequestMessageBodyMatcher"/> class.
+        /// </summary>
+        /// <param name="func">
+        /// The body func.
+        /// </param>
+        public RequestMessageBodyMatcher([NotNull] Func<byte[], bool> func)
+        {
+            Check.NotNull(func, nameof(func));
+            _bodyDataFunc = func;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RequestMessageBodyMatcher"/> class.
+        /// </summary>
+        /// <param name="matcher">
+        /// The body matcher.
+        /// </param>
+        public RequestMessageBodyMatcher([NotNull] IMatcher matcher)
+        {
+            Check.NotNull(matcher, nameof(matcher));
+            Matcher = matcher;
+        }
+
+        /// <summary>
+        /// Determines whether the specified RequestMessage is match.
+        /// </summary>
+        /// <param name="requestMessage">The RequestMessage.</param>
+        /// <returns>
+        ///   <c>true</c> if the specified RequestMessage is match; otherwise, <c>false</c>.
+        /// </returns>
+        public bool IsMatch(RequestMessage requestMessage)
+        {
+            if (Matcher != null)
+                return Matcher.IsMatch(requestMessage.Body);
+
+            if (_body != null)
+                return requestMessage.Body == _body;
+
+            if (_bodyData != null)
+                return requestMessage.BodyAsBytes == _bodyData;
+
+            if (_bodyFunc != null)
+                return _bodyFunc(requestMessage.Body);
+
+            if (_bodyDataFunc != null)
+                return _bodyDataFunc(requestMessage.BodyAsBytes);
+
+            return false;
+        }
+    }
+}

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

@@ -0,0 +1,50 @@
+using System.Collections.Generic;
+using System.Linq;
+using JetBrains.Annotations;
+using WireMock.Validation;
+
+namespace WireMock.Matchers.Request
+{
+    /// <summary>
+    /// The composite request matcher.
+    /// </summary>
+    public abstract class RequestMessageCompositeMatcher : IRequestMatcher
+    {
+        private readonly CompositeMatcherType _type;
+
+        /// <summary>
+        /// Gets the request matchers.
+        /// </summary>
+        /// <value>
+        /// The request matchers.
+        /// </value>
+        private IEnumerable<IRequestMatcher> RequestMatchers { get; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RequestMessageCompositeMatcher"/> class.
+        /// </summary>
+        /// <param name="requestMatchers">The request matchers.</param>
+        /// <param name="type">The CompositeMatcherType type (Defaults to 'And')</param>
+        protected RequestMessageCompositeMatcher([NotNull] IEnumerable<IRequestMatcher> requestMatchers, CompositeMatcherType type = CompositeMatcherType.And)
+        {
+            Check.NotNull(requestMatchers, nameof(requestMatchers));
+
+            _type = type;
+            RequestMatchers = requestMatchers;
+        }
+
+        /// <summary>
+        /// Determines whether the specified RequestMessage is match.
+        /// </summary>
+        /// <param name="requestMessage">The RequestMessage.</param>
+        /// <returns>
+        ///   <c>true</c> if the specified RequestMessage is match; otherwise, <c>false</c>.
+        /// </returns>
+        public virtual bool IsMatch(RequestMessage requestMessage)
+        {
+            return _type == CompositeMatcherType.And ?
+                RequestMatchers.All(matcher => matcher.IsMatch(requestMessage)) :
+                RequestMatchers.Any(matcher => matcher.IsMatch(requestMessage));
+        }
+    }
+}

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

@@ -0,0 +1,73 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using JetBrains.Annotations;
+using WireMock.Validation;
+
+namespace WireMock.Matchers.Request
+{
+    /// <summary>
+    /// The request cookie matcher.
+    /// </summary>
+    public class RequestMessageCookieMatcher : IRequestMatcher
+    {
+        private readonly Func<IDictionary<string, string>, bool>[] _cookieFuncs;
+
+        /// <summary>
+        /// The name
+        /// </summary>
+        public string Name { get; }
+
+        /// <summary>
+        /// Gets the matchers.
+        /// </summary>
+        /// <value>
+        /// The matchers.
+        /// </value>
+        public IMatcher[] Matchers { get; }
+        
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RequestMessageCookieMatcher"/> class.
+        /// </summary>
+        /// <param name="name">The name.</param>
+        /// <param name="pattern">The pattern.</param>
+        /// <param name="ignoreCase">The ignoreCase.</param>
+        public RequestMessageCookieMatcher([NotNull] string name, [NotNull] string pattern, bool ignoreCase = true)
+        {
+            Check.NotNull(name, nameof(name));
+            Check.NotNull(pattern, nameof(pattern));
+
+            Name = name;
+            Matchers = new IMatcher[] { new WildcardMatcher(pattern, ignoreCase) };
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RequestMessageCookieMatcher"/> class.
+        /// </summary>
+        /// <param name="funcs">The funcs.</param>
+        public RequestMessageCookieMatcher([NotNull] params Func<IDictionary<string, string>, bool>[] funcs)
+        {
+            Check.NotNull(funcs, nameof(funcs));
+            _cookieFuncs = funcs;
+        }
+
+        /// <summary>
+        /// Determines whether the specified RequestMessage is match.
+        /// </summary>
+        /// <param name="requestMessage">The RequestMessage.</param>
+        /// <returns>
+        ///   <c>true</c> if the specified RequestMessage is match; otherwise, <c>false</c>.
+        /// </returns>
+        public bool IsMatch(RequestMessage requestMessage)
+        {
+            if (_cookieFuncs != null)
+                return _cookieFuncs.Any(cf => cf(requestMessage.Cookies));
+
+            if (requestMessage.Cookies == null)
+                return false;
+
+            string headerValue = requestMessage.Cookies[Name];
+            return Matchers.Any(m => m.IsMatch(headerValue));
+        }
+    }
+}

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

@@ -0,0 +1,73 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using JetBrains.Annotations;
+using WireMock.Validation;
+
+namespace WireMock.Matchers.Request
+{
+    /// <summary>
+    /// The request header matcher.
+    /// </summary>
+    public class RequestMessageHeaderMatcher : IRequestMatcher
+    {
+        private readonly Func<IDictionary<string, string>, bool>[] _headerFuncs;
+
+        /// <summary>
+        /// The name
+        /// </summary>
+        public string Name { get; }
+
+        /// <summary>
+        /// Gets the matchers.
+        /// </summary>
+        /// <value>
+        /// The matchers.
+        /// </value>
+        public IMatcher[] Matchers { get; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RequestMessageHeaderMatcher"/> class.
+        /// </summary>
+        /// <param name="name">The name.</param>
+        /// <param name="pattern">The pattern.</param>
+        /// <param name="ignoreCase">The ignoreCase.</param>
+        public RequestMessageHeaderMatcher([NotNull] string name, [NotNull] string pattern, bool ignoreCase = true)
+        {
+            Check.NotNull(name, nameof(name));
+            Check.NotNull(pattern, nameof(pattern));
+
+            Name = name;
+            Matchers = new IMatcher[] { new WildcardMatcher(pattern, ignoreCase) };
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RequestMessageHeaderMatcher"/> class.
+        /// </summary>
+        /// <param name="funcs">The funcs.</param>
+        public RequestMessageHeaderMatcher([NotNull] params Func<IDictionary<string, string>, bool>[] funcs)
+        {
+            Check.NotNull(funcs, nameof(funcs));
+            _headerFuncs = funcs;
+        }
+
+        /// <summary>
+        /// Determines whether the specified RequestMessage is match.
+        /// </summary>
+        /// <param name="requestMessage">The RequestMessage.</param>
+        /// <returns>
+        ///   <c>true</c> if the specified RequestMessage is match; otherwise, <c>false</c>.
+        /// </returns>
+        public bool IsMatch(RequestMessage requestMessage)
+        {
+            if (_headerFuncs != null)
+                return _headerFuncs.Any(hf => hf(requestMessage.Headers));
+
+            if (requestMessage.Headers == null)
+                return false;
+
+            string headerValue = requestMessage.Headers[Name];
+            return Matchers.Any(m => m.IsMatch(headerValue));
+        }
+    }
+}

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

@@ -0,0 +1,71 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using JetBrains.Annotations;
+using WireMock.Util;
+using WireMock.Validation;
+
+namespace WireMock.Matchers.Request
+{
+    /// <summary>
+    /// The request parameters matcher.
+    /// </summary>
+    public class RequestMessageParamMatcher : IRequestMatcher
+    {
+        private readonly Func<IDictionary<string, WireMockList<string>>, bool>[] _funcs;
+
+        /// <summary>
+        /// The key
+        /// </summary>
+        public string Key { get; }
+
+        /// <summary>
+        /// The values
+        /// </summary>
+        public IEnumerable<string> Values { get; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RequestMessageParamMatcher"/> class.
+        /// </summary>
+        /// <param name="key">
+        /// The key.
+        /// </param>
+        /// <param name="values">
+        /// The values.
+        /// </param>
+        public RequestMessageParamMatcher([NotNull] string key, [NotNull] IEnumerable<string> values)
+        {
+            Check.NotNull(key, nameof(key));
+            Check.NotNull(values, nameof(values));
+
+            Key = key;
+            Values = values;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RequestMessageParamMatcher"/> class.
+        /// </summary>
+        /// <param name="funcs">The funcs.</param>
+        public RequestMessageParamMatcher([NotNull] params Func<IDictionary<string, WireMockList<string>>, bool>[] funcs)
+        {
+            Check.NotNull(funcs, nameof(funcs));
+            _funcs = funcs;
+        }
+
+        /// <summary>
+        /// Determines whether the specified RequestMessage is match.
+        /// </summary>
+        /// <param name="requestMessage">The RequestMessage.</param>
+        /// <returns>
+        ///   <c>true</c> if the specified RequestMessage is match; otherwise, <c>false</c>.
+        /// </returns>
+        public bool IsMatch(RequestMessage requestMessage)
+        {
+            if (_funcs != null)
+                return _funcs.Any(f => f(requestMessage.Query));
+
+            var values = requestMessage.GetParameter(Key);
+            return values?.Intersect(Values).Count() == Values.Count();
+        }
+    }
+}

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

@@ -0,0 +1,70 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using JetBrains.Annotations;
+using WireMock.Validation;
+
+namespace WireMock.Matchers.Request
+{
+    /// <summary>
+    /// The request path matcher.
+    /// </summary>
+    public class RequestMessagePathMatcher : IRequestMatcher
+    {
+        /// <summary>
+        /// The matcher.
+        /// </summary>
+        public IReadOnlyList<IMatcher> Matchers { get; }
+
+        /// <summary>
+        /// The path functions
+        /// </summary>
+        private readonly Func<string, bool>[] _pathFuncs;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RequestMessagePathMatcher"/> class.
+        /// </summary>
+        /// <param name="paths">The paths.</param>
+        public RequestMessagePathMatcher([NotNull] params string[] paths) : this(paths.Select(path => new WildcardMatcher(path)).ToArray())
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RequestMessagePathMatcher"/> class.
+        /// </summary>
+        /// <param name="matchers">The matchers.</param>
+        public RequestMessagePathMatcher([NotNull] params IMatcher[] matchers)
+        {
+            Check.NotNull(matchers, nameof(matchers));
+            Matchers = matchers;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RequestMessagePathMatcher"/> class.
+        /// </summary>
+        /// <param name="funcs">The path functions.</param>
+        public RequestMessagePathMatcher([NotNull] params Func<string, bool>[] funcs)
+        {
+            Check.NotNull(funcs, nameof(funcs));
+            _pathFuncs = funcs;
+        }
+
+        /// <summary>
+        /// Determines whether the specified RequestMessage is match.
+        /// </summary>
+        /// <param name="requestMessage">The RequestMessage.</param>
+        /// <returns>
+        ///   <c>true</c> if the specified RequestMessage is match; otherwise, <c>false</c>.
+        /// </returns>
+        public bool IsMatch(RequestMessage requestMessage)
+        {
+            if (Matchers != null)
+                return Matchers.Any(matcher => matcher.IsMatch(requestMessage.Path));
+
+            if (_pathFuncs != null)
+                return _pathFuncs.Any(func => func(requestMessage.Path));
+
+            return false;
+        }
+    }
+}

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

@@ -0,0 +1,70 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using JetBrains.Annotations;
+using WireMock.Validation;
+
+namespace WireMock.Matchers.Request
+{
+    /// <summary>
+    /// The request url matcher.
+    /// </summary>
+    public class RequestMessageUrlMatcher : IRequestMatcher
+    {
+        /// <summary>
+        /// The matcher.
+        /// </summary>
+        public readonly IReadOnlyList<IMatcher> Matchers;
+
+        /// <summary>
+        /// The url functions
+        /// </summary>
+        private readonly Func<string, bool>[] _urlFuncs;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RequestMessageUrlMatcher"/> class.
+        /// </summary>
+        /// <param name="urls">The urls.</param>
+        public RequestMessageUrlMatcher([NotNull] params string[] urls) : this(urls.Select(url => new WildcardMatcher(url)).ToArray())
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RequestMessageUrlMatcher"/> class.
+        /// </summary>
+        /// <param name="matchers">The matchers.</param>
+        public RequestMessageUrlMatcher([NotNull] params IMatcher[] matchers)
+        {
+            Check.NotNull(matchers, nameof(matchers));
+            Matchers = matchers;
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RequestMessageUrlMatcher"/> class.
+        /// </summary>
+        /// <param name="funcs">The url functions.</param>
+        public RequestMessageUrlMatcher([NotNull] params Func<string, bool>[] funcs)
+        {
+            Check.NotNull(funcs, nameof(funcs));
+            _urlFuncs = funcs;
+        }
+
+        /// <summary>
+        /// Determines whether the specified RequestMessage is match.
+        /// </summary>
+        /// <param name="requestMessage">The RequestMessage.</param>
+        /// <returns>
+        ///   <c>true</c> if the specified RequestMessage is match; otherwise, <c>false</c>.
+        /// </returns>
+        public bool IsMatch(RequestMessage requestMessage)
+        {
+            if (Matchers != null)
+                return Matchers.Any(matcher => matcher.IsMatch(requestMessage.Path));
+
+            if (_urlFuncs != null)
+                return _urlFuncs.Any(func => func(requestMessage.Url));
+
+            return false;
+        }
+    }
+}

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

@@ -0,0 +1,41 @@
+using System.Linq;
+using JetBrains.Annotations;
+using WireMock.Validation;
+
+namespace WireMock.Matchers.Request
+{
+    /// <summary>
+    /// The request verb matcher.
+    /// </summary>
+    internal class RequestMessageVerbMatcher : IRequestMatcher
+    {
+        /// <summary>
+        /// The verbs
+        /// </summary>
+        public string[] Verbs { get; }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RequestMessageVerbMatcher"/> class.
+        /// </summary>
+        /// <param name="verbs">
+        /// The verb.
+        /// </param>
+        public RequestMessageVerbMatcher([NotNull] params string[] verbs)
+        {
+            Check.NotNull(verbs, nameof(verbs));
+            Verbs = verbs.Select(v => v.ToLower()).ToArray();
+        }
+
+        /// <summary>
+        /// Determines whether the specified RequestMessage is match.
+        /// </summary>
+        /// <param name="requestMessage">The RequestMessage.</param>
+        /// <returns>
+        ///   <c>true</c> if the specified RequestMessage is match; otherwise, <c>false</c>.
+        /// </returns>
+        public bool IsMatch(RequestMessage requestMessage)
+        {
+            return Verbs.Contains(requestMessage.Verb);
+        }
+    }
+}

src/WireMock.Net/Matchers/WildcardMatcher.cs

@@ -0,0 +1,111 @@
+using JetBrains.Annotations;
+using WireMock.Validation;
+
+namespace WireMock.Matchers
+{
+    /// <summary>
+    /// WildcardMatcher
+    /// </summary>
+    /// <seealso cref="WireMock.Matchers.IMatcher" />
+    public class WildcardMatcher : IMatcher
+    {
+        private readonly string _pattern;
+        private readonly bool _ignoreCase;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RegexMatcher"/> class.
+        /// </summary>
+        /// <param name="pattern">The pattern.</param>
+        /// <param name="ignoreCase">IgnoreCase</param>
+        public WildcardMatcher([NotNull] string pattern, bool ignoreCase = false)
+        {
+            Check.NotNull(pattern, nameof(pattern));
+
+            _pattern = pattern;
+            _ignoreCase = ignoreCase;
+        }
+
+        /// <summary>
+        /// Determines whether the specified input is match.
+        /// </summary>
+        /// <param name="input">The input.</param>
+        /// <returns>
+        ///   <c>true</c> if the specified input is match; otherwise, <c>false</c>.
+        /// </returns>
+        public bool IsMatch(string input)
+        {
+            return MatchWildcardString(_pattern, input);
+        }
+
+        /// <summary>
+        /// Gets the pattern.
+        /// </summary>
+        /// <returns>Pattern</returns>
+        public string GetPattern()
+        {
+            return _pattern;
+        }
+
+        /// <summary>
+        /// Copy/paste from http://www.codeproject.com/Tips/57304/Use-wildcard-characters-and-to-compare-strings
+        /// </summary>
+        private bool MatchWildcardString([NotNull] string pattern, string input)
+        {
+            if (input != null && _ignoreCase)
+                input = input.ToLower();
+
+            if (_ignoreCase)
+                pattern = pattern.ToLower();
+
+            if (string.CompareOrdinal(pattern, input) == 0)
+            {
+                return true;
+            }
+
+            if (string.IsNullOrEmpty(input))
+            {
+                return string.IsNullOrEmpty(pattern.Trim('*'));
+            }
+
+            if (pattern.Length == 0)
+            {
+                return false;
+            }
+
+            if (pattern[0] == '?')
+            {
+                return MatchWildcardString(pattern.Substring(1), input.Substring(1));
+            }
+
+            if (pattern[pattern.Length - 1] == '?')
+            {
+                return MatchWildcardString(pattern.Substring(0, pattern.Length - 1), input.Substring(0, input.Length - 1));
+            }
+
+            if (pattern[0] == '*')
+            {
+                if (MatchWildcardString(pattern.Substring(1), input))
+                {
+                    return true;
+                }
+                return MatchWildcardString(pattern, input.Substring(1));
+            }
+
+            if (pattern[pattern.Length - 1] == '*')
+            {
+                if (MatchWildcardString(pattern.Substring(0, pattern.Length - 1), input))
+                {
+                    return true;
+                }
+                return MatchWildcardString(pattern, input.Substring(0, input.Length - 1));
+            }
+
+            if (pattern[0] == input[0])
+            {
+                return MatchWildcardString(pattern.Substring(1), input.Substring(1));
+            }
+
+            return false;
+        }
+    }
+}

src/WireMock.Net/Matchers/XPathMatcher.cs

@@ -0,0 +1,62 @@
+using System;
+using System.Xml;
+using JetBrains.Annotations;
+using WireMock.Validation;
+using Wmhelp.XPath2;
+
+namespace WireMock.Matchers
+{
+    /// <summary>
+    /// XPath2Matcher
+    /// </summary>
+    /// <seealso cref="WireMock.Matchers.IMatcher" />
+    public class XPathMatcher : IMatcher
+    {
+        private readonly string _pattern;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="XPathMatcher"/> class.
+        /// </summary>
+        /// <param name="pattern">The pattern.</param>
+        public XPathMatcher([NotNull] string pattern)
+        {
+            Check.NotNull(pattern, nameof(pattern));
+
+            _pattern = pattern;
+        }
+
+        /// <summary>
+        /// Determines whether the specified input is match.
+        /// </summary>
+        /// <param name="input">The input.</param>
+        /// <returns>
+        ///   <c>true</c> if the specified input is match; otherwise, <c>false</c>.
+        /// </returns>
+        public bool IsMatch(string input)
+        {
+            if (input == null)
+                return false;
+
+            try
+            {
+                var nav = new XmlDocument { InnerXml = input }.CreateNavigator();
+                object result = nav.XPath2Evaluate($"boolean({_pattern})");
+
+                return true.Equals(result);
+            }
+            catch (Exception)
+            {
+                return false;
+            }
+        }
+
+        /// <summary>
+        /// Gets the pattern.
+        /// </summary>
+        /// <returns>Pattern</returns>
+        public string GetPattern()
+        {
+            return _pattern;
+        }
+    }
+}