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

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

test/WireMock.Net.Tests/Owin/GlobalExceptionMiddlewareTests.cs

@@ -0,0 +1,44 @@
+using System.Threading.Tasks;
+using Moq;
+using NFluent;
+using WireMock.Owin;
+using WireMock.Owin.Mappers;
+using Xunit;
+#if NET452
+using IContext = Microsoft.Owin.IOwinContext;
+using IResponse = Microsoft.Owin.IOwinResponse;
+#else
+using IContext = Microsoft.AspNetCore.Http.HttpContext;
+using IResponse = Microsoft.AspNetCore.Http.HttpResponse;
+#endif
+
+namespace WireMock.Net.Tests.Owin
+{
+    public class GlobalExceptionMiddlewareTests
+    {
+        private Mock<IWireMockMiddlewareOptions> _optionsMock;
+        private Mock<IOwinResponseMapper> _responseMapperMock;
+        private Mock<IContext> _contextMock;
+
+        private GlobalExceptionMiddleware _sut;
+
+        public GlobalExceptionMiddlewareTests()
+        {
+            _optionsMock = new Mock<IWireMockMiddlewareOptions>();
+            _optionsMock.SetupAllProperties();
+
+            _responseMapperMock = new Mock<IOwinResponseMapper>();
+            _responseMapperMock.SetupAllProperties();
+            _responseMapperMock.Setup(m => m.MapAsync(It.IsAny<ResponseMessage>(), It.IsAny<IResponse>())).Returns(Task.FromResult(true));
+
+            _sut = new GlobalExceptionMiddleware(null, _optionsMock.Object, _responseMapperMock.Object);
+        }
+
+        [Fact]
+        public void GlobalExceptionMiddleware_Invoke_NullAsNext_Throws()
+        {
+            // Act
+            Check.ThatAsyncCode(() => _sut.Invoke(_contextMock.Object)).ThrowsAny();
+        }
+    }
+}

test/WireMock.Net.Tests/Owin/Mappers/OwinResponseMapperTests.cs

