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

// Copyright © WireMock.Net

using System;
using System.Collections.Generic;
using System.IO;
using Xunit;
using Moq;
using System.Threading.Tasks;
using System.Threading;
using FluentAssertions;
using WireMock.Handlers;
using WireMock.Owin.Mappers;
using WireMock.ResponseBuilders;
using WireMock.Types;
using WireMock.Util;
using WireMock.Owin;
#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 readonly Task CompletedTask = Task.FromResult(true);
    private readonly OwinResponseMapper _sut;
    private readonly Mock<IResponse> _responseMock;
    private readonly Mock<Stream> _stream;
    private readonly Mock<IHeaderDictionary> _headers;
    private readonly Mock<IFileSystemHandler> _fileSystemHandlerMock;
    private readonly Mock<IWireMockMiddlewareOptions> _optionsMock;

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

        _fileSystemHandlerMock = new Mock<IFileSystemHandler>();
        _fileSystemHandlerMock.SetupAllProperties();

        _optionsMock = new Mock<IWireMockMiddlewareOptions>();
        _optionsMock.SetupAllProperties();
        _optionsMock.SetupGet(o => o.FileSystemHandler).Returns(_fileSystemHandlerMock.Object);

        _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(_optionsMock.Object);
    }

    [Fact]
    public async Task OwinResponseMapper_MapAsync_Null()
    {
        // Act
        await _sut.MapAsync(null, _responseMock.Object).ConfigureAwait(false);
    }

    [Theory]
    [InlineData(300, 300)]
    [InlineData(500, 500)]
    public async Task OwinResponseMapper_MapAsync_Valid_StatusCode(object code, int expected)
    {
        // Arrange
        var responseMessage = new ResponseMessage
        {
            StatusCode = code
        };

        // Act
        await _sut.MapAsync(responseMessage, _responseMock.Object).ConfigureAwait(false);

        // Assert
        _responseMock.VerifySet(r => r.StatusCode = expected, Times.Once);
    }

    [Theory]
    [InlineData(0, 200)]
    [InlineData(-1, 200)]
    [InlineData(10000, 200)]
    [InlineData(300, 300)]
    public async Task OwinResponseMapper_MapAsync_Invalid_StatusCode_When_AllowOnlyDefinedHttpStatusCodeInResponseSet_Is_True(object code, int expected)
    {
        // Arrange
        _optionsMock.SetupGet(o => o.AllowOnlyDefinedHttpStatusCodeInResponse).Returns(true);
        var responseMessage = new ResponseMessage
        {
            StatusCode = code
        };

        // Act
        await _sut.MapAsync(responseMessage, _responseMock.Object).ConfigureAwait(false);

        // Assert
        _responseMock.VerifySet(r => r.StatusCode = expected, Times.Once);
    }

    [Fact]
    public async Task OwinResponseMapper_MapAsync_StatusCode_Is_Null()
    {
        // Arrange
        var responseMessage = new ResponseMessage
        {
            StatusCode = null
        };

        // Act
        await _sut.MapAsync(responseMessage, _responseMock.Object).ConfigureAwait(false);

        // Assert
        _responseMock.VerifySet(r => r.StatusCode = It.IsAny<int>(), Times.Never);
    }

    [Theory]
    [InlineData(0, 0)]
    [InlineData(-1, -1)]
    [InlineData(10000, 10000)]
    [InlineData(300, 300)]
    public async Task OwinResponseMapper_MapAsync_StatusCode_Is_NotInEnumRange(object code, int expected)
    {
        // Arrange
        var responseMessage = new ResponseMessage
        {
            StatusCode = code
        };

        // Act
        await _sut.MapAsync(responseMessage, _responseMock.Object).ConfigureAwait(false);

        // Assert
        _responseMock.VerifySet(r => r.StatusCode = expected, Times.Once);
    }

    [Fact]
    public async Task OwinResponseMapper_MapAsync_NoBody()
    {
        // Arrange
        var responseMessage = new ResponseMessage
        {
            Headers = new Dictionary<string, WireMockList<string>>()
        };

        // Act
        await _sut.MapAsync(responseMessage, _responseMock.Object).ConfigureAwait(false);

        // Assert
        _stream.Verify(s => s.WriteAsync(It.IsAny<byte[]>(), It.IsAny<int>(), It.IsAny<int>(), It.IsAny<CancellationToken>()), Times.Never);
    }

    [Fact]
    public async Task OwinResponseMapper_MapAsync_Body()
    {
        // Arrange
        string body = "abcd";
        var responseMessage = new ResponseMessage
        {
            Headers = new Dictionary<string, WireMockList<string>>(),
            BodyData = new BodyData { DetectedBodyType = BodyType.String, BodyAsString = body }
        };

        // Act
        await _sut.MapAsync(responseMessage, _responseMock.Object).ConfigureAwait(false);

        // Assert
        _stream.Verify(s => s.WriteAsync(new byte[] { 97, 98, 99, 100 }, 0, 4, It.IsAny<CancellationToken>()), Times.Once);
    }

    [Fact]
    public async Task OwinResponseMapper_MapAsync_BodyAsBytes()
    {
        // Arrange
        var bytes = new byte[] { 48, 49 };
        var responseMessage = new ResponseMessage
        {
            Headers = new Dictionary<string, WireMockList<string>>(),
            BodyData = new BodyData { DetectedBodyType = BodyType.Bytes, BodyAsBytes = bytes }
        };

        // Act
        await _sut.MapAsync(responseMessage, _responseMock.Object).ConfigureAwait(false);

        // Assert
        _stream.Verify(s => s.WriteAsync(bytes, 0, bytes.Length, It.IsAny<CancellationToken>()), Times.Once);
    }

    [Fact]
    public async Task OwinResponseMapper_MapAsync_BodyAsJson()
    {
        // Arrange
        var json = new { t = "x", i = (string?)null };
        var responseMessage = new ResponseMessage
        {
            Headers = new Dictionary<string, WireMockList<string>>(),
            BodyData = new BodyData { DetectedBodyType = BodyType.Json, BodyAsJson = json, BodyAsJsonIndented = false }
        };

        // Act
        await _sut.MapAsync(responseMessage, _responseMock.Object).ConfigureAwait(false);

        // 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 Task OwinResponseMapper_MapAsync_SetResponseHeaders()
    {
        // Arrange
        var responseMessage = new ResponseMessage
        {
            Headers = new Dictionary<string, WireMockList<string>> { { "h", new WireMockList<string>("x", "y") } }
        };

        // Act
        await _sut.MapAsync(responseMessage, _responseMock.Object).ConfigureAwait(false);

        // 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
    }

    [Fact]
    public void OwinResponseMapper_MapAsync_BodyAsFile_ThrowsException()
    {
        // Arrange
        var responseMessage = new ResponseMessage
        {
            Headers = new Dictionary<string, WireMockList<string>>(),
            BodyData = new BodyData { DetectedBodyType = BodyType.File, BodyAsFile = string.Empty }
        };
        _fileSystemHandlerMock.Setup(f => f.ReadResponseBodyAsFile(It.IsAny<string>())).Throws<FileNotFoundException>();

        // Act
        Func<Task> action = () => _sut.MapAsync(responseMessage, _responseMock.Object);

        // Assert
        action.Should().ThrowAsync<FileNotFoundException>();
    }

    [Fact]
    public async Task OwinResponseMapper_MapAsync_WithFault_EMPTY_RESPONSE()
    {
        // Arrange
        string body = "abc";
        var responseMessage = new ResponseMessage
        {
            Headers = new Dictionary<string, WireMockList<string>>(),
            BodyData = new BodyData { DetectedBodyType = BodyType.String, BodyAsString = body },
            FaultType = FaultType.EMPTY_RESPONSE
        };

        // Act
        await _sut.MapAsync(responseMessage, _responseMock.Object).ConfigureAwait(false);

        // Assert
        _stream.Verify(s => s.WriteAsync(EmptyArray<byte>.Value, 0, 0, It.IsAny<CancellationToken>()), Times.Once);
    }

    [Theory]
    [InlineData("abcd", BodyType.String)]
    [InlineData("", BodyType.String)]
    [InlineData(null, BodyType.None)]
    public async Task OwinResponseMapper_MapAsync_WithFault_MALFORMED_RESPONSE_CHUNK(string body, BodyType detected)
    {
        // Arrange
        var responseMessage = new ResponseMessage
        {
            Headers = new Dictionary<string, WireMockList<string>>(),
            BodyData = new BodyData { DetectedBodyType = detected, BodyAsString = body },
            StatusCode = 100,
            FaultType = FaultType.MALFORMED_RESPONSE_CHUNK
        };

        // Act
        await _sut.MapAsync(responseMessage, _responseMock.Object).ConfigureAwait(false);

        // Assert
        _responseMock.VerifySet(r => r.StatusCode = 100, Times.Once);
        _stream.Verify(s => s.WriteAsync(It.IsAny<byte[]>(), 0, It.Is<int>(count => count >= 0), It.IsAny<CancellationToken>()), Times.Once);
    }
}