public TArgument Arg <TArgument>(int index)
{
if (index < 0 || index >= _call.GetArguments().Length)
{
throw new InvalidOperationException("Method '" + _call.GetMethodInfo().Name + "' do not have that many arguments.");
}
if (_call.GetArguments()[index] is TArgument)
{
return((TArgument)_call.GetArguments()[index]);
}
throw new InvalidOperationException("Argument " + index + " of '" + _call.GetMethodInfo().Name + "' cannot be converted to '" + typeof(TArgument) + "'.");
}
public IEnumerable<ArgumentMatchInfo> NonMatchingArguments(ICall call)
{
var arguments = call.GetArguments();
return arguments
.Select((arg, index) => new ArgumentMatchInfo(index, arg, _argumentSpecifications[index]))
.Where(x => !x.IsMatch);
}
/// <summary>
/// Try to handle the call - set ref/out params and return value.
/// </summary>
public RouteAction Handle(ICall call)
{
if (call == null)
{
throw new ArgumentNullException(nameof(call));
}
// Don't care about concurrency. If race condition happens - simply use the latest result.
CallResultData result;
if (!this.ResultCache.TryGetResult(call, out result))
{
result = this.ResultResolver.ResolveResult(call);
var callSpec = this.CallSpecificationFactory.CreateFrom(call, MatchArgs.AsSpecifiedInCall);
this.ResultCache.AddResult(callSpec, result);
}
var callArguments = call.GetArguments();
var originalArguments = call.GetOriginalArguments();
foreach (var argumentValue in result.ArgumentValues)
{
var argIndex = argumentValue.Index;
// If ref/out value has been already modified (e.g. by When..Do), don't override that value.
if (!ArgValueWasModified(callArguments[argIndex], originalArguments[argIndex]))
{
callArguments[argIndex] = argumentValue.Value;
}
}
return(result.ReturnValue.Fold(RouteAction.Continue, RouteAction.Return));
}
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())));
}
private bool IsSpecifyingACall(ICall call)
{
var args = call.GetArguments() ?? EmptyArgs;
var argSpecs = call.GetArgumentSpecifications() ?? EmptyArgSpecs;
return(_isSetToDefaultRoute && args.Any() && argSpecs.Any());
}
private static bool IsSpecifyingACall(ICall call, IRoute currentRoute)
{
var args = call.GetArguments() ?? EmptyArgs;
var argSpecs = call.GetArgumentSpecifications() ?? EmptyArgSpecs;
return(currentRoute.IsRecordReplayRoute && args.Any() && argSpecs.Any());
}
public IEnumerable <ArgumentMatchInfo> NonMatchingArguments(ICall call)
{
var arguments = call.GetArguments();
return(arguments
.Select((arg, index) => new ArgumentMatchInfo(index, arg, _argumentSpecifications[index]))
.Where(x => !x.IsMatch));
}
private void If(ICall call, Func<ICall, Predicate<EventInfo>> meetsThisSpecification, Action<string, object> takeThisAction)
{
var events = GetEvents(call, meetsThisSpecification);
if (events.Any())
{
takeThisAction(events.First().Name, call.GetArguments()[0]);
}
}
/// <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()));
}
private string Format(ICall call)
{
var methodInfo = call.GetMethodInfo();
var args = methodInfo.GetParameters()
.Zip(call.GetArguments(), (p, a) => new ArgAndParamInfo(p, a))
.ToArray();
return(_callFormatter.Format(methodInfo, FormatArgs(args)));
}
public ICallSpecification CreateFrom(ICall call, MatchArgs matchArgs)
{
var methodInfo = call.GetMethodInfo();
var argumentSpecs = call.GetArgumentSpecifications();
var arguments = call.GetArguments();
var parameterInfos = call.GetParameterInfos();
var argumentSpecificationsForCall = _argumentSpecificationsFactory.Create(argumentSpecs, arguments, parameterInfos, matchArgs);
return new CallSpecification(methodInfo, argumentSpecificationsForCall);
}
public IEnumerable<int> NonMatchingArgumentIndicies(ICall call)
{
var arguments = call.GetArguments();
for (var i = 0; i < arguments.Length; i++)
{
var argumentMatchesSpecification = ArgIsSpecifiedAndMatchesSpec(arguments[i], i);
if (!argumentMatchesSpecification) yield return i;
}
}
private static void If(ICall call, Func <ICall, Predicate <EventInfo> > meetsThisSpecification, Action <string, object> takeThisAction)
{
var matchingEvent = GetEvents(call, meetsThisSpecification).FirstOrDefault();
if (matchingEvent != null)
{
takeThisAction(matchingEvent.Name, call.GetArguments()[0]);
}
}
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);
}
private void If(ICall call, Func <ICall, Predicate <EventInfo> > meetsThisSpecification, Action <string, object> takeThisAction)
{
var events = GetEvents(call, meetsThisSpecification);
if (events.Any())
{
takeThisAction(events.First().Name, call.GetArguments()[0]);
}
}
public RouteAction Handle(ICall call)
{
if (_propertyHelper.IsCallToSetAReadWriteProperty(call))
{
var callToPropertyGetter = _propertyHelper.CreateCallToPropertyGetterFromSetterCall(call);
var valueBeingSetOnProperty = call.GetArguments().Last();
_resultSetter.SetResultForCall(callToPropertyGetter, new ReturnValue(valueBeingSetOnProperty), MatchArgs.AsSpecifiedInCall);
}
return(RouteAction.Continue());
}
public RouteAction Handle(ICall call)
{
if (_propertyHelper.IsCallToSetAReadWriteProperty(call))
{
var callToPropertyGetter = _propertyHelper.CreateCallToPropertyGetterFromSetterCall(call);
var valueBeingSetOnProperty = call.GetArguments().First();
_resultSetter.SetResultForCall(callToPropertyGetter, new ReturnValue(valueBeingSetOnProperty), MatchArgs.AsSpecifiedInCall);
}
return RouteAction.Continue();
}
public object Handle(ICall call)
{
if (_propertyHelper.IsCallToSetAReadWriteProperty(call))
{
var callToPropertyGetter = _propertyHelper.CreateCallToPropertyGetterFromSetterCall(call);
var valueBeingSetOnProperty = call.GetArguments().First();
_resultSetter.SetResultForCall(callToPropertyGetter, valueBeingSetOnProperty);
}
return null;
}
public ICallSpecification CreateFrom(ICall call, MatchArgs matchArgs)
{
var methodInfo = call.GetMethodInfo();
var argumentSpecs = call.GetArgumentSpecifications();
var arguments = call.GetArguments();
var parameterInfos = call.GetParameterInfos();
var argumentSpecificationsForCall = _argumentSpecificationsFactory.Create(argumentSpecs, arguments, parameterInfos, matchArgs);
return(new CallSpecification(methodInfo, argumentSpecificationsForCall));
}
private static IEnumerable<Argument> GetArgumentsFromCall(ICall call)
{
var values = call.GetArguments();
var types = call.GetParameterInfos().Select(x => x.ParameterType).ToArray();
for (var index = 0; index < values.Length; index++)
{
var i = index;
yield return new Argument(types[i], () => values[i], x => values[i] = x);
}
}
private static string DumpCallInfo(ICall cur)
{
var methodName = cur.GetMethodInfo().Name;
var args = cur.GetArguments()
.Select(a => a is string
?$"\"{a}\""
: a)
.JoinWith(", ");
return($"{methodName}({args})");
}
private static IEnumerable <Argument> GetArgumentsFromCall(ICall call)
{
var values = call.GetArguments();
var parameterInfos = call.GetParameterInfos();
for (var index = 0; index < values.Length; index++)
{
var i = index;
yield return(new Argument(parameterInfos[i].ParameterType, () => values[i], x => values[i] = x));
}
}
private static IEnumerable <Argument> GetArgumentsFromCall(ICall call)
{
var values = call.GetArguments();
var types = call.GetParameterInfos().Select(x => x.ParameterType).ToArray();
for (var index = 0; index < values.Length; index++)
{
var i = index;
yield return(new Argument(types[i], () => values[i], x => values[i] = x));
}
}
public bool IsSatisfiedBy(ICall call)
{
if (MethodInfo != call.GetMethodInfo()) return false;
var arguments = call.GetArguments();
if (arguments.Length != ArgumentSpecifications.Count) return false;
for (int i = 0; i < arguments.Length; i++)
{
var argumentMatchesSpecification = ArgumentSpecifications[i].IsSatisfiedBy(arguments[i]);
if (!argumentMatchesSpecification) return false;
}
return true;
}
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());
}
static bool LogOneWarning(ICall call)
{
if (call.GetMethodInfo().Name != "Log")
{
return(false);
}
var args = call.GetArguments();
var logLevel = (LogLevel)args[0];
var exception = (Exception)args[3];
return(logLevel == LogLevel.Warning && exception.Message.Contains("null"));
}
/// <summary>
/// Gets a notification if one was scheduled.
/// </summary>
/// <returns>The scheduled notification.</returns>
public ScheduledNotification <Guid> GetScheduledNotification()
{
ICall saveScheduledNotification =
this.NotificationRepository
.ReceivedCalls()
.SingleOrDefault(call => call.GetMethodInfo().Name == nameof(INotificationRepository <Guid> .SaveScheduledNotification));
if (saveScheduledNotification == null)
{
throw new InvalidOperationException("A notification was not scheduled.");
}
return(saveScheduledNotification.GetArguments().Cast <ScheduledNotification <Guid> >().Single());
}
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 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.GetArguments());
var getterArgumentSpecifications = GetGetterCallSpecificationsFromSetterCall(callToSetter);
return(_callFactory.Create(getter, getterArgs, callToSetter.Target(), getterArgumentSpecifications));
}
/// <summary>
/// Validate a call to <see cref="IFluentQuery{TEntity, TId}.Where(string, object)"/>
/// </summary>
/// <param name="call">Call</param>
/// <param name="expectedClause">Expected clause</param>
/// <param name="expectedParameters">Expected parameters</param>
public static void AssertWhere(ICall call, string expectedClause, object expectedParameters)
{
// Check the method name
AssertMethodName(call, nameof(IFake.Where));
// Check the parameters
AssertCollection(call.GetArguments(),
// Check that the correct clause is being used
actualClause => AssertEqualType(expectedClause, actualClause),
// Check that the correct parameters are being used -
// using Json serialisation to support anonymous types
actualParameters => AssertEqualJson(expectedParameters, actualParameters)
);
}
private bool CallArgsWere(ICall call, object[] expectedArguments)
{
var callArguments = call.GetArguments();
if (callArguments.Length != expectedArguments.Length)
{
return(false);
}
for (int i = 0; i < callArguments.Length; i++)
{
if (!callArguments[i].Equals(expectedArguments[i]))
{
return(false);
}
}
return(true);
}
/// <summary>
/// Validate a call to <see cref="IFluentQuery{TEntity, TId}.Sort{TValue}(Expression{Func{TEntity, TValue}}, SortOrder)"/>
/// </summary>
/// <typeparam name="TEntity">Entity type</typeparam>
/// <typeparam name="TValue">Column select value type</typeparam>
/// <param name="call">Call</param>
/// <param name="expectedProperty">Expected property</param>
/// <param name="expectedOrder">Expected sort order</param>
public static void AssertSort <TEntity, TValue>(ICall call, string expectedProperty, SortOrder expectedOrder)
{
// Check the method
AssertMethodName(call, nameof(IFake.Sort));
// Check the generic arguments
AssertGenericArgument <TValue>(call);
// Check each predicate
Assert.Collection(call.GetArguments(),
// Check that the correct property is being used
actualProperty => AssertPropertyExpression <TEntity, TValue>(expectedProperty, actualProperty),
// Check that the correct order is being used
actualCompare => AssertEqualType(expectedOrder, actualCompare)
);
}
/// <summary>
/// Validate a call to <see cref="IFluentQuery{TEntity, TId}.WhereNotIn{TValue}(Expression{Func{TEntity, TValue}}, IEnumerable{TValue})"/>
/// </summary>
/// <typeparam name="TEntity">Entity type</typeparam>
/// <typeparam name="TValue">Column select value type</typeparam>
/// <param name="call">Call</param>
/// <param name="expectedProperty">Expected property</param>
/// <param name="expectedValues">Expected values</param>
public static void AssertWhereNotIn <TEntity, TValue>(ICall call, string expectedProperty, TValue[] expectedValues)
{
// Check the method
AssertMethodName(call, nameof(IFake.WhereNotIn));
// Check the generic arguments
AssertGenericArgument <TValue>(call);
// Check each parameters
AssertCollection(call.GetArguments(),
// Check that the correct property is being used
actualProperty => AssertPropertyExpression <TEntity, TValue>(expectedProperty, actualProperty),
// Check that the correct values are being used
actualValue => AssertEqualType(expectedValues, actualValue)
);
}
public override void Context()
{
base.Context();
var methodInfo = ReflectionHelper.GetMethod(() => SampleMethod());
var arguments = new[] { new object() };
_call = CreateStubCall(methodInfo, arguments);
_call.stub(x => x.GetArgumentSpecifications()).Return(mock <IList <IArgumentSpecification> >());
_argumentSpecificationsFactory = mock <IArgumentSpecificationsFactory>();
_argSpecsFromFactory = new[] { mock <IArgumentSpecification>(), mock <IArgumentSpecification>() };
_argumentSpecificationsFactory
.Stub(x => x.Create(
_call.GetArgumentSpecifications(),
_call.GetArguments(),
_call.GetParameterInfos(),
_argMatching))
.Return(_argSpecsFromFactory);
}
private static void AssertCalculateCall(ICall call,
BalancedFieldLengthCalculation calculation,
int failureVelocity)
{
object[] arguments = call.GetArguments();
AircraftDataTestHelper.AssertAircraftData(calculation.AircraftData,
calculation.EngineData,
(KernelAircraftData)arguments[0]);
Assert.That(arguments[1], Is.TypeOf <EulerIntegrator>());
GeneralSimulationSettingsData simulationSettings = calculation.SimulationSettings;
Assert.That(arguments[2], Is.EqualTo(calculation.EngineData.NrOfFailedEngines));
Assert.That(arguments[3], Is.EqualTo(simulationSettings.Density));
Assert.That(arguments[4], Is.EqualTo(simulationSettings.GravitationalAcceleration));
CalculationSettingsTestHelper.AssertCalculationSettings(simulationSettings, failureVelocity,
(CalculationSettings)arguments[5]);
}
public ICallSpecification CreateFrom(ICall call)
{
var result = new CallSpecification(call.GetMethodInfo());
var argumentSpecs = _context.DequeueAllArgumentSpecifications();
var arguments = call.GetArguments();
if (argumentSpecs.Count == 0)
{
AddArgumentSpecsToCallSpec(result, arguments.Select(x => (IArgumentSpecification) new ArgumentEqualsSpecification(x)));
}
else if (argumentSpecs.Count == arguments.Length)
{
AddArgumentSpecsToCallSpec(result, argumentSpecs);
}
else
{
throw new AmbiguousArgumentsException(
"Cannot determine argument specifications to use. Please use specifications for all arguments.");
}
return result;
}
public void Validate_Always_FactoryReceiveCorrectData()
{
// Setup
var calculation = new BalancedFieldLengthCalculation();
SetValidAircraftData(calculation.AircraftData);
SetEngineData(calculation.EngineData);
SetSimulationSettingsData(calculation.SimulationSettings);
var kernel = Substitute.For <IAggregatedDistanceCalculatorKernel>();
kernel.Validate(Arg.Any <KernelAircraftData>(),
Arg.Any <double>(),
Arg.Any <double>(),
Arg.Any <int>())
.ReturnsForAnyArgs(KernelValidationError.None);
var testFactory = new TestKernelFactory(kernel);
using (new BalancedFieldLengthKernelFactoryConfig(testFactory))
{
var module = new BalancedFieldLengthCalculationModule();
// Call
module.Validate(calculation);
// Assert
ICall calls = kernel.ReceivedCalls().Single();
object[] arguments = calls.GetArguments();
AircraftDataTestHelper.AssertAircraftData(calculation.AircraftData,
calculation.EngineData,
(KernelAircraftData)arguments[0]);
GeneralSimulationSettingsData simulationSettings = calculation.SimulationSettings;
Assert.That(arguments[1], Is.EqualTo(simulationSettings.Density));
Assert.That(arguments[2], Is.EqualTo(simulationSettings.GravitationalAcceleration));
Assert.That(arguments[3], Is.EqualTo(calculation.EngineData.NrOfFailedEngines));
}
}
/// <summary>
/// Validate a call to <see cref="IFluentQuery{TEntity, TId}.ExecuteAsync{TValue}(Expression{Func{TEntity, TValue}})"/>
/// </summary>
/// <typeparam name="TEntity">Entity type</typeparam>
/// <typeparam name="TValue">Column select value type</typeparam>
/// <param name="call">Call</param>
/// <param name="expected">Expected property</param>
/// <param name="withTransaction">Whether or not to check for a transaction</param>
public static void AssertExecute <TEntity, TValue>(ICall call, string expected, bool withTransaction)
{
// Check the method name
AssertMethodName(call, nameof(IFake.ExecuteAsync));
// Check the generic arguments
AssertGenericArgument <TValue>(call);
// Check the parameters
var inspectors = new List <Action <object?> >
{
// Check that the correct property is being used
{ actualProperty => AssertPropertyExpression <TEntity, TValue>(expected, actualProperty) }
};
if (withTransaction)
{
// Use discard as a placeholder so the right number of items is checked in the collection
inspectors.Add(_ => { });
}
AssertCollection(call.GetArguments(), inspectors.ToArray());
}
/// <summary>
/// Validate a call to <see cref="IFluentQuery{TEntity, TId}.Where{TValue}(Expression{Func{TEntity, TValue}}, Compare, TValue)"/>
/// </summary>
/// <typeparam name="TEntity">Entity type</typeparam>
/// <typeparam name="TValue">Column select value type</typeparam>
/// <param name="call">Call</param>
/// <param name="expectedProperty">Expected property</param>
/// <param name="expectedCompare">Expected comparison</param>
/// <param name="expectedValue">Expected value</param>
public static void AssertWhere <TEntity, TValue>(
ICall call,
string expectedProperty,
Compare expectedCompare,
TValue expectedValue
)
{
// Check the method name
AssertMethodName(call, nameof(IFake.Where));
// Check the generic arguments
AssertGenericArgument <TValue>(call);
// Check the parameters
AssertCollection(call.GetArguments(),
// Check that the correct property is being used
actualProperty => AssertPropertyExpression <TEntity, TValue>(expectedProperty, actualProperty),
// Check that the correct compare is being used
actualCompare => AssertEqualType(expectedCompare, actualCompare),
// Check that the correct value is being used
actualValue =>
{
if (actualValue is null)
{
Assert.Null(actualValue);
}
else
{
AssertEqual(expectedValue, actualValue);
}
}
);
}
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));
}
public string Format(ICall call, ICallSpecification withRespectToCallSpec)
{
return Format(call.GetMethodInfo(), call.GetArguments(), withRespectToCallSpec.NonMatchingArgumentIndicies(call));
}
public static T Arg <T>(this ICall call, int index)
{
return((T)call.GetArguments()[index]);
}
private bool HasDifferentNumberOfArguments(ICall call)
{
return _argumentSpecifications.Length != call.GetArguments().Length;
}
private string Format(ICall call)
{
return _callFormatter.Format(call.GetMethodInfo(), FormatArgs(call.GetArguments()));
}
public object Handle(ICall call)
{
_actionToPerform(call.GetArguments());
return null;
}
private bool IsSpecifyingACall(ICall call)
{
var args = call.GetArguments() ?? EmptyArgs;
var argSpecs = call.GetArgumentSpecifications() ?? EmptyArgSpecs;
return _isSetToDefaultRoute && args.Any() && argSpecs.Any();
}
public string Format(ICall call)
{
return CallFormatter.Format(call.GetMethodInfo(), FormatArguments(call.GetArguments()));
}
