tk/Ocelot
1
0
Fork 0
mirror of https://github.com/nsnail/Ocelot.git synced 2025-06-19 08:18:16 +08:00
Code Issues Packages Projects Releases Wiki Activity

Moved common middleare test setup into a base class

Browse Source
This commit is contained in:
Philip Wood
2017-07-18 09:28:32 +01:00
parent b0c12431d6
commit 8042bbab2c
20 changed files with 787 additions and 916 deletions
Download Patch File Download Diff File Expand all files Collapse all files

142
test/Ocelot.UnitTests/Responder/ResponderMiddlewareTests.cs
View File

@ -1,11 +1,6 @@
using System;
using System.IO;
using System.Net.Http;
using System.Net.Http;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Moq;
using Ocelot.Infrastructure.RequestData;
using Ocelot.Logging;
@ -14,77 +9,109 @@ using Ocelot.Responder.Middleware;
using Ocelot.Responses;
using TestStack.BDDfy;
using Xunit;
using Microsoft.AspNetCore.Builder;
using Shouldly;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Http;
using System.Collections.Generic;
using Ocelot.Errors;
using System.Net;
using Ocelot.Headers;
namespace Ocelot.UnitTests.Responder
{
public class ResponderMiddlewareTests : IDisposable
public class ResponderMiddlewareTests : ServerHostedMiddlewareTest
{
private readonly Mock<IHttpResponder> _responder;
private readonly IHttpResponder _responder;
private readonly Mock<IRequestScopedDataRepository> _scopedRepository;
private readonly Mock<IErrorsToHttpStatusCodeMapper> _codeMapper;
private readonly string _url;
private readonly TestServer _server;
private readonly HttpClient _client;
private HttpResponseMessage _result;
private readonly Mock<IRemoveOutputHeaders> _outputHeaderRemover;
private HttpStatusCode _httpStatusFromController;
private string _contentFromController;
private OkResponse<HttpResponseMessage> _response;
private List<Error> _pipelineErrors;
public ResponderMiddlewareTests()
{
_url = "http://localhost:51879";
_responder = new Mock<IHttpResponder>();
_outputHeaderRemover = new Mock<IRemoveOutputHeaders>();
_responder = new HttpContextResponder(_outputHeaderRemover.Object);
_scopedRepository = new Mock<IRequestScopedDataRepository>();
_codeMapper = new Mock<IErrorsToHttpStatusCodeMapper>();
var builder = new WebHostBuilder()
.ConfigureServices(x =>
{
x.AddSingleton<IOcelotLoggerFactory, AspDotNetLoggerFactory>();
x.AddLogging();
x.AddSingleton(_codeMapper.Object);
x.AddSingleton(_responder.Object);
x.AddSingleton(_scopedRepository.Object);
})
.UseUrls(_url)
.UseKestrel()
.UseContentRoot(Directory.GetCurrentDirectory())
.UseIISIntegration()
.UseUrls(_url)
.Configure(app =>
{
app.UseResponderMiddleware();
});
_server = new TestServer(builder);
_client = _server.CreateClient();
GivenTheTestServerIsConfigured();
}
[Fact]
public void should_not_return_any_errors()
public void PipelineErrors()
{
this.Given(x => x.GivenTheHttpResponseMessageIs(new HttpResponseMessage()))
var responseMessage = new HttpResponseMessage(System.Net.HttpStatusCode.Continue);
this.Given(x => x.GivenTheIncomingHttpResponseMessageIs(new HttpResponseMessage()))
.And(x => x.GivenThereArePipelineErrors())
.And(x => x.GivenTheErrorWillBeMappedToAnHttpStatus())
.When(x => x.WhenICallTheMiddleware())
.Then(x => x.ThenThereAreErrors())
.BDDfy();
}
[Fact]
public void NoPipelineErrors()
{
this.Given(x => x.GivenTheIncomingHttpResponseMessageIs(new HttpResponseMessage()))
.And(x => x.GivenThereAreNoPipelineErrors())
.When(x => x.WhenICallTheMiddleware())
.Then(x => x.ThenThereAreNoErrors())
.BDDfy();
}
protected override void GivenTheTestServerServicesAreConfigured(IServiceCollection services)
{
services.AddSingleton<IOcelotLoggerFactory, AspDotNetLoggerFactory>();
services.AddLogging();
services.AddSingleton(_codeMapper.Object);
services.AddSingleton(_responder);
services.AddSingleton(_scopedRepository.Object);
}
protected override void GivenTheTestServerPipelineIsConfigured(IApplicationBuilder app)
{
app.UseResponderMiddleware();
app.Run(SetControllerResponse);
}
private async Task SetControllerResponse(HttpContext context)
{
_httpStatusFromController = HttpStatusCode.OK;
_contentFromController = "test response";
context.Response.StatusCode = (int)_httpStatusFromController;
await context.Response.WriteAsync(_contentFromController);
}
private void GivenThereAreNoPipelineErrors()
{
GivenThereArePipelineErrors(new List<Error>());
}
private void GivenThereArePipelineErrors()
{
GivenThereArePipelineErrors(new List<Error>() { new AnyError() });
}
private void GivenThereArePipelineErrors(List<Error> pipelineErrors)
{
_pipelineErrors = pipelineErrors;
_scopedRepository
.Setup(x => x.Get<bool>(It.IsAny<string>()))
.Returns(new OkResponse<bool>(false));
.Setup(x => x.Get<bool>("OcelotMiddlewareError"))
.Returns(new OkResponse<bool>(_pipelineErrors.Count != 0));
_scopedRepository
.Setup(sr => sr.Get<List<Error>>("OcelotMiddlewareErrors"))
.Returns(new OkResponse<List<Error>>(_pipelineErrors));
}
private void ThenThereAreNoErrors()
{
//todo a better assert?
}
private void WhenICallTheMiddleware()
{
_result = _client.GetAsync(_url).Result;
}
private void GivenTheHttpResponseMessageIs(HttpResponseMessage response)
private void GivenTheIncomingHttpResponseMessageIs(HttpResponseMessage response)
{
_response = new OkResponse<HttpResponseMessage>(response);
_scopedRepository
@ -92,10 +119,21 @@ namespace Ocelot.UnitTests.Responder
.Returns(_response);
}
public void Dispose()
private void GivenTheErrorWillBeMappedToAnHttpStatus()
{
_client.Dispose();
_server.Dispose();
_codeMapper.Setup(cm => cm.Map(_pipelineErrors))
.Returns((int)HttpStatusCode.InternalServerError);
}
private void ThenThereAreNoErrors()
{
ResponseMessage.StatusCode.ShouldBe(_httpStatusFromController);
ResponseMessage.Content.ReadAsStringAsync().Result.ShouldBe(_contentFromController);
}
private void ThenThereAreErrors()
{
ResponseMessage.StatusCode.ShouldBe(System.Net.HttpStatusCode.BadRequest);
}
}
}