public void Updated_ref_parameter_doesnt_affect_call_specification()
{
//arrange
var source = Substitute.For <IValueSource>();
var router = SubstitutionContext.Current.GetCallRouterFor(source);
//Configure our handler to update "ref" argument value
router.RegisterCustomCallHandlerFactory(state =>
new ActionHandler(
call =>
{
if (call.GetMethodInfo().Name != nameof(IValueSource.GetValueWithRef))
{
return(RouteAction.Continue());
}
var args = call.GetArguments();
args[0] = "refArg";
return(RouteAction.Return("xxx"));
}));
string refValue = "ref";
source.GetValueWithRef(ref refValue).Returns("42");
//act
refValue = "ref";
var result = source.GetValueWithRef(ref refValue);
//assert
Assert.That(result, Is.EqualTo("42"));
}
public RouteAction Handle(ICall call)
{
var mockedDbContext = call.Target();
var invokedMethod = call.GetMethodInfo();
var arguments = call.GetArguments();
var modelType = GetModelType(invokedMethod);
if (modelType == null)
{
return(RouteAction.Return(invokedMethod.ReturnType.GetDefaultValue()));
}
Logger.LogDebug("Setting up model '{type}'", modelType);
var modelEntityType = _allModelEntityTypes.SingleOrDefault(x => x.ClrType.Equals(modelType));
if (modelEntityType == null)
{
throw new InvalidOperationException(string.Format(ExceptionMessages.CannotCreateDbSetTypeNotIncludedInModel,
invokedMethod.GetGenericArguments().Single().Name));
}
var setUpModelMethod = typeof(NoSetUpHandler <TDbContext>).GetMethods(BindingFlags.Instance | BindingFlags.NonPublic)
.Single(x => x.Name.Equals(modelEntityType.FindPrimaryKey() != null ? "SetUpModel" : "SetUpReadOnlyModel"));
setUpModelMethod.MakeGenericMethod(modelType).Invoke(this, new[] { mockedDbContext });
return(RouteAction.Return(invokedMethod.Invoke(mockedDbContext, arguments?.ToArray())));
}
public RouteAction Handle(ICall call)
{
if (_callResults.HasResultFor(call))
{
return(RouteAction.Return(_callResults.GetResult(call)));
}
return(RouteAction.Continue());
}
/// <summary>
/// Checks the last method invocation on the mock;
/// if Add was invoked the unexpected match is set up;
/// if GetOrAdd or GetOrAddAsync was invoked the unexpected match is set up and the addItemFactory result will be
/// returned;
/// otherwise the default value for the specified type will be returned.
/// </summary>
/// <param name="call"></param>
/// <returns>
/// if GetOrAdd or GetOrAddAsync was invoked the unexpected match is set up and the addItemFactory result will be
/// returned;
/// otherwise the default value for the specified type will be returned if the last method invocation has a return
/// type.
/// </returns>
public RouteAction Handle(ICall call)
{
Logger.LogDebug("NoSetUpHandler invoked");
var methodInfo = call.GetMethodInfo();
var args = call.GetArguments();
if (methodInfo.Name.Equals("Add"))
{
//We have everything we need to set up a match, so let's do it
var key = args[0].ToString();
var value = args[1];
ProjectReflectionShortcuts.SetUpCacheEntryMethod(value.GetType()).Invoke(null, new[] { _mockedCachingService, key, value });
return(RouteAction.Return(null));
}
if (methodInfo.Name.Equals("GetOrAdd"))
{
//We have everything we need to set up a match, so let's do it
var key = args[0].ToString();
var value = args[1].GetType().GetMethod("Invoke").Invoke(args[1], new object[] { new CacheEntryFake(key) });
ProjectReflectionShortcuts.SetUpCacheEntryMethod(value.GetType()).Invoke(null, new[] { _mockedCachingService, key, value });
return(RouteAction.Return(value));
}
if (methodInfo.Name.Equals("GetOrAddAsync"))
{
//We have everything we need to set up a match, so let's do it
var key = args[0].ToString();
var task = args[1].GetType().GetMethod("Invoke").Invoke(args[1], new object[] { new CacheEntryFake(key) });
var taskResult = task.GetType().GetProperty("Result").GetValue(task);
ProjectReflectionShortcuts.SetUpCacheEntryMethod(taskResult.GetType()).Invoke(null, new[] { _mockedCachingService, key, taskResult });
return(RouteAction.Return(task));
}
//void method
if (methodInfo.ReturnType == typeof(void))
{
return(RouteAction.Return(null));
}
//Return default values
if (methodInfo.ReturnType.IsGenericType && methodInfo.ReturnType.GetGenericTypeDefinition() == typeof(Task <>))
{
var genericArgument = methodInfo.ReturnType.GetGenericArguments().Single();
var defaultValue = genericArgument.GetDefaultValue();
return(RouteAction.Return(CoreReflectionShortcuts.TaskFromResultMethod(genericArgument).Invoke(null, new[] { defaultValue })));
}
return(RouteAction.Return(methodInfo.ReturnType.GetDefaultValue()));
}
public RouteAction Handle(ICall call)
{
if (_callResults.TryGetResult(call, out var configuredResult))
{
return(RouteAction.Return(configuredResult));
}
return(RouteAction.Continue());
}
private Func <IAutoValueProvider, RouteAction> ReturnValueUsingProvider(ICall call, Type type)
{
return(provider =>
{
var valueToReturn = provider.GetValue(type);
ConfigureCall.SetResultForCall(call, new ReturnValue(valueToReturn), MatchArgs.AsSpecifiedInCall);
return RouteAction.Return(valueToReturn);
});
}
public RouteAction Handle(ICall call)
{
if (_resultsForType.TryGetResult(call, out var result))
{
return(RouteAction.Return(result));
}
return(RouteAction.Continue());
}
public override void Context()
{
_call = mock <ICall>();
_firstHandler = mock <ICallHandler>();
_firstHandler.stub(x => x.Handle(_call)).Return(RouteAction.Continue());
_secondHandler = mock <ICallHandler>();
_secondHandler.stub(x => x.Handle(_call)).Return(RouteAction.Return(_valueToReturn));
_handlers = new[] { _firstHandler, _secondHandler };
}
private Func <IAutoValueProvider, RouteAction> ReturnValueUsingProvider(ICall call, Type type)
{
return(provider =>
{
var valueToReturn = provider.GetValue(type);
if (_autoValueBehaviour == AutoValueBehaviour.UseValueForSubsequentCalls)
{
ConfigureCall.SetResultForCall(call, new ReturnValue(valueToReturn), MatchArgs.AsSpecifiedInCall);
}
return RouteAction.Return(valueToReturn);
});
}
private Func <IAutoValueProvider, RouteAction> ReturnValueUsingProvider(ICall call, Type type)
{
return(provider =>
{
var valueToReturn = provider.GetValue(type);
if (_autoValueBehaviour == AutoValueBehaviour.UseValueForSubsequentCalls)
{
var spec = _callSpecificationFactory.CreateFrom(call, MatchArgs.AsSpecifiedInCall);
_callResults.SetResult(spec, new ReturnValue(valueToReturn));
}
return RouteAction.Return(valueToReturn);
});
}
public RouteAction Handle(ICall call)
{
if (ReturnsDynamic(call))
{
var stubToReturn = new DynamicStub();
_configureCall.SetResultForCall(call, new ReturnValue(stubToReturn), MatchArgs.AsSpecifiedInCall);
return(RouteAction.Return(new DynamicStub()));
}
else
{
return(RouteAction.Continue());
}
}
public RouteAction Handle(ICall call)
{
var type = call.GetReturnType();
var compatibleProviders = _autoValueProviders.Where(x => x.CanProvideValueFor(type));
if (compatibleProviders.Any())
{
var valueToReturn = compatibleProviders.First().GetValue(type);
_resultSetter.SetResultForCall(call, new ReturnValue(valueToReturn), MatchArgs.AsSpecifiedInCall);
return(RouteAction.Return(valueToReturn));
}
return(RouteAction.Continue());
}
public RouteAction Handle(ICall call)
{
if (_callResults.TryGetResult(call, out var cachedResult))
{
return(RouteAction.Return(cachedResult));
}
var type = call.GetReturnType();
var compatibleProviders = _autoValueProviders.Where(x => x.CanProvideValueFor(type)).FirstOrNothing();
return(compatibleProviders.Fold(
RouteAction.Continue,
ReturnValueUsingProvider(call, type)));
}
public RouteAction Handle(ICall call)
{
var methodInfo = call.GetMethodInfo();
if (methodInfo.Name.Equals("Query") || methodInfo.Name.Equals("Set"))
{
throw new InvalidOperationException(string.Format(ExceptionMessages.CannotCreateDbSetTypeNotIncludedInModel, methodInfo.GetGenericArguments().Single().Name));
}
if (methodInfo.ReturnType == typeof(void))
{
return(RouteAction.Return(null));
}
return(RouteAction.Return(methodInfo.ReturnType.GetDefaultValue()));
}
public void Value_from_custom_handler_is_returned()
{
//arrange
var source = Substitute.For <IValueSource>();
var router = SubstitutionContext.Current.GetCallRouterFor(source);
router.RegisterCustomCallHandlerFactory(state =>
new ActionHandler(
_ => RouteAction.Return("42")));
//act
var result = source.GetValue();
//assert
Assert.That(result, Is.EqualTo("42"));
}
public RouteAction Handle(ICall call)
{
var property = call.GetMethodInfo().GetPropertyFromGetterCallOrNull();
if (property is null)
{
return(RouteAction.Continue());
}
var service = _context.ResolveOptional(call.GetReturnType());
if (service is null)
{
return(RouteAction.Continue());
}
return(RouteAction.Return(service));
}
public void Configured_call_has_more_priority_than_custom_handler()
{
//arrange
var source = Substitute.For <IValueSource>();
var router = SubstitutionContext.Current.GetCallRouterFor(source);
router.RegisterCustomCallHandlerFactory(state =>
new ActionHandler(
_ => RouteAction.Return("xxx")));
source.GetValue().Returns("42");
//act
var result = source.GetValue();
//assert
Assert.That(result, Is.EqualTo("42"));
}
public void Custom_handler_is_called_for_each_time()
{
//arrange
var source = Substitute.For <IValueSource>();
var router = SubstitutionContext.Current.GetCallRouterFor(source);
var values = new Queue <string>(new[] { "42", "10" });
router.RegisterCustomCallHandlerFactory(state =>
new ActionHandler(
_ => RouteAction.Return(values.Dequeue())));
//act
var result = source.GetValue();
result = source.GetValue();
//assert
Assert.That(result, Is.EqualTo("10"));
}
public RouteAction Handle(ICall call)
{
if (_callResults.TryGetResult(call, out var cachedResult))
{
return(RouteAction.Return(cachedResult));
}
var type = call.GetReturnType();
// This is a hot method which is invoked frequently and has major impact on performance.
// Therefore, the LINQ cycle was unwinded to loop.
foreach (var autoValueProvider in _autoValueProviders)
{
if (autoValueProvider.CanProvideValueFor(type))
{
return(RouteAction.Return(GetResultValueUsingProvider(call, type, autoValueProvider)));
}
}
return(RouteAction.Continue());
}
public RouteAction Handle(ICall call)
{
return(_resultsForType.HasResultFor(call)
? RouteAction.Return(_resultsForType.GetResult(call))
: RouteAction.Continue());
}
public RouteAction Handle(ICall call)
{
var returnValue = _defaultForType.GetDefaultFor(call.GetMethodInfo().ReturnType);
return(RouteAction.Return(returnValue));
}
