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

reorganised project so its a bit more vertical for features

Browse Source
This commit is contained in:
TomPallister
2016-10-18 18:52:43 +01:00
parent 2e6640c6ef
commit f79b76b414
77 changed files with 324 additions and 298 deletions
Download Patch File Download Diff File Expand all files Collapse all files

153
test/Ocelot.UnitTests/RequestBuilder/AddHeadersToRequestTests.cs
View File

@ -1,153 +0,0 @@
using System.Collections.Generic;
using System.Linq;
using System.Security.Claims;
using Microsoft.AspNetCore.Http;
using Microsoft.Extensions.Primitives;
using Moq;
using Ocelot.Library.Configuration;
using Ocelot.Library.Errors;
using Ocelot.Library.RequestBuilder;
using Ocelot.Library.Responses;
using Shouldly;
using TestStack.BDDfy;
using Xunit;
namespace Ocelot.UnitTests.RequestBuilder
{
public class AddHeadersToRequestTests
{
private readonly AddHeadersToRequest _addHeadersToRequest;
private readonly Mock<IClaimsParser> _parser;
private List<ClaimToHeader> _configuration;
private HttpContext _context;
private Response _result;
private Response<string> _claimValue;
public AddHeadersToRequestTests()
{
_parser = new Mock<IClaimsParser>();
_addHeadersToRequest = new AddHeadersToRequest(_parser.Object);
}
[Fact]
public void should_add_headers_to_context()
{
var context = new DefaultHttpContext
{
User = new ClaimsPrincipal(new ClaimsIdentity(new List<Claim>
{
new Claim("test", "data")
}))
};
this.Given(
x => x.GivenConfigurationHeaderExtractorProperties(new List<ClaimToHeader>
{
new ClaimToHeader("header-key", "", "", 0)
}))
.Given(x => x.GivenHttpContext(context))
.And(x => x.GivenTheClaimParserReturns(new OkResponse<string>("value")))
.When(x => x.WhenIAddHeadersToTheRequest())
.Then(x => x.ThenTheResultIsSuccess())
.And(x => x.ThenTheHeaderIsAdded())
.BDDfy();
}
[Fact]
public void if_header_exists_should_replace_it()
{
var context = new DefaultHttpContext
{
User = new ClaimsPrincipal(new ClaimsIdentity(new List<Claim>
{
new Claim("test", "data")
})),
};
context.Request.Headers.Add("header-key", new StringValues("initial"));
this.Given(
x => x.GivenConfigurationHeaderExtractorProperties(new List<ClaimToHeader>
{
new ClaimToHeader("header-key", "", "", 0)
}))
.Given(x => x.GivenHttpContext(context))
.And(x => x.GivenTheClaimParserReturns(new OkResponse<string>("value")))
.When(x => x.WhenIAddHeadersToTheRequest())
.Then(x => x.ThenTheResultIsSuccess())
.And(x => x.ThenTheHeaderIsAdded())
.BDDfy();
}
[Fact]
public void should_return_error()
{
this.Given(
x => x.GivenConfigurationHeaderExtractorProperties(new List<ClaimToHeader>
{
new ClaimToHeader("", "", "", 0)
}))
.Given(x => x.GivenHttpContext(new DefaultHttpContext()))
.And(x => x.GivenTheClaimParserReturns(new ErrorResponse<string>(new List<Error>
{
new AnyError()
})))
.When(x => x.WhenIAddHeadersToTheRequest())
.Then(x => x.ThenTheResultIsError())
.BDDfy();
}
private void ThenTheHeaderIsAdded()
{
var header = _context.Request.Headers.First(x => x.Key == "header-key");
header.Value.First().ShouldBe(_claimValue.Data);
}
private void GivenConfigurationHeaderExtractorProperties(List<ClaimToHeader> configuration)
{
_configuration = configuration;
}
private void GivenHttpContext(HttpContext context)
{
_context = context;
}
private void GivenTheClaimParserReturns(Response<string> claimValue)
{
_claimValue = claimValue;
_parser
.Setup(
x =>
x.GetValue(It.IsAny<IEnumerable<Claim>>(),
It.IsAny<string>(),
It.IsAny<string>(),
It.IsAny<int>()))
.Returns(_claimValue);
}
private void WhenIAddHeadersToTheRequest()
{
_result = _addHeadersToRequest.SetHeadersOnContext(_configuration, _context);
}
private void ThenTheResultIsSuccess()
{
_result.IsError.ShouldBe(false);
}
private void ThenTheResultIsError()
{
_result.IsError.ShouldBe(true);
}
class AnyError : Error
{
public AnyError()
: base("blahh", OcelotErrorCode.UnknownError)
{
}
}
}
}

