public void RaiseCallWasIntercepted(IWritableFakeObjectCall call)
{
var handler = this.CallWasIntercepted;
if (handler != null)
{
handler(this, new CallInterceptedEventArgs(call));
}
}
public void ApplyNext(IWritableFakeObjectCall call)
{
if (this.enumerator == null || !this.enumerator.MoveNext())
{
this.enumerator = this.Xml.Root.Elements().GetEnumerator();
this.enumerator.MoveNext();
}
call.SetReturnValue(Deserialize(this.enumerator.Current));
}
private bool TryHandleToString(IWritableFakeObjectCall fakeObjectCall)
{
if (!fakeObjectCall.Method.Name.Equals("ToString"))
{
return(false);
}
fakeObjectCall.SetReturnValue("Faked {0}".FormatInvariant(this.FakeObject.FakeObjectType.FullName));
return(true);
}
public void Apply(IWritableFakeObjectCall fakeObjectCall)
{
if (this.IsPropertyGetter(fakeObjectCall))
{
fakeObjectCall.SetReturnValue(this.Value);
}
else
{
this.Value = fakeObjectCall.Arguments[0];
}
}
private void Intercept(IWritableFakeObjectCall fakeObjectCall)
{
var ruleToUse =
(from rule in this.AllRules
where rule.Rule.IsApplicableTo(fakeObjectCall) && rule.HasNotBeenCalledSpecifiedNumberOfTimes()
select rule).First();
this.ApplyRule(ruleToUse, fakeObjectCall);
FakeScope.Current.AddInterceptedCall(this, fakeObjectCall.AsReadOnly());
}
internal void Intercept(IWritableFakeObjectCall fakeObjectCall)
{
this.recordedCallsField.Add(fakeObjectCall);
var ruleToUse =
(from rule in this.AllRules
where rule.Rule.IsApplicableTo(fakeObjectCall) && rule.HasNotBeenCalledSpecifiedNumberOfTimes()
select rule).First();
this.ApplyRule(ruleToUse, fakeObjectCall);
}
private static object ResolveReturnValue(IWritableFakeObjectCall fakeObjectCall)
{
var generator = GetFakeObjectGeneratorForCall(fakeObjectCall);
if (!generator.GenerateFakeObject())
{
return(Helpers.GetDefaultValueOfType(fakeObjectCall.Method.ReturnType));
}
return(generator.GeneratedFake);
}
/// <summary>
/// Applies the call if the call has been recorded.
/// </summary>
/// <param name="call">The call to apply to from recording.</param>
public void ApplyNext(IWritableFakeObjectCall call)
{
this.AssertThatCallQueueIsNotEmpty();
var callToApply = this.callQueue.Dequeue();
AssertThatMethodsMatches(call, callToApply);
ApplyOutputArguments(call, callToApply);
call.SetReturnValue(callToApply.RecordedCall.ReturnValue);
callToApply.HasBeenApplied = true;
}
public void Apply(IWritableFakeObjectCall fakeObjectCall)
{
if (this.Recorder.IsRecording)
{
this.WrappedObjectRule.Apply(fakeObjectCall);
this.Recorder.RecordCall(fakeObjectCall.Freeze());
}
else
{
this.Recorder.ApplyNext(fakeObjectCall);
}
}
/// <summary>
/// Applies an action to the call, might set a return value or throw
/// an exception.
/// </summary>
/// <param name="fakeObjectCall">The call to apply the interceptor to.</param>
public void Apply(IWritableFakeObjectCall fakeObjectCall)
{
if (this.recorder.IsRecording)
{
this.wrappedRule.Apply(fakeObjectCall);
this.recorder.RecordCall(fakeObjectCall.AsReadOnly());
}
else
{
this.recorder.ApplyNext(fakeObjectCall);
}
}
public void Apply(IWritableFakeObjectCall fakeObjectCall)
{
this.RecordedRule.ApplicableToMethod = fakeObjectCall.Method;
if (this.RecordedRule.IsApplicableToArguments == null)
{
this.CreateArgumentsPredicateFromArguments(fakeObjectCall);
}
this.fakeObject.AddRule(this.RecordedRule);
fakeObjectCall.SetReturnValue(Helpers.GetDefaultValueOfType(fakeObjectCall.Method.ReturnType));
}
private static bool TryHandleGetHashCode(IWritableFakeObjectCall fakeObjectCall)
{
if (!fakeObjectCall.Method.Name.Equals("GetHashCode"))
{
return(false);
}
var fakeObject = Fake.GetFakeObject(fakeObjectCall.FakedObject);
fakeObjectCall.SetReturnValue(fakeObject.GetHashCode());
return(true);
}
public void Apply(IWritableFakeObjectCall fakeObjectCall)
{
var newRule = new CallRuleMetadata
{
CalledNumberOfTimes = 1,
Rule = new PropertyBehaviorRule(fakeObjectCall.Method)
{
Value = fakeObjectCall.Arguments[0]
}
};
this.FakeObject.allUserRulesField.AddFirst(newRule);
}
public void Apply_should_call_the_applicator_with_the_incoming_call()
{
IWritableFakeObjectCall callPassedToApplicator = null;
var callPassedToRule = FakeCall.Create <IFoo>("Bar");
var rule = CreateRule <IFoo>(x => x.Bar());
rule.Applicator = x => callPassedToApplicator = x;
rule.Apply(callPassedToRule);
Assert.That(callPassedToApplicator, Is.SameAs(callPassedToRule));
}
public void Apply(IWritableFakeObjectCall fakeObjectCall)
{
var newRule = new CallRuleMetadata
{
Rule = new PropertyBehaviorRule(fakeObjectCall.Method, FakeObject)
{
Value = new FakeObject(fakeObjectCall.Method.ReturnType).Object
},
CalledNumberOfTimes = 1
};
this.FakeObject.allUserRulesField.AddFirst(newRule);
newRule.Rule.Apply(fakeObjectCall);
}
public virtual void Apply(IWritableFakeObjectCall fakeObjectCall)
{
foreach (var action in this.Actions)
{
action.Invoke(fakeObjectCall);
}
this.Applicator.Invoke(fakeObjectCall);
this.ApplyOutAndRefParametersValues(fakeObjectCall);
if (this.CallBaseMethod)
{
fakeObjectCall.CallBaseMethod();
}
}
private static ICollection <int> GetIndexesOfOutAndRefParameters(IWritableFakeObjectCall fakeObjectCall)
{
var indexes = new List <int>();
var arguments = fakeObjectCall.Method.GetParameters();
for (int i = 0; i < arguments.Length; i++)
{
if (arguments[i].ParameterType.IsByRef)
{
indexes.Add(i);
}
}
return(indexes);
}
public void Apply(IWritableFakeObjectCall fakeObjectCall)
{
if (TryHandleToString(fakeObjectCall))
{
return;
}
if (TryHandleGetHashCode(fakeObjectCall))
{
return;
}
if (TryHandleEquals(fakeObjectCall))
{
return;
}
}
public virtual void Apply(IWritableFakeObjectCall fakeObjectCall)
{
if (this.Applicator == null)
{
throw new InvalidOperationException(ExceptionMessages.ApplicatorNotSetExceptionMessage);
}
foreach (var action in this.Actions)
{
action.Invoke(fakeObjectCall);
}
this.Applicator.Invoke(fakeObjectCall);
if (this.CallBaseMethod)
{
fakeObjectCall.CallBaseMethod();
}
}
public void GenerateProxy_should_generate_result_that_raises_events_when_calls_are_intercepted(Type someInterfaceType)
{
var generator = this.CreateGenerator();
var result = generator.GenerateProxy(someInterfaceType, this.fakeObject, this.container);
IWritableFakeObjectCall interceptedCall = null;
result.CallWasIntercepted += (s, e) =>
{
interceptedCall = e.Call;
};
var someInterface = (ISomeInterface)result.Proxy;
someInterface.Bar();
Assert.That(interceptedCall.Method.Name, Is.EqualTo("Bar"));
}
private void ApplyOutAndRefParametersValues(IWritableFakeObjectCall fakeObjectCall)
{
if (this.OutAndRefParametersValues == null)
{
return;
}
var indexes = GetIndexesOfOutAndRefParameters(fakeObjectCall);
if (this.OutAndRefParametersValues.Count != indexes.Count)
{
throw new InvalidOperationException(ExceptionMessages.NumberOfOutAndRefParametersDoesNotMatchCall);
}
foreach (var argument in indexes.Pairwise(this.OutAndRefParametersValues))
{
fakeObjectCall.SetArgumentValue(argument.First, argument.Second);
}
}
public void GenerateProxy_with_arguments_for_constructor_should_generate_proxies_raises_events_when_calls_made_to_proxy()
{
var generator = this.CreateGenerator();
var result = generator.GenerateProxy(typeof(TypeWithConstructorThatTakesSingleString), this.fakeObject, new object[] { "foo" });
IWritableFakeObjectCall interceptedCall = null;
result.CallWasIntercepted += (s, e) =>
{
interceptedCall = e.Call;
};
var fake = result.Proxy as TypeWithConstructorThatTakesSingleString;
fake.Bar();
Assert.That(interceptedCall.Method.Name, Is.EqualTo("Bar"));
}
public void Should_delegate_to_fake_call_processor_when_method_on_fake_is_called(Type typeThatImplementsInterfaceType)
{
// Arrange
IWritableFakeObjectCall interceptedFakeObjectCall = null;
var fakeCallProcessorProvider = CreateFakeCallProcessorProvider(c => interceptedFakeObjectCall = c);
var result = this.generator.GenerateProxy(typeThatImplementsInterfaceType, Enumerable.Empty <Type>(), null, fakeCallProcessorProvider);
var proxy = (IInterfaceType)result.GeneratedProxy;
// Act
proxy.Foo(1, 2);
// Assert
interceptedFakeObjectCall.Should().NotBeNull();
interceptedFakeObjectCall.Arguments.Should().BeEquivalentTo(1, 2);
interceptedFakeObjectCall.Method.Name.Should().Be(typeof(IInterfaceType).GetMethod("Foo").Name);
interceptedFakeObjectCall.FakedObject.Should().BeSameAs(proxy);
}
private bool TryHandleEquals(IWritableFakeObjectCall fakeObjectCall)
{
if (!fakeObjectCall.Method.Name.Equals("Equals"))
{
return(false);
}
var argument = fakeObjectCall.Arguments[0] as IFakedProxy;
if (argument != null)
{
fakeObjectCall.SetReturnValue(argument.GetFakeObject().Equals(this.FakeObject));
}
else
{
fakeObjectCall.SetReturnValue(false);
}
return(true);
}
public void Should_raise_event_on_event_raiser_when_method_on_fake_is_called(Type typeThatImplementsInterfaceType)
{
// Arrange
var result = this.generator.GenerateProxy(typeThatImplementsInterfaceType, Enumerable.Empty <Type>(), null);
IWritableFakeObjectCall callMadeToProxy = null;
result.CallInterceptedEventRaiser.CallWasIntercepted += (sender, e) =>
{
callMadeToProxy = e.Call;
};
var proxy = (IInterfaceType)result.GeneratedProxy;
// Act
proxy.Foo(1, 2);
// Assert
Assert.That(callMadeToProxy, Is.Not.Null);
Assert.That(callMadeToProxy.Arguments, Is.EquivalentTo(new object[] { 1, 2 }));
Assert.That(callMadeToProxy.Method.Name, Is.EqualTo(typeof(IInterfaceType).GetMethod("Foo").Name));
Assert.That(callMadeToProxy.FakedObject, Is.SameAs(proxy));
}
private void Intercept(IWritableFakeObjectCall fakeObjectCall)
{
var ruleToUse =
(from rule in this.AllRules
where rule.Rule.IsApplicableTo(fakeObjectCall) && rule.HasNotBeenCalledSpecifiedNumberOfTimes()
select rule).First();
var interceptedCall = new InterceptedCallAdapter(fakeObjectCall);
try
{
ApplyRule(ruleToUse, interceptedCall);
}
finally
{
this.RecordInterceptedCall(interceptedCall);
}
}
private void ApplyRule(CallRuleMetadata rule, IWritableFakeObjectCall fakeObjectCall)
{
rule.CalledNumberOfTimes++;
rule.Rule.Apply(fakeObjectCall);
}
public void Apply(IWritableFakeObjectCall fakeObjectCall)
{
EventCall eventCall = EventCall.GetEventCall(fakeObjectCall);
this.HandleEventCall(eventCall);
}
public CallInterceptedEventArgs(IWritableFakeObjectCall call)
{
Guard.AgainstNull(call, "call");
this.Call = call;
}
private static IEnumerable <Tuple <int, object> > GetIndicesAndValuesOfOutputParameters(IWritableFakeObjectCall call, CallData recordedCall)
{
return
((from argument in call.Method.GetParameters().Zip(Enumerable.Range(0, int.MaxValue))
where argument.First.ParameterType.IsByRef
select argument.Second).Zip(recordedCall.OutputArguments));
}
public CallInterceptedEventArgs(IWritableFakeObjectCall call)
{
Guard.AgainstNull(call, "call");
this.Call = call;
}
private void Intercept(IWritableFakeObjectCall fakeObjectCall)
{
foreach (var listener in this.interceptionListeners)
{
listener.OnBeforeCallIntercepted(fakeObjectCall);
}
var ruleToUse =
(from rule in this.AllRules
where rule.Rule.IsApplicableTo(fakeObjectCall) && rule.HasNotBeenCalledSpecifiedNumberOfTimes()
select rule).First();
var interceptedCall = new InterceptedCallAdapter(fakeObjectCall);
try
{
ApplyRule(ruleToUse, interceptedCall);
}
finally
{
var readonlyCall = fakeObjectCall.AsReadOnly();
if (!interceptedCall.IgnoreCallInRecording)
{
FakeScope.Current.AddInterceptedCall(this, readonlyCall);
}
foreach (var listener in this.interceptionListeners.Reverse())
{
listener.OnAfterCallIntercepted(readonlyCall, ruleToUse.Rule);
}
}
}
public void Apply(IWritableFakeObjectCall fakeObjectCall)
{
var returnValue = Helpers.GetDefaultValueOfType(fakeObjectCall.Method.ReturnType);
fakeObjectCall.SetReturnValue(returnValue);
}
public InterceptedCallAdapter(IWritableFakeObjectCall call)
{
this.call = call;
}
public InterceptedCallAdapter(IWritableFakeObjectCall call)
{
this.call = call;
}