Rename to WireMock.Net

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);
+        }
+    }
+}