123
test/Ocelot.UnitTests/RequestBuilder/ClaimParserTests.cs
View File

@ -1,123 +0,0 @@
using System.Collections.Generic;
using System.Security.Claims;
using Ocelot.Library.Errors;
using Ocelot.Library.RequestBuilder;
using Ocelot.Library.Responses;
using Shouldly;
using TestStack.BDDfy;
using Xunit;
namespace Ocelot.UnitTests.RequestBuilder
{
public class ClaimParserTests
{
private readonly IClaimsParser _claimsParser;
private readonly List<Claim> _claims;
private string _key;
private Response<string> _result;
private string _delimiter;
private int _index;
public ClaimParserTests()
{
_claims = new List<Claim>();
_claimsParser = new Library.RequestBuilder.ClaimsParser();
}
[Fact]
public void can_parse_claims_dictionary_access_string_returning_value_to_function()
{
this.Given(x => x.GivenAClaimOf(new Claim("CustomerId", "1234")))
.And(x => x.GivenTheKeyIs("CustomerId"))
.When(x => x.WhenICallTheParser())
.Then(x => x.ThenTheResultIs(new OkResponse<string>("1234")))
.BDDfy();
}
[Fact]
public void should_return_error_response_when_cannot_find_requested_claim()
{
this.Given(x => x.GivenAClaimOf(new Claim("BallsId", "1234")))
.And(x => x.GivenTheKeyIs("CustomerId"))
.When(x => x.WhenICallTheParser())
.Then(x => x.ThenTheResultIs(new ErrorResponse<string>(new List<Error>
{
new CannotFindClaimError($"Cannot find claim for key: {_key}")
})))
.BDDfy();
}
[Fact]
public void can_parse_claims_dictionary_access_string_using_delimiter_and_retuning_at_correct_index()
{
this.Given(x => x.GivenAClaimOf(new Claim("Subject", "registered|4321")))
.And(x => x.GivenTheDelimiterIs("|"))
.And(x => x.GivenTheIndexIs(1))
.And(x => x.GivenTheKeyIs("Subject"))
.When(x => x.WhenICallTheParser())
.Then(x => x.ThenTheResultIs(new OkResponse<string>("4321")))
.BDDfy();
}
[Fact]
public void should_return_error_response_if_index_too_large()
{
this.Given(x => x.GivenAClaimOf(new Claim("Subject", "registered|4321")))
.And(x => x.GivenTheDelimiterIs("|"))
.And(x => x.GivenTheIndexIs(24))
.And(x => x.GivenTheKeyIs("Subject"))
.When(x => x.WhenICallTheParser())
.Then(x => x.ThenTheResultIs(new ErrorResponse<string>(new List<Error>
{
new CannotFindClaimError($"Cannot find claim for key: {_key}, delimiter: {_delimiter}, index: {_index}")
})))
.BDDfy();
}
[Fact]
public void should_return_error_response_if_index_too_small()
{
this.Given(x => x.GivenAClaimOf(new Claim("Subject", "registered|4321")))
.And(x => x.GivenTheDelimiterIs("|"))
.And(x => x.GivenTheIndexIs(-1))
.And(x => x.GivenTheKeyIs("Subject"))
.When(x => x.WhenICallTheParser())
.Then(x => x.ThenTheResultIs(new ErrorResponse<string>(new List<Error>
{
new CannotFindClaimError($"Cannot find claim for key: {_key}, delimiter: {_delimiter}, index: {_index}")
})))
.BDDfy();
}
private void GivenTheIndexIs(int index)
{
_index = index;
}
private void GivenTheDelimiterIs(string delimiter)
{
_delimiter = delimiter;
}
private void GivenAClaimOf(Claim claim)
{
_claims.Add(claim);
}
private void GivenTheKeyIs(string key)
{
_key = key;
}
private void WhenICallTheParser()
{
_result = _claimsParser.GetValue(_claims, _key, _delimiter, _index);
}
private void ThenTheResultIs(Response<string> expected)
{
_result.Data.ShouldBe(expected.Data);
_result.IsError.ShouldBe(expected.IsError);
}
}
}

118
test/Ocelot.UnitTests/RequestBuilder/ConfigurationHeadersExtractorTests.cs
View File

@ -1,118 +0,0 @@
using System.Collections.Generic;
using System.Linq;
using Ocelot.Library.Configuration;
using Ocelot.Library.Configuration.Parser;
using Ocelot.Library.Errors;
using Ocelot.Library.RequestBuilder;
using Ocelot.Library.Responses;
using Shouldly;
using TestStack.BDDfy;
using Xunit;
namespace Ocelot.UnitTests.RequestBuilder
{
public class ConfigurationHeadersExtractorTests
{
private Dictionary<string, string> _dictionary;
private readonly IClaimToHeaderConfigurationParser _claimToHeaderConfigurationParser;
private Response<ClaimToHeader> _result;
public ConfigurationHeadersExtractorTests()
{
_claimToHeaderConfigurationParser = new ClaimToHeaderConfigurationParser();
}
[Fact]
public void returns_no_instructions_error()
{
this.Given(x => x.GivenTheDictionaryIs(new Dictionary<string, string>()
{
{"CustomerId", ""},
}))
.When(x => x.WhenICallTheExtractor())
.Then(
x =>
x.ThenAnErrorIsReturned(new ErrorResponse<ClaimToHeader>(
new List<Error>
{
new NoInstructionsError(">")
})))
.BDDfy();
}
[Fact]
public void returns_no_instructions_not_for_claims_error()
{
this.Given(x => x.GivenTheDictionaryIs(new Dictionary<string, string>()
{
{"CustomerId", "Cheese[CustomerId] > value"},
}))
.When(x => x.WhenICallTheExtractor())
.Then(
x =>
x.ThenAnErrorIsReturned(new ErrorResponse<ClaimToHeader>(
new List<Error>
{
new InstructionNotForClaimsError()
})))
.BDDfy();
}
[Fact]
public void can_parse_entry_to_work_out_properties_with_key()
{
this.Given(x => x.GivenTheDictionaryIs(new Dictionary<string, string>()
{
{"CustomerId", "Claims[CustomerId] > value"},
}))
.When(x => x.WhenICallTheExtractor())
.Then(
x =>
x.ThenTheClaimParserPropertiesAreReturned(
new OkResponse<ClaimToHeader>(
new ClaimToHeader("CustomerId", "CustomerId", "", 0))))
.BDDfy();
}
[Fact]
public void can_parse_entry_to_work_out_properties_with_key_delimiter_and_index()
{
this.Given(x => x.GivenTheDictionaryIs(new Dictionary<string, string>()
{
{"UserId", "Claims[Subject] > value[0] > |"},
}))
.When(x => x.WhenICallTheExtractor())
.Then(
x =>
x.ThenTheClaimParserPropertiesAreReturned(
new OkResponse<ClaimToHeader>(
new ClaimToHeader("UserId", "Subject", "|", 0))))
.BDDfy();
}
private void ThenAnErrorIsReturned(Response<ClaimToHeader> expected)
{
_result.IsError.ShouldBe(expected.IsError);
_result.Errors[0].ShouldBeOfType(expected.Errors[0].GetType());
}
private void ThenTheClaimParserPropertiesAreReturned(Response<ClaimToHeader> expected)
{
_result.Data.ClaimKey.ShouldBe(expected.Data.ClaimKey);
_result.Data.Delimiter.ShouldBe(expected.Data.Delimiter);
_result.Data.Index.ShouldBe(expected.Data.Index);
_result.IsError.ShouldBe(expected.IsError);
}
private void WhenICallTheExtractor()
{
var first = _dictionary.First();
_result = _claimToHeaderConfigurationParser.Extract(first.Key, first.Value);
}
private void GivenTheDictionaryIs(Dictionary<string, string> dictionary)
{
_dictionary = dictionary;
}
}
}

