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

Back out of some of the functional changes to the ResponderMiddleware tests... I'll look at these again once the consolidation changes are merged.

Browse Source
This commit is contained in:
Philip Wood
2017-07-18 11:11:24 +01:00
parent d02e921a58
commit ca4efa5e10
2 changed files with 11 additions and 216 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -1,62 +1,34 @@
namespace Ocelot.UnitTests.Responder
{
using System.Net.Http;
using System.Threading.Tasks;
using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.DependencyInjection;
using Moq;
using Ocelot.Errors;
using Ocelot.Headers;
using Ocelot.Logging;
using Ocelot.Responder;
using Ocelot.Responder.Middleware;
using Ocelot.Responses;
using Shouldly;
using System.Collections.Generic;
using System.Net;
using TestStack.BDDfy;
using Xunit;
public class ResponderMiddlewareTests : ServerHostedMiddlewareTest
{
private readonly IHttpResponder _responder;
private readonly Mock<IHttpResponder> _responder;
private readonly Mock<IErrorsToHttpStatusCodeMapper> _codeMapper;
private readonly Mock<IRemoveOutputHeaders> _outputHeaderRemover;
private HttpStatusCode _httpStatusFromController;
private string _contentFromController;
private OkResponse<HttpResponseMessage> _response;
private List<Error> _pipelineErrors;
public ResponderMiddlewareTests()
{
_outputHeaderRemover = new Mock<IRemoveOutputHeaders>();
_responder = new Mock<IHttpResponder>();
_codeMapper = new Mock<IErrorsToHttpStatusCodeMapper>();
_responder = new HttpContextResponder(_outputHeaderRemover.Object);
GivenTheTestServerIsConfigured();
}
[Fact]
public void PipelineErrors()
public void should_not_return_any_errors()
{
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()))
this.Given(x => x.GivenTheHttpResponseMessageIs(new HttpResponseMessage()))
.And(x => x.GivenThereAreNoPipelineErrors())
.When(x => x.WhenICallTheMiddleware())
.Then(x => x.ThenThereAreNoErrors())
@ -68,48 +40,16 @@
services.AddSingleton<IOcelotLoggerFactory, AspDotNetLoggerFactory>();
services.AddLogging();
services.AddSingleton(_codeMapper.Object);
services.AddSingleton(_responder);
services.AddSingleton(_responder.Object);
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>("OcelotMiddlewareError"))
.Returns(new OkResponse<bool>(_pipelineErrors.Count != 0));
ScopedRepository
.Setup(sr => sr.Get<List<Error>>("OcelotMiddlewareErrors"))
.Returns(new OkResponse<List<Error>>(_pipelineErrors));
}
private void GivenTheIncomingHttpResponseMessageIs(HttpResponseMessage response)
private void GivenTheHttpResponseMessageIs(HttpResponseMessage response)
{
_response = new OkResponse<HttpResponseMessage>(response);
ScopedRepository
@ -117,21 +57,16 @@
.Returns(_response);
}
private void GivenTheErrorWillBeMappedToAnHttpStatus()
private void GivenThereAreNoPipelineErrors()
{
_codeMapper.Setup(cm => cm.Map(_pipelineErrors))
.Returns((int)HttpStatusCode.InternalServerError);
ScopedRepository
.Setup(x => x.Get<bool>(It.IsAny<string>()))
.Returns(new OkResponse<bool>(false));
}
private void ThenThereAreNoErrors()
{
ResponseMessage.StatusCode.ShouldBe(_httpStatusFromController);
ResponseMessage.Content.ReadAsStringAsync().Result.ShouldBe(_contentFromController);
}
private void ThenThereAreErrors()
{
ResponseMessage.StatusCode.ShouldBe(System.Net.HttpStatusCode.BadRequest);
//todo a better assert?
}
}
}