public void CreateInvocationDelegate_CalledWhenNoInnerInvocations_ExpectArgumentExceptionWithCorrectParamName(
MethodInfo method, ServiceMethodInvocationContext context)
{
new ServiceMethodInvocationChain(new IServiceMethodInvocation[0])
.Invoking(x => x.CreateInvocationDelegate(method, context))
.ShouldThrow <ArgumentException>().And.ParamName.Should().Be("serviceMethod");
}
private static void ExpectCreateInvocationDelegateThrowsArgumentExceptionForMethod(
MethodInfo invalidServiceMethod, ServiceMethodInvocationContext context)
{
new SyncServiceMethodInvocation().Invoking(
x => x.CreateInvocationDelegate(invalidServiceMethod, context))
.ShouldThrow <ArgumentException>()
.And.ParamName.Should().Be("serviceMethod", invalidServiceMethod + " is not of the correct signature");
}
public void CreateInvocationDelegate_CalledMultipleTimes_ExpectEnumerableOfInnerInvocationsIsOnlyEnumeratedOnce(
MethodInfo method1, ServiceMethodInvocationContext context1, MethodInfo method2, ServiceMethodInvocationContext context2)
{
var innerInvocations = Mock.Enumerable <IServiceMethodInvocation>();
var chain = new ServiceMethodInvocationChain(innerInvocations);
chain.Invoking(x => x.CreateInvocationDelegate(method1, context1)).ShouldThrow <Exception>();
chain.Invoking(x => x.CreateInvocationDelegate(method2, context2)).ShouldThrow <Exception>();
innerInvocations.AssertWasCalled(x => x.GetEnumerator(), x => x.Repeat.Once());
}
public Delegate CreateInvocationDelegate(MethodInfo serviceMethod, ServiceMethodInvocationContext context)
{
if (!this.CanCreateInvocationDelegateFor(serviceMethod))
{
throw new ArgumentException(
"Method " + serviceMethod + " should have a single parameter, be marked as async or return a Task, and should not be static",
"serviceMethod");
}
MethodInfo delegateCreator = CreateSpecialisedDelegateCreator(serviceMethod);
return((Delegate)delegateCreator.Invoke(null, new object[] { serviceMethod, context }));
}
public static MethodCallExpression CreateCallExpression(
MethodInfo serviceMethod, ServiceMethodInvocationContext context, ParameterExpression request)
{
return Expression.Call(
Expression.Convert(
Expression.Invoke(Expression.Constant(context.ServiceFactory)),
serviceMethod.DeclaringType),
serviceMethod,
Expression.Convert(
Expression.Invoke(
Expression.Constant(context.RequestBinder),
request),
serviceMethod.TypeOfFirstParameter()));
}
public static MethodCallExpression CreateCallExpression(
MethodInfo serviceMethod, ServiceMethodInvocationContext context, ParameterExpression request)
{
return(Expression.Call(
Expression.Convert(
Expression.Invoke(Expression.Constant(context.ServiceFactory)),
serviceMethod.DeclaringType),
serviceMethod,
Expression.Convert(
Expression.Invoke(
Expression.Constant(context.RequestBinder),
request),
serviceMethod.TypeOfFirstParameter())));
}
private static Func <object, CancellationToken, Task <object> > CreateInvocationDelegate <T>(
MethodInfo serviceMethod, ServiceMethodInvocationContext context)
{
ParameterExpression request = Expression.Parameter(typeof(object), "request");
ParameterExpression cancel = Expression.Parameter(typeof(CancellationToken), "cancel");
Func <object, CancellationToken, Task <T> > lambda = Expression.Lambda <Func <object, CancellationToken, Task <T> > >(
serviceMethod.NumberOfParameters() == 1?
AsyncServiceMethodCall.CreateCallExpression(serviceMethod, context, request):
AsyncServiceMethodCall.CreateCallExpression(serviceMethod, context, request, cancel),
request,
cancel).Compile();
return(async(r, c) => await lambda(r, c));
}
public void CreateInvocationDelegate_CalledWhenAtLeastOneInnerInvocationCanCreateDelegate_ExpectReturnedDelegateIsFromInnerInvocation(
[WithinInclusiveRange(0, 10)] int numberOfFalseInnerInvocations,
[WithinInclusiveRange(1, 10)] int numberOfTrueInnerInvocations,
MethodInfo method,
ServiceMethodInvocationContext context)
{
Action constructedDelegate = () => { };
var falseInvocations = CreateNumberOfStubServiceMethodInvocationsUnableToCreateDelegate(numberOfFalseInnerInvocations, method);
var trueInvocations = CreateNumberOfStubServiceMethodInvocationsAbleToCreateDelegate(numberOfTrueInnerInvocations, method);
trueInvocations.ForEach(inv => inv.Stub(
x => x.CreateInvocationDelegate(Arg <MethodInfo> .Is.Same(method), Arg <ServiceMethodInvocationContext> .Is.Same(context)))
.Return(constructedDelegate));
var chain = new ServiceMethodInvocationChain(falseInvocations.Concat(trueInvocations).Shuffle());
chain.CreateInvocationDelegate(method, context).Should().BeSameAs(constructedDelegate);
}
public Delegate CreateInvocationDelegate(MethodInfo serviceMethod, ServiceMethodInvocationContext context)
{
if (!this.CanCreateInvocationDelegateFor(serviceMethod))
{
throw new ArgumentException(
"Method " + serviceMethod + " should have a single parameter, not return a Task nor be marked async, and should not be static",
"serviceMethod");
}
ParameterExpression request = Expression.Parameter(typeof(object), "request");
if (serviceMethod.ReturnType == typeof(void))
{
return Expression.Lambda<Func<object, object>>(
Expression.Block(
SyncServiceMethodCall.CreateCallExpression(serviceMethod, context, request),
Expression.Constant(context.DefaultResponse, typeof(object))),
request).Compile();
}
return Expression.Lambda<Func<object, object>>(
SyncServiceMethodCall.CreateCallExpression(serviceMethod, context, request),
request).Compile();
}
public Delegate CreateInvocationDelegate(MethodInfo serviceMethod, ServiceMethodInvocationContext context)
{
if (!this.CanCreateInvocationDelegateFor(serviceMethod))
{
throw new ArgumentException(
"Method " + serviceMethod + " should have a single parameter, be marked as async or return a Task, and should not be static",
"serviceMethod");
}
ParameterExpression request = Expression.Parameter(typeof(object), "request");
ParameterExpression cancel = Expression.Parameter(typeof(CancellationToken), "cancel");
Action<object, CancellationToken> lambda = Expression.Lambda<Action<object, CancellationToken>>(
serviceMethod.NumberOfParameters() == 1?
AsyncServiceMethodCall.CreateCallExpression(serviceMethod, context, request):
AsyncServiceMethodCall.CreateCallExpression(serviceMethod, context, request, cancel),
request,
cancel).Compile();
return new Func<object, CancellationToken, Task<object>>((r, c) =>
{
lambda(r, c);
return TaskEx.FromResult(context.DefaultResponse);
});
}
public Delegate CreateInvocationDelegate(MethodInfo serviceMethod, ServiceMethodInvocationContext context)
{
if (!this.CanCreateInvocationDelegateFor(serviceMethod))
{
throw new ArgumentException(
"Method " + serviceMethod + " should have a single parameter, not return a Task nor be marked async, and should not be static",
"serviceMethod");
}
ParameterExpression request = Expression.Parameter(typeof(object), "request");
if (serviceMethod.ReturnType == typeof(void))
{
return(Expression.Lambda <Func <object, object> >(
Expression.Block(
SyncServiceMethodCall.CreateCallExpression(serviceMethod, context, request),
Expression.Constant(context.DefaultResponse, typeof(object))),
request).Compile());
}
return(Expression.Lambda <Func <object, object> >(
SyncServiceMethodCall.CreateCallExpression(serviceMethod, context, request),
request).Compile());
}
public Delegate CreateInvocationDelegate(MethodInfo serviceMethod, ServiceMethodInvocationContext context)
{
if (!this.CanCreateInvocationDelegateFor(serviceMethod))
{
throw new ArgumentException(
"Method " + serviceMethod + " should have a single parameter, be marked as async or return a Task, and should not be static",
"serviceMethod");
}
ParameterExpression request = Expression.Parameter(typeof(object), "request");
ParameterExpression cancel = Expression.Parameter(typeof(CancellationToken), "cancel");
Action <object, CancellationToken> lambda = Expression.Lambda <Action <object, CancellationToken> >(
serviceMethod.NumberOfParameters() == 1?
AsyncServiceMethodCall.CreateCallExpression(serviceMethod, context, request):
AsyncServiceMethodCall.CreateCallExpression(serviceMethod, context, request, cancel),
request,
cancel).Compile();
return(new Func <object, CancellationToken, Task <object> >((r, c) =>
{
lambda(r, c);
return TaskEx.FromResult(context.DefaultResponse);
}));
}
private static void ExpectCreateInvocationDelegateThrowsArgumentExceptionForMethod(
MethodInfo invalidServiceMethod, ServiceMethodInvocationContext context)
{
new AsyncTaskServiceMethodInvocation().Invoking(
x => x.CreateInvocationDelegate(invalidServiceMethod, context))
.ShouldThrow<ArgumentException>()
.And.ParamName.Should().Be("serviceMethod", invalidServiceMethod + " is not of the correct signature");
}
public void CreateInvocationDelegate_CalledForAnyMethodInThisType_ExpectArgumentExceptionWithCorrectParamName(
Type serviceType, ServiceMethodInvocationContext context)
{
serviceType.GetAllDeclaredMethods().ForEach(m => ExpectCreateInvocationDelegateThrowsArgumentExceptionForMethod(m, context));
}
public void CreateInvocationDelegate_CalledWithNullServiceMethod_ExpectArgumentNullExceptionWithCorrectParamName(
ServiceMethodInvocationContext context)
{
new AsyncTaskServiceMethodInvocation().Invoking(x => x.CreateInvocationDelegate(null, context))
.ShouldThrow<ArgumentNullException>().And.ParamName.Should().Be("serviceMethod");
}
public static MethodCallExpression CreateCallExpression(
MethodInfo serviceMethod, ServiceMethodInvocationContext context, ParameterExpression request)
{
return SyncServiceMethodCall.CreateCallExpression(serviceMethod, context, request);
}
public void CreateInvocationDelegate_CalledWhenNoInnerInvocationsCanCreateDelegate_ExpectArgumentExceptionWithCorrectParamName(
[WithinInclusiveRange(1, 10)] int numberOfInnerInvocations, MethodInfo method, ServiceMethodInvocationContext context)
{
var innerInvocations = CreateNumberOfStubServiceMethodInvocationsUnableToCreateDelegate(numberOfInnerInvocations, method);
new ServiceMethodInvocationChain(innerInvocations)
.Invoking(x => x.CreateInvocationDelegate(method, context))
.ShouldThrow<ArgumentException>().And.ParamName.Should().Be("serviceMethod");
}
public static MethodCallExpression CreateCallExpression(
MethodInfo serviceMethod, ServiceMethodInvocationContext context, ParameterExpression request)
{
return(SyncServiceMethodCall.CreateCallExpression(serviceMethod, context, request));
}
public void CreateInvocationDelegate_CalledMultipleTimes_ExpectEnumerableOfInnerInvocationsIsOnlyEnumeratedOnce(
MethodInfo method1, ServiceMethodInvocationContext context1, MethodInfo method2, ServiceMethodInvocationContext context2)
{
var innerInvocations = Mock.Enumerable<IServiceMethodInvocation>();
var chain = new ServiceMethodInvocationChain(innerInvocations);
chain.Invoking(x => x.CreateInvocationDelegate(method1, context1)).ShouldThrow<Exception>();
chain.Invoking(x => x.CreateInvocationDelegate(method2, context2)).ShouldThrow<Exception>();
innerInvocations.AssertWasCalled(x => x.GetEnumerator(), x => x.Repeat.Once());
}
public void CreateInvocationDelegate_CalledWhenAtLeastOneInnerInvocationCanCreateDelegate_ExpectReturnedDelegateIsFromInnerInvocation(
[WithinInclusiveRange(0, 10)] int numberOfFalseInnerInvocations,
[WithinInclusiveRange(1, 10)] int numberOfTrueInnerInvocations,
MethodInfo method,
ServiceMethodInvocationContext context)
{
Action constructedDelegate = () => { };
var falseInvocations = CreateNumberOfStubServiceMethodInvocationsUnableToCreateDelegate(numberOfFalseInnerInvocations, method);
var trueInvocations = CreateNumberOfStubServiceMethodInvocationsAbleToCreateDelegate(numberOfTrueInnerInvocations, method);
trueInvocations.ForEach(inv => inv.Stub(
x => x.CreateInvocationDelegate(Arg<MethodInfo>.Is.Same(method), Arg<ServiceMethodInvocationContext>.Is.Same(context)))
.Return(constructedDelegate));
var chain = new ServiceMethodInvocationChain(falseInvocations.Concat(trueInvocations).Shuffle());
chain.CreateInvocationDelegate(method, context).Should().BeSameAs(constructedDelegate);
}
public void CreateInvocationDelegate_CalledForAnyMethodInThisType_ExpectArgumentExceptionWithCorrectParamName(
Type serviceType, ServiceMethodInvocationContext context)
{
serviceType.GetAllDeclaredMethods().ForEach(m => ExpectCreateInvocationDelegateThrowsArgumentExceptionForMethod(m, context));
}
public void CreateInvocationDelegate_CalledWhenNoInnerInvocationsCanCreateDelegate_ExpectArgumentExceptionWithCorrectParamName(
[WithinInclusiveRange(1, 10)] int numberOfInnerInvocations, MethodInfo method, ServiceMethodInvocationContext context)
{
var innerInvocations = CreateNumberOfStubServiceMethodInvocationsUnableToCreateDelegate(numberOfInnerInvocations, method);
new ServiceMethodInvocationChain(innerInvocations)
.Invoking(x => x.CreateInvocationDelegate(method, context))
.ShouldThrow <ArgumentException>().And.ParamName.Should().Be("serviceMethod");
}
public void CreateInvocationDelegate_CalledWithNullServiceMethod_ExpectArgumentNullExceptionWithCorrectParamName(
ServiceMethodInvocationContext context)
{
new SyncServiceMethodInvocation().Invoking(x => x.CreateInvocationDelegate(null, context))
.ShouldThrow <ArgumentNullException>().And.ParamName.Should().Be("serviceMethod");
}
public void CreateInvocationDelegate_CalledWhenNoInnerInvocations_ExpectArgumentExceptionWithCorrectParamName(
MethodInfo method, ServiceMethodInvocationContext context)
{
new ServiceMethodInvocationChain(new IServiceMethodInvocation[0])
.Invoking(x => x.CreateInvocationDelegate(method, context))
.ShouldThrow<ArgumentException>().And.ParamName.Should().Be("serviceMethod");
}
