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

Feature/issue with path and query string #458 (#565)

Browse Source 
* #548 added failing test

* #548 fixed failing tests for issue where using /{everything} didnt build path correctly
This commit is contained in:
Tom Pallister 2018-08-20 22:28:58 +01:00 committed by GitHub
parent 7e01caf550
commit 00a600064d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
5 changed files with 616 additions and 509 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

300
src/Ocelot/DownstreamRouteFinder/UrlMatcher/UrlPathPlaceholderNameAndValueFinder.cs
View File

@ -1,150 +1,150 @@
using System.Collections.Generic; using System.Collections.Generic;
using Ocelot.Responses; using Ocelot.Responses;
namespace Ocelot.DownstreamRouteFinder.UrlMatcher namespace Ocelot.DownstreamRouteFinder.UrlMatcher
{ {
public class UrlPathPlaceholderNameAndValueFinder : IPlaceholderNameAndValueFinder public class UrlPathPlaceholderNameAndValueFinder : IPlaceholderNameAndValueFinder
{ {
public Response<List<PlaceholderNameAndValue>> Find(string path, string query, string pathTemplate) public Response<List<PlaceholderNameAndValue>> Find(string path, string query, string pathTemplate)
{ {
var placeHolderNameAndValues = new List<PlaceholderNameAndValue>(); var placeHolderNameAndValues = new List<PlaceholderNameAndValue>();
path = $"{path}{query}"; path = $"{path}{query}";
int counterForPath = 0; int counterForPath = 0;
var delimiter = '/'; var delimiter = '/';
var nextDelimiter = '/'; var nextDelimiter = '/';
for (int counterForTemplate = 0; counterForTemplate < pathTemplate.Length; counterForTemplate++) for (int counterForTemplate = 0; counterForTemplate < pathTemplate.Length; counterForTemplate++)
{ {
if ((path.Length > counterForPath) && CharactersDontMatch(pathTemplate[counterForTemplate], path[counterForPath]) && ContinueScanningUrl(counterForPath,path.Length)) if ((path.Length > counterForPath) && CharactersDontMatch(pathTemplate[counterForTemplate], path[counterForPath]) && ContinueScanningUrl(counterForPath,path.Length))
{ {
if (IsPlaceholder(pathTemplate[counterForTemplate])) if (IsPlaceholder(pathTemplate[counterForTemplate]))
{ {
//should_find_multiple_query_string make test pass //should_find_multiple_query_string make test pass
if (PassedQueryString(pathTemplate, counterForTemplate)) if (PassedQueryString(pathTemplate, counterForTemplate))
{ {
delimiter = '&'; delimiter = '&';
nextDelimiter = '&'; nextDelimiter = '&';
} }
//should_find_multiple_query_string_and_path makes test pass //should_find_multiple_query_string_and_path makes test pass
if (NotPassedQueryString(pathTemplate, counterForTemplate) && NoMoreForwardSlash(pathTemplate, counterForTemplate)) if (NotPassedQueryString(pathTemplate, counterForTemplate) && NoMoreForwardSlash(pathTemplate, counterForTemplate))
{ {
delimiter = '?'; delimiter = '?';
nextDelimiter = '?'; nextDelimiter = '?';
} }
var placeholderName = GetPlaceholderName(pathTemplate, counterForTemplate); var placeholderName = GetPlaceholderName(pathTemplate, counterForTemplate);
var placeholderValue = GetPlaceholderValue(pathTemplate, query, placeholderName, path, counterForPath, delimiter); var placeholderValue = GetPlaceholderValue(pathTemplate, query, placeholderName, path, counterForPath, delimiter);
placeHolderNameAndValues.Add(new PlaceholderNameAndValue(placeholderName, placeholderValue)); placeHolderNameAndValues.Add(new PlaceholderNameAndValue(placeholderName, placeholderValue));
counterForTemplate = GetNextCounterPosition(pathTemplate, counterForTemplate, '}'); counterForTemplate = GetNextCounterPosition(pathTemplate, counterForTemplate, '}');
counterForPath = GetNextCounterPosition(path, counterForPath, nextDelimiter); counterForPath = GetNextCounterPosition(path, counterForPath, nextDelimiter);
continue; continue;
} }
return new OkResponse<List<PlaceholderNameAndValue>>(placeHolderNameAndValues); return new OkResponse<List<PlaceholderNameAndValue>>(placeHolderNameAndValues);
} }
else if(IsCatchAll(path, counterForPath, pathTemplate)) else if(IsCatchAll(path, counterForPath, pathTemplate))
{ {
var endOfPlaceholder = GetNextCounterPosition(pathTemplate, counterForTemplate, '}'); var endOfPlaceholder = GetNextCounterPosition(pathTemplate, counterForTemplate, '}');
var placeholderName = GetPlaceholderName(pathTemplate, 1); var placeholderName = GetPlaceholderName(pathTemplate, 1);
if(NothingAfterFirstForwardSlash(path)) if(NothingAfterFirstForwardSlash(path))
{ {
placeHolderNameAndValues.Add(new PlaceholderNameAndValue(placeholderName, "")); placeHolderNameAndValues.Add(new PlaceholderNameAndValue(placeholderName, ""));
} }
else else
{ {
var placeholderValue = GetPlaceholderValue(pathTemplate, query, placeholderName, path, counterForPath + 1, '/'); var placeholderValue = GetPlaceholderValue(pathTemplate, query, placeholderName, path, counterForPath + 1, '?');
placeHolderNameAndValues.Add(new PlaceholderNameAndValue(placeholderName, placeholderValue)); placeHolderNameAndValues.Add(new PlaceholderNameAndValue(placeholderName, placeholderValue));
} }
counterForTemplate = endOfPlaceholder; counterForTemplate = endOfPlaceholder;
} }
counterForPath++; counterForPath++;
} }
return new OkResponse<List<PlaceholderNameAndValue>>(placeHolderNameAndValues); return new OkResponse<List<PlaceholderNameAndValue>>(placeHolderNameAndValues);
} }
private static bool NoMoreForwardSlash(string pathTemplate, int counterForTemplate) private static bool NoMoreForwardSlash(string pathTemplate, int counterForTemplate)
{ {
return !pathTemplate.Substring(counterForTemplate).Contains("/"); return !pathTemplate.Substring(counterForTemplate).Contains("/");
} }
private static bool NotPassedQueryString(string pathTemplate, int counterForTemplate) private static bool NotPassedQueryString(string pathTemplate, int counterForTemplate)
{ {
return !pathTemplate.Substring(0, counterForTemplate).Contains("?"); return !pathTemplate.Substring(0, counterForTemplate).Contains("?");
} }
private static bool PassedQueryString(string pathTemplate, int counterForTemplate) private static bool PassedQueryString(string pathTemplate, int counterForTemplate)
{ {
return pathTemplate.Substring(0, counterForTemplate).Contains("?"); return pathTemplate.Substring(0, counterForTemplate).Contains("?");
} }
private bool IsCatchAll(string path, int counterForPath, string pathTemplate) private bool IsCatchAll(string path, int counterForPath, string pathTemplate)
{ {
return string.IsNullOrEmpty(path) || (path.Length > counterForPath && path[counterForPath] == '/') && pathTemplate.Length > 1 return string.IsNullOrEmpty(path) || (path.Length > counterForPath && path[counterForPath] == '/') && pathTemplate.Length > 1
&& pathTemplate.Substring(0, 2) == "/{" && pathTemplate.Substring(0, 2) == "/{"
&& pathTemplate.IndexOf('}') == pathTemplate.Length - 1; && pathTemplate.IndexOf('}') == pathTemplate.Length - 1;
} }
private bool NothingAfterFirstForwardSlash(string path) private bool NothingAfterFirstForwardSlash(string path)
{ {
return path.Length == 1 || path.Length == 0; return path.Length == 1 || path.Length == 0;
} }
private string GetPlaceholderValue(string urlPathTemplate, string query, string variableName, string urlPath, int counterForUrl, char delimiter) private string GetPlaceholderValue(string urlPathTemplate, string query, string variableName, string urlPath, int counterForUrl, char delimiter)
{ {
var positionOfNextSlash = urlPath.IndexOf(delimiter, counterForUrl); var positionOfNextSlash = urlPath.IndexOf(delimiter, counterForUrl);
if (positionOfNextSlash == -1 || (urlPathTemplate.Trim(delimiter).EndsWith(variableName) && string.IsNullOrEmpty(query))) if (positionOfNextSlash == -1 || (urlPathTemplate.Trim(delimiter).EndsWith(variableName) && string.IsNullOrEmpty(query)))
{ {
positionOfNextSlash = urlPath.Length; positionOfNextSlash = urlPath.Length;
} }
var variableValue = urlPath.Substring(counterForUrl, positionOfNextSlash - counterForUrl); var variableValue = urlPath.Substring(counterForUrl, positionOfNextSlash - counterForUrl);
return variableValue; return variableValue;
} }
private string GetPlaceholderName(string urlPathTemplate, int counterForTemplate) private string GetPlaceholderName(string urlPathTemplate, int counterForTemplate)
{ {
var postitionOfPlaceHolderClosingBracket = urlPathTemplate.IndexOf('}', counterForTemplate) + 1; var postitionOfPlaceHolderClosingBracket = urlPathTemplate.IndexOf('}', counterForTemplate) + 1;
var variableName = urlPathTemplate.Substring(counterForTemplate, postitionOfPlaceHolderClosingBracket - counterForTemplate); var variableName = urlPathTemplate.Substring(counterForTemplate, postitionOfPlaceHolderClosingBracket - counterForTemplate);
return variableName; return variableName;
} }
private int GetNextCounterPosition(string urlTemplate, int counterForTemplate, char delimiter) private int GetNextCounterPosition(string urlTemplate, int counterForTemplate, char delimiter)
{ {
var closingPlaceHolderPositionOnTemplate = urlTemplate.IndexOf(delimiter, counterForTemplate); var closingPlaceHolderPositionOnTemplate = urlTemplate.IndexOf(delimiter, counterForTemplate);
return closingPlaceHolderPositionOnTemplate + 1; return closingPlaceHolderPositionOnTemplate + 1;
} }
private bool CharactersDontMatch(char characterOne, char characterTwo) private bool CharactersDontMatch(char characterOne, char characterTwo)
{ {
return char.ToLower(characterOne) != char.ToLower(characterTwo); return char.ToLower(characterOne) != char.ToLower(characterTwo);
} }
private bool ContinueScanningUrl(int counterForUrl, int urlLength) private bool ContinueScanningUrl(int counterForUrl, int urlLength)
{ {
return counterForUrl < urlLength; return counterForUrl < urlLength;
} }
private bool IsPlaceholder(char character) private bool IsPlaceholder(char character)
{ {
return character == '{'; return character == '{';
} }
} }
} }

