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

now matches and returns templates and values@

Browse Source
This commit is contained in:
Tom Gardham-Pallister 2016-07-10 18:49:09 +01:00
parent cea6a557e9
commit 1993915564
5 changed files with 177 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/Ocelot.Library/Infrastructure/UrlPathMatcher/IUrlPathToUrlPathTemplateMatcher.cs
View File

@ -2,6 +2,6 @@ namespace Ocelot.Library.Infrastructure.UrlPathMatcher
{
public interface IUrlPathToUrlPathTemplateMatcher
{
bool Match(string urlPath, string urlPathTemplate);
UrlPathMatch Match(string urlPath, string urlPathTemplate);
}
}

13
src/Ocelot.Library/Infrastructure/UrlPathMatcher/TemplateVariableNameAndValue.cs Normal file
View File

@ -0,0 +1,13 @@
namespace Ocelot.Library.Infrastructure.UrlPathMatcher
{
public class TemplateVariableNameAndValue
{
public TemplateVariableNameAndValue(string templateVariableName, string templateVariableValue)
{
TemplateVariableName = templateVariableName;
TemplateVariableValue = templateVariableValue;
}
public string TemplateVariableName {get;private set;}
public string TemplateVariableValue {get;private set;}
}
}

15
src/Ocelot.Library/Infrastructure/UrlPathMatcher/UrlPathMatch.cs Normal file
View File

@ -0,0 +1,15 @@
using System.Collections.Generic;
namespace Ocelot.Library.Infrastructure.UrlPathMatcher
{
public class UrlPathMatch
{
public UrlPathMatch(bool match, List<TemplateVariableNameAndValue> templateVariableNameAndValues)
{
Match = match;
TemplateVariableNameAndValues = templateVariableNameAndValues;
}
public bool Match {get;private set;}
public List<TemplateVariableNameAndValue> TemplateVariableNameAndValues {get;private set;}
}
}

43
src/Ocelot.Library/Infrastructure/UrlPathMatcher/UrlPathToUrlPathTemplateMatcher.cs
View File

