private void IndexHandler(ResourceModel resource, HandlerModel handler, ResourceMetadata metadata)
{
var exclusions = new List <string> {
"ToString", "GetType", "GetHashCode", "Equals"
};
foreach (var uri in metadata.Uris)
{
var candidateMethods = handler.Type.StaticType.GetMethods()
.Where(x => x.IsPublic)
.Where(x => !exclusions.Contains(x.Name))
.Where(x => !x.IsSpecialName)
.Where(x => !IsMethodObsolete(x))
.ToList();
foreach (var publicMethod in candidateMethods)
{
var operation = new OperationMetadata(uri, resource.ResourceKey as IType);
if (DiscoveryRules.All(x => x.Discover(publicMethod, operation)))
{
metadata.Add(operation);
operation.Group = _grouper.Group(resource, uri, operation);
}
}
}
}
public void SetUp()
{
_sut = new DiscoverReturnType();
_returnType = new Mock<IMember>();
_metadata = new OperationMetadata(new UriModel { Uri = "/some/uri" }, _returnType.Object);
}
public void NamesMatchCorrectly()
{
var method1 = typeof(SampleHandler).GetMethod("NameTest1");
var method2 = typeof(SampleHandler).GetMethod("NameTest2");
var metadata = new OperationMetadata(new UriModel { Uri = "/some/uri", Name = "NameTest1" }, null);
Assert.IsTrue(_sut.Discover(method1, metadata));
Assert.IsFalse(_sut.Discover(method2, metadata));
}
public void CanFindQueryParamForPrimativeType()
{
var methodToDetect = typeof(TestHandler).GetMethod("GetInt");
var metadata = new OperationMetadata(new UriModel { Uri = "/some/uri?s={i}" });
_sut.Discover(methodToDetect, metadata);
Assert.That(metadata.InputParameters[0].LocationType, Is.EqualTo(InputParameter.LocationTypes.Query));
}
public void CanFindPathParam()
{
var methodToDetect = typeof(TestHandler).GetMethod("GetString");
var metadata = new OperationMetadata(new UriModel { Uri = "/some/uri/{s}" });
_sut.Discover(methodToDetect, metadata);
Assert.That(metadata.InputParameters[0].LocationType, Is.EqualTo(InputParameter.LocationTypes.Path));
}
public OperationGroup Group(ResourceModel resourceModel, UriModel uriModel, OperationMetadata operation)
{
var operationCanBeGroupedByUri = _groupRegex.Match(uriModel.Uri);
if (!operationCanBeGroupedByUri.Success)
{
return new OperationGroup { Name = "everything else", Path = "misc" };
}
string resourceName = operationCanBeGroupedByUri.Groups[1].Value.ToLower();
return new OperationGroup
{
Name = string.Format("Operations about {0}", resourceName),
Path = resourceName
};
}
public void CanFindHeaderParams()
{
var methodToDetect = typeof(TestHandler).GetMethod("GetString");
var metadata = new OperationMetadata(new UriModel { Uri = "/some" });
_sut.Discover(methodToDetect, metadata);
Assert.That(metadata.InputParameters[1].LocationType, Is.EqualTo(InputParameter.LocationTypes.Header));
Assert.That(metadata.InputParameters[1].Name, Is.EqualTo("A required header name"));
Assert.That(metadata.InputParameters[1].Type, Is.EqualTo(typeof(int)));
Assert.That(metadata.InputParameters[1].IsRequired, Is.EqualTo(true));
Assert.That(metadata.InputParameters[2].LocationType, Is.EqualTo(InputParameter.LocationTypes.Header));
Assert.That(metadata.InputParameters[2].Name, Is.EqualTo("A header name"));
Assert.That(metadata.InputParameters[2].Type, Is.EqualTo(typeof(string)));
Assert.That(metadata.InputParameters[2].IsRequired, Is.EqualTo(false));
}
private void IndexHandler(ResourceModel resource, HandlerModel handler, ResourceMetadata metadata)
{
var exclusions = new List<string> { "ToString", "GetType", "GetHashCode", "Equals" };
foreach (var uri in metadata.Uris)
{
var candidateMethods = handler.Type.StaticType.GetMethods()
.Where(x => x.IsPublic && !exclusions.Contains(x.Name) && !x.IsSpecialName);
foreach (var publicMethod in candidateMethods)
{
var operation = new OperationMetadata(uri, resource.ResourceKey as IType);
if (DiscoveryRules.All(x => x.Discover(publicMethod, operation)))
{
metadata.Add(operation);
operation.Group = _grouper.Group(resource, uri, operation);
}
}
}
}
public OperationGroup Group(ResourceModel resourceModel, UriModel uriModel, OperationMetadata operation)
{
if (IsUnknownReturnType(operation.ReturnType))
{
return new OperationGroup { Name = "Unknown", Path = "unknown" };
}
if (IsEnumerableButNotAString(operation))
{
var collectionType = operation.ReturnType.GetElementType();
if (operation.ReturnType.IsGenericType)
{
collectionType = operation.ReturnType.GetGenericArguments()[0];
}
return new OperationGroup
{
Name = "Collection of " + collectionType.Name,
Path = collectionType.Name.ToLower() + "[]"
};
}
return new OperationGroup {Name = operation.ReturnType.Name, Path = operation.ReturnType.Name.ToLower()};
}
public void IfComplexTypeAndSpecifiedInPath()
{
var methodToDetect = typeof(TestHandler).GetMethod("GetRequest");
var metadata = new OperationMetadata(new UriModel { Uri = "/some/uri/{req}" });
_sut.Discover(methodToDetect, metadata);
Assert.That(metadata.InputParameters[0].LocationType, Is.EqualTo(InputParameter.LocationTypes.Path));
Assert.That(metadata.InputParameters[0].Type, Is.EqualTo(typeof(string)));
}
public void InfersSimpleParamToBeQueryStringWhenNotSpecified()
{
var methodToDetect = typeof(TestHandler).GetMethod("GetString");
var metadata = new OperationMetadata(new UriModel { Uri = "/some/uri" });
_sut.Discover(methodToDetect, metadata);
Assert.That(metadata.InputParameters[0].LocationType, Is.EqualTo(InputParameter.LocationTypes.Query));
}
public void InfersComplexParamToBeBody()
{
var methodToDetect = typeof(TestHandler).GetMethod("GetRequest");
var metadata = new OperationMetadata(new UriModel { Uri = "/some/uri" });
_sut.Discover(methodToDetect, metadata);
Assert.That(metadata.InputParameters[0].LocationType, Is.EqualTo(InputParameter.LocationTypes.Body));
}
public void SetUp()
{
_sut = new DiscoverHttpMethodVerbs();
_metadata = new OperationMetadata(new UriModel { Uri = "/some/uri" });
}
public void ParamsMatch()
{
var method1 = typeof(TestHandler).GetMethod("ParamTest1");
var method2 = typeof(TestHandler).GetMethod("ParamTest2");
var metadata = new OperationMetadata(new UriModel { Uri = "/some/uri/{myString}" }, null);
Assert.That(_sut.Discover(method1, metadata), Is.True);
Assert.That(_sut.Discover(method2, metadata), Is.False);
}
public bool Discover(MethodInfo method, OperationMetadata methodMetdata)
{
Called = true;
MethodInfo = method;
return true;
}
private static bool IsEnumerableButNotAString(OperationMetadata operation)
{
return (operation.ReturnType != typeof(string)) && operation.ReturnType.Implements<IEnumerable>();
}