@@ -0,0 +1,166 @@
+using System.Collections.Generic;
+using System.IO;
+using Xunit;
+using Moq;
+using System.Threading.Tasks;
+using System.Threading;
+using WireMock.Owin.Mappers;
+using WireMock.Util;
+#if NET452
+using Microsoft.Owin;
+using IResponse = Microsoft.Owin.IOwinResponse;
+using Response = Microsoft.Owin.OwinResponse;
+#else
+using Microsoft.AspNetCore.Http;
+using IResponse = Microsoft.AspNetCore.Http.HttpResponse;
+using Response = Microsoft.AspNetCore.Http.HttpResponse;
+using Microsoft.Extensions.Primitives;
+#endif
+
+namespace WireMock.Net.Tests.Owin.Mappers
+{
+    public class OwinResponseMapperTests
+    {
+        private static Task completedTask = Task.FromResult(true);
+        private OwinResponseMapper _sut;
+        private Mock<IResponse> _responseMock;
+        private Mock<Stream> _stream;
+        private Mock<IHeaderDictionary> _headers;
+
+        public OwinResponseMapperTests()
+        {
+            _stream = new Mock<Stream>();
+            _stream.SetupAllProperties();
+            _stream.Setup(s => s.WriteAsync(It.IsAny<byte[]>(), It.IsAny<int>(), It.IsAny<int>(), It.IsAny<CancellationToken>())).Returns(completedTask);
+
+            _headers = new Mock<IHeaderDictionary>();
+            _headers.SetupAllProperties();
+#if NET452
+            _headers.Setup(h => h.AppendValues(It.IsAny<string>(), It.IsAny<string[]>()));
+#else
+            _headers.Setup(h => h.Add(It.IsAny<string>(), It.IsAny<StringValues>()));
+#endif
+
+            _responseMock = new Mock<IResponse>();
+            _responseMock.SetupAllProperties();
+            _responseMock.SetupGet(r => r.Body).Returns(_stream.Object);
+            _responseMock.SetupGet(r => r.Headers).Returns(_headers.Object);
+
+            _sut = new OwinResponseMapper();
+        }
+
+        [Fact]
+        public async void OwinResponseMapper_MapAsync_Null()
+        {
+            // Act
+            await _sut.MapAsync(null, _responseMock.Object);
+        }
+
+        [Fact]
+        public async void OwinResponseMapper_MapAsync_StatusCode()
+        {
+            // Assign
+            var responseMessage = new ResponseMessage
+            {
+                StatusCode = 302
+            };
+
+            // Act
+            await _sut.MapAsync(responseMessage, _responseMock.Object);
+
+            // Assert
+            _responseMock.VerifySet(r => r.StatusCode = 302, Times.Once);
+        }
+
+        [Fact]
+        public async void OwinResponseMapper_MapAsync_NoBody()
+        {
+            // Assign
+            var responseMessage = new ResponseMessage
+            {
+                Headers = new Dictionary<string, WireMockList<string>>()
+            };
+
+            // Act
+            await _sut.MapAsync(responseMessage, _responseMock.Object);
+
+            // Assert
+            _stream.Verify(s => s.WriteAsync(It.IsAny<byte[]>(), It.IsAny<int>(), It.IsAny<int>(), It.IsAny<CancellationToken>()), Times.Never);
+        }
+
+        [Fact]
+        public async void OwinResponseMapper_MapAsync_Body()
+        {
+            // Assign
+            string body = "abc";
+            var responseMessage = new ResponseMessage
+            {
+                Headers = new Dictionary<string, WireMockList<string>>(),
+                Body = body
+            };
+
+            // Act
+            await _sut.MapAsync(responseMessage, _responseMock.Object);
+
+            // Assert
+            _stream.Verify(s => s.WriteAsync(new byte[] { 97, 98, 99 }, 0, 3, It.IsAny<CancellationToken>()), Times.Once);
+        }
+
+        [Fact]
+        public async void OwinResponseMapper_MapAsync_BodyAsBytes()
+        {
+            // Assign
+            var bytes = new byte[] { 48, 49 };
+            var responseMessage = new ResponseMessage
+            {
+                Headers = new Dictionary<string, WireMockList<string>>(),
+                BodyAsBytes = bytes
+            };
+
+            // Act
+            await _sut.MapAsync(responseMessage, _responseMock.Object);
+
+            // Assert
+            _stream.Verify(s => s.WriteAsync(bytes, 0, bytes.Length, It.IsAny<CancellationToken>()), Times.Once);
+        }
+
+        [Fact]
+        public async void OwinResponseMapper_MapAsync_BodyAsJson()
+        {
+            // Assign
+            var responseMessage = new ResponseMessage
+            {
+                Headers = new Dictionary<string, WireMockList<string>>(),
+                BodyAsJson = new { t = "x", i = (string)null },
+                BodyAsJsonIndented = false
+            };
+
+            // Act
+            await _sut.MapAsync(responseMessage, _responseMock.Object);
+
+            // Assert
+            _stream.Verify(s => s.WriteAsync(new byte[] { 123, 34, 116, 34, 58, 34, 120, 34, 125 }, 0, 9, It.IsAny<CancellationToken>()), Times.Once);
+        }
+
+        [Fact]
+        public async void OwinResponseMapper_MapAsync_SetResponseHeaders()
+        {
+            // Assign
+            var responseMessage = new ResponseMessage
+            {
+                Headers = new Dictionary<string, WireMockList<string>> { { "h", new WireMockList<string>("x", "y") } }
+            };
+
+            // Act
+            await _sut.MapAsync(responseMessage, _responseMock.Object);
+
+            // Assert
+#if NET452
+            _headers.Verify(h => h.AppendValues("h", new string[] { "x", "y" } ), Times.Once);
+#else
+            var v = new StringValues();
+            _headers.Verify(h => h.TryGetValue("h", out v), Times.Once);
+#endif
+        }
+    }
+}

