private static void RunTest(
string template,
string path,
DispatcherValueCollection defaults,
IDictionary <string, object> expected)
{
// Arrange
var matcher = new RoutePatternMatcher(
RoutePatternParser.Parse(template),
defaults ?? new DispatcherValueCollection());
var values = new DispatcherValueCollection();
// Act
var match = matcher.TryMatch(new PathString(path), values);
// Assert
if (expected == null)
{
Assert.False(match);
}
else
{
Assert.True(match);
Assert.Equal(expected.Count, values.Count);
foreach (string key in values.Keys)
{
Assert.Equal(expected[key], values[key]);
}
}
}
public HttpEndpoint(
string pattern,
object values,
string httpMethod,
Func <RequestDelegate, RequestDelegate> delegateFactory,
string displayName,
params object[] metadata)
{
if (pattern == null)
{
throw new ArgumentNullException(nameof(pattern));
}
if (delegateFactory == null)
{
throw new ArgumentNullException(nameof(delegateFactory));
}
if (metadata == null)
{
throw new ArgumentNullException(nameof(metadata));
}
Pattern = pattern;
Values = new DispatcherValueCollection(values);
HttpMethod = httpMethod;
HandlerFactory = delegateFactory;
DisplayName = displayName;
Metadata = new MetadataCollection(metadata);
}
public EndpointSelectorContext(HttpContext httpContext, DispatcherValueCollection values, IList <Endpoint> endpoints, IList <EndpointSelector> selectors)
{
if (httpContext == null)
{
throw new ArgumentNullException(nameof(httpContext));
}
if (values == null)
{
throw new ArgumentNullException(nameof(values));
}
if (endpoints == null)
{
throw new ArgumentNullException(nameof(endpoints));
}
if (selectors == null)
{
throw new ArgumentNullException(nameof(selectors));
}
HttpContext = httpContext;
Values = values;
Endpoints = endpoints;
Selectors = selectors;
}
public void TryMatch_OptionalParameter_FollowedByPeriod_3Parameters_Valid(
string template,
string path,
string p1,
string p2,
string p3)
{
// Arrange
var matcher = CreateMatcher(template);
var values = new DispatcherValueCollection();
// Act
var match = matcher.TryMatch(path, values);
// Assert
Assert.True(match);
Assert.Equal(p1, values["p1"]);
if (p2 != null)
{
Assert.Equal(p2, values["p2"]);
}
if (p3 != null)
{
Assert.Equal(p3, values["p3"]);
}
}
internal RoutePatternBinder(
UrlEncoder urlEncoder,
ObjectPool <UriBuildingContext> pool,
RoutePattern pattern,
DispatcherValueCollection defaults)
{
if (urlEncoder == null)
{
throw new ArgumentNullException(nameof(urlEncoder));
}
if (pool == null)
{
throw new ArgumentNullException(nameof(pool));
}
if (pattern == null)
{
throw new ArgumentNullException(nameof(pattern));
}
_urlEncoder = urlEncoder;
_pool = pool;
_pattern = pattern;
_defaults = defaults;
// Any default that doesn't have a corresponding parameter is a 'filter' and if a value
// is provided for that 'filter' it must match the value in defaults.
_filters = new DispatcherValueCollection(_defaults);
foreach (var parameter in _pattern.Parameters)
{
_filters.Remove(parameter.Name);
}
}
public void Binding_WithEmptyAndNull_DefaultValues(
string pattern,
DispatcherValueCollection defaults,
DispatcherValueCollection values,
string expected)
{
// Arrange
var binder = BinderFactory.Create(pattern, defaults);
// Act & Assert
(var acceptedValues, var combinedValues) = binder.GetValues(ambientValues: null, values: values);
if (acceptedValues == null)
{
if (expected == null)
{
return;
}
else
{
Assert.NotNull(acceptedValues);
}
}
var result = binder.BindValues(acceptedValues);
if (expected == null)
{
Assert.Null(result);
}
else
{
Assert.NotNull(result);
Assert.Equal(expected, result);
}
}
public void CreateFromObject_CopiesPropertiesFromRegularType_IncludesInherited()
{
// Arrange
var obj = new Derived()
{
TotallySweetProperty = true, DerivedProperty = false
};
// Act
var dict = new DispatcherValueCollection(obj);
// Assert
Assert.IsType <DispatcherValueCollection.PropertyStorage>(dict._storage);
Assert.Collection(
dict.OrderBy(kvp => kvp.Key),
kvp =>
{
Assert.Equal("DerivedProperty", kvp.Key);
var value = Assert.IsType <bool>(kvp.Value);
Assert.False(value);
},
kvp =>
{
Assert.Equal("TotallySweetProperty", kvp.Key);
var value = Assert.IsType <bool>(kvp.Value);
Assert.True(value);
});
}
public void CreateFromObject_CopiesPropertiesFromRegularType()
{
// Arrange
var obj = new RegularType()
{
CoolnessFactor = 73
};
// Act
var dict = new DispatcherValueCollection(obj);
// Assert
Assert.IsType <DispatcherValueCollection.PropertyStorage>(dict._storage);
Assert.Collection(
dict.OrderBy(kvp => kvp.Key),
kvp =>
{
Assert.Equal("CoolnessFactor", kvp.Key);
Assert.Equal(73, kvp.Value);
},
kvp =>
{
Assert.Equal("IsAwesome", kvp.Key);
var value = Assert.IsType <bool>(kvp.Value);
Assert.False(value);
});
}
public void ListStorage_RemoveAt_RearrangesInnerArray()
{
// Arrange
var dict = new DispatcherValueCollection();
dict.Add("key", "value");
dict.Add("key2", "value2");
dict.Add("key3", "value3");
// Assert 1
var storage = Assert.IsType <DispatcherValueCollection.ListStorage>(dict._storage);
Assert.Equal(3, storage.Count);
// Act
dict.Remove("key2");
// Assert 2
Assert.Equal(2, storage.Count);
Assert.Equal("key", storage[0].Key);
Assert.Equal("value", storage[0].Value);
Assert.Equal("key3", storage[1].Key);
Assert.Equal("value3", storage[1].Value);
Assert.Throws <ArgumentOutOfRangeException>(() => storage[2]);
}
public RoutePatternEndpoint(
string pattern,
object values,
string httpMethod,
RequestDelegate requestDelegate,
string displayName,
params object[] metadata)
{
if (pattern == null)
{
throw new ArgumentNullException(nameof(pattern));
}
if (requestDelegate == null)
{
throw new ArgumentNullException(nameof(requestDelegate));
}
if (metadata == null)
{
throw new ArgumentNullException(nameof(metadata));
}
Pattern = pattern;
Values = new DispatcherValueCollection(values);
HttpMethod = httpMethod;
HandlerFactory = (next) => requestDelegate;
DisplayName = displayName;
Metadata = new MetadataCollection(metadata);
}
public async Task MatchAsync_MatchesConstrainedEndpointsWithDefaults(string url, object[] values)
{
// Arrange
var dataSource = new DefaultDispatcherDataSource()
{
Endpoints =
{
new RoutePatternEndpoint("{parameter1:int=1}/{parameter2:int=2}/{parameter3:int=3}/{parameter4:int=4}",
new { parameter1 = 1, parameter2= 2, parameter3 = 3, parameter4 = 4 }, Test_Delegate, "Test"),
},
};
var valueKeys = new[] { "parameter1", "parameter2", "parameter3", "parameter4" };
var expectedValues = new DispatcherValueCollection();
for (int i = 0; i < valueKeys.Length; i++)
{
expectedValues.Add(valueKeys[i], values[i]);
}
var context = CreateMatcherContext(url);
var factory = new TreeMatcherFactory();
var matcher = factory.CreateMatcher(dataSource, new List <EndpointSelector>());
// Act
await matcher.MatchAsync(context);
// Assert
foreach (var entry in expectedValues)
{
var data = Assert.Single(context.Values, v => v.Key == entry.Key);
Assert.Equal(entry.Value, data.Value);
}
}
// Step 2: If the route is a match generate the appropriate URI
public string BindValues(DispatcherValueCollection acceptedValues)
{
var context = _pool.Get();
var result = BindValues(context, acceptedValues);
_pool.Return(context);
return(result);
}
private static void RouteFormatHelper(string routeUrl, string requestUrl)
{
var defaults = new DispatcherValueCollection(new { route = "matched" });
var r = CreateRoute(routeUrl, defaults, null);
GetRouteDataHelper(r, requestUrl, defaults);
GetVirtualPathHelper(r, new DispatcherValueCollection(), null, Uri.EscapeUriString(requestUrl));
}
private void RunTest(
string pattern,
DispatcherValueCollection defaults,
DispatcherValueCollection ambientValues,
DispatcherValueCollection values,
string expected,
UrlEncoder encoder = null)
{
// Arrange
var binderFactory = encoder == null ? BinderFactory : new RoutePatternBinderFactory(encoder, new DefaultObjectPoolProvider());
var binder = binderFactory.Create(pattern, defaults ?? new DispatcherValueCollection());
// Act & Assert
(var acceptedValues, var combinedValues) = binder.GetValues(ambientValues, values);
if (acceptedValues == null)
{
if (expected == null)
{
return;
}
else
{
Assert.NotNull(acceptedValues);
}
}
var result = binder.BindValues(acceptedValues);
if (expected == null)
{
Assert.Null(result);
}
else
{
Assert.NotNull(result);
// We want to chop off the query string and compare that using an unordered comparison
var expectedParts = new PathAndQuery(expected);
var actualParts = new PathAndQuery(result);
Assert.Equal(expectedParts.Path, actualParts.Path);
if (expectedParts.Parameters == null)
{
Assert.Null(actualParts.Parameters);
}
else
{
Assert.Equal(expectedParts.Parameters.Count, actualParts.Parameters.Count);
foreach (var kvp in expectedParts.Parameters)
{
Assert.True(actualParts.Parameters.TryGetValue(kvp.Key, out var value));
Assert.Equal(kvp.Value, value);
}
}
}
}
public void Comparer_IsOrdinalIgnoreCase()
{
// Arrange
// Act
var dict = new DispatcherValueCollection();
// Assert
Assert.Same(StringComparer.OrdinalIgnoreCase, dict.Comparer);
}
public static RouteValueDictionary AsRouteValueDictionary(this DispatcherValueCollection values)
{
if (values == null)
{
throw new ArgumentNullException(nameof(values));
}
return(values as RouteValueDictionary ?? new RouteValueDictionary(values));
}
public override string GetUrl(DispatcherValueCollection values)
{
if (values == null)
{
throw new ArgumentNullException(nameof(values));
}
return(GetUrl(null, values));
}
public void DefaultCtor_UsesEmptyStorage()
{
// Arrange
// Act
var dict = new DispatcherValueCollection();
// Assert
Assert.Empty(dict);
Assert.IsType <DispatcherValueCollection.EmptyStorage>(dict._storage);
}
public void CreateFromNull_UsesEmptyStorage()
{
// Arrange
// Act
var dict = new DispatcherValueCollection(null);
// Assert
Assert.Empty(dict);
Assert.IsType <DispatcherValueCollection.EmptyStorage>(dict._storage);
}
public void IsReadOnly_False()
{
// Arrange
var dict = new DispatcherValueCollection();
// Act
var result = ((ICollection <KeyValuePair <string, object> >)dict).IsReadOnly;
// Assert
Assert.False(result);
}
public void RegexConstraintConstructedWithRegex_SimpleFailedMatch()
{
// Arrange
var constraint = new RegexDispatcherValueConstraint(new Regex("^abc$"));
var values = new DispatcherValueCollection(new { controller = "Abc" });
// Act
var match = TestConstraint(constraint, values, "controller");
// Assert
Assert.False(match);
}
public Enumerator(DispatcherValueCollection collection)
{
if (collection == null)
{
throw new ArgumentNullException();
}
_storage = collection._storage;
Current = default(KeyValuePair <string, object>);
_index = -1;
}
public void Add_EmptyStorage()
{
// Arrange
var dict = new DispatcherValueCollection();
// Act
dict.Add("key", "value");
// Assert
Assert.Collection(dict, kvp => { Assert.Equal("key", kvp.Key); Assert.Equal("value", kvp.Value); });
Assert.IsType <DispatcherValueCollection.ListStorage>(dict._storage);
}
public void Clear_EmptyStorage()
{
// Arrange
var dict = new DispatcherValueCollection();
// Act
dict.Clear();
// Assert
Assert.Empty(dict);
Assert.IsType <DispatcherValueCollection.EmptyStorage>(dict._storage);
}
public void Clear_PropertyStorage_AlreadyEmpty()
{
// Arrange
var dict = new DispatcherValueCollection(new { });
// Act
dict.Clear();
// Assert
Assert.Empty(dict);
Assert.IsType <DispatcherValueCollection.PropertyStorage>(dict._storage);
}
public void TryMatch_RouteWithComplexSegment_Success(string template, string path)
{
var matcher = CreateMatcher(template);
var values = new DispatcherValueCollection();
// Act
var match = matcher.TryMatch(path, values);
// Assert
Assert.True(match);
}
public void Clear_PropertyStorage()
{
// Arrange
var dict = new DispatcherValueCollection(new { key = "value" });
// Act
dict.Clear();
// Assert
Assert.Empty(dict);
Assert.IsType <DispatcherValueCollection.ListStorage>(dict._storage);
}
private static bool TestConstraint(IDispatcherValueConstraint constraint, DispatcherValueCollection values, string routeKey)
{
var httpContext = new DefaultHttpContext();
var constraintPurpose = ConstraintPurpose.IncomingRequest;
var dispatcherValueConstraintContext = new DispatcherValueConstraintContext(httpContext, values, constraintPurpose)
{
Key = routeKey
};
return(constraint.Match(dispatcherValueConstraintContext));
}
public void RegexConstraint_TakesRegexAsInput_SimpleMatch()
{
// Arrange
var constraint = new RegexDispatcherValueConstraint(new Regex("^abc$"));
var values = new DispatcherValueCollection(new { controller = "abc" });
// Act
var match = TestConstraint(constraint, values, "controller");
// Assert
Assert.True(match);
}
public void RegexConstraintFailsIfKeyIsNotFoundInRouteValues()
{
// Arrange
var constraint = new RegexDispatcherValueConstraint(new Regex("^abc$"));
var values = new DispatcherValueCollection(new { action = "abc" });
// Act
var match = TestConstraint(constraint, values, "controller");
// Assert
Assert.False(match);
}