public void Setup()
{
Mock <IDefaultValueRelationSelector> defaultSourceSelector = new Mock <IDefaultValueRelationSelector>(MockBehavior.Strict);
defaultSourceSelector.Setup(instance => instance.ProvideDefault(It.IsAny <ParameterInfo>(), It.IsAny <Verb>()))
.Returns <ParameterInfo, Verb>((parameter, verb) => FromQueryStringAttribute.For(parameter));
defaultSourceSelector.Setup(instance => instance.ProvideDefault(It.IsAny <ParameterInfo>()))
.Returns <ParameterInfo>(parameter => new ToBodyAttribute());
_builder = new ControllerDescriptionBuilder <AnotherTestController <TestController> >(defaultSourceSelector.Object);
}
private static ParameterSourceAttribute GetDefaultParameterSource(ParameterInfo parameter)
{
if ((typeof(Guid) == parameter.ParameterType) || (typeof(DateTime) == parameter.ParameterType) ||
((parameter.ParameterType.IsIdentity()) && (PopularIdentifierPropertyNames.Contains(parameter.Name, StringComparer.OrdinalIgnoreCase))))
{
return(FromUrlAttribute.For(parameter));
}
if ((!parameter.ParameterType.IsValueType) && (typeof(string) != parameter.ParameterType) &&
(!((System.TypeExtensions.IsEnumerable(parameter.ParameterType)) && (parameter.ParameterType.GetItemType().IsNumber()))))
{
return(FromBodyAttribute.For(parameter));
}
return(FromQueryStringAttribute.For(parameter));
}
private static OperationInfo <Verb> CreateOperation(MethodInfo method, Verb verb)
{
string queryString = String.Empty;
string uriTemplate = null;
IList <ArgumentInfo> arguments = new List <ArgumentInfo>();
foreach (var parameter in method.GetParameters())
{
if (parameter.IsOut)
{
continue;
}
string parameterTemplate = null;
ParameterSourceAttribute source = null;
if (parameter.ParameterType == typeof(Guid))
{
source = FromUrlAttribute.For(parameter);
uriTemplate += (parameterTemplate = "/" + parameter.Name + "/{?value}");
}
else if (parameter.ParameterType.IsValueType)
{
source = FromQueryStringAttribute.For(parameter);
queryString += (parameterTemplate = "&" + parameter.Name + "={?value}");
}
else if (!parameter.ParameterType.IsValueType)
{
source = FromBodyAttribute.For(parameter);
}
arguments.Add(new ArgumentInfo(parameter, source, parameterTemplate, (parameterTemplate != null ? parameter.Name : null)));
}
if (queryString.Length > 0)
{
uriTemplate += "?" + queryString.Substring(1);
}
return(new OperationInfo <Verb>(method, (HttpUrl)UrlParser.Parse("/"), uriTemplate, new Regex(".*"), verb, arguments.ToArray()).WithSecurityDetailsFrom(method));
}
public void Setup()
{
var method = typeof(TestController).GetMethod("Add");
var baseUri = (HttpUrl)UrlParser.Parse("/api/test/");
var operationUri = ((HttpUrl)UrlParser.Parse("/add")).InsertSegments(0, baseUri.Segments);
var operation = new OperationInfo <Verb>(
method,
operationUri,
operationUri + "?operandA={?operandA}&operandB={?operandB}",
new Regex(operationUri.ToString(), RegexOptions.IgnoreCase),
Verb.GET,
new ArgumentInfo(method.GetParameters()[0], FromQueryStringAttribute.For(method.GetParameters()[0]), "&operandA={?operandA}", "operandA"),
new ArgumentInfo(method.GetParameters()[1], FromQueryStringAttribute.For(method.GetParameters()[1]), "&operandB={?operandB}", "operandB"));
var description = new ControllerInfo <TestController>(null, (HttpUrl)UrlParser.Parse("/api/test/"), operation);
Mock <IHttpControllerDescriptionBuilder <TestController> > builder = new Mock <IHttpControllerDescriptionBuilder <TestController> >();
builder.As <IControllerDescriptionBuilder>().Setup(instance => instance.BuildDescriptor()).Returns(description);
Mock <IControllerActivator> activator = new Mock <IControllerActivator>();
activator.Setup(instance => instance.CreateInstance(It.IsAny <Type>(), It.IsAny <IDictionary <string, object> >())).Returns(new TestController());
_mapper = new DelegateMapper(new IHttpControllerDescriptionBuilder[] { builder.Object }, activator.Object);
}
private static ParameterSourceAttribute GetParameterTarget(this ParameterInfo parameter)
{
var explicitSetting = parameter.GetCustomAttribute <ParameterSourceAttribute>(true);
if (explicitSetting != null)
{
return(explicitSetting);
}
if ((typeof(Guid) == parameter.ParameterType) || (typeof(DateTime) == parameter.ParameterType) ||
((IsIdentity(parameter.ParameterType)) &&
(PopularIdentifierPropertyNames.Contains(parameter.Name, StringComparer.OrdinalIgnoreCase))))
{
return(FromUrlAttribute.For(parameter));
}
if ((!parameter.ParameterType.IsValueType) && (typeof(string) != parameter.ParameterType) &&
(!((System.TypeExtensions.IsEnumerable(parameter.ParameterType)) && (IsNumber(parameter.ParameterType.GetItemType())))))
{
return(FromBodyAttribute.For(parameter));
}
return(FromQueryStringAttribute.For(parameter));
}
private object[] BindArguments(string callUri, MethodInfo method, Verb verb, bool indirectly = false)
{
var methodUri = Regex.Replace(callUri, "\\?.+", String.Empty);
var queryStringParameters = Regex.Matches(callUri, "[?&]([^=]+)=[^&]+").Cast <System.Text.RegularExpressions.Match>();
var queryStringRegex = (queryStringParameters.Any() ? "[?&](" + String.Join("|", queryStringParameters.Select(item => item.Groups[1].Value)) + ")=[^&]+" : String.Empty);
var arguments = method.GetParameters()
.Select(item => new ArgumentInfo(item, FromQueryStringAttribute.For(item), "&test={?test}", "test"));
var operation = new OperationInfo <Verb>(
method,
(HttpUrl)UrlParser.Parse(methodUri),
callUri,
new Regex("^" + methodUri + queryStringRegex + "$"),
verb,
arguments.ToArray());
var request = new RequestInfo(Verb.GET, (HttpUrl)UrlParser.Parse("http://temp.uri" + callUri), new MemoryStream(), new BasicClaimBasedIdentity());
var mapping = new RequestMapping(GetControllerInstance(), operation, (HttpUrl)UrlParser.Parse(methodUri));
if (indirectly)
{
return(_binder.BindArguments((IRequestInfo)request, (IRequestMapping)mapping));
}
return(_binder.BindArguments(request, mapping));
}
public void Setup()
{
var method = typeof(TestController).GetMethod("Add");
_controller = new TestController();
_operation = new OperationInfo <Verb>(
method,
(HttpUrl)UrlParser.Parse("/add"),
"/api/test/add?{?operandA}&{?operandB}",
new Regex(".*"),
Verb.GET,
method.GetParameters().Select(parameter => (ValueInfo) new ArgumentInfo(parameter, FromQueryStringAttribute.For(parameter), "add?{?" + parameter.Name + "}", parameter.Name)).ToArray());
var controllerInfo = new ControllerInfo <TestController>(null, (HttpUrl)UrlParser.Parse("api/test"), _operation);
Mock <IHttpControllerDescriptionBuilder> controllerDescriptionBuilder = new Mock <IHttpControllerDescriptionBuilder>(MockBehavior.Strict);
controllerDescriptionBuilder.Setup(instance => instance.BuildDescriptor()).Returns(controllerInfo);
Mock <IControllerActivator> controllerActivator = new Mock <IControllerActivator>(MockBehavior.Strict);
controllerActivator.Setup(instance => instance.CreateInstance(It.IsAny <Type>(), It.IsAny <IDictionary <string, object> >())).Returns(_controller);
_delegateMapper = new DelegateMapper(new[] { controllerDescriptionBuilder.Object }, controllerActivator.Object);
}
private static void CreateParameterTemplateRegex(this ParameterInfo parameter, FromQueryStringAttribute fromQueryString, out string parameterTemplateRegex)
{
var parameterName = UriTemplateBuilder.VariableTemplateRegex.Match(fromQueryString.UrlTemplate).Groups["ParameterName"].Value;
parameterTemplateRegex = (parameter.HasDefaultValue) || (!parameter.ParameterType.IsValueType) ?
String.Format("([?&]({0}=[^&]*)){{0,}}", parameterName) :
String.Format("([?&]({0}=[^&]*)){{1,}}", parameterName);
}
public void it_should_create_an_instance_correctly()
{
var result = FromQueryStringAttribute.For(Parameter);
result.Should().BeOfType <FromQueryStringAttribute>().Which.UrlTemplate.Should().Be("{?input}");
}
public void it_should_throw_when_no_parameter_is_provided()
{
((FromQueryStringAttribute)null).Invoking(_ => FromQueryStringAttribute.For(null)).ShouldThrow <ArgumentNullException>().Which.ParamName.Should().Be("parameter");
}
private static void CreateParameterTemplateRegex(this ParameterInfo parameter, FromQueryStringAttribute fromQueryString, out string parameterTemplateRegex)
{
var parameterName = UriTemplateBuilder.VariableTemplateRegex.Match(fromQueryString.UrlTemplate).Groups["ParameterName"].Value;
parameterTemplateRegex = (parameter.HasDefaultValue) || (!parameter.ParameterType.IsValueType) ?
String.Format("([?&]({0}=[^&]*)){{0,}}", parameterName) :
String.Format("([?&]({0}=[^&]*)){{1,}}", parameterName);
}
private OperationInfo <Verb> CreateOperation(string methodName)
{
var method = typeof(TestController).GetMethod(methodName);
var arguments = method.GetParameters().Select(parameter => (ValueInfo) new ArgumentInfo(parameter, FromQueryStringAttribute.For(parameter), "test", "test"));
return(new OperationInfo <Verb>(
method,
(HttpUrl)UrlParser.Parse("/"),
(arguments.Any() ? "test" : null),
new Regex(".*"),
Verb.GET,
arguments.ToArray())
.WithSecurityDetailsFrom(method));
}