test/WireMock.Net.Tests/Owin/MappingMatcherTests.cs

@@ -0,0 +1,99 @@
+using System;
+using System.Collections.Concurrent;
+using Moq;
+using NFluent;
+using WireMock.Logging;
+using WireMock.Matchers.Request;
+using WireMock.Models;
+using WireMock.Owin;
+using WireMock.Util;
+using Xunit;
+
+namespace WireMock.Net.Tests.Owin
+{
+    public class MappingMatcherTests
+    {
+        private Mock<IWireMockMiddlewareOptions> _optionsMock;
+
+        private IMappingMatcher _sut;
+
+        public MappingMatcherTests()
+        {
+            _optionsMock = new Mock<IWireMockMiddlewareOptions>();
+            _optionsMock.SetupAllProperties();
+            _optionsMock.Setup(o => o.Mappings).Returns(new ConcurrentDictionary<Guid, IMapping>());
+            _optionsMock.Setup(o => o.LogEntries).Returns(new ConcurentObservableCollection<LogEntry>());
+            _optionsMock.Setup(o => o.Scenarios).Returns(new ConcurrentDictionary<string, ScenarioState>());
+
+            _sut = new MappingMatcher(_optionsMock.Object);
+        }
+
+        [Fact]
+        public void MappingMatcher_Match_NoMappingsDefined()
+        {
+            // Assign
+            var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "GET", "::1");
+
+            // Act
+            var result = _sut.Match(request);
+
+            // Assert and Verify
+            Check.That(result.Mapping).IsNull();
+            Check.That(result.RequestMatchResult).IsNull();
+        }
+
+        [Fact]
+        public void MappingMatcher_Match_GetBestMapping_Exact()
+        {
+            // Assign
+            var mappings = InitMappings(new[] { (Guid.Parse("00000000-0000-0000-0000-000000000001"), 0.1), (Guid.Parse("00000000-0000-0000-0000-000000000002"), 1.0) });
+            _optionsMock.Setup(o => o.Mappings).Returns(mappings);
+
+            var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "GET", "::1");
+
+            // Act
+            var result = _sut.Match(request);
+
+            // Assert and Verify
+            Check.That(result.Mapping.Guid).IsEqualTo(Guid.Parse("00000000-0000-0000-0000-000000000002"));
+            Check.That(result.RequestMatchResult.AverageTotalScore).IsEqualTo(1.0);
+        }
+
+        [Fact]
+        public void MappingMatcher_Match_GetBestMapping_AllowPartialMapping()
+        {
+            // Assign
+            _optionsMock.SetupGet(o => o.AllowPartialMapping).Returns(true);
+            var mappings = InitMappings(new[] { (Guid.Parse("00000000-0000-0000-0000-000000000001"), 0.1), (Guid.Parse("00000000-0000-0000-0000-000000000002"), 0.9) });
+            _optionsMock.Setup(o => o.Mappings).Returns(mappings);
+
+            var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "GET", "::1");
+
+            // Act
+            var result = _sut.Match(request);
+
+            // Assert and Verify
+            Check.That(result.Mapping.Guid).IsEqualTo(Guid.Parse("00000000-0000-0000-0000-000000000002"));
+            Check.That(result.RequestMatchResult.AverageTotalScore).IsEqualTo(0.9);
+        }
+
+        private ConcurrentDictionary<Guid, IMapping> InitMappings(params (Guid guid, double match)[] matches)
+        {
+            var mappings = new ConcurrentDictionary<Guid, IMapping>();
+
+            foreach (var match in matches)
+            {
+                var mappingMock = new Mock<IMapping>();
+                mappingMock.SetupGet(m => m.Guid).Returns(match.guid);
+
+                var partialMatchResult = new RequestMatchResult();
+                partialMatchResult.AddScore(typeof(object), match.match);
+                mappingMock.Setup(m => m.GetRequestMatchResult(It.IsAny<RequestMessage>(), It.IsAny<string>())).Returns(partialMatchResult);
+
+                mappings.TryAdd(match.guid, mappingMock.Object);
+            }
+
+            return mappings;
+        }
+    }
+}

