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);