public static string GetModifiers(MethodMetadata model)
{
string type = null;
type += model.Modifiers.AccessLevel.ToString().ToLower() + " ";
type += model.Modifiers.AbstractEnum == AbstractEnum.Abstract ? AbstractEnum.Abstract.ToString().ToLower() + " " : String.Empty;
type += model.Modifiers.StaticEnum == StaticEnum.Static ? StaticEnum.Static.ToString().ToLower() + " " : String.Empty;
type += model.Modifiers.VirtualEnum == VirtualEnum.Virtual ? VirtualEnum.Virtual.ToString().ToLower() + " " : String.Empty;
return(type);
}
public void Can_add_header_parameter()
{
MethodMetadata metadata = new MethodMetadata();
metadata.AddHeaderParameter("Header-Name", "Header-Value");
WebRequest request = CreateRequest(metadata);
Assert.AreEqual("Header-Value", request.Headers["Header-Name"]);
}
public void Accept_header_defaults_to_consumes_property()
{
MethodMetadata metadata = new MethodMetadata();
metadata.Consumes = "application/json";
HttpWebRequest request = (HttpWebRequest)CreateRequest(metadata);
Assert.AreEqual("application/json", request.Accept);
}
internal MethodMetadata GetMethodMetadata(ActionModel actionModel, JsonRpcMethodOptions methodOptions)
{
var serializer = Utils.GetSerializer(serializers, methodOptions.RequestSerializer);
var controllerName = serializer.GetJsonName(actionModel.Controller.ControllerName);
var actionName = serializer.GetJsonName(actionModel.ActionName);
var result = new MethodMetadata(methodOptions, controllerName, actionName);
log.LogTrace($"{actionModel.DisplayName}: metadata [{result}]");
return(result);
}
public void Full_uri_uses_service_path()
{
MethodMetadata meta = new MethodMetadata {
ServicePath = "/service/1.0"
};
WebRequest request = CreateRequest(meta);
Assert.AreEqual("http://example.com/service/1.0/", request.RequestUri.AbsoluteUri);
}
public void Request_method_is_set_to_verb_property()
{
MethodMetadata metadata = new MethodMetadata {
Verb = HttpVerb.DELETE
};
HttpWebRequest request = (HttpWebRequest)CreateRequest(metadata);
Assert.AreEqual("DELETE", request.Method);
}
public void Can_add_content_type_header()
{
MethodMetadata metadata = new MethodMetadata();
metadata.AddHeaderParameter("Content-Type", "application/json");
WebRequest request = CreateRequest(metadata);
Assert.AreEqual("application/json", request.ContentType);
}
public void Can_add_accept_header()
{
MethodMetadata metadata = new MethodMetadata();
metadata.AddHeaderParameter("Accept", "application/json");
HttpWebRequest request = (HttpWebRequest)CreateRequest(metadata);
Assert.AreEqual("application/json", request.Accept);
}
private static MethodDTG MethodDtg(MethodMetadata methodModel)
{
return(new MethodDTG()
{
Name = methodModel.Name,
MetadataName = methodModel.MetadataName,
SerReturnType = LoadType(methodModel.ReturnType),
SerParameters = methodModel.Parameters?.Select(ParameterDtg).ToList()
});
}
private static DTGTypeMetadata EmitReturnTypeDTG(MethodMetadata method)
{
MethodMetadata methodInfo = method as MethodMetadata;
if (methodInfo == null)
{
return(null);
}
return(TypeMapper.EmitReferenceDTG(methodInfo.ReturnType));
}
internal OverrideActionMethodSelector(List <MethodInfo> namedMethods)
{
_metadataList = new MethodMetadata[namedMethods.Count];
for (int i = 0; i < namedMethods.Count; i++)
{
var namedMethod = namedMethods[i];
MethodMetadata metadata = GetMethodMetadata(namedMethod);
_metadataList[i] = metadata;
}
}
public DelegateMetadata Build()
{
var methodMetadata = new MethodMetadata(
Lambda.Method,
Name,
hasInstance: true,
parameters: BuildParameterMetadatas()
);
return(new DelegateMetadata(Lambda, methodMetadata));
}
public void Test_GetActionName_ThrowsOnUnknown()
{
var matcher = testEnvironment.ServiceProvider.GetRequiredService <MethodMatcher>();
var metadata = new MethodMetadata(new JsonRpcMethodOptions()
{
MethodStyle = (MethodStyle)(-1)
}, new JsonName("", ""), new JsonName("", ""));
Action action = () => matcher.GetActionName(metadata);
action.Should().Throw <ArgumentOutOfRangeException>();
}
public void Test_GetActionName_ReturnsName(MethodStyle style, string expected)
{
var matcher = testEnvironment.ServiceProvider.GetRequiredService <MethodMatcher>();
var metadata = new MethodMetadata(new JsonRpcMethodOptions()
{
MethodStyle = style
}, new JsonName("", "controller"), new JsonName("", "action"));
var result = matcher.GetActionName(metadata);
result.Should().Be(expected);
}
public static TypeViewModelAbstract CreateTypeViewClass(MethodMetadata metadata)
{
switch (metadata)
{
case ConstructorMetadata constructorMetadata:
return(new ConstructorViewModel(constructorMetadata));
default:
return(new MethodViewModel(metadata));
}
}
private MethodMetadata GetMethodMetadata(MethodKey key)
{
MethodMetadata metadata;
if (!MethodAttributes.TryGetValue(key, out metadata))
{
metadata = new MethodMetadata(key.Parameters.Count);
}
return(metadata);
}
public void Can_add_query_parameters_to_request()
{
MethodMetadata meta = new MethodMetadata();
meta.AddQueryParameter("q", "test");
meta.AddQueryParameter("q2", "test2");
WebRequest request = CreateRequest(meta);
Assert.AreEqual("http://example.com/?q=test&q2=test2", request.RequestUri.AbsoluteUri);
}
private object GetResult(MethodMetadata methodMetadata, IResponse response)
{
var responseMetadata = methodMetadata.Response;
var responseType = response.GetType();
if (responseMetadata.ResultType.IsAssignableFrom(responseType))
{
return(response);
}
return(_modelMapper.MapResponse(methodMetadata.Response, response));
}
public static IEnumerable <ParameterBinder> GetParameterBinders(this MethodMetadata method)
{
var binders = method.Attributes.OfType <ParameterBinderCollection>().FirstOrDefault();
if (binders == null)
{
binders = new ParameterBinderCollection(CreateParameterBinders(method).ToArray());
method.Attributes.Add(binders);
}
return(binders.Binders);
}
public static DTGMethodMetadata MapToDTGModel(MethodMetadata methodMetadata)
{
DTGMethodMetadata methodModel = new DTGMethodMetadata
{
Name = methodMetadata.Name,
GenericArguments = TypeMapper.EmitGenericArgumentsDTG(methodMetadata.GenericArguments),
ReturnType = EmitReturnTypeDTG(methodMetadata),
Parameters = EmitParametersDTG(methodMetadata.Parameters),
};
return(methodModel);
}
public void Test_IsMatch_ComparesIgnoreCase(string method, bool expected)
{
var matcher = testEnvironment.ServiceProvider.GetRequiredService <MethodMatcher>();
var metadata = new MethodMetadata(new JsonRpcMethodOptions()
{
MethodStyle = MethodStyle.ActionOnly
}, new JsonName("", ""), new JsonName("", "action"));
var result = matcher.IsMatch(metadata, method);
result.Should().Be(expected);
}
public void Method_path_is_appended_to_uri()
{
MethodMetadata meta = new MethodMetadata
{
ServicePath = "api/v1",
MethodPath = "/action"
};
WebRequest request = CreateRequest(meta);
Assert.AreEqual("http://example.com/api/v1/action", request.RequestUri.AbsoluteUri);
}
public static MethodMetadata MapToModel(DTGMethodMetadata methodMetadata)
{
MethodMetadata methodModel = new MethodMetadata
{
Name = methodMetadata.Name,
GenericArguments = TypeMapper.EmitGenericArgumentsModel(methodMetadata.GenericArguments),
ReturnType = EmitReturnTypeModel(methodMetadata),
Parameters = EmitParametersModel(methodMetadata.Parameters),
};
return(methodModel);
}
public void Test_GetRpcBindingContext_ThrowsOnNoParameterMetadata()
{
var methodMetadata = new MethodMetadata(new JsonRpcMethodOptions(), new JsonName("test", "test"), new JsonName("test", "test"));
var bindingContextMock = MockContext(methodMetadata: methodMetadata);
var binder = testEnvironment.ServiceProvider.GetRequiredService <JsonRpcModelBinder>();
Action action = () => binder.GetRpcBindingContext(bindingContextMock.Object, "test");
action.Should().Throw <ArgumentNullException>();
bindingContextMock.VerifyGet(x => x.HttpContext);
bindingContextMock.VerifyGet(x => x.ActionContext);
}
private TreeItem MapItem(MethodMetadata objectToMap)
{
bool hasChildren =
objectToMap.GenericArguments.Any() ||
objectToMap.Parameters.Any();
return(new TreeItem(
$"{objectToMap.Modifiers.Item1} " +
$"{objectToMap.ReturnType?.Name ?? "void"} " +
$"{objectToMap.Name}",
hasChildren));
}
/// <summary>
/// Returns the test file that is associated with the
/// given type
/// </summary>
/// <param name="methodMetadata">The type to determine the test file for</param>
/// <returns>The test file that should contain the tests for the specified type</returns>
public TestFile MapMethodToTestFile(MethodMetadata methodMetadata)
{
List <string> paths = new List <string>();
paths.Add(BaseDirectory);
paths.AddRange(methodMetadata.ParentType.Namespace.Split('.'));
paths.Add(methodMetadata.Name + "Tests.cs");
string pathToTestFile = Path.Combine(paths.ToArray());
return(new TestFile(pathToTestFile));
}
public void Test_ParseObject_ThrowsOnUnknownIfNotAllowed()
{
jsonRpcOptions.AllowRawResponses = false;
var converter = GetConverterMock();
var serializerMock = new Mock <IJsonRpcSerializer>();
serializerMock.Setup(x => x.Serializer)
.Returns(new JsonSerializer());
var metadata = new MethodMetadata(new JsonRpcMethodOptions(), new JsonName("", ""), new JsonName("", ""));
Action action = () => converter.Object.ConvertActionResult(new FileContentResult(new byte[] { }, "application/octet-stream"), metadata, serializerMock.Object);
action.Should().Throw <JsonRpcInternalException>();
}
private IRestRequest GetRequest(MethodMetadata methodMetadata, object[] args)
{
var bindingSource = new ModelBindingSource();
foreach (var parameter in methodMetadata.MethodInfo.GetParameters())
{
var parameterValue = new RestValue(args[parameter.Position], parameter.ParameterType);
bindingSource.AddValue(parameter.Name, parameterValue);
}
return(_modelMapper.MapRequest(methodMetadata.Request, bindingSource));
}
private static MethodMetadata InstantiateMethodWithType(
MethodMetadata methodTemplate,
TypeMetadata typeMetadata)
{
return(new MethodMetadata(
methodTemplate.Name,
methodTemplate.ProtectionLevel,
methodTemplate.IsStatic)
{
ReturnType = methodTemplate.ReturnType == s_arrayProbeTypeMetadata ? typeMetadata : methodTemplate.ReturnType,
GenericParameters = InstantiateGenericParameterListWithType(methodTemplate.GenericParameters, typeMetadata)
});
}
public void Uri_is_escaped()
{
MethodMetadata meta = new MethodMetadata
{
MethodPath = "/users/{user}"
};
meta.AddPathParameter("user", "bart simpson");
WebRequest request = CreateRequest(meta);
Assert.AreEqual("http://example.com/users/bart%20simpson", request.RequestUri.AbsoluteUri);
}
public virtual void DeserializeAllMetadataAndCacheIt(Stream byteStream)
{
long initialStreamPostion = byteStream.Position;
uint metadataByteCount = byteStream.DeserializeUint32();
long metadataLastBytePosition = metadataByteCount + sizeof (uint) + initialStreamPostion;
while (byteStream.Position < metadataLastBytePosition)
{
MetadataTypes metadataType = byteStream.DeserializeMetadataType();
MetadataBase result = null;
switch (metadataType)
{
case MetadataTypes.AssemblyMetadata:
var assemblyMetadata = new AssemblyMetadata(byteStream);
_assemblyCache.Add(assemblyMetadata);
result = assemblyMetadata;
break;
case MetadataTypes.ModuleMedatada:
var moduleMetadata = new ModuleMetadata(byteStream, _assemblyCache);
_moduleCache.Add(moduleMetadata);
result = moduleMetadata;
break;
case MetadataTypes.ClassMedatada:
var classMetadata = new ClassMetadata(byteStream, _moduleCache);
_classCache.Add(classMetadata);
result = classMetadata;
break;
case MetadataTypes.MethodMedatada:
var methodMetadata = new MethodMetadata(byteStream, _classCache, _sourceLocatorFactory);
_methodCache.Add(methodMetadata);
result = methodMetadata;
break;
default:
throw new ArgumentOutOfRangeException();
}
Contract.Assume(result != null);
Contract.Assume(result.Id != 0);
Contract.Assume(result.MdToken != 0);
Contract.Assume(metadataType == result.MetadataType);
}
}
public SamplingMethodAggregator(MethodMetadata methodMd)
{
FunctionId = methodMd.Id;
MethodMd = methodMd;
}
/// <summary>
/// Transforms the <paramref name="method" />.
/// </summary>
private static Ssm.Method Transform(MethodMetadata method)
{
var transformation = new MethodBodyTransformation(method.DeclaringObject);
var methodBody = method.MethodBody;
var locals = methodBody == null ? Enumerable.Empty<Ssm.Var>() : methodBody.LocalVariables.Select(Transform);
var body = methodBody == null ? Ssm.Stm.NopStm : transformation.TransformMethodBody(methodBody.Body);
Ssm.MethodKind kind;
if (method is RequiredPortMetadata)
kind = Ssm.MethodKind.ReqPort;
else if (method is ProvidedPortMetadata || method is GuardMetadata || method is ActionMetadata)
kind = Ssm.MethodKind.ProvPort;
else if (method is FaultEffectMetadata) // TODO: Fault effects for non-provided ports
kind = Ssm.MethodKind.ProvPort;
else
kind = Ssm.MethodKind.Step;
return Ssm.CreateMethod(method.Name, method.MethodInfo.GetParameters().Select(Transform), body,
Transform(method.MethodInfo.ReturnType), locals, kind);
}
/// <summary>
/// Recursively inlines all methods invoked within <paramref name="method" />'s body.
/// </summary>
/// <param name="method">The method which should have all invoked methods inlined.</param>
public static MethodBodyMetadata Inline(MethodMetadata method)
{
Requires.NotNull(method, () => method);
return Inline(method.MethodBody, _ => true);
}
public ISourceLocator GetSourceLocator(MethodMetadata methodMd)
{
return GetSourceLocator(methodMd.Class.Module.FilePath);
}
public ISourceLocator GetSourceLocator(MethodMetadata methodMd)
{
ISourceLocator sourceLocator = GetSourceLocator(methodMd.Class.Module.FilePath);
return sourceLocator;
}
public void SetUp()
{
var mockModuleCache = new Mock<MetadataCache<ModuleMetadata>>(MockBehavior.Strict);
mockModuleCache.Setup(cache => cache[It.IsAny<uint>()]).Returns(() => null);
_classMetadata = new ClassMetadata(_classBytes.ConvertToMemoryStream(), mockModuleCache.Object);
var mockClassCache = new Mock<MetadataCache<ClassMetadata>>(MockBehavior.Strict);
mockClassCache.Setup(cache => cache[It.IsAny<uint>()]).Returns(_classMetadata);
_mockMethodLine = new Mock<IMethodLine>(MockBehavior.Strict);
_mockMethodLine.SetupGet(meLin => meLin.StartLine).Returns(12);
_mockMethodLine.SetupGet(meLin => meLin.EndLine).Returns(12);
_mockMethodLine.SetupGet(meLin => meLin.StartIndex).Returns(160);
_mockMethodLine.SetupGet(meLin => meLin.EndIndex).Returns(220);
_mockMethodLine.SetupGet(meLin => meLin.StartColumn).Returns(10);
_mockMethodLine.SetupGet(meLin => meLin.EndColumn).Returns(70);
var mockSourceLocator = new Mock<ISourceLocator>(MockBehavior.Strict);
mockSourceLocator.Setup(soLoc => soLoc.GetMethodLines(It.IsAny<uint>())).Returns(
new[]
{
_mockMethodLine.Object,
_mockMethodLine.Object,
_mockMethodLine.Object
});
mockSourceLocator.Setup(soLoc => soLoc.GetSourceFilePath(It.IsAny<uint>())).Returns(SourceFilePath);
_mockSourceLocatorFactory = new Mock<ISourceLocatorFactory>(MockBehavior.Strict);
_mockSourceLocatorFactory.Setup(soFac => soFac.GetSourceLocator(It.IsAny<MethodMetadata>())).Returns(
mockSourceLocator.Object);
_methodMetadata1 = new MethodMetadata(_method1Bytes.ConvertToMemoryStream(), mockClassCache.Object,
_mockSourceLocatorFactory.Object);
_methodMetadata2 = new MethodMetadata(_method2Bytes.ConvertToMemoryStream(), mockClassCache.Object,
_mockSourceLocatorFactory.Object);
_methodMetadata3 = new MethodMetadata(_method3Bytes.ConvertToMemoryStream(), mockClassCache.Object,
_mockSourceLocatorFactory.Object);
mockClassCache.Verify(cache => cache[It.IsAny<uint>()], Times.Exactly(3));
}
/// <summary>
/// Dumps the specified Method metadata instance
/// </summary>
/// <param name="meth">The Method metadata to dump</param>
internal void Dump(MethodMetadata meth)
{
Begin("MethodMetadata", "Name", meth.Name, "IsStatic", meth.IsStatic);
Dump(meth.DefiningType, "DeclaringType");
Dump(meth.Parameters);
Dump(meth.Type, "ReturnType");
End("MethodMetadata");
}