@ -1,9 +1,14 @@
using System;
using System.Collections.Generic;
namespace Ocelot.Library.Infrastructure.UrlPathMatcher
{
public class UrlPathToUrlPathTemplateMatcher : IUrlPathToUrlPathTemplateMatcher
{
public bool Match(string urlPath, string urlPathTemplate)
public UrlPathMatch Match(string urlPath, string urlPathTemplate)
{
var templateKeysAndValues = new List<TemplateVariableNameAndValue>();
urlPath = urlPath.ToLower();
urlPathTemplate = urlPathTemplate.ToLower();
@ -16,20 +21,52 @@ namespace Ocelot.Library.Infrastructure.UrlPathMatcher
{
if (IsPlaceholder(urlPathTemplate[counterForTemplate]))
{
var variableName = GetPlaceholderVariableName(urlPathTemplate, counterForTemplate);
var variableValue = GetPlaceholderVariableValue(urlPath, counterForUrl);
var templateVariableNameAndValue = new TemplateVariableNameAndValue(variableName, variableValue);
templateKeysAndValues.Add(templateVariableNameAndValue);
counterForTemplate = GetNextCounterPosition(urlPathTemplate, counterForTemplate, '}');
counterForUrl = GetNextCounterPosition(urlPath, counterForUrl, '/');
continue;
}
else
{
return false;
return new UrlPathMatch(false, templateKeysAndValues);
}
}
counterForUrl++;
}
return true;
return new UrlPathMatch(true, templateKeysAndValues);
}
private string GetPlaceholderVariableValue(string urlPath, int counterForUrl)
{
var positionOfNextSlash = urlPath.IndexOf('/', counterForUrl);
if(positionOfNextSlash == -1)
{
positionOfNextSlash = urlPath.Length;
}
var variableValue = urlPath.Substring(counterForUrl, positionOfNextSlash - counterForUrl);
return variableValue;
}
private string GetPlaceholderVariableName(string urlPathTemplate, int counterForTemplate)
{
var postitionOfPlaceHolderClosingBracket = urlPathTemplate.IndexOf('}', counterForTemplate) + 1;
var variableName = urlPathTemplate.Substring(counterForTemplate, postitionOfPlaceHolderClosingBracket - counterForTemplate);
return variableName;
}
private int GetNextCounterPosition(string urlTemplate, int counterForTemplate, char delimiter)
{
var closingPlaceHolderPositionOnTemplate = urlTemplate.IndexOf(delimiter, counterForTemplate);

139
test/Ocelot.UnitTests/UrlPathToUrlPathTemplateMatcherTests.cs
View File

@ -1,13 +1,17 @@
using System.Collections.Generic;
using System.Linq;
using Ocelot.Library.Infrastructure.UrlPathMatcher;
using Shouldly;
using Xunit;
namespace Ocelot.UnitTests
{
public class UrlPathToUrlPathTemplateMatcherTests
{
private IUrlPathToUrlPathTemplateMatcher _urlMapper;
private string _downstreamPath;
private string _downstreamPathTemplate;
private UrlPathMatch _result;
public UrlPathToUrlPathTemplateMatcherTests()
{
_urlMapper = new UrlPathToUrlPathTemplateMatcher();
@ -16,64 +20,137 @@ namespace Ocelot.UnitTests
[Fact]
public void can_match_down_stream_url_with_downstream_template_with_one_query_string_parameter()
{
var downstreamUrl = "api/product/products/?soldout=false";
var downstreamTemplate = "api/product/products/";
var result = _urlMapper.Match(downstreamUrl, downstreamTemplate);
result.ShouldBeTrue();
GivenIHaveADownstreamPath("api/product/products/?soldout=false");
GivenIHaveAnDownstreamPathTemplate("api/product/products/");
WhenIMatchThePaths();
ThenTheResultIsTrue();
ThenTheTemplatesDictionaryIs(new List<TemplateVariableNameAndValue>());
}
[Fact]
[Fact]
public void can_match_down_stream_url_with_downstream_template_with_one_query_string_parameter_and_one_template()
{
var downstreamUrl = "api/product/products/1/variants/?soldout=false";
var downstreamTemplate = "api/product/products/{productId}/variants/";
var result = _urlMapper.Match(downstreamUrl, downstreamTemplate);
result.ShouldBeTrue();
var expectedTemplates = new List<TemplateVariableNameAndValue>
{
new TemplateVariableNameAndValue("{productid}", "1")
};
GivenIHaveADownstreamPath("api/product/products/1/variants/?soldout=false");
GivenIHaveAnDownstreamPathTemplate("api/product/products/{productId}/variants/");
WhenIMatchThePaths();
ThenTheResultIsTrue();
ThenTheTemplatesDictionaryIs(expectedTemplates);
}
[Fact]
public void can_match_down_stream_url_with_downstream_template_with_one_place_holder()
{
var downstreamUrl = "api/product/products/1";
var downstreamTemplate = "api/product/products/{productId}";
var result = _urlMapper.Match(downstreamUrl, downstreamTemplate);
result.ShouldBeTrue();
var expectedTemplates = new List<TemplateVariableNameAndValue>
{
new TemplateVariableNameAndValue("{productid}", "1")
};
GivenIHaveADownstreamPath("api/product/products/1");
GivenIHaveAnDownstreamPathTemplate("api/product/products/{productId}");
WhenIMatchThePaths();
ThenTheResultIsTrue();
ThenTheTemplatesDictionaryIs(expectedTemplates);
}
[Fact]
public void can_match_down_stream_url_with_downstream_template_with_two_place_holders()
{
var downstreamUrl = "api/product/products/1/2";
var downstreamTemplate = "api/product/products/{productId}/{categoryId}";
var result = _urlMapper.Match(downstreamUrl, downstreamTemplate);
result.ShouldBeTrue();
var expectedTemplates = new List<TemplateVariableNameAndValue>
{
new TemplateVariableNameAndValue("{productid}", "1"),
new TemplateVariableNameAndValue("{categoryid}", "2")
};
GivenIHaveADownstreamPath("api/product/products/1/2");
GivenIHaveAnDownstreamPathTemplate("api/product/products/{productId}/{categoryId}");
WhenIMatchThePaths();
ThenTheResultIsTrue();
ThenTheTemplatesDictionaryIs(expectedTemplates);
}
[Fact]
public void can_match_down_stream_url_with_downstream_template_with_two_place_holders_seperated_by_something()
{
var downstreamUrl = "api/product/products/1/categories/2";
var downstreamTemplate = "api/product/products/{productId}/categories/{categoryId}";
var result = _urlMapper.Match(downstreamUrl, downstreamTemplate);
result.ShouldBeTrue();
var expectedTemplates = new List<TemplateVariableNameAndValue>
{
new TemplateVariableNameAndValue("{productid}", "1"),
new TemplateVariableNameAndValue("{categoryid}", "2")
};
GivenIHaveADownstreamPath("api/product/products/1/categories/2");
GivenIHaveAnDownstreamPathTemplate("api/product/products/{productId}/categories/{categoryId}");
WhenIMatchThePaths();
ThenTheResultIsTrue();
ThenTheTemplatesDictionaryIs(expectedTemplates);
}
[Fact]
public void can_match_down_stream_url_with_downstream_template_with_three_place_holders_seperated_by_something()
{
var downstreamUrl = "api/product/products/1/categories/2/variant/123";
var downstreamTemplate = "api/product/products/{productId}/categories/{categoryId}/variant/{variantId}";
var result = _urlMapper.Match(downstreamUrl, downstreamTemplate);
result.ShouldBeTrue();
var expectedTemplates = new List<TemplateVariableNameAndValue>
{
new TemplateVariableNameAndValue("{productid}", "1"),
new TemplateVariableNameAndValue("{categoryid}", "2"),
new TemplateVariableNameAndValue("{variantid}", "123")
};
GivenIHaveADownstreamPath("api/product/products/1/categories/2/variant/123");
GivenIHaveAnDownstreamPathTemplate("api/product/products/{productId}/categories/{categoryId}/variant/{variantId}");
WhenIMatchThePaths();
ThenTheResultIsTrue();
ThenTheTemplatesDictionaryIs(expectedTemplates);
}
[Fact]
public void can_match_down_stream_url_with_downstream_template_with_three_place_holders()
{
var downstreamUrl = "api/product/products/1/categories/2/variant/";
var downstreamTemplate = "api/product/products/{productId}/categories/{categoryId}/variant/";
var result = _urlMapper.Match(downstreamUrl, downstreamTemplate);
result.ShouldBeTrue();
var expectedTemplates = new List<TemplateVariableNameAndValue>
{
new TemplateVariableNameAndValue("{productid}", "1"),
new TemplateVariableNameAndValue("{categoryid}", "2")
};
GivenIHaveADownstreamPath("api/product/products/1/categories/2/variant/");
GivenIHaveAnDownstreamPathTemplate("api/product/products/{productId}/categories/{categoryId}/variant/");
WhenIMatchThePaths();
ThenTheResultIsTrue();
ThenTheTemplatesDictionaryIs(expectedTemplates);
}
private void ThenTheTemplatesDictionaryIs(List<TemplateVariableNameAndValue> expectedResults)
{
foreach (var expectedResult in expectedResults)
{
var result = _result.TemplateVariableNameAndValues
.First(t => t.TemplateVariableName == expectedResult.TemplateVariableName);
result.TemplateVariableValue.ShouldBe(expectedResult.TemplateVariableValue);
}
}
private void GivenIHaveADownstreamPath(string downstreamPath)
{
_downstreamPath = downstreamPath;
}
private void GivenIHaveAnDownstreamPathTemplate(string downstreamTemplate)
{
_downstreamPathTemplate = downstreamTemplate;
}
private void WhenIMatchThePaths()
{
_result = _urlMapper.Match(_downstreamPath, _downstreamPathTemplate);
}
private void ThenTheResultIsTrue()
{
_result.Match.ShouldBeTrue();
}
}
}