5
src/Ocelot/Responder/HttpContextResponder.cs
View File

@ -38,7 +38,10 @@ namespace Ocelot.Responder
var content = await response.Content.ReadAsStreamAsync(); var content = await response.Content.ReadAsStreamAsync();
AddHeaderIfDoesntExist(context, new Header("Content-Length", new []{ content.Length.ToString() }) ); if(response.Content.Headers.ContentLength != null)
{
AddHeaderIfDoesntExist(context, new Header("Content-Length", new []{ response.Content.Headers.ContentLength.ToString() }) );
}
context.Response.OnStarting(state => context.Response.OnStarting(state =>
{ {

35
test/Ocelot.AcceptanceTests/RoutingTests.cs
View File

@ -915,6 +915,41 @@ namespace Ocelot.AcceptanceTests
.BDDfy(); .BDDfy();
} }
[Fact]
public void should_match_multiple_paths_with_catch_all()
{
var port = 61999;
var configuration = new FileConfiguration
{
ReRoutes = new List<FileReRoute>
{
new FileReRoute
{
DownstreamPathTemplate = "/{everything}",
DownstreamScheme = "http",
UpstreamPathTemplate = "/{everything}",
UpstreamHttpMethod = new List<string> { "Get" },
DownstreamHostAndPorts = new List<FileHostAndPort>
{
new FileHostAndPort
{
Host = "localhost",
Port = port,
}
},
}
}
};
this.Given(x => x.GivenThereIsAServiceRunningOn($"http://localhost:{port}/", "/test/toot", 200, "Hello from Laura"))
.And(x => _steps.GivenThereIsAConfiguration(configuration))
.And(x => _steps.GivenOcelotIsRunning())
.When(x => _steps.WhenIGetUrlOnTheApiGateway("/test/toot"))
.Then(x => _steps.ThenTheStatusCodeShouldBe(HttpStatusCode.OK))
.And(x => _steps.ThenTheResponseBodyShouldBe("Hello from Laura"))
.BDDfy();
}
[Fact] [Fact]
public void should_fix_issue_271() public void should_fix_issue_271()
{ {

40
test/Ocelot.AcceptanceTests/RoutingWithQueryStringTests.cs
View File

@ -56,6 +56,44 @@ namespace Ocelot.AcceptanceTests
.BDDfy(); .BDDfy();
} }
[Fact]
public void should_return_response_200_with_odata_query_string()
{
var subscriptionId = Guid.NewGuid().ToString();
var unitId = Guid.NewGuid().ToString();
var port = 57359;
var configuration = new FileConfiguration
{
ReRoutes = new List<FileReRoute>
{
new FileReRoute
{
DownstreamPathTemplate = "/{everything}",
DownstreamScheme = "http",
DownstreamHostAndPorts = new List<FileHostAndPort>
{
new FileHostAndPort
{
Host = "localhost",
Port = port,
}
},
UpstreamPathTemplate = "/{everything}",
UpstreamHttpMethod = new List<string> { "Get" },
}
}
};
this.Given(x => x.GivenThereIsAServiceRunningOn($"http://localhost:{port}", $"/odata/customers", "?$filter=Name%20eq%20'Sam'", 200, "Hello from Laura"))
.And(x => _steps.GivenThereIsAConfiguration(configuration))
.And(x => _steps.GivenOcelotIsRunning())
.When(x => _steps.WhenIGetUrlOnTheApiGateway($"/odata/customers?$filter=Name eq 'Sam' "))
.Then(x => _steps.ThenTheStatusCodeShouldBe(HttpStatusCode.OK))
.And(x => _steps.ThenTheResponseBodyShouldBe("Hello from Laura"))
.BDDfy();
}
[Fact] [Fact]
public void should_return_response_200_with_query_string_upstream_template() public void should_return_response_200_with_query_string_upstream_template()
{ {
@ -206,7 +244,7 @@ namespace Ocelot.AcceptanceTests
{ {
_serviceHandler.GivenThereIsAServiceRunningOn(baseUrl, basePath, async context => _serviceHandler.GivenThereIsAServiceRunningOn(baseUrl, basePath, async context =>
{ {
if (context.Request.PathBase.Value != basePath || context.Request.QueryString.Value != queryString) if ((context.Request.PathBase.Value != basePath) || context.Request.QueryString.Value != queryString)
{ {
context.Response.StatusCode = 500; context.Response.StatusCode = 500;
await context.Response.WriteAsync("downstream path didnt match base path"); await context.Response.WriteAsync("downstream path didnt match base path");

745
test/Ocelot.UnitTests/DownstreamRouteFinder/UrlMatcher/UrlPathPlaceholderNameAndValueFinderTests.cs
View File

@ -1,357 +1,388 @@
using System.Collections.Generic; using System.Collections.Generic;
using System.Linq; using System.Linq;
using Ocelot.DownstreamRouteFinder.UrlMatcher; using Ocelot.DownstreamRouteFinder.UrlMatcher;
using Ocelot.Responses; using Ocelot.Responses;
using Shouldly; using Shouldly;
using TestStack.BDDfy; using TestStack.BDDfy;
using Xunit; using Xunit;
namespace Ocelot.UnitTests.DownstreamRouteFinder.UrlMatcher namespace Ocelot.UnitTests.DownstreamRouteFinder.UrlMatcher
{ {
public class UrlPathPlaceholderNameAndValueFinderTests public class UrlPathPlaceholderNameAndValueFinderTests
{ {
private readonly IPlaceholderNameAndValueFinder _finder; private readonly IPlaceholderNameAndValueFinder _finder;
private string _downstreamUrlPath; private string _downstreamUrlPath;
private string _downstreamPathTemplate; private string _downstreamPathTemplate;
private Response<List<PlaceholderNameAndValue>> _result; private Response<List<PlaceholderNameAndValue>> _result;
private string _query; private string _query;
public UrlPathPlaceholderNameAndValueFinderTests() public UrlPathPlaceholderNameAndValueFinderTests()
{ {
_finder = new UrlPathPlaceholderNameAndValueFinder(); _finder = new UrlPathPlaceholderNameAndValueFinder();
} }
[Fact] [Fact]
public void can_match_down_stream_url() public void can_match_down_stream_url()
{ {
this.Given(x => x.GivenIHaveAUpstreamPath("")) this.Given(x => x.GivenIHaveAUpstreamPath(""))
.And(x => x.GivenIHaveAnUpstreamUrlTemplate("")) .And(x => x.GivenIHaveAnUpstreamUrlTemplate(""))
.When(x => x.WhenIFindTheUrlVariableNamesAndValues()) .When(x => x.WhenIFindTheUrlVariableNamesAndValues())
.And(x => x.ThenTheTemplatesVariablesAre(new List<PlaceholderNameAndValue>())) .And(x => x.ThenTheTemplatesVariablesAre(new List<PlaceholderNameAndValue>()))
.BDDfy(); .BDDfy();
} }
[Fact] [Fact]
public void can_match_down_stream_url_with_nothing_then_placeholder_no_value_is_blank() public void can_match_down_stream_url_with_nothing_then_placeholder_no_value_is_blank()
{ {
var expectedTemplates = new List<PlaceholderNameAndValue> var expectedTemplates = new List<PlaceholderNameAndValue>
{ {
new PlaceholderNameAndValue("{url}", "") new PlaceholderNameAndValue("{url}", "")
}; };
this.Given(x => x.GivenIHaveAUpstreamPath("")) this.Given(x => x.GivenIHaveAUpstreamPath(""))
.And(x => x.GivenIHaveAnUpstreamUrlTemplate("/{url}")) .And(x => x.GivenIHaveAnUpstreamUrlTemplate("/{url}"))
.When(x => x.WhenIFindTheUrlVariableNamesAndValues()) .When(x => x.WhenIFindTheUrlVariableNamesAndValues())
.And(x => x.ThenTheTemplatesVariablesAre(expectedTemplates)) .And(x => x.ThenTheTemplatesVariablesAre(expectedTemplates))
.BDDfy(); .BDDfy();
} }
[Fact] [Fact]
public void can_match_down_stream_url_with_nothing_then_placeholder_value_is_test() public void can_match_down_stream_url_with_nothing_then_placeholder_value_is_test()
{ {
var expectedTemplates = new List<PlaceholderNameAndValue> var expectedTemplates = new List<PlaceholderNameAndValue>
{ {
new PlaceholderNameAndValue("{url}", "test") new PlaceholderNameAndValue("{url}", "test")
}; };
this.Given(x => x.GivenIHaveAUpstreamPath("/test")) this.Given(x => x.GivenIHaveAUpstreamPath("/test"))
.And(x => x.GivenIHaveAnUpstreamUrlTemplate("/{url}")) .And(x => x.GivenIHaveAnUpstreamUrlTemplate("/{url}"))
.When(x => x.WhenIFindTheUrlVariableNamesAndValues()) .When(x => x.WhenIFindTheUrlVariableNamesAndValues())
.And(x => x.ThenTheTemplatesVariablesAre(expectedTemplates)) .And(x => x.ThenTheTemplatesVariablesAre(expectedTemplates))
.BDDfy(); .BDDfy();
} }
[Fact] [Fact]
public void can_match_down_stream_url_with_forward_slash_then_placeholder_no_value_is_blank() public void should_match_everything_in_path_with_query()
{ {
var expectedTemplates = new List<PlaceholderNameAndValue> var expectedTemplates = new List<PlaceholderNameAndValue>
{ {
new PlaceholderNameAndValue("{url}", "") new PlaceholderNameAndValue("{everything}", "test/toot")
}; };
this.Given(x => x.GivenIHaveAUpstreamPath("/")) this.Given(x => x.GivenIHaveAUpstreamPath("/test/toot"))
.And(x => x.GivenIHaveAnUpstreamUrlTemplate("/{url}")) .And(x => GivenIHaveAQuery("?$filter=Name%20eq%20'Sam'"))
.When(x => x.WhenIFindTheUrlVariableNamesAndValues()) .And(x => x.GivenIHaveAnUpstreamUrlTemplate("/{everything}"))
.And(x => x.ThenTheTemplatesVariablesAre(expectedTemplates)) .When(x => x.WhenIFindTheUrlVariableNamesAndValues())
.BDDfy(); .And(x => x.ThenTheTemplatesVariablesAre(expectedTemplates))
} .BDDfy();
}
[Fact]
public void can_match_down_stream_url_with_forward_slash() [Fact]
{ public void should_match_everything_in_path()
var expectedTemplates = new List<PlaceholderNameAndValue> {
{ var expectedTemplates = new List<PlaceholderNameAndValue>
}; {
new PlaceholderNameAndValue("{everything}", "test/toot")
this.Given(x => x.GivenIHaveAUpstreamPath("/")) };
.And(x => x.GivenIHaveAnUpstreamUrlTemplate("/"))
.When(x => x.WhenIFindTheUrlVariableNamesAndValues()) this.Given(x => x.GivenIHaveAUpstreamPath("/test/toot"))
.And(x => x.ThenTheTemplatesVariablesAre(expectedTemplates)) .And(x => x.GivenIHaveAnUpstreamUrlTemplate("/{everything}"))
.BDDfy(); .When(x => x.WhenIFindTheUrlVariableNamesAndValues())
} .And(x => x.ThenTheTemplatesVariablesAre(expectedTemplates))
.BDDfy();
[Fact] }
public void can_match_down_stream_url_with_forward_slash_then_placeholder_then_another_value()
{ [Fact]
var expectedTemplates = new List<PlaceholderNameAndValue> public void can_match_down_stream_url_with_forward_slash_then_placeholder_no_value_is_blank()
{ {
new PlaceholderNameAndValue("{url}", "1") var expectedTemplates = new List<PlaceholderNameAndValue>
}; {
new PlaceholderNameAndValue("{url}", "")
this.Given(x => x.GivenIHaveAUpstreamPath("/1/products")) };
.And(x => x.GivenIHaveAnUpstreamUrlTemplate("/{url}/products"))
.When(x => x.WhenIFindTheUrlVariableNamesAndValues()) this.Given(x => x.GivenIHaveAUpstreamPath("/"))
.And(x => x.ThenTheTemplatesVariablesAre(expectedTemplates)) .And(x => x.GivenIHaveAnUpstreamUrlTemplate("/{url}"))
.BDDfy(); .When(x => x.WhenIFindTheUrlVariableNamesAndValues())
} .And(x => x.ThenTheTemplatesVariablesAre(expectedTemplates))
.BDDfy();
[Fact] }
public void should_not_find_anything()
{ [Fact]
this.Given(x => x.GivenIHaveAUpstreamPath("/products")) public void can_match_down_stream_url_with_forward_slash()
.And(x => x.GivenIHaveAnUpstreamUrlTemplate("/products/")) {
.When(x => x.WhenIFindTheUrlVariableNamesAndValues()) var expectedTemplates = new List<PlaceholderNameAndValue>
.And(x => x.ThenTheTemplatesVariablesAre(new List<PlaceholderNameAndValue>())) {
.BDDfy(); };
}
this.Given(x => x.GivenIHaveAUpstreamPath("/"))
[Fact] .And(x => x.GivenIHaveAnUpstreamUrlTemplate("/"))
public void should_find_query_string() .When(x => x.WhenIFindTheUrlVariableNamesAndValues())
{ .And(x => x.ThenTheTemplatesVariablesAre(expectedTemplates))
var expectedTemplates = new List<PlaceholderNameAndValue> .BDDfy();
{ }
new PlaceholderNameAndValue("{productId}", "1")
}; [Fact]
public void can_match_down_stream_url_with_forward_slash_then_placeholder_then_another_value()
this.Given(x => x.GivenIHaveAUpstreamPath("/products")) {
.And(x => x.GivenIHaveAQuery("?productId=1")) var expectedTemplates = new List<PlaceholderNameAndValue>
.And(x => x.GivenIHaveAnUpstreamUrlTemplate("/products?productId={productId}")) {
.When(x => x.WhenIFindTheUrlVariableNamesAndValues()) new PlaceholderNameAndValue("{url}", "1")
.And(x => x.ThenTheTemplatesVariablesAre(expectedTemplates)) };
.BDDfy();
} this.Given(x => x.GivenIHaveAUpstreamPath("/1/products"))
.And(x => x.GivenIHaveAnUpstreamUrlTemplate("/{url}/products"))
[Fact] .When(x => x.WhenIFindTheUrlVariableNamesAndValues())
public void should_find_query_string_dont_include_hardcoded() .And(x => x.ThenTheTemplatesVariablesAre(expectedTemplates))
{ .BDDfy();
var expectedTemplates = new List<PlaceholderNameAndValue> }
{
new PlaceholderNameAndValue("{productId}", "1") [Fact]
}; public void should_not_find_anything()
{
this.Given(x => x.GivenIHaveAUpstreamPath("/products")) this.Given(x => x.GivenIHaveAUpstreamPath("/products"))
.And(x => x.GivenIHaveAQuery("?productId=1&categoryId=2")) .And(x => x.GivenIHaveAnUpstreamUrlTemplate("/products/"))
.And(x => x.GivenIHaveAnUpstreamUrlTemplate("/products?productId={productId}")) .When(x => x.WhenIFindTheUrlVariableNamesAndValues())
.When(x => x.WhenIFindTheUrlVariableNamesAndValues()) .And(x => x.ThenTheTemplatesVariablesAre(new List<PlaceholderNameAndValue>()))
.And(x => x.ThenTheTemplatesVariablesAre(expectedTemplates)) .BDDfy();
.BDDfy(); }
}
[Fact]
[Fact] public void should_find_query_string()
public void should_find_multiple_query_string() {
{ var expectedTemplates = new List<PlaceholderNameAndValue>
var expectedTemplates = new List<PlaceholderNameAndValue> {
{ new PlaceholderNameAndValue("{productId}", "1")
new PlaceholderNameAndValue("{productId}", "1"), };
new PlaceholderNameAndValue("{categoryId}", "2")
}; this.Given(x => x.GivenIHaveAUpstreamPath("/products"))
.And(x => x.GivenIHaveAQuery("?productId=1"))
this.Given(x => x.GivenIHaveAUpstreamPath("/products")) .And(x => x.GivenIHaveAnUpstreamUrlTemplate("/products?productId={productId}"))
.And(x => x.GivenIHaveAQuery("?productId=1&categoryId=2")) .When(x => x.WhenIFindTheUrlVariableNamesAndValues())
.And(x => x.GivenIHaveAnUpstreamUrlTemplate("/products?productId={productId}&categoryId={categoryId}")) .And(x => x.ThenTheTemplatesVariablesAre(expectedTemplates))
.When(x => x.WhenIFindTheUrlVariableNamesAndValues()) .BDDfy();
.And(x => x.ThenTheTemplatesVariablesAre(expectedTemplates)) }
.BDDfy();
} [Fact]
public void should_find_query_string_dont_include_hardcoded()
[Fact] {
public void should_find_multiple_query_string_and_path() var expectedTemplates = new List<PlaceholderNameAndValue>
{ {
var expectedTemplates = new List<PlaceholderNameAndValue> new PlaceholderNameAndValue("{productId}", "1")
{ };
new PlaceholderNameAndValue("{productId}", "1"),
new PlaceholderNameAndValue("{categoryId}", "2"), this.Given(x => x.GivenIHaveAUpstreamPath("/products"))
new PlaceholderNameAndValue("{account}", "3") .And(x => x.GivenIHaveAQuery("?productId=1&categoryId=2"))
}; .And(x => x.GivenIHaveAnUpstreamUrlTemplate("/products?productId={productId}"))
.When(x => x.WhenIFindTheUrlVariableNamesAndValues())
this.Given(x => x.GivenIHaveAUpstreamPath("/products/3")) .And(x => x.ThenTheTemplatesVariablesAre(expectedTemplates))
.And(x => x.GivenIHaveAQuery("?productId=1&categoryId=2")) .BDDfy();
.And(x => x.GivenIHaveAnUpstreamUrlTemplate("/products/{account}?productId={productId}&categoryId={categoryId}")) }
.When(x => x.WhenIFindTheUrlVariableNamesAndValues())
.And(x => x.ThenTheTemplatesVariablesAre(expectedTemplates)) [Fact]
.BDDfy(); public void should_find_multiple_query_string()
} {
var expectedTemplates = new List<PlaceholderNameAndValue>
[Fact] {
public void should_find_multiple_query_string_and_path_that_ends_with_slash() new PlaceholderNameAndValue("{productId}", "1"),
{ new PlaceholderNameAndValue("{categoryId}", "2")
var expectedTemplates = new List<PlaceholderNameAndValue> };
{
new PlaceholderNameAndValue("{productId}", "1"), this.Given(x => x.GivenIHaveAUpstreamPath("/products"))
new PlaceholderNameAndValue("{categoryId}", "2"), .And(x => x.GivenIHaveAQuery("?productId=1&categoryId=2"))
new PlaceholderNameAndValue("{account}", "3") .And(x => x.GivenIHaveAnUpstreamUrlTemplate("/products?productId={productId}&categoryId={categoryId}"))
}; .When(x => x.WhenIFindTheUrlVariableNamesAndValues())
.And(x => x.ThenTheTemplatesVariablesAre(expectedTemplates))
this.Given(x => x.GivenIHaveAUpstreamPath("/products/3/")) .BDDfy();
.And(x => x.GivenIHaveAQuery("?productId=1&categoryId=2")) }
.And(x => x.GivenIHaveAnUpstreamUrlTemplate("/products/{account}/?productId={productId}&categoryId={categoryId}"))
.When(x => x.WhenIFindTheUrlVariableNamesAndValues()) [Fact]
.And(x => x.ThenTheTemplatesVariablesAre(expectedTemplates)) public void should_find_multiple_query_string_and_path()
.BDDfy(); {
} var expectedTemplates = new List<PlaceholderNameAndValue>
{
[Fact] new PlaceholderNameAndValue("{productId}", "1"),
public void can_match_down_stream_url_with_no_slash() new PlaceholderNameAndValue("{categoryId}", "2"),
{ new PlaceholderNameAndValue("{account}", "3")
this.Given(x => x.GivenIHaveAUpstreamPath("api")) };
.Given(x => x.GivenIHaveAnUpstreamUrlTemplate("api"))
.When(x => x.WhenIFindTheUrlVariableNamesAndValues()) this.Given(x => x.GivenIHaveAUpstreamPath("/products/3"))
.And(x => x.ThenTheTemplatesVariablesAre(new List<PlaceholderNameAndValue>())) .And(x => x.GivenIHaveAQuery("?productId=1&categoryId=2"))
.BDDfy(); .And(x => x.GivenIHaveAnUpstreamUrlTemplate("/products/{account}?productId={productId}&categoryId={categoryId}"))
} .When(x => x.WhenIFindTheUrlVariableNamesAndValues())
.And(x => x.ThenTheTemplatesVariablesAre(expectedTemplates))
[Fact] .BDDfy();
public void can_match_down_stream_url_with_one_slash() }
{
this.Given(x => x.GivenIHaveAUpstreamPath("api/")) [Fact]
.Given(x => x.GivenIHaveAnUpstreamUrlTemplate("api/")) public void should_find_multiple_query_string_and_path_that_ends_with_slash()
.When(x => x.WhenIFindTheUrlVariableNamesAndValues()) {
.And(x => x.ThenTheTemplatesVariablesAre(new List<PlaceholderNameAndValue>())) var expectedTemplates = new List<PlaceholderNameAndValue>
.BDDfy(); {
} new PlaceholderNameAndValue("{productId}", "1"),
new PlaceholderNameAndValue("{categoryId}", "2"),
[Fact] new PlaceholderNameAndValue("{account}", "3")
public void can_match_down_stream_url_with_downstream_template() };
{
this.Given(x => x.GivenIHaveAUpstreamPath("api/product/products/")) this.Given(x => x.GivenIHaveAUpstreamPath("/products/3/"))
.Given(x => x.GivenIHaveAnUpstreamUrlTemplate("api/product/products/")) .And(x => x.GivenIHaveAQuery("?productId=1&categoryId=2"))
.When(x => x.WhenIFindTheUrlVariableNamesAndValues()) .And(x => x.GivenIHaveAnUpstreamUrlTemplate("/products/{account}/?productId={productId}&categoryId={categoryId}"))
.And(x => x.ThenTheTemplatesVariablesAre(new List<PlaceholderNameAndValue>())) .When(x => x.WhenIFindTheUrlVariableNamesAndValues())
.BDDfy(); .And(x => x.ThenTheTemplatesVariablesAre(expectedTemplates))
} .BDDfy();
}
[Fact]
public void can_match_down_stream_url_with_downstream_template_with_one_place_holder() [Fact]
{ public void can_match_down_stream_url_with_no_slash()
var expectedTemplates = new List<PlaceholderNameAndValue> {
{ this.Given(x => x.GivenIHaveAUpstreamPath("api"))
new PlaceholderNameAndValue("{productId}", "1") .Given(x => x.GivenIHaveAnUpstreamUrlTemplate("api"))
}; .When(x => x.WhenIFindTheUrlVariableNamesAndValues())
.And(x => x.ThenTheTemplatesVariablesAre(new List<PlaceholderNameAndValue>()))
this.Given(x => x.GivenIHaveAUpstreamPath("api/product/products/1")) .BDDfy();
.Given(x => x.GivenIHaveAnUpstreamUrlTemplate("api/product/products/{productId}")) }
.When(x => x.WhenIFindTheUrlVariableNamesAndValues())
.And(x => x.ThenTheTemplatesVariablesAre(expectedTemplates)) [Fact]
.BDDfy(); public void can_match_down_stream_url_with_one_slash()
} {
this.Given(x => x.GivenIHaveAUpstreamPath("api/"))
[Fact] .Given(x => x.GivenIHaveAnUpstreamUrlTemplate("api/"))
public void can_match_down_stream_url_with_downstream_template_with_two_place_holders() .When(x => x.WhenIFindTheUrlVariableNamesAndValues())
{ .And(x => x.ThenTheTemplatesVariablesAre(new List<PlaceholderNameAndValue>()))
var expectedTemplates = new List<PlaceholderNameAndValue> .BDDfy();
{ }
new PlaceholderNameAndValue("{productId}", "1"),
new PlaceholderNameAndValue("{categoryId}", "2") [Fact]
}; public void can_match_down_stream_url_with_downstream_template()
{
this.Given(x => x.GivenIHaveAUpstreamPath("api/product/products/1/2")) this.Given(x => x.GivenIHaveAUpstreamPath("api/product/products/"))
.Given(x => x.GivenIHaveAnUpstreamUrlTemplate("api/product/products/{productId}/{categoryId}")) .Given(x => x.GivenIHaveAnUpstreamUrlTemplate("api/product/products/"))
.When(x => x.WhenIFindTheUrlVariableNamesAndValues()) .When(x => x.WhenIFindTheUrlVariableNamesAndValues())
.And(x => x.ThenTheTemplatesVariablesAre(expectedTemplates)) .And(x => x.ThenTheTemplatesVariablesAre(new List<PlaceholderNameAndValue>()))
.BDDfy(); .BDDfy();
} }
[Fact] [Fact]
public void can_match_down_stream_url_with_downstream_template_with_two_place_holders_seperated_by_something() public void can_match_down_stream_url_with_downstream_template_with_one_place_holder()
{ {
var expectedTemplates = new List<PlaceholderNameAndValue> var expectedTemplates = new List<PlaceholderNameAndValue>
{ {
new PlaceholderNameAndValue("{productId}", "1"), new PlaceholderNameAndValue("{productId}", "1")
new PlaceholderNameAndValue("{categoryId}", "2") };
};
this.Given(x => x.GivenIHaveAUpstreamPath("api/product/products/1"))
this.Given(x => x.GivenIHaveAUpstreamPath("api/product/products/1/categories/2")) .Given(x => x.GivenIHaveAnUpstreamUrlTemplate("api/product/products/{productId}"))
.And(x => x.GivenIHaveAnUpstreamUrlTemplate("api/product/products/{productId}/categories/{categoryId}")) .When(x => x.WhenIFindTheUrlVariableNamesAndValues())
.When(x => x.WhenIFindTheUrlVariableNamesAndValues()) .And(x => x.ThenTheTemplatesVariablesAre(expectedTemplates))
.And(x => x.ThenTheTemplatesVariablesAre(expectedTemplates)) .BDDfy();
.BDDfy(); }
}
[Fact]
[Fact] public void can_match_down_stream_url_with_downstream_template_with_two_place_holders()
public void can_match_down_stream_url_with_downstream_template_with_three_place_holders_seperated_by_something() {
{ var expectedTemplates = new List<PlaceholderNameAndValue>
var expectedTemplates = new List<PlaceholderNameAndValue> {
{ new PlaceholderNameAndValue("{productId}", "1"),
new PlaceholderNameAndValue("{productId}", "1"), new PlaceholderNameAndValue("{categoryId}", "2")
new PlaceholderNameAndValue("{categoryId}", "2"), };
new PlaceholderNameAndValue("{variantId}", "123")
}; this.Given(x => x.GivenIHaveAUpstreamPath("api/product/products/1/2"))
.Given(x => x.GivenIHaveAnUpstreamUrlTemplate("api/product/products/{productId}/{categoryId}"))
this.Given(x => x.GivenIHaveAUpstreamPath("api/product/products/1/categories/2/variant/123")) .When(x => x.WhenIFindTheUrlVariableNamesAndValues())
.And(x => x.GivenIHaveAnUpstreamUrlTemplate("api/product/products/{productId}/categories/{categoryId}/variant/{variantId}")) .And(x => x.ThenTheTemplatesVariablesAre(expectedTemplates))
.When(x => x.WhenIFindTheUrlVariableNamesAndValues()) .BDDfy();
.And(x => x.ThenTheTemplatesVariablesAre(expectedTemplates)) }
.BDDfy();
} [Fact]
public void can_match_down_stream_url_with_downstream_template_with_two_place_holders_seperated_by_something()
[Fact] {
public void can_match_down_stream_url_with_downstream_template_with_three_place_holders() var expectedTemplates = new List<PlaceholderNameAndValue>
{ {
var expectedTemplates = new List<PlaceholderNameAndValue> new PlaceholderNameAndValue("{productId}", "1"),
{ new PlaceholderNameAndValue("{categoryId}", "2")
new PlaceholderNameAndValue("{productId}", "1"), };
new PlaceholderNameAndValue("{categoryId}", "2")
}; this.Given(x => x.GivenIHaveAUpstreamPath("api/product/products/1/categories/2"))
.And(x => x.GivenIHaveAnUpstreamUrlTemplate("api/product/products/{productId}/categories/{categoryId}"))
this.Given(x => x.GivenIHaveAUpstreamPath("api/product/products/1/categories/2/variant/")) .When(x => x.WhenIFindTheUrlVariableNamesAndValues())
.And(x => x.GivenIHaveAnUpstreamUrlTemplate("api/product/products/{productId}/categories/{categoryId}/variant/")) .And(x => x.ThenTheTemplatesVariablesAre(expectedTemplates))
.When(x => x.WhenIFindTheUrlVariableNamesAndValues()) .BDDfy();
.And(x => x.ThenTheTemplatesVariablesAre(expectedTemplates)) }
.BDDfy();
} [Fact]
public void can_match_down_stream_url_with_downstream_template_with_three_place_holders_seperated_by_something()
[Fact] {
public void can_match_down_stream_url_with_downstream_template_with_place_holder_to_final_url_path() var expectedTemplates = new List<PlaceholderNameAndValue>
{ {
var expectedTemplates = new List<PlaceholderNameAndValue> new PlaceholderNameAndValue("{productId}", "1"),
{ new PlaceholderNameAndValue("{categoryId}", "2"),
new PlaceholderNameAndValue("{finalUrlPath}", "product/products/categories/"), new PlaceholderNameAndValue("{variantId}", "123")
}; };
this.Given(x => x.GivenIHaveAUpstreamPath("api/product/products/categories/")) this.Given(x => x.GivenIHaveAUpstreamPath("api/product/products/1/categories/2/variant/123"))
.And(x => x.GivenIHaveAnUpstreamUrlTemplate("api/{finalUrlPath}/")) .And(x => x.GivenIHaveAnUpstreamUrlTemplate("api/product/products/{productId}/categories/{categoryId}/variant/{variantId}"))
.When(x => x.WhenIFindTheUrlVariableNamesAndValues()) .When(x => x.WhenIFindTheUrlVariableNamesAndValues())
.And(x => x.ThenTheTemplatesVariablesAre(expectedTemplates)) .And(x => x.ThenTheTemplatesVariablesAre(expectedTemplates))
.BDDfy(); .BDDfy();
} }
private void ThenTheTemplatesVariablesAre(List<PlaceholderNameAndValue> expectedResults) [Fact]
{ public void can_match_down_stream_url_with_downstream_template_with_three_place_holders()
foreach (var expectedResult in expectedResults) {
{ var expectedTemplates = new List<PlaceholderNameAndValue>
var result = _result.Data.First(t => t.Name == expectedResult.Name); {
result.Value.ShouldBe(expectedResult.Value); new PlaceholderNameAndValue("{productId}", "1"),
} new PlaceholderNameAndValue("{categoryId}", "2")
} };
private void GivenIHaveAUpstreamPath(string downstreamPath) this.Given(x => x.GivenIHaveAUpstreamPath("api/product/products/1/categories/2/variant/"))
{ .And(x => x.GivenIHaveAnUpstreamUrlTemplate("api/product/products/{productId}/categories/{categoryId}/variant/"))
_downstreamUrlPath = downstreamPath; .When(x => x.WhenIFindTheUrlVariableNamesAndValues())
} .And(x => x.ThenTheTemplatesVariablesAre(expectedTemplates))
.BDDfy();
private void GivenIHaveAnUpstreamUrlTemplate(string downstreamUrlTemplate) }
{
_downstreamPathTemplate = downstreamUrlTemplate; [Fact]
} public void can_match_down_stream_url_with_downstream_template_with_place_holder_to_final_url_path()
{
private void WhenIFindTheUrlVariableNamesAndValues() var expectedTemplates = new List<PlaceholderNameAndValue>
{ {
_result = _finder.Find(_downstreamUrlPath, _query, _downstreamPathTemplate); new PlaceholderNameAndValue("{finalUrlPath}", "product/products/categories/"),
} };
private void GivenIHaveAQuery(string query) this.Given(x => x.GivenIHaveAUpstreamPath("api/product/products/categories/"))
{ .And(x => x.GivenIHaveAnUpstreamUrlTemplate("api/{finalUrlPath}/"))
_query = query; .When(x => x.WhenIFindTheUrlVariableNamesAndValues())
} .And(x => x.ThenTheTemplatesVariablesAre(expectedTemplates))
} .BDDfy();
} }
private void ThenTheTemplatesVariablesAre(List<PlaceholderNameAndValue> expectedResults)
{
foreach (var expectedResult in expectedResults)
{
var result = _result.Data.First(t => t.Name == expectedResult.Name);
result.Value.ShouldBe(expectedResult.Value);
}
}
private void GivenIHaveAUpstreamPath(string downstreamPath)
{
_downstreamUrlPath = downstreamPath;
}
private void GivenIHaveAnUpstreamUrlTemplate(string downstreamUrlTemplate)
{
_downstreamPathTemplate = downstreamUrlTemplate;
}
private void WhenIFindTheUrlVariableNamesAndValues()
{
_result = _finder.Find(_downstreamUrlPath, _query, _downstreamPathTemplate);
}
private void GivenIHaveAQuery(string query)
{
_query = query;
}
}
}