public void CannotResolveArg()
{
var method = typeof(Handler).GetMethod("Handle", new Type[] { typeof(int?), typeof(string) });
var messageMock = new Mock <IMessage>();
_message = messageMock.Object;
_resolvers = new HandlerMethodArgumentResolverComposite();
var ex = Assert.Throws <MethodArgumentResolutionException>(() => Invoke(new Handler(), method));
Assert.Contains("Could not resolve parameter [0]", ex.Message);
}
public void HandleSinglePrimitiveReturnVoidPerf()
{
var handler = new Handler2();
var messageMock = new Mock <IMessage>();
_message = messageMock.Object;
_resolvers = new HandlerMethodArgumentResolverComposite();
var method = typeof(Handler2).GetMethod("HandleSinglePrimitiveReturnVoid");
Invoke(handler, method, 1.0d);
Assert.Equal(1.0d, handler.DoubleValue);
}
public void HandleNullablePrimitive()
{
var handler = new Handler2();
var messageMock = new Mock <IMessage>();
_message = messageMock.Object;
_resolvers = new HandlerMethodArgumentResolverComposite();
var method = typeof(Handler2).GetMethod("HandleNullablePrimitive");
var result = Invoke(handler, method, 10, "stringArg");
Assert.Equal(1, handler.InvocationCount);
Assert.Equal("10-stringArg", result);
}
public void ExceptionInResolvingArg()
{
var method = typeof(Handler).GetMethod("Handle", new Type[] { typeof(int?), typeof(string) });
var messageMock = new Mock <IMessage>();
_message = messageMock.Object;
_resolvers = new HandlerMethodArgumentResolverComposite();
_resolvers.AddResolver(new ExceptionRaisingArgumentResolver());
Assert.Throws <ArgumentException>(() => Invoke(new Handler(), method));
// expected - allow HandlerMethodArgumentResolver exceptions to propagate
}
public void ResolveProvidedArgFirst()
{
var method = typeof(Handler).GetMethod("Handle", new Type[] { typeof(int?), typeof(string) });
var messageMock = new Mock <IMessage>();
_message = messageMock.Object;
_resolvers = new HandlerMethodArgumentResolverComposite();
_resolvers.AddResolver(new StubArgumentResolver(1));
_resolvers.AddResolver(new StubArgumentResolver("value1"));
var value = Invoke(new Handler(), method, 2, "value2");
Assert.Equal("2-value2", value);
}
public void ResolveProvidedArg()
{
var method = typeof(Handler).GetMethod("Handle", new Type[] { typeof(int?), typeof(string) });
var messageMock = new Mock <IMessage>();
_message = messageMock.Object;
_resolvers = new HandlerMethodArgumentResolverComposite();
var value = Invoke(new Handler(), method, 99, "value");
Assert.NotNull(value);
Assert.IsType <string>(value);
Assert.Equal("99-value", value);
}
public async Task HandleAsyncStringMethod()
{
var handler = new Handler2();
var messageMock = new Mock <IMessage>();
_message = messageMock.Object;
_resolvers = new HandlerMethodArgumentResolverComposite();
var method = typeof(Handler2).GetMethod("HandleAsyncStringMethod");
var result = Invoke(handler, method, 10, "stringArg") as Task <string>;
var str = await result;
Assert.Equal(1, handler.InvocationCount);
Assert.Equal("10-stringArg", str);
}
public async Task HandleAsyncVoidMethod()
{
var handler = new Handler2();
var messageMock = new Mock <IMessage>();
_message = messageMock.Object;
_resolvers = new HandlerMethodArgumentResolverComposite();
var method = typeof(Handler2).GetMethod("HandleAsyncVoidMethod");
var result = Invoke(handler, method, 1.0d) as Task;
await result;
Assert.Equal(1, handler.InvocationCount);
Assert.Equal(1.0d, handler.DoubleValue);
}
public void HandleMultiReturnVoid()
{
var handler = new Handler2();
var messageMock = new Mock <IMessage>();
_message = messageMock.Object;
_resolvers = new HandlerMethodArgumentResolverComposite();
var method = typeof(Handler2).GetMethod("HandleMultiReturnVoid");
Invoke(handler, method, 1.0d, 2, handler);
Assert.Equal(1.0d, handler.DoubleValue);
Assert.Equal(2, handler.IntValue);
Assert.Same(handler, handler.ObjectValue);
}
public void ComparePerfHandleSinglePrimitiveReturnVoid()
{
var handler = new Handler2();
var messageMock = new Mock <IMessage>();
_message = messageMock.Object;
_resolvers = new HandlerMethodArgumentResolverComposite();
var method = typeof(Handler2).GetMethod("HandleSinglePrimitiveReturnVoid");
var ticks1 = TimedInvoke(handler, method, 100_000, 1.0d);
Assert.Equal(100_000, handler.InvocationCount);
var ticks2 = TimedReflectionInvoke(handler, method, 100_000, 1.0d);
Assert.Equal(200_000, handler.InvocationCount);
Assert.True(ticks2 > ticks1);
}
public void ResolveNoArgValue()
{
var messageMock = new Mock <IMessage>();
_message = messageMock.Object;
_resolvers = new HandlerMethodArgumentResolverComposite();
_resolvers.AddResolver(new StubArgumentResolver(typeof(int?)));
_resolvers.AddResolver(new StubArgumentResolver(typeof(string)));
var method = typeof(Handler).GetMethod("Handle", new Type[] { typeof(int?), typeof(string) });
var value = Invoke(new Handler(), method);
Assert.Single(GetStubResolver(0).ResolvedParameters);
Assert.Single(GetStubResolver(1).ResolvedParameters);
Assert.Equal("null-null", value);
}
public void ResolveArg()
{
var messageMock = new Mock <IMessage>();
_message = messageMock.Object;
_resolvers = new HandlerMethodArgumentResolverComposite();
_resolvers.AddResolver(new StubArgumentResolver(99));
_resolvers.AddResolver(new StubArgumentResolver("value"));
var method = typeof(Handler).GetMethod("Handle", new Type[] { typeof(int?), typeof(string) });
var value = Invoke(new Handler(), method);
Assert.Single(GetStubResolver(0).ResolvedParameters);
Assert.Single(GetStubResolver(1).ResolvedParameters);
Assert.Equal("99-value", value);
Assert.Equal("intArg", GetStubResolver(0).ResolvedParameters[0].Name);
Assert.Equal("stringArg", GetStubResolver(1).ResolvedParameters[0].Name);
}
public void InvocationTargetException()
{
var handler = new Handler();
var messageMock = new Mock <IMessage>();
_message = messageMock.Object;
_resolvers = new HandlerMethodArgumentResolverComposite();
var method = typeof(Handler).GetMethod("HandleWithException");
var runtimeException = new Exception("error");
var ex = Assert.Throws <Exception>(() => Invoke(handler, method, runtimeException));
Assert.Same(runtimeException, ex);
var error = new IndexOutOfRangeException("error");
var ex2 = Assert.Throws <IndexOutOfRangeException>(() => Invoke(handler, method, error));
Assert.Same(error, ex2);
}
public void IllegalArgumentException()
{
var method = typeof(Handler).GetMethod("Handle", new Type[] { typeof(int?), typeof(string) });
var messageMock = new Mock <IMessage>();
_message = messageMock.Object;
_resolvers = new HandlerMethodArgumentResolverComposite();
_resolvers.AddResolver(new StubArgumentResolver(typeof(int?), "__not_an_int__"));
_resolvers.AddResolver(new StubArgumentResolver("value"));
var ex = Assert.Throws <InvalidOperationException>(() => Invoke(new Handler(), method));
Assert.IsType <ArgumentException>(ex.InnerException);
Assert.Contains("Endpoint [", ex.Message);
Assert.Contains("Method [", ex.Message);
Assert.Contains("with argument values:", ex.Message);
Assert.Contains("[0] [type=System.String] [value=__not_an_int__]", ex.Message);
Assert.Contains("[1] [type=System.String] [value=value", ex.Message);
}
