Rewrite some unit-integration-tests to unit-tests (#206 #207)

Rewrite some unit-integration-tests to unit-tests (#206)

src/WireMock.Net/Owin/Mappers/IOwinRequestMapper.cs

@@ -0,0 +1,22 @@
+using System.Threading.Tasks;
+#if !USE_ASPNETCORE
+using IRequest = Microsoft.Owin.IOwinRequest;
+#else
+using IRequest = Microsoft.AspNetCore.Http.HttpRequest;
+#endif
+
+namespace WireMock.Owin.Mappers
+{
+    /// <summary>
+    /// IOwinRequestMapper
+    /// </summary>
+    internal interface IOwinRequestMapper
+    {
+        /// <summary>
+        /// MapAsync IRequest to RequestMessage
+        /// </summary>
+        /// <param name="request">The OwinRequest/HttpRequest</param>
+        /// <returns>RequestMessage</returns>
+        Task<RequestMessage> MapAsync(IRequest request);
+    }
+}

src/WireMock.Net/Owin/Mappers/IOwinResponseMapper.cs

@@ -0,0 +1,22 @@
+using System.Threading.Tasks;
+#if !USE_ASPNETCORE
+using IResponse = Microsoft.Owin.IOwinResponse;
+#else
+using IResponse = Microsoft.AspNetCore.Http.HttpResponse;
+#endif
+
+namespace WireMock.Owin.Mappers
+{
+    /// <summary>
+    /// IOwinResponseMapper
+    /// </summary>
+    internal interface IOwinResponseMapper
+    {
+        /// <summary>
+        /// Map ResponseMessage to IResponse.
+        /// </summary>
+        /// <param name="responseMessage">The ResponseMessage</param>
+        /// <param name="response">The OwinResponse/HttpResponse</param>
+        Task MapAsync(ResponseMessage responseMessage, IResponse response);
+    }
+}

src/WireMock.Net/Owin/Mappers/OwinRequestMapper.cs

@@ -0,0 +1,89 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using WireMock.Models;
+using WireMock.Util;
+#if !USE_ASPNETCORE
+using IRequest = Microsoft.Owin.IOwinRequest;
+#else
+using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Http.Extensions;
+using IRequest = Microsoft.AspNetCore.Http.HttpRequest;
+#endif
+
+namespace WireMock.Owin.Mappers
+{
+    /// <summary>
+    /// OwinRequestMapper
+    /// </summary>
+    internal class OwinRequestMapper : IOwinRequestMapper
+    {
+        /// <inheritdoc cref="IOwinRequestMapper.MapAsync"/>
+        public async Task<RequestMessage> MapAsync(IRequest request)
+        {
+            (UrlDetails urldetails, string clientIP) = ParseRequest(request);
+
+            string method = request.Method;
+
+            Dictionary<string, string[]> headers = null;
+            if (request.Headers.Any())
+            {
+                headers = new Dictionary<string, string[]>();
+                foreach (var header in request.Headers)
+                {
+                    headers.Add(header.Key, header.Value);
+                }
+            }
+
+            IDictionary<string, string> cookies = null;
+            if (request.Cookies.Any())
+            {
+                cookies = new Dictionary<string, string>();
+                foreach (var cookie in request.Cookies)
+                {
+                    cookies.Add(cookie.Key, cookie.Value);
+                }
+            }
+
+            BodyData body = null;
+            if (request.Body != null && ShouldParseBody(method))
+            {
+                body = await BodyParser.Parse(request.Body, request.ContentType);
+            }
+
+            return new RequestMessage(urldetails, method, clientIP, body, headers, cookies) { DateTime = DateTime.UtcNow };
+        }
+
+        private (UrlDetails UrlDetails, string ClientIP) ParseRequest(IRequest request)
+        {
+#if !USE_ASPNETCORE
+            var urldetails = UrlUtils.Parse(request.Uri, request.PathBase);
+            string clientIP = request.RemoteIpAddress;
+#else
+            var urldetails = UrlUtils.Parse(new Uri(request.GetEncodedUrl()), request.PathBase);
+            var connection = request.HttpContext.Connection;
+            string clientIP = connection.RemoteIpAddress.IsIPv4MappedToIPv6
+                ? connection.RemoteIpAddress.MapToIPv4().ToString()
+                : connection.RemoteIpAddress.ToString();
+#endif
+            return (urldetails, clientIP);
+        }
+
+        private bool ShouldParseBody(string method)
+        {
+            /*
+                HEAD - No defined body semantics.
+                GET - No defined body semantics.
+                PUT - Body supported.
+                POST - Body supported.
+                DELETE - No defined body semantics.
+                TRACE - Body not supported.
+                OPTIONS - Body supported but no semantics on usage (maybe in the future).
+                CONNECT - No defined body semantics
+                PATCH - Body supported.
+            */
+            return new[] { "PUT", "POST", "OPTIONS", "PATCH" }.Contains(method.ToUpper());
+        }
+    }
+}

src/WireMock.Net/Owin/Mappers/OwinResponseMapper.cs

@@ -0,0 +1,100 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Newtonsoft.Json;
+using WireMock.Http;
+using WireMock.Util;
+#if !USE_ASPNETCORE
+using System.Net;
+using Microsoft.Owin;
+using IResponse = Microsoft.Owin.IOwinResponse;
+#else
+using Microsoft.AspNetCore.Http;
+using IResponse = Microsoft.AspNetCore.Http.HttpResponse;
+#endif
+
+namespace WireMock.Owin.Mappers
+{
+    /// <summary>
+    /// OwinResponseMapper
+    /// </summary>
+    public class OwinResponseMapper : IOwinResponseMapper
+    {
+        private readonly Encoding _utf8NoBom = new UTF8Encoding(false);
+
+        // https://msdn.microsoft.com/en-us/library/78h415ay(v=vs.110).aspx
+#if !USE_ASPNETCORE
+        private static readonly IDictionary<string, Action<IResponse, WireMockList<string>>> ResponseHeadersToFix = new Dictionary<string, Action<IResponse, WireMockList<string>>>(StringComparer.OrdinalIgnoreCase) {
+#else
+        private static readonly IDictionary<string, Action<IResponse, WireMockList<string>>> ResponseHeadersToFix = new Dictionary<string, Action<IResponse, WireMockList<string>>>(StringComparer.OrdinalIgnoreCase) {
+#endif
+            { HttpKnownHeaderNames.ContentType, (r, v) => r.ContentType = v.FirstOrDefault() }
+        };
+
+        /// <inheritdoc cref="IOwinResponseMapper.MapAsync"/>
+        public async Task MapAsync(ResponseMessage responseMessage, IResponse response)
+        {
+            if (responseMessage == null)
+            {
+                return;
+            }
+
+            response.StatusCode = responseMessage.StatusCode;
+
+            byte[] bytes = null;
+            if (responseMessage.BodyAsBytes != null)
+            {
+                bytes = responseMessage.BodyAsBytes;
+            }
+            else if (responseMessage.BodyAsFile != null)
+            {
+                bytes = File.ReadAllBytes(responseMessage.BodyAsFile);
+            }
+            else if (responseMessage.BodyAsJson != null)
+            {
+                Formatting formatting = responseMessage.BodyAsJsonIndented == true ? Formatting.Indented : Formatting.None;
+                string jsonBody = JsonConvert.SerializeObject(responseMessage.BodyAsJson, new JsonSerializerSettings { Formatting = formatting, NullValueHandling = NullValueHandling.Ignore });
+                bytes = (responseMessage.BodyEncoding ?? _utf8NoBom).GetBytes(jsonBody);
+            }
+            else if (responseMessage.Body != null)
+            {
+                bytes = (responseMessage.BodyEncoding ?? _utf8NoBom).GetBytes(responseMessage.Body);
+            }
+
+            SetResponseHeaders(responseMessage, response);
+
+            if (bytes != null)
+            {
+                await response.Body.WriteAsync(bytes, 0, bytes.Length);
+            }
+        }
+
+        private void SetResponseHeaders(ResponseMessage responseMessage, IResponse response)
+        {
+            // Set headers
+            foreach (var pair in responseMessage.Headers)
+            {
+                if (ResponseHeadersToFix.ContainsKey(pair.Key))
+                {
+                    ResponseHeadersToFix[pair.Key]?.Invoke(response, pair.Value);
+                }
+                else
+                {
+#if !USE_ASPNETCORE
+                    // For non-NETSTANDARD, check if this response header can be added (#148)
+                    if (!WebHeaderCollection.IsRestricted(pair.Key, true))
+                    {
+                        response.Headers.AppendValues(pair.Key, pair.Value.ToArray());
+                    }
+#else
+                    // NETSTANDARD can add any header (or so it seems)
+                    response.Headers.Append(pair.Key, pair.Value.ToArray());
+#endif
+                }
+            }
+        }
+    }
+}