public void ChooseAffirmativeExpetationOnPropertySetter() { var mock = new Mock <IFoo>(); var when = true; var positive = false; var negative = false; mock.When(() => when).SetupSet(x => x.Value = "foo").Callback(() => positive = true); mock.When(() => !when).SetupSet(x => x.Value = "foo").Callback(() => negative = true); mock.Object.Value = "foo"; Assert.True(positive); Assert.False(negative); when = false; positive = false; mock.Object.Value = "foo"; Assert.False(positive); Assert.True(negative); when = true; negative = false; mock.Object.Value = "foo"; Assert.True(positive); Assert.False(negative); }
public void ChooseAffirmativeExpetationOnVoidMethod() { var mock = new Mock <IFoo>(); var when = true; var positive = false; var negative = false; mock.When(() => when).Setup(x => x.Bar()).Callback(() => positive = true); mock.When(() => !when).Setup(x => x.Bar()).Callback(() => negative = true); mock.Object.Bar(); Assert.True(positive); Assert.False(negative); when = false; positive = false; mock.Object.Bar(); Assert.False(positive); Assert.True(negative); when = true; negative = false; mock.Object.Bar(); Assert.True(positive); Assert.False(negative); }
public void ShouldSupportMultipleMethod() { var target = Mocks.Of <IBaz>().First(x => !x.HasElements("1") && x.HasElements("2")); Assert.False(target.HasElements("1")); Assert.True(target.HasElements("2")); }
public void MockObjectsEqualityIsReferenceEquals() { var mock1 = new Mock <IFoo>(); var mock2 = new Mock <IFoo>(); Assert.True(mock1.Object.Equals(mock1.Object)); Assert.False(mock1.Object.Equals(mock2.Object)); }
public void NeverChecksZeroTimes() { var target = Times.Never(); Assert.False(target.Verify(-1)); Assert.True(target.Verify(0)); Assert.False(target.Verify(1)); Assert.False(target.Verify(int.MaxValue)); }
public void OnceChecksOneTime() { var target = Times.Once(); Assert.False(target.Verify(-1)); Assert.False(target.Verify(0)); Assert.True(target.Verify(1)); Assert.False(target.Verify(int.MaxValue)); }
public void DoesNotCallBaseClassVirtualImplementationByDefault() { var mock = new Mock <FooBase>(); Assert.False(mock.Object.BaseCalled); mock.Object.BaseCall(); Assert.False(mock.Object.BaseCalled); }
public void UsesCustomMatcherWithArgument() { var mock = new Mock <IFoo>(); mock.Setup(m => m.Do(Between(1, 5, Range.Inclusive))).Returns(true); Assert.False(mock.Object.Do(6)); Assert.True(mock.Object.Do(1)); Assert.True(mock.Object.Do(5)); }
public void AtMostOnceRangesBetweenZeroAndOne() { var target = Times.AtMostOnce(); Assert.False(target.Verify(-1)); Assert.True(target.Verify(0)); Assert.True(target.Verify(1)); Assert.False(target.Verify(5)); Assert.False(target.Verify(int.MaxValue)); }
public void MatchesSameReference() { var a = new object(); var b = new object(); var matcher = new RefMatcher(a); Assert.True(matcher.Matches(a)); Assert.False(matcher.Matches(b)); }
public void AtLeastRangesBetweenTimesAndMaxValue() { var target = Times.AtLeast(10); Assert.False(target.Verify(-1)); Assert.False(target.Verify(0)); Assert.False(target.Verify(9)); Assert.True(target.Verify(10)); Assert.True(target.Verify(int.MaxValue)); }
public void DoesntMatchIfNotAssignableType() { var expr = ToExpression <IFormatProvider>(() => It.IsAny <IFormatProvider>()).ToLambda().Body; var matcher = MatcherFactory.CreateMatcher(expr, false); matcher.Initialize(expr); Assert.False(matcher.Matches("foo")); }
public void AtMostRangesBetweenZeroAndTimes() { var target = Times.AtMost(10); Assert.False(target.Verify(-1)); Assert.True(target.Verify(0)); Assert.True(target.Verify(6)); Assert.True(target.Verify(10)); Assert.False(target.Verify(11)); Assert.False(target.Verify(int.MaxValue)); }
public void ShouldRaiseEventIfAttachedAfterUse() { var view = new Mock <IFooView>(); var presenter = new FooPresenter(view.Object); Assert.False(presenter.Canceled); view.Raise(v => v.Canceled += null, EventArgs.Empty); Assert.True(presenter.Canceled); }
public void ExactlyCheckExactTimes() { var target = Times.Exactly(10); Assert.False(target.Verify(-1)); Assert.False(target.Verify(0)); Assert.False(target.Verify(9)); Assert.True(target.Verify(10)); Assert.False(target.Verify(11)); Assert.False(target.Verify(int.MaxValue)); }
public void OverridesBehaviorFromAbstractClass() { var mock = new Mock <FooBase>(); mock.CallBase = true; mock.Setup(x => x.Check("foo")).Returns(false); Assert.False(mock.Object.Check("foo")); Assert.True(mock.Object.Check("bar")); }
public void ShouldExpectAddGenericHandler() { var view = new Mock <IFooView>(); var presenter = new FooPresenter(view.Object); Assert.False(presenter.Canceled); view.Raise(v => v.Canceled += null, EventArgs.Empty); Assert.True(presenter.Canceled); }
public void BetweenExclusiveRangesBetweenFromPlusOneAndToMinusOne() { var target = Times.Between(10, 20, Range.Exclusive); Assert.False(target.Verify(0)); Assert.False(target.Verify(10)); Assert.True(target.Verify(11)); Assert.True(target.Verify(14)); Assert.True(target.Verify(19)); Assert.False(target.Verify(20)); Assert.False(target.Verify(int.MaxValue)); }
public void WhenQueryingWithNoValue_ThenAlwaysHasPropertyStubBehavior() { var foo = Mock.Of <IFoo>(); foo.IsValid = true; Assert.True(foo.IsValid); foo.IsValid = false; Assert.False(foo.IsValid); }
public void BetweenInclusiveRangesBetweenFromAndTo() { var target = Times.Between(10, 20, Range.Inclusive); Assert.False(target.Verify(0)); Assert.False(target.Verify(9)); Assert.True(target.Verify(10)); Assert.True(target.Verify(14)); Assert.True(target.Verify(20)); Assert.False(target.Verify(21)); Assert.False(target.Verify(int.MaxValue)); }
public void DoesNotCallBaseClassVirtualImplementationIfSpecified() { var mock = new Mock <FooBase>(); mock.CallBase = false; Assert.False(mock.Object.BaseCalled); mock.Object.BaseCall(); Assert.Equal(default(bool), mock.Object.BaseCall("foo")); Assert.False(mock.Object.BaseCalled); }
public void CallbackCalledAfterReturnsCallWithArg() { var mock = new Mock <IFoo>(); bool returnsCalled = false; mock.Setup(foo => foo.Execute(It.IsAny <string>())) .Callback <string>(s => Assert.False(returnsCalled)) .Returns(() => { returnsCalled = true; return("ack"); }) .Callback <string>(s => Assert.True(returnsCalled)); mock.Object.Execute("ping"); Assert.True(returnsCalled); }
public void MatchesDifferentOverloadsWithItIsAny() { var mock = new Mock <IFoo>(); mock.Setup(foo => foo.DoTypeOverload(It.IsAny <Bar>())) .Returns(true); mock.Setup(foo => foo.DoTypeOverload(It.IsAny <Baz>())) .Returns(false); bool bar = mock.Object.DoTypeOverload(new Bar()); bool baz = mock.Object.DoTypeOverload(new Baz()); Assert.True(bar); Assert.False(baz); }
public void FillingDoesNotRemoveIfNotEnoughInStock() { //setup - data var order = new Order(TALISKER, 50); var mock = new Mock <IWarehouse>(); //setup - expectations mock.Setup(x => x.HasInventory(It.IsAny <string>(), It.IsInRange(0, 100, Range.Inclusive))).Returns(false); mock.Setup(x => x.Remove(It.IsAny <string>(), It.IsAny <int>())).Throws(new InvalidOperationException()); //exercise order.Fill(mock.Object); //verify Assert.False(order.IsFilled); }
public void DoesNotRaiseEventOnSubObject() { var mock = new Mock <IParent> { DefaultValue = DefaultValue.Mock }; bool raised = false; mock.Object.Adder.Added += (sender, args) => raised = true; Assert.Same(mock.Object.Adder, mock.Object.Adder); mock.Raise(p => p.Adder.Added += null, EventArgs.Empty); Assert.False(raised); }
public void CallbackCalledAfterReturnsCall() { var mock = new Mock <IFoo>(); bool returnsCalled = false; bool beforeCalled = false; bool afterCalled = false; mock.Setup(foo => foo.Execute("ping")) .Callback(() => { Assert.False(returnsCalled); beforeCalled = true; }) .Returns(() => { returnsCalled = true; return("ack"); }) .Callback(() => { Assert.True(returnsCalled); afterCalled = true; }); Assert.Equal("ack", mock.Object.Execute("ping")); Assert.True(beforeCalled); Assert.True(afterCalled); }
public void ShouldCreateMocksWithFactoryCallBase() { var repository = new MockRepository(MockBehavior.Loose); var mock = repository.Create <BaseClass>(); mock.Object.BaseMethod(); Assert.False(mock.Object.BaseCalled); repository.CallBase = true; mock = repository.Create <BaseClass>(); mock.Object.BaseMethod(); Assert.True(mock.Object.BaseCalled); }
public void ShouldVerifyVerifiables() { try { var repository = new MockRepository(MockBehavior.Default); var mock = repository.Create <IFoo>(); mock.Setup(foo => foo.Do()); mock.Setup(foo => foo.Undo()).Verifiable(); repository.Verify(); } catch (MockException mex) { Assert.Equal(MockException.ExceptionReason.VerificationFailed, mex.Reason); Expression <Action <IFoo> > doExpr = foo => foo.Do(); Assert.False(mex.Message.Contains(doExpr.ToString())); } }
public void ShouldAllowListenerListToBeModifiedDuringEventHandling() { var parent = new Mock <IParent>(MockBehavior.Strict); parent.Object.Event += delegate { parent.Object.Event += delegate { raisedField = true; }; }; parent.Raise(p => p.Event += null, EventArgs.Empty); // we don't expect the inner event to be raised the first time Assert.False(raisedField); // the second time around, the event handler added the first time // should kick in parent.Raise(p => p.Event += null, EventArgs.Empty); Assert.True(raisedField); }
public void ShouldAttachAndDetachListenerMethod() { var parent = new Mock <IParent>(MockBehavior.Strict); raisedField = false; parent.Object.Event += this.OnRaised; parent.Raise(p => p.Event += null, EventArgs.Empty); Assert.True(raisedField); raisedField = false; parent.Object.Event -= OnRaised; parent.Raise(p => p.Event += null, EventArgs.Empty); Assert.False(raisedField); }