public void BindUriFunctionName_CanBindStaticAndInstanceOfDifferentDeclerationType()
{
const string FUNCTION_NAME = "addtwice";
MethodInfo addTwiceStaticMethodInfo = typeof(UriFunctionBinderTests).GetMethod("AddStringTwiceStatic", BindingFlags.NonPublic | BindingFlags.Static);
MethodInfo addTwiceInstanceMethodInfo = typeof(UriFunctionBinderTests).GetMethod("AddStringTwiceInstance", BindingFlags.NonPublic | BindingFlags.Instance);
try
{
UriFunctionsBinder.BindUriFunctionName(FUNCTION_NAME, addTwiceStaticMethodInfo);
UriFunctionsBinder.BindUriFunctionName(FUNCTION_NAME, addTwiceInstanceMethodInfo);
MethodInfo resultMethoInfoStatic;
UriFunctionsBinder.TryGetMethodInfo(FUNCTION_NAME, new Type[] { typeof(string), typeof(string) }, out resultMethoInfoStatic);
Assert.Equal(addTwiceStaticMethodInfo, resultMethoInfoStatic);
MethodInfo resultMethoInfoInstance;
UriFunctionsBinder.TryGetMethodInfo(FUNCTION_NAME, new Type[] { typeof(UriFunctionBinderTests), typeof(string) }, out resultMethoInfoInstance);
Assert.Equal(addTwiceInstanceMethodInfo, resultMethoInfoInstance);
}
finally
{
Assert.True(
UriFunctionsBinder.UnbindUriFunctionName(FUNCTION_NAME, addTwiceStaticMethodInfo));
Assert.True(
UriFunctionsBinder.UnbindUriFunctionName(FUNCTION_NAME, addTwiceInstanceMethodInfo));
}
}
public void BindUriFunctionName_MethodInfoNull()
{
Action bindUriFunction = () =>
UriFunctionsBinder.BindUriFunctionName("startswith", null);
ExceptionAssert.ThrowsArgumentNull(bindUriFunction, "methodInfo");
}
/// <summary>
/// This is a shortcut of removing the FunctionSignature through 'CustomUriFunctions' class and
/// unbinding the function name from it's MethodInfo through 'UriFunctionsBinder' class.
/// See these classes documentations.
/// </summary>
/// <param name="functionName">The uri function name that appears in the OData request uri.</param>
/// <param name="functionSignature">The new custom function signature.</param>
/// <param name="methodInfo">The MethodInfo to bind the given function name.</param>
/// <exception cref="Exception">Any exception thrown by 'CustomUriFunctions.RemoveCustomUriFunction' and 'UriFunctionsBinder.UnbindUriFunctionName' methods.</exception>
/// <returns>'True' if the fucntion signature has successfully removed and unbinded. 'False' otherwise.</returns>
public static bool RemoveCustomUriFunction(string functionName,
FunctionSignatureWithReturnType functionSignature, MethodInfo methodInfo)
{
return
(CustomUriFunctions.RemoveCustomUriFunction(functionName, functionSignature) &&
UriFunctionsBinder.UnbindUriFunctionName(functionName, methodInfo));
}
public void UnbindUriFunctionName_FunctionNameNull()
{
MethodInfo padRightStringMethodInfo = typeof(string).GetMethod("PadRight", new Type[] { typeof(int) });
Action bindUriFunction = () =>
UriFunctionsBinder.UnbindUriFunctionName(null, padRightStringMethodInfo);
Assert.ThrowsArgumentNull(bindUriFunction, "functionName");
}
public void BindUriFunctionName_FunctionNameStringEmpty()
{
MethodInfo padRightStringMethodInfo = typeof(string).GetMethod("PadRight", new Type[] { typeof(int) });
Action bindUriFunction = () =>
UriFunctionsBinder.BindUriFunctionName(string.Empty, padRightStringMethodInfo);
ExceptionAssert.ThrowsArgumentNull(bindUriFunction, "functionName");
}
public void UnbindUriFunctionName_CanUnbindInstanceMethod()
{
const string FUNCTION_NAME = "padright";
MethodInfo padRightStringMethodInfo = typeof(string).GetMethod("PadRight", new Type[] { typeof(int) });
UriFunctionsBinder.BindUriFunctionName(FUNCTION_NAME, padRightStringMethodInfo);
Assert.True(UriFunctionsBinder.UnbindUriFunctionName(FUNCTION_NAME, padRightStringMethodInfo));
MethodInfo resultMethoInfo;
Assert.False(UriFunctionsBinder.TryGetMethodInfo(FUNCTION_NAME, new Type[] { typeof(string), typeof(int) }, out resultMethoInfo));
Assert.Null(resultMethoInfo);
}
public void UnbindUriFunctionName_CanUnbindExtensionStaticMethod()
{
const string FUNCTION_NAME = "addtwice";
MethodInfo addStrTwiceStaticExtensionMethodInfo =
typeof(UriFunctionClrBinderTestsStaticExtensionMethods).GetMethod("AddStringTwice", BindingFlags.NonPublic | BindingFlags.Static);
UriFunctionsBinder.BindUriFunctionName(FUNCTION_NAME, addStrTwiceStaticExtensionMethodInfo);
Assert.True(UriFunctionsBinder.UnbindUriFunctionName(FUNCTION_NAME, addStrTwiceStaticExtensionMethodInfo));
MethodInfo resultMethoInfo;
Assert.False(UriFunctionsBinder.TryGetMethodInfo(FUNCTION_NAME, new Type[] { typeof(string), typeof(string) }, out resultMethoInfo));
Assert.Null(resultMethoInfo);
}
public void UnbindUriFunctionName_CannotUnbindNotBindedFunction_DifferentFunctionName()
{
const string FUNCTION_NAME = "padright";
MethodInfo padRightStringMethodInfo = typeof(string).GetMethod("PadRight", new Type[] { typeof(int) });
try
{
UriFunctionsBinder.BindUriFunctionName(FUNCTION_NAME, padRightStringMethodInfo);
Assert.False(UriFunctionsBinder.UnbindUriFunctionName("AnotherFunctionName", padRightStringMethodInfo));
}
finally
{
Assert.True(UriFunctionsBinder.UnbindUriFunctionName(FUNCTION_NAME, padRightStringMethodInfo));
}
}
/// <summary>
/// This is a shortcut of adding the custom FunctionSignature through 'CustomUriFunctions' class and
/// binding the function name to it's MethodInfo through 'UriFunctionsBinder' class.
/// See these classes documentations.
/// In case of an exception, both operations(adding the signature and binding the function) will be undone.
/// </summary>
/// <param name="functionName">The uri function name that appears in the OData request uri.</param>
/// <param name="functionSignature">The new custom function signature.</param>
/// <param name="methodInfo">The MethodInfo to bind the given function name.</param>
/// <exception cref="Exception">Any exception thrown by 'CustomUriFunctions.AddCustomUriFunction' and 'UriFunctionBinder.BindUriFunctionName' methods.</exception>
public static void AddCustomUriFunction(string functionName,
FunctionSignatureWithReturnType functionSignature, MethodInfo methodInfo)
{
try
{
// Add to OData.Libs function signature
CustomUriFunctions.AddCustomUriFunction(functionName, functionSignature);
// Bind the method to it's MethoInfo
UriFunctionsBinder.BindUriFunctionName(functionName, methodInfo);
}
catch
{
// Clear in case of excpetion
RemoveCustomUriFunction(functionName, functionSignature, methodInfo);
throw;
}
}
public void UnbindUriFunctionName_CannotUnbindWithDifferentMethod()
{
const string FUNCTION_NAME = "padright";
MethodInfo padRightStringMethodInfo = typeof(string).GetMethod("PadRight", new Type[] { typeof(int) });
try
{
UriFunctionsBinder.BindUriFunctionName(FUNCTION_NAME, padRightStringMethodInfo);
MethodInfo addStrTwiceStaticMethodInfo = typeof(UriFunctionBinderTests).GetMethod("AddStringTwiceStatic", BindingFlags.NonPublic | BindingFlags.Static);
Assert.False(UriFunctionsBinder.UnbindUriFunctionName(FUNCTION_NAME, addStrTwiceStaticMethodInfo));
}
finally
{
UriFunctionsBinder.UnbindUriFunctionName(FUNCTION_NAME, padRightStringMethodInfo);
}
}
public void UnbindUriFunctionName_CannotUnbindNotBindedFunction_DifferentMethodInfo()
{
const string FUNCTION_NAME = "padright";
MethodInfo padRightStringMethodInfo = typeof(string).GetMethod("PadRight", new Type[] { typeof(int) });
try
{
UriFunctionsBinder.BindUriFunctionName(FUNCTION_NAME, padRightStringMethodInfo);
MethodInfo differentMethodInfo = typeof(UriFunctionBinderTests).GetMethod("AddStringTwiceInstance", BindingFlags.NonPublic | BindingFlags.Instance);
Assert.False(UriFunctionsBinder.UnbindUriFunctionName(FUNCTION_NAME, differentMethodInfo));
}
finally
{
Assert.True(UriFunctionsBinder.UnbindUriFunctionName(FUNCTION_NAME, padRightStringMethodInfo));
}
}
public void BindUriFunctionName_CannotBindStaticAndInstanceMethodWithSameArguments()
{
const string FUNCTION_NAME = "padright";
MethodInfo padRightStaticMethodInfo = typeof(UriFunctionBinderTests).GetMethod("PadRightStatic", BindingFlags.NonPublic | BindingFlags.Static);
MethodInfo padRightInstanceMethodInfo = typeof(string).GetMethod("PadRight", new Type[] { typeof(int) });
try
{
UriFunctionsBinder.BindUriFunctionName(FUNCTION_NAME, padRightStaticMethodInfo);
Action bindingInstance = () => UriFunctionsBinder.BindUriFunctionName(FUNCTION_NAME, padRightInstanceMethodInfo);
ExceptionAssert.Throws <ODataException>(bindingInstance);
}
finally
{
Assert.True(
UriFunctionsBinder.UnbindUriFunctionName(FUNCTION_NAME, padRightStaticMethodInfo));
}
}
public void BindUriFunctionName_CanBind()
{
const string FUNCTION_NAME = "padright";
MethodInfo padRightStringMethodInfo = typeof(string).GetMethod("PadRight", new Type[] { typeof(int) });
try
{
UriFunctionsBinder.BindUriFunctionName(FUNCTION_NAME, padRightStringMethodInfo);
MethodInfo resultMethoInfo;
UriFunctionsBinder.TryGetMethodInfo(FUNCTION_NAME, new Type[] { typeof(string), typeof(int) }, out resultMethoInfo);
Assert.Equal(padRightStringMethodInfo, resultMethoInfo);
}
finally
{
Assert.True(
UriFunctionsBinder.UnbindUriFunctionName(FUNCTION_NAME, padRightStringMethodInfo));
}
}
public void BindUriFunctionName_CannotBindIfAlreadyBinded()
{
const string FUNCTION_NAME = "addtwice";
MethodInfo addStrTwiceStaticMethodInfo = typeof(UriFunctionBinderTests).GetMethod("AddStringTwiceStatic", BindingFlags.NonPublic | BindingFlags.Static);
try
{
// Add for the first time
UriFunctionsBinder.BindUriFunctionName(FUNCTION_NAME, addStrTwiceStaticMethodInfo);
// Add for the second time
Action bindExisting = () => UriFunctionsBinder.BindUriFunctionName(FUNCTION_NAME, addStrTwiceStaticMethodInfo);
ExceptionAssert.Throws <ODataException>(bindExisting);
}
finally
{
Assert.True(
UriFunctionsBinder.UnbindUriFunctionName(FUNCTION_NAME, addStrTwiceStaticMethodInfo));
}
}
public void BindUriFunctionName_CanBindInstanceMethod()
{
// this test originally used "padright" as case, it has a running conflict with 'CustomMethod_InstanceMethodOfDeclaringType' in 'FilterBinderTests"
// Therefore, let's change it to use "PadLeft" as case.
// TODO: need to refactor the static logic for UriFunctionsBinder.
const string FUNCTION_NAME = "padLeft";
MethodInfo padRightInstanceMethodInfo = typeof(string).GetMethod("PadLeft", new Type[] { typeof(int) });
try
{
UriFunctionsBinder.BindUriFunctionName(FUNCTION_NAME, padRightInstanceMethodInfo);
MethodInfo resultMethoInfo;
UriFunctionsBinder.TryGetMethodInfo(FUNCTION_NAME, new Type[] { typeof(string), typeof(int) }, out resultMethoInfo);
Assert.Equal(padRightInstanceMethodInfo, resultMethoInfo);
}
finally
{
Assert.True(
UriFunctionsBinder.UnbindUriFunctionName(FUNCTION_NAME, padRightInstanceMethodInfo));
}
}
public void BindUriFunctionName_CannotBindInstanceMethodOfDifferentDeclaringType()
{
const string FUNCTION_NAME = "addtwice";
MethodInfo addTwiceInstanceThisDelcaringTypeMethodInfo =
typeof(UriFunctionBinderTests).GetMethod("AddStringTwiceInstance", BindingFlags.NonPublic | BindingFlags.Instance);
try
{
UriFunctionsBinder.BindUriFunctionName(FUNCTION_NAME, addTwiceInstanceThisDelcaringTypeMethodInfo);
MethodInfo resultMethoInfo;
bool couldFindBinding =
UriFunctionsBinder.TryGetMethodInfo(FUNCTION_NAME, new Type[] { typeof(string), typeof(string) }, out resultMethoInfo);
Assert.False(couldFindBinding);
Assert.Null(resultMethoInfo);
}
finally
{
Assert.True(
UriFunctionsBinder.UnbindUriFunctionName(FUNCTION_NAME, addTwiceInstanceThisDelcaringTypeMethodInfo));
}
}
private static void RegisterFunction(Type type, string methodName)
{
var best = type.GetMethods().Where(m => m.Name == methodName).First();
UriFunctionsBinder.BindUriFunctionName($"Default.{methodName}", best);
}