101
test/Ocelot.UnitTests/RequestBuilder/HttpRequestBuilderMiddlewareTests.cs Normal file
View File

@ -0,0 +1,101 @@
using System;
using System.IO;
using System.Net;
using System.Net.Http;
using Microsoft.AspNetCore.Hosting;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.TestHost;
using Microsoft.Extensions.DependencyInjection;
using Moq;
using Ocelot.Library.RequestBuilder;
using Ocelot.Library.RequestBuilder.Builder;
using Ocelot.Library.RequestBuilder.Middleware;
using Ocelot.Library.Responses;
using Ocelot.Library.ScopedData;
using TestStack.BDDfy;
using Xunit;
namespace Ocelot.UnitTests.RequestBuilder
{
public class HttpRequestBuilderMiddlewareTests : IDisposable
{
private readonly Mock<IRequestBuilder> _requestBuilder;
private readonly Mock<IScopedRequestDataRepository> _scopedRepository;
private readonly string _url;
private readonly TestServer _server;
private readonly HttpClient _client;
private HttpResponseMessage _result;
private OkResponse<Request> _request;
private OkResponse<string> _downstreamUrl;
public HttpRequestBuilderMiddlewareTests()
{
_url = "http://localhost:51879";
_requestBuilder = new Mock<IRequestBuilder>();
_scopedRepository = new Mock<IScopedRequestDataRepository>();
var builder = new WebHostBuilder()
.ConfigureServices(x =>
{
x.AddSingleton(_requestBuilder.Object);
x.AddSingleton(_scopedRepository.Object);
})
.UseUrls(_url)
.UseKestrel()
.UseContentRoot(Directory.GetCurrentDirectory())
.UseIISIntegration()
.UseUrls(_url)
.Configure(app =>
{
app.UseHttpRequestBuilderMiddleware();
});
_server = new TestServer(builder);
_client = _server.CreateClient();
}
[Fact]
public void happy_path()
{
this.Given(x => x.GivenTheDownStreamUrlIs("any old string"))
.And(x => x.GivenTheRequestBuilderReturns(new Request(new HttpRequestMessage(), new CookieContainer())))
.When(x => x.WhenICallTheMiddleware())
.Then(x => x.ThenTheScopedDataRepositoryIsCalledCorrectly())
.BDDfy();
}
private void GivenTheRequestBuilderReturns(Request request)
{
_request = new OkResponse<Request>(request);
_requestBuilder
.Setup(x => x.Build(It.IsAny<string>(), It.IsAny<string>(), It.IsAny<Stream>(), It.IsAny<IHeaderDictionary>(),
It.IsAny<IRequestCookieCollection>(), It.IsAny<string>(), It.IsAny<string>()))
.ReturnsAsync(_request);
}
private void ThenTheScopedDataRepositoryIsCalledCorrectly()
{
_scopedRepository
.Verify(x => x.Add("Request", _request.Data), Times.Once());
}
private void WhenICallTheMiddleware()
{
_result = _client.GetAsync(_url).Result;
}
private void GivenTheDownStreamUrlIs(string downstreamUrl)
{
_downstreamUrl = new OkResponse<string>(downstreamUrl);
_scopedRepository
.Setup(x => x.Get<string>(It.IsAny<string>()))
.Returns(_downstreamUrl);
}
public void Dispose()
{
_client.Dispose();
_server.Dispose();
}
}
}

1
test/Ocelot.UnitTests/RequestBuilder/RequestBuilderTests.cs
View File

@ -5,6 +5,7 @@ using System.Net;
using System.Net.Http;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Http.Internal;
using Ocelot.Library.RequestBuilder.Builder;
using Shouldly;
using TestStack.BDDfy;
using Xunit;