Ocelot/test/Ocelot.UnitTests/Requester/HttpClientHttpRequesterTest.cs

using Moq;
using Ocelot.Logging;
using Ocelot.Requester;
using Ocelot.Responses;
using System;
using System.Collections.Generic;
using System.Net.Http;
using Microsoft.AspNetCore.Http;
using Ocelot.Configuration;
using Ocelot.Configuration.Builder;
using Ocelot.Middleware;
using TestStack.BDDfy;
using Xunit;
using Shouldly;
using Ocelot.Request.Middleware;
using System.Threading.Tasks;
using System.Threading;

namespace Ocelot.UnitTests.Requester
{
    public class HttpClientHttpRequesterTest
    {
        private readonly Mock<IHttpClientCache> _cacheHandlers;
        private Mock<IDelegatingHandlerHandlerFactory> _factory;
        private Response<HttpResponseMessage> _response;
        private readonly HttpClientHttpRequester _httpClientRequester;
        private DownstreamContext _request;
        private Mock<IOcelotLoggerFactory> _loggerFactory;
        private Mock<IOcelotLogger> _logger;

        public HttpClientHttpRequesterTest()
        {
            _factory = new Mock<IDelegatingHandlerHandlerFactory>();
            _factory.Setup(x => x.Get(It.IsAny<DownstreamReRoute>())).Returns(new OkResponse<List<Func<DelegatingHandler>>>(new List<Func<DelegatingHandler>>()));
            _logger = new Mock<IOcelotLogger>();
            _loggerFactory = new Mock<IOcelotLoggerFactory>();
            _loggerFactory
                .Setup(x => x.CreateLogger<HttpClientHttpRequester>())
                .Returns(_logger.Object);
            _cacheHandlers = new Mock<IHttpClientCache>();
            _httpClientRequester = new HttpClientHttpRequester(
                _loggerFactory.Object, 
                _cacheHandlers.Object, 
                _factory.Object);            
        }

        [Fact]
        public void should_call_request_correctly()
        {
            var reRoute = new DownstreamReRouteBuilder().WithIsQos(false)
                .WithHttpHandlerOptions(new HttpHandlerOptions(false, false, false)).WithReRouteKey("").Build();

            var context = new DownstreamContext(new DefaultHttpContext())
            {
                DownstreamReRoute = reRoute,
                DownstreamRequest = new DownstreamRequest(new HttpRequestMessage() { RequestUri = new Uri("http://www.bbc.co.uk") }),
            };

            this.Given(x=>x.GivenTheRequestIs(context))
                .And(x => GivenTheHouseReturnsOkHandler())
                .When(x=>x.WhenIGetResponse())
                .Then(x => x.ThenTheResponseIsCalledCorrectly())
                .BDDfy();
        }

        [Fact]
        public void should_call_request_unable_to_complete_request()
        {
            var reRoute = new DownstreamReRouteBuilder().WithIsQos(false)
                .WithHttpHandlerOptions(new HttpHandlerOptions(false, false, false)).WithReRouteKey("").Build();

            var context = new DownstreamContext(new DefaultHttpContext())
            {
                DownstreamReRoute = reRoute,
                DownstreamRequest = new DownstreamRequest(new HttpRequestMessage() { RequestUri = new Uri("http://localhost:60080") }),
            };

            this.Given(x => x.GivenTheRequestIs(context))
                .When(x => x.WhenIGetResponse())
                .Then(x => x.ThenTheResponseIsCalledError())
                .BDDfy();
        }

        private void GivenTheRequestIs(DownstreamContext request)
        {
            _request = request;            
        }

        private void WhenIGetResponse()
        {
            _response = _httpClientRequester.GetResponse(_request).Result;
        }

        private void ThenTheResponseIsCalledCorrectly()
        {
            _response.IsError.ShouldBeFalse();
        }

        private void ThenTheResponseIsCalledError()
        {
            _response.IsError.ShouldBeTrue();
        }

        private void GivenTheHouseReturnsOkHandler()
        {
            var handlers = new List<Func<DelegatingHandler>>
            {
                () => new OkDelegatingHandler()
            };

            _factory.Setup(x => x.Get(It.IsAny<DownstreamReRoute>())).Returns(new OkResponse<List<Func<DelegatingHandler>>>(handlers));
        }

        class OkDelegatingHandler : DelegatingHandler
        {
            protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
            {
                return Task.FromResult(new HttpResponseMessage());
            }
        }
    }  
}