private static ParameterInfo[] GetMethodParameters(ICall call)
{
// A workaround for the older versions of NSubstitute to retrieve the original delegate signature.
// The related issue has been fixed in v4, so no tweaks are required there.
// The workaround will be self disabled in v4+ due to the internal NSubstitute refactoring.
if (call.Target().GetType() == DelegateCallType && DelegateTypeFieldInfo != null)
{
var delegateType = (Type)DelegateTypeFieldInfo.GetValue(call.Target());
return(delegateType.GetMethod("Invoke").GetParameters());
}
return(call.GetMethodInfo().GetParameters());
}
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)
{
var target = call.Target();
var callSpec = _callSpecificationFactory.CreateFrom(call, MatchArgs.AsSpecifiedInCall);
_context.AddToQuery(target, callSpec);
return RouteAction.Continue();
}
private static bool Matches(ICall call, CallSpecAndTarget specAndTarget)
{
if (object.ReferenceEquals(call.Target(), specAndTarget.Target))
{
return(specAndTarget.CallSpecification.IsSatisfiedBy(call));
}
return(false);
}
public static string DiagName(this ICall call, DiagContextInternal ctx)
{
var substituteId = call.Target().SubstituteId(ctx);
var callArgs = call.FormatArgs(ctx);
var signature = call.GetMethodInfo().DiagName();
return($"<[{substituteId}].{callArgs} Signature: {signature}>");
}
public RouteAction Handle(ICall call)
{
var target = call.Target();
var callSpec = _callSpecificationFactory.CreateFrom(call, MatchArgs.AsSpecifiedInCall);
_context.AddToQuery(target, callSpec);
return(RouteAction.Continue());
}
private string FormatCall(ICall call, bool isAcrossMultipleTargets, TypeInstanceNumberLookup instanceLookup)
{
var s = _callFormatter.Format(call.GetMethodInfo(), FormatArgs(call.GetArguments()));
if (!isAcrossMultipleTargets) return s;
var target = call.Target();
var methodInfo = call.GetMethodInfo();
return FormatCallForInstance(instanceLookup, target, methodInfo, s);
}
public ICall CreateCallToPropertyGetterFromSetterCall(ICall callToSetter)
{
var propertyInfo = GetPropertyFromSetterCallOrNull(callToSetter);
if (!PropertySetterExistsAndHasAGetMethod(propertyInfo))
{
throw new InvalidOperationException("Could not find a GetMethod for \"" + callToSetter.GetMethodInfo() + "\"");
}
var getter = propertyInfo.GetGetMethod();
return new CallToPropertyGetter(getter, callToSetter.Target());
}
public ICall CreateCallToPropertyGetterFromSetterCall(ICall callToSetter)
{
var propertyInfo = GetPropertyFromSetterCallOrNull(callToSetter);
if (!PropertySetterExistsAndHasAGetMethod(propertyInfo))
{
throw new InvalidOperationException("Could not find a GetMethod for \"" + callToSetter.GetMethodInfo() + "\"");
}
var setterArgs = callToSetter.GetArguments();
var getter = propertyInfo.GetGetMethod();
var getterArgs = setterArgs.Take(setterArgs.Length - 1).ToArray();
return new Call(getter, getterArgs, callToSetter.Target(), callToSetter.GetArgumentSpecifications());
}
object[] WorkOutSenderAndEventArgs(Type eventArgsType, ICall call)
{
object sender;
object eventArgs;
if (_providedArguments.Length == 0)
{
sender = call.Target();
eventArgs = GetDefaultForEventArgType(eventArgsType);
}
else if (_providedArguments[0].IsCompatibleWith(eventArgsType))
{
sender = call.Target();
eventArgs = _providedArguments[0];
}
else
{
sender = _providedArguments[0];
eventArgs = GetDefaultForEventArgType(eventArgsType);
}
return(new[] { sender, eventArgs });
}
public ICall CreateCallToPropertyGetterFromSetterCall(ICall callToSetter)
{
var propertyInfo = GetPropertyFromSetterCallOrNull(callToSetter);
if (!PropertySetterExistsAndHasAGetMethod(propertyInfo))
{
throw new InvalidOperationException("Could not find a GetMethod for \"" + callToSetter.GetMethodInfo() + "\"");
}
var setterArgs = callToSetter.GetArguments();
var getter = propertyInfo.GetGetMethod();
var getterArgs = setterArgs.Take(setterArgs.Length - 1).ToArray();
return(new Call(getter, getterArgs, callToSetter.Target(), callToSetter.GetArgumentSpecifications()));
}
public object Route(ICall call)
{
Trace($"Route(call: {call.DiagName(_ctx)})");
Log($"[Received call] " +
$"Substitute: {call.Target().SubstituteId(_ctx)} " +
$"Call: {call.FormatArgs(_ctx)} " +
$"Signature: {call.GetMethodInfo().DiagName()} " +
$"Argument specifications: {call.GetArgumentSpecifications().Print(s => s.DiagName())}");
using (new LoggingScope())
{
return(_impl.Route(call));
}
}
protected override object[] WorkOutRequiredArguments(ICall call)
{
var sender = _sender;
var eventArgs = _eventArgs;
if (sender == null)
{
sender = call.Target();
}
if (eventArgs == null)
{
eventArgs = GetDefaultForEventArgType(typeof(TEventArgs));
}
return(new[] { sender, eventArgs });
}
public ICall CreateCallToPropertyGetterFromSetterCall(ICall callToSetter)
{
var propertyInfo = GetPropertyFromSetterCallOrNull(callToSetter);
if (!PropertySetterExistsAndHasAGetMethod(propertyInfo))
{
throw new InvalidOperationException("Could not find a GetMethod for \"" + callToSetter.GetMethodInfo() + "\"");
}
var getter = propertyInfo.GetGetMethod();
var getterArgs = SkipLast(callToSetter.GetOriginalArguments());
var getterArgumentSpecifications = GetGetterCallSpecificationsFromSetterCall(callToSetter);
return(_callFactory.Create(getter, getterArgs, callToSetter.Target(), getterArgumentSpecifications));
}
public void RegisterCall(ICall call)
{
if (call == null)
{
throw new ArgumentNullException(nameof(call));
}
var target = call.Target();
var callSpecification = _callSpecificationFactory.CreateFrom(call, MatchArgs.AsSpecifiedInCall);
_querySpec.Add(new CallSpecAndTarget(callSpecification, target));
var allMatchingCallsOnTarget = target.ReceivedCalls().Where(callSpecification.IsSatisfiedBy);
_matchingCalls.UnionWith(allMatchingCallsOnTarget);
}
private bool Matches(ICall call, CallSpecAndTarget specAndTarget)
{
return(ReferenceEquals(call.Target(), specAndTarget.Target) &&
specAndTarget.CallSpecification.IsSatisfiedBy(call));
}
private bool Matches(ICall call, CallSpecAndTarget specAndTarget)
{
return ReferenceEquals(call.Target(), specAndTarget.Target)
&& specAndTarget.CallSpecification.IsSatisfiedBy(call);
}
public void Should_set_required_call_properties()
{
Assert.That(_result.GetMethodInfo(), Is.EqualTo(_method));
Assert.That(_result.GetArguments(), Is.EqualTo(_args));
Assert.That(_result.Target(), Is.SameAs(_target));
}
private static bool Matches(ICall call, CallSpecAndTarget specAndTarget) => call.Target() == specAndTarget.Target && specAndTarget.CallSpecification.IsSatisfiedBy(call);