test/WireMock.Net.Tests/Owin/WireMockMiddlewareTests.cs

@@ -0,0 +1,138 @@
+using System;
+using System.Collections.Concurrent;
+using System.Linq.Expressions;
+using System.Threading.Tasks;
+using Moq;
+using Xunit;
+using WireMock.Admin.Mappings;
+using WireMock.Models;
+using WireMock.Owin;
+using WireMock.Owin.Mappers;
+using WireMock.Util;
+using WireMock.Admin.Requests;
+using WireMock.Logging;
+using WireMock.Matchers.Request;
+using WireMock.Matchers;
+using System.Collections.Generic;
+#if NET452
+using Microsoft.Owin;
+using IContext = Microsoft.Owin.IOwinContext;
+using IRequest = Microsoft.Owin.IOwinRequest;
+using IResponse = Microsoft.Owin.IOwinResponse;
+#else
+using Microsoft.AspNetCore.Http;
+using IContext = Microsoft.AspNetCore.Http.HttpContext;
+using IRequest = Microsoft.AspNetCore.Http.HttpRequest;
+using IResponse = Microsoft.AspNetCore.Http.HttpResponse;
+#endif
+
+namespace WireMock.Net.Tests.Owin
+{
+    public class WireMockMiddlewareTests
+    {
+        private WireMockMiddleware _sut;
+
+        private Mock<IWireMockMiddlewareOptions> _optionsMock;
+        private Mock<IOwinRequestMapper> _requestMapperMock;
+        private Mock<IOwinResponseMapper> _responseMapperMock;
+        private Mock<IMappingMatcher> _matcherMock;
+        private Mock<IMapping> _mappingMock;
+        private Mock<IContext> _contextMock;
+
+        public WireMockMiddlewareTests()
+        {
+            _optionsMock = new Mock<IWireMockMiddlewareOptions>();
+            _optionsMock.SetupAllProperties();
+            _optionsMock.Setup(o => o.Mappings).Returns(new ConcurrentDictionary<Guid, IMapping>());
+            _optionsMock.Setup(o => o.LogEntries).Returns(new ConcurentObservableCollection<LogEntry>());
+            _optionsMock.Setup(o => o.Scenarios).Returns(new ConcurrentDictionary<string, ScenarioState>());
+            _optionsMock.Setup(o => o.Logger.Warn(It.IsAny<string>(), It.IsAny<object[]>()));
+            _optionsMock.Setup(o => o.Logger.Error(It.IsAny<string>(), It.IsAny<object[]>()));
+            _optionsMock.Setup(o => o.Logger.DebugRequestResponse(It.IsAny<LogEntryModel>(), It.IsAny<bool>()));
+
+            _requestMapperMock = new Mock<IOwinRequestMapper>();
+            _requestMapperMock.SetupAllProperties();
+            var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "GET", "::1");
+            _requestMapperMock.Setup(m => m.MapAsync(It.IsAny<IRequest>())).ReturnsAsync(request);
+
+            _responseMapperMock = new Mock<IOwinResponseMapper>();
+            _responseMapperMock.SetupAllProperties();
+            _responseMapperMock.Setup(m => m.MapAsync(It.IsAny<ResponseMessage>(), It.IsAny<IResponse>())).Returns(Task.FromResult(true));
+
+            _matcherMock = new Mock<IMappingMatcher>();
+            _matcherMock.SetupAllProperties();
+            _matcherMock.Setup(m => m.Match(It.IsAny<RequestMessage>())).Returns(((IMapping)null, (RequestMatchResult)null));
+
+            _contextMock = new Mock<IContext>();
+
+            _mappingMock = new Mock<IMapping>();
+
+            _sut = new WireMockMiddleware(null, _optionsMock.Object, _requestMapperMock.Object, _responseMapperMock.Object, _matcherMock.Object);
+        }
+
+        [Fact]
+        public async void WireMockMiddleware_Invoke_NoMatch()
+        {
+            // Act
+            await _sut.Invoke(_contextMock.Object);
+
+            // Assert and Verify
+            _optionsMock.Verify(o => o.Logger.Warn(It.IsAny<string>(), It.IsAny<object[]>()), Times.Once);
+
+            Expression<Func<ResponseMessage, bool>> match = r => r.StatusCode == 404 && ((StatusModel)r.BodyAsJson).Status == "No matching mapping found";
+            _responseMapperMock.Verify(m => m.MapAsync(It.Is(match), It.IsAny<IResponse>()), Times.Once);
+        }
+
+        [Fact]
+        public async void WireMockMiddleware_Invoke_IsAdminInterface_EmptyHeaders_401()
+        {
+            // Assign
+            var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "GET", "::1", null, new Dictionary<string, string[]>());
+            _requestMapperMock.Setup(m => m.MapAsync(It.IsAny<IRequest>())).ReturnsAsync(request);
+
+            _optionsMock.SetupGet(o => o.AuthorizationMatcher).Returns(new ExactMatcher());
+            _mappingMock.SetupGet(m => m.IsAdminInterface).Returns(true);
+            _matcherMock.Setup(m => m.Match(It.IsAny<RequestMessage>())).Returns((_mappingMock.Object, (RequestMatchResult)null));
+
+            // Act
+            await _sut.Invoke(_contextMock.Object);
+
+            // Assert and Verify
+            _optionsMock.Verify(o => o.Logger.Error(It.IsAny<string>(), It.IsAny<object[]>()), Times.Once);
+
+            Expression<Func<ResponseMessage, bool>> match = r => r.StatusCode == 401;
+            _responseMapperMock.Verify(m => m.MapAsync(It.Is(match), It.IsAny<IResponse>()), Times.Once);
+        }
+
+        [Fact]
+        public async void WireMockMiddleware_Invoke_IsAdminInterface_MissingHeader_401()
+        {
+            // Assign
+            var request = new RequestMessage(new UrlDetails("http://localhost/foo"), "GET", "::1", null, new Dictionary<string, string[]> { { "h", new[] { "x" } } });
+            _requestMapperMock.Setup(m => m.MapAsync(It.IsAny<IRequest>())).ReturnsAsync(request);
+
+            _optionsMock.SetupGet(o => o.AuthorizationMatcher).Returns(new ExactMatcher());
+            _mappingMock.SetupGet(m => m.IsAdminInterface).Returns(true);
+            _matcherMock.Setup(m => m.Match(It.IsAny<RequestMessage>())).Returns((_mappingMock.Object, (RequestMatchResult)null));
+
+            // Act
+            await _sut.Invoke(_contextMock.Object);
+
+            // Assert and Verify
+            _optionsMock.Verify(o => o.Logger.Error(It.IsAny<string>(), It.IsAny<object[]>()), Times.Once);
+
+            Expression<Func<ResponseMessage, bool>> match = r => r.StatusCode == 401;
+            _responseMapperMock.Verify(m => m.MapAsync(It.Is(match), It.IsAny<IResponse>()), Times.Once);
+        }
+
+        [Fact]
+        public async void WireMockMiddleware_Invoke_RequestLogExpirationDurationIsDefined()
+        {
+            // Assign
+            _optionsMock.SetupGet(o => o.RequestLogExpirationDuration).Returns(1);
+
+            // Act
+            await _sut.Invoke(_contextMock.Object);
+        }
+    }
+}