public void type_match_user_function_not_invoked_if_type_doesnt_match()
{
ParameterBindingRulesCollection pb = new ParameterBindingRulesCollection();
HttpParameterBinding mockBinding = new EmptyParameterBinding();
pb.Add(
typeof(string),
param =>
{
throw new InvalidOperationException("shouldn't be called");
}
);
pb.Insert(
0,
typeof(string),
param =>
{
throw new InvalidOperationException("shouldn't be called");
}
);
// Act
HttpParameterBinding b2 = pb.LookupBinding(
CreateParameterDescriptor(typeof(int), "first")
);
// Assert - made it through the action without throwing.
}
// Create an instance and add some default binders
internal static ParameterBindingRulesCollection GetDefaultParameterBinders()
{
ParameterBindingRulesCollection pb = new ParameterBindingRulesCollection();
pb.Add(
typeof(CancellationToken),
parameter => new CancellationTokenParameterBinding(parameter)
);
pb.Add(
typeof(HttpRequestMessage),
parameter => new HttpRequestParameterBinding(parameter)
);
// Warning binder for HttpContent.
pb.Add(
parameter =>
typeof(HttpContent).IsAssignableFrom(parameter.ParameterType)
? parameter.BindAsError(
Error.Format(
SRResources.ParameterBindingIllegalType,
parameter.ParameterType.Name,
parameter.ParameterName
)
)
: null
);
return(pb);
}
public void Lookup_is_ordered()
{
ParameterBindingRulesCollection pb = new ParameterBindingRulesCollection();
HttpParameterBinding mockBinding1 = new EmptyParameterBinding();
HttpParameterBinding mockBinding2 = new EmptyParameterBinding();
HttpParameterBinding mockBinding3 = new EmptyParameterBinding();
pb.Add(param => param.ParameterName == "first" ? mockBinding1 : null);
pb.Add(param => param.ParameterName == "first" ? mockBinding2 : null);
pb.Add(param => param.ParameterType == typeof(int) ? mockBinding3 : null);
// Act
HttpParameterBinding b1 = pb.LookupBinding(CreateParameterDescriptor(null, "first"));
HttpParameterBinding b2 = pb.LookupBinding(
CreateParameterDescriptor(typeof(string), "none")
);
HttpParameterBinding b3 = pb.LookupBinding(
CreateParameterDescriptor(typeof(int), "first")
);
HttpParameterBinding b4 = pb.LookupBinding(
CreateParameterDescriptor(typeof(int), "last")
);
// Assert
Assert.Equal(mockBinding1, b1);
Assert.Null(b2);
Assert.Equal(mockBinding1, b3);
Assert.Equal(mockBinding3, b4);
}
public void AsCollection()
{
ParameterBindingRulesCollection pb = new ParameterBindingRulesCollection();
// Knowing that it's a collection means we have known behavior around
// the collection methods (like insert, add, clear, etc).
Assert.True(pb is Collection <Func <HttpParameterDescriptor, HttpParameterBinding> >);
}
public void Lookup_empty_collection_returns_null()
{
// The collection is empty, so lookup will fail.
ParameterBindingRulesCollection pb = new ParameterBindingRulesCollection();
HttpParameterDescriptor parameter = CreateParameterDescriptor(typeof(object), "none");
// Act
HttpParameterBinding binding = pb.LookupBinding(parameter);
// Assert.
Assert.Null(binding);
}
public void Add_with_type_match()
{
ParameterBindingRulesCollection pb = new ParameterBindingRulesCollection();
HttpParameterBinding mockBinding = new EmptyParameterBinding();
pb.Add(typeof(string), param => mockBinding);
// Act
HttpParameterBinding b1 = pb.LookupBinding(CreateParameterDescriptor(typeof(string), "first"));
HttpParameterBinding b2 = pb.LookupBinding(CreateParameterDescriptor(typeof(int), "first"));
// Assert
Assert.Equal(mockBinding, b1);
Assert.Null(b2); // doesn't match type, misses.
}
public void Insert_with_type_match()
{
ParameterBindingRulesCollection pb = new ParameterBindingRulesCollection();
HttpParameterBinding mockBinding1 = new EmptyParameterBinding();
HttpParameterBinding mockBinding2 = new EmptyParameterBinding();
HttpParameterBinding mockBinding3 = new EmptyParameterBinding();
// Act, test insertion
pb.Add(typeof(string), param => mockBinding2);
pb.Add(typeof(int), param => mockBinding2);
pb.Insert(0, typeof(string), param => mockBinding1);
pb.Insert(2, typeof(int), param => mockBinding3); // goes in middle
// Assert via lookups
Assert.Equal(mockBinding1, pb.LookupBinding(CreateParameterDescriptor(typeof(string), "first")));
Assert.Equal(mockBinding3, pb.LookupBinding(CreateParameterDescriptor(typeof(int), "first")));
}
// Determine how a single parameter will get bound.
// This is all sync. We don't need to actually read the body just to determine that we'll bind to the body.
protected virtual HttpParameterBinding GetParameterBinding(
HttpParameterDescriptor parameter
)
{
// Attribute has the highest precedence
// Presence of a model binder attribute overrides.
ParameterBindingAttribute attr = parameter.ParameterBinderAttribute;
if (attr != null)
{
return(attr.GetBinding(parameter));
}
// No attribute, so lookup in global map.
ParameterBindingRulesCollection pb = parameter.Configuration.ParameterBindingRules;
if (pb != null)
{
HttpParameterBinding binding = pb.LookupBinding(parameter);
if (binding != null)
{
return(binding);
}
}
// Not explicitly specified in global map or attribute.
// Use a default policy to determine it. These are catch-all policies.
Type type = parameter.ParameterType;
if (TypeHelper.CanConvertFromString(type))
{
// For simple types, the default is to look in URI. Exactly as if the parameter had a [FromUri] attribute.
return(parameter.BindWithAttribute(new FromUriAttribute()));
}
// Fallback. Must be a complex type. Default is to look in body. Exactly as if this type had a [FromBody] attribute.
attr = new FromBodyAttribute();
return(attr.GetBinding(parameter));
}