public void CanExpect() { demo.Expect(x => x.Prop) .Return("Ayende"); Assert.Equal("Ayende", demo.Prop); }
public void CanSetupExpectations() { demo.Expect(x => x.ReturnIntNoArgs()) .Return(30); Assert.Equal(30, demo.ReturnIntNoArgs()); Assert.Equal(0, demo.ReturnIntNoArgs()); }
private static void RecordOrdered(IDemo demo) { demo.Expect(x => x.ReturnStringNoArgs()) .Return(null); demo.Expect(x => x.VoidNoArgs()) .Repeat.Twice(); demo.Expect(x => x.VoidStringArg("Hello")); demo.Expect(x => x.VoidStringArg("World")); }
public void MockInterface() { IDemo demo = MockRepository.Mock <IDemo>(); demo.Expect(x => x.ReturnIntNoArgs()) .Return(54); demo.Expect(x => x.VoidStringArg("54")); contextSwitcher.DoStuff(demo); demo.VerifyAllExpectations(); }
public void RecursiveExpectationsOnUnordered() { demo = (IDemo)MockRepository.GenerateStrictMock(typeof(IDemo)); demo.Expect(x => x.VoidNoArgs()) .Callback(new DelegateDefinations.NoArgsDelegate(CallMethodOnDemo)); demo.Expect(x => x.VoidStringArg("Ayende")); demo.VoidNoArgs(); demo.VerifyAllExpectations(); }
public void MockInterfaceUnexpectedCall() { IDemo demo = MockRepository.Mock <IDemo>(); demo.Expect(x => x.ReturnIntNoArgs()) .Return(34); demo.Expect(x => x.VoidStringArg("bang")); contextSwitcher.DoStuff(demo); Assert.Throws <ExpectationViolationException>( () => demo.VerifyExpectations(true)); }
public void RecursiveExpectationsOnOrdered() { demo = (IDemo)MockRepository.GenerateStrictMock(typeof(IDemo)); demo.Expect(x => x.VoidNoArgs()) .Callback(CallMethodOnDemo); demo.Expect(x => x.VoidStringArg("Ayende")); Assert.Throws <ExpectationViolationException>( "Unordered method call! The expected call is: 'Ordered: { IDemo.VoidNoArgs(callback method: RhinoMockTests.CallMethodOnDemo); }' but was: 'IDemo.VoidStringArg(\"Ayende\");'", () => demo.VoidNoArgs()); }
public void SteppingFromInnerOrderringToOuterWithoutFullifingAllOrderringInInnerThrows() { demo = (IDemo)MockRepository.GenerateStrictMock(typeof(IDemo)); demo.Expect(x => x.VoidThreeStringArgs("", "", "")); demo.Expect(x => x.VoidNoArgs()); demo.Expect(x => x.VoidStringArg("Ayende")); demo.VoidNoArgs(); Assert.Throws <ExpectationViolationException>( "Unordered method call! The expected call is: 'Ordered: { IDemo.VoidStringArg(\"Ayende\"); }' but was: 'IDemo.VoidThreeStringArgs(\"\", \"\", \"\");'", () => demo.VoidThreeStringArgs("", "", "")); }
public void MockInterface() { IDemo demo = MockRepository.Mock <IDemo>(); demo.SetUnexpectedBehavior(UnexpectedCallBehaviors.BaseOrDefault); demo.Expect(x => x.ReturnIntNoArgs()) .Return(54); demo.Expect(x => x.VoidStringArg("54")); contextSwitcher.DoStuff(demo); demo.VerifyAllExpectations(); }
public void CanFailIfCalledMoreThanOnceUsingDynamicMock() { IDemo demo = Repository.Mock <IDemo>(); demo.Expect(x => x.VoidNoArgs()) .Repeat.Once(); demo.Expect(x => x.VoidNoArgs()) .Repeat.Never(); Assert.Throws <ExpectationViolationException>( "IDemo.VoidNoArgs(); Expected #0, Actual #1.", demo.VoidNoArgs); }
public void CanSetupResultForMethodAndIgnoreArgs() { demo.Expect(x => x.StringArgString(null)) .IgnoreArguments() .Return("Ayende") .Repeat.Any(); Assert.Equal("Ayende", demo.StringArgString("a")); Assert.Equal("Ayende", demo.StringArgString("b")); demo.VerifyAllExpectations(); }
public void CantCallOriginalMethodOnInterface() { IDemo demo = MockRepository.Mock <IDemo>(); Assert.Throws <InvalidOperationException>( () => demo.Expect(x => x.ReturnIntNoArgs()) .CallOriginalMethod()); }
public void ShouldNotExpect() { demo.Expect(x => x.StringArgString("Ayende")) .Repeat.Never(); demo.StringArgString("Ayende"); Assert.Throws <ExpectationViolationException>( () => demo.VerifyExpectations()); }
public void TryingToGetEventRaiserFromNonEvenTrhows() { IDemo demo = MockRepository.GenerateStrictMock <IDemo>(); Assert.Throws <InvalidOperationException>( "The last method call EnumNoArgs was not an event add / remove method", () => demo.Expect(x => x.EnumNoArgs()) .GetEventRaiser()); }
public void NaturalSyntaxForCallingMethods() { IDemo demo = MockRepository.Mock <IDemo>(); demo.Expect(x => x.VoidNoArgs()); demo.VoidNoArgs(); demo.VerifyExpectations(); }
public void NaturalSyntaxForCallingMethods_WithArguments_WhenNotCalled_WouldFailVerification() { IDemo demo = MockRepository.Mock <IDemo>(); demo.Expect(x => x.VoidStringArg("blah")); Assert.Throws <ExpectationViolationException>( () => demo.VerifyExpectations()); }
public void CallbackThatThrows() { demo = (IDemo)MockRepository.GenerateStrictMock(typeof(IDemo)); demo.Expect(x => x.VoidNoArgs()) .Callback(new DelegateDefinations.NoArgsDelegate(ThrowFromCallback)); Assert.Throws <AddressAlreadyInUseException>(demo.VoidNoArgs); }
public void NaturalSyntaxForCallingMethods_WithArguments() { IDemo demo = MockRepository.Mock <IDemo>(); demo.Expect(x => x.VoidStringArg("blah")); demo.VoidStringArg("blah"); demo.VerifyExpectations(); }
public void MockInterfaceWithSameName() { IDemo demo = MockRepository.Mock <IDemo>(); Other.IDemo remotingDemo = MockRepository.Mock <Other.IDemo>(); demo.Expect(x => x.ReturnIntNoArgs()) .Return(54); demo.Expect(x => x.VoidStringArg("54")); remotingDemo.Expect(x => x.ProcessString("in")); contextSwitcher.DoStuff(demo); contextSwitcher.DoStuff(remotingDemo); demo.VerifyAllExpectations(); remotingDemo.VerifyAllExpectations(); }
public void CantCallOriginalMethodOnInterface() { IDemo demo = MockRepository.Mock <IDemo>(); demo.SetUnexpectedBehavior(UnexpectedCallBehaviors.BaseOrDefault); Assert.Throws <InvalidOperationException>( () => demo.Expect(x => x.ReturnIntNoArgs()) .CallOriginalMethod()); }
public void MockInterfaceExpectException() { IDemo demo = MockRepository.Mock <IDemo>(); demo.Expect(x => x.ReturnIntNoArgs()) .Throws <InvalidOperationException>(); Assert.Throws <InvalidOperationException>( () => contextSwitcher.DoStuff(demo)); }
public void GetArgsOfEpectedAndActualMethodCallOnException() { demo = (IDemo)MockRepository.GenerateStrictMock(typeof(IDemo)); demo.Expect(x => x.VoidThreeStringArgs("a", "b", "c")); Assert.Throws <ExpectationViolationException>( "IDemo.VoidThreeStringArgs(\"c\", \"b\", \"a\"); Expected #0, Actual #1.\r\nIDemo.VoidThreeStringArgs(\"a\", \"b\", \"c\"); Expected #1, Actual #0.", () => demo.VoidThreeStringArgs("c", "b", "a")); }
public void NaturalSyntaxForCallingMethods_WithArguments_WhenCalledWithDifferentArgument() { IDemo demo = MockRepository.Mock <IDemo>(); demo.Expect(x => x.VoidStringArg("blah")); demo.VoidStringArg("arg"); Assert.Throws <ExpectationViolationException>( () => demo.VerifyExpectations(true)); }
public void UsingReturnAndThenIgnoreArgs() { IDemo demo = MockRepository.Mock <IDemo>(); demo.Expect(x => x.StringArgString(null)) .IgnoreArguments() .Return("ayende"); Assert.Equal("ayende", demo.StringArgString("rahien")); demo.VerifyExpectations(true); }
public void NaturalSyntaxForCallingMethods() { IDemo demo = MockRepository.Mock <IDemo>(); demo.SetUnexpectedBehavior(UnexpectedCallBehaviors.BaseOrDefault); demo.Expect(x => x.VoidNoArgs()); demo.VoidNoArgs(); demo.VerifyExpectations(); }
public void NaturalSyntaxForCallingMethods_WithArguments() { IDemo demo = MockRepository.Mock <IDemo>(); demo.SetUnexpectedBehavior(UnexpectedCallBehaviors.BaseOrDefault); demo.Expect(x => x.VoidStringArg("blah")); demo.VoidStringArg("blah"); demo.VerifyExpectations(); }
public void MockRepositoryClearsArgData() { Arg <int> .Is.Equal(4); Arg <int> .Is.Equal(4); demoMock = MockRepository.Mock <IDemo>(); demoMock.Expect(x => x.VoidThreeArgs( Arg <int> .Is.Equal(4), Arg.Text.Contains("World"), Arg <float> .Is.Equal(3.14f))); }
public void CanCallMethodWithParameters_WithoutSpecifyingParameters_WillAcceptAnyParameter() { IDemo demo = MockRepository.Mock <IDemo>(); demo.Expect(x => x.VoidStringArg("blah")) .IgnoreArguments(); demo.VoidStringArg("asd"); demo.VerifyExpectations(); }
public void MockRepositoryClearsArgData() { Arg <int> .Is.Equal(4); Arg <int> .Is.Equal(4); demoMock = MockRepository.Mock <IDemo>(); demoMock.SetUnexpectedBehavior(UnexpectedCallBehaviors.BaseOrDefault); demoMock.Expect(x => x.VoidThreeArgs( Arg <int> .Is.Equal(4), Arg.Text.Contains("World"), Arg <float> .Is.Equal(3.14f))); }
public void MockInterfaceExpectException() { IDemo demo = MockRepository.Mock <IDemo>(); demo.SetUnexpectedBehavior(UnexpectedCallBehaviors.BaseOrDefault); demo.Expect(x => x.ReturnIntNoArgs()) .Throws <InvalidOperationException>(); Assert.Throws <InvalidOperationException>( () => contextSwitcher.DoStuff(demo)); }
private static void CanCreateAStrictMultiMockFromTwoInterfacesCommon(IDemo demo) { demo.Expect(x => x.ReturnIntNoArgs()) .Return(1); IDisposable disposable = demo as IDisposable; Assert.NotNull(disposable); disposable.Expect(x => x.Dispose()); Assert.Equal(1, demo.ReturnIntNoArgs()); disposable.Dispose(); demo.VerifyAllExpectations(); }
public void GetArgsOfEpectedAndActualMethodCallOnException() { demo = (IDemo)MockRepository.GenerateStrictMock(typeof(IDemo)); demo.Expect(x => x.VoidThreeStringArgs("a", "b", "c")); Assert.Throws<ExpectationViolationException>( "IDemo.VoidThreeStringArgs(\"c\", \"b\", \"a\"); Expected #0, Actual #1.\r\nIDemo.VoidThreeStringArgs(\"a\", \"b\", \"c\"); Expected #1, Actual #0.", () => demo.VoidThreeStringArgs("c", "b", "a")); }
private static void CanCreateADynamicMultiMockFromTwoInterfacesCommon(IDemo demo, IEditableObject editable) { Assert.IsNotNull(demo, "IDemo null"); Assert.IsNotNull(editable, "IEditableObject null"); // Set expectation on one member on each interface demo.Expect(x => demo.ReadOnly).Return("foo"); editable.Expect(x => x.BeginEdit()); // Drive two members on each interface to check dynamic nature Assert.AreEqual("foo", demo.ReadOnly); demo.VoidNoArgs(); editable.BeginEdit(); editable.EndEdit(); demo.VerifyAllExpectations(); }
public void SteppingFromInnerOrderringToOuterWithoutFullifingAllOrderringInInnerThrows() { demo = (IDemo) MockRepository.GenerateStrictMock(typeof (IDemo)); demo.Expect(x => x.VoidThreeStringArgs("", "", "")); demo.Expect(x => x.VoidNoArgs()); demo.Expect(x => x.VoidStringArg("Ayende")); demo.VoidNoArgs(); Assert.Throws<ExpectationViolationException>( "Unordered method call! The expected call is: 'Ordered: { IDemo.VoidStringArg(\"Ayende\"); }' but was: 'IDemo.VoidThreeStringArgs(\"\", \"\", \"\");'", () => demo.VoidThreeStringArgs("", "", "")); }
public void CallbackThatThrows() { demo = (IDemo) MockRepository.GenerateStrictMock(typeof (IDemo)); demo.Expect(x => x.VoidNoArgs()) .Callback(new DelegateDefinations.NoArgsDelegate(ThrowFromCallback)); Assert.Throws<AddressAlreadyInUseException>(demo.VoidNoArgs); }
public void MockRepositoryClearsArgData() { Arg<int>.Is.Equal(4); Arg<int>.Is.Equal(4); // create new MockRepository to see if the Arg data has been cleared demoMock = MockRepository.GenerateStrictMock<IDemo>(); demoMock.Expect(x => x.VoidThreeArgs(Arg<int>.Is.Equal(4), Arg.Text.Contains("World"), Arg<float>.Is.Equal(3.14f))); }
public void RecursiveExpectationsOnOrdered() { demo = (IDemo)MockRepository.GenerateStrictMock(typeof(IDemo)); demo.Expect(x => x.VoidNoArgs()) .Callback(CallMethodOnDemo); demo.Expect(x => x.VoidStringArg("Ayende")); Assert.Throws<ExpectationViolationException>( "Unordered method call! The expected call is: 'Ordered: { IDemo.VoidNoArgs(callback method: RhinoMockTests.CallMethodOnDemo); }' but was: 'IDemo.VoidStringArg(\"Ayende\");'", () => demo.VoidNoArgs()); }
public void MockRepositoryClearsArgData() { Arg<int>.Is.Equal(4); Arg<int>.Is.Equal(4); demoMock = MockRepository.Mock<IDemo>(); demoMock.Expect(x => x.VoidThreeArgs( Arg<int>.Is.Equal(4), Arg.Text.Contains("World"), Arg<float>.Is.Equal(3.14f))); }