public void SetupGetAllowsProtectedPropertyGet()
{
var mock = new Mock <FooBase>();
mock.Protected()
.SetupGet <string>("ProtectedValue")
.Returns("foo");
Assert.Equal("foo", mock.Object.GetProtectedValue());
}
public void SetupResultAllowsProtectedMethodInBaseClass()
{
var mock = new Mock <FooDerived>();
mock.Protected()
.Setup <int>("ProtectedInt")
.Returns(5);
Assert.Equal(5, mock.Object.DoProtectedInt());
}
public void DifferentArgumentsReturnDifferentValues()
{
var mock = new Mock <IFoo>();
mock.Setup(x => x.Execute("ping")).Returns("ack");
mock.Setup(x => x.Execute("send")).Returns("ok");
Assert.Equal("ack", mock.Object.Execute("ping"));
Assert.Equal("ok", mock.Object.Execute("send"));
}
public void DifferentiatesCallWithNullArgument()
{
var mock = new Mock <IFoo>();
mock.Setup(x => x.Execute(null)).Returns("null");
mock.Setup(x => x.Execute("ping")).Returns("ack");
Assert.Equal("null", mock.Object.Execute(null));
Assert.Equal("ack", mock.Object.Execute("ping"));
}
public void CallParameterCanBeMethodCall2()
{
// @mbrit - 2012-05-31 - test to try out the theory that it's boxing that's breaking this...
string value = "5";
var mock = new Mock <IFoo>();
mock.Setup(x => x.EchoString(GetValue(value))).Returns(() => value + value);
Assert.Equal(value + value, mock.Object.EchoString(value + value));
}
public void DifferentMethodCallsReturnDifferentValues()
{
var mock = new Mock <IFoo>();
mock.Setup(x => x.Execute("ping")).Returns("ack");
mock.Setup(x => x.Execute("ping", "foo")).Returns("ack2");
Assert.Equal("ack", mock.Object.Execute("ping"));
Assert.Equal("ack2", mock.Object.Execute("ping", "foo"));
}
public void DistinguishesSameMethodsWithDifferentGenericArguments()
{
var mock = new Mock <FooBase>();
mock.Setup(foo => foo.Generic <int>()).Returns(2);
mock.Setup(foo => foo.Generic <string>()).Returns(3);
Assert.Equal(2, mock.Object.Generic <int>());
Assert.Equal(3, mock.Object.Generic <string>());
}
public void IntermediateMethodInvocationAreSupported()
{
var mock = new Mock <IFoo>();
mock.Setup(m => m.GetBar().Do("ping")).Returns("ack");
var result = mock.Object.GetBar().Do("ping");
Assert.Equal("ack", result);
}
public void IntermediateIndexerAccessIsSupported()
{
var mock = new Mock <IFoo>();
mock.Setup(m => m[0].Do("ping")).Returns("ack");
var result = mock.Object[0].Do("ping");
Assert.Equal("ack", result);
}
public void SetupAllowsProtectedInternalResultMethod()
{
var mock = new Mock <FooBase>();
mock.Protected()
.Setup <int>("ProtectedInternalInt")
.Returns(5);
Assert.Equal(5, mock.Object.ProtectedInternalInt());
}
public void FailsIfArgumentException()
{
var mock = new Mock <IParent>();
var prop = "";
mock.Object.PropertyChanged += (sender, args) => prop = args.PropertyName;
Assert.Throws <ArgumentException>(() => mock.Raise(x => x.PropertyChanged -= null, EventArgs.Empty));
}
public void GetMockFromNonAddedInterfaceThrows()
{
var bag = new Mock <IBag>();
bag.As <IFoo>();
bag.As <IComparable>();
object b = bag.Object;
Assert.Throws <ArgumentException>(() => Mock.Get(b));
}
public void VerifiesHierarchyPropertyGetWithExpression()
{
var mock = new Mock <IFoo>();
Assert.Throws <MockException>(() => mock.VerifyGet(m => m.Bar.Value));
var value = mock.Object.Bar.Value;
mock.VerifyGet(m => m.Bar.Value);
}
public void AsInterfaceVerifiesReturningMethodWithExpressionAndMessage()
{
var disposable = new Mock <IDisposable>();
var mock = disposable.As <IFoo>();
var e = Assert.Throws <MockException>(
() => mock.Verify(f => f.Execute("ping"), "Execute should have been invoked with 'ping'"));
Assert.True(e.Message.Contains("Execute should have been invoked with 'ping'"));
Assert.True(e.Message.Contains("f.Execute(\"ping\")"));
}
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 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 ExpectsOnIndexer()
{
var mock = new Mock <ISomeInterface>();
mock.Setup(m => m[0]).Returns("a");
mock.Setup(m => m[1]).Returns("b");
Assert.Equal("a", mock.Object[0]);
Assert.Equal("b", mock.Object[1]);
Assert.Equal(default(string), mock.Object[2]);
}
public void ShouldReturnEnum()
{
var provider = new Mock <IMembershipService>();
// For some reason, this particular lambda doesn't let me specify
// a method return value for the method even though it returns a
// MembershipCreateStatus enum
provider.Setup(p => p.CreateUser(string.Empty, string.Empty, string.Empty)).Returns(MembershipCreateStatus.Invalid);
Assert.Equal(MembershipCreateStatus.Invalid, provider.Object.CreateUser("", "", ""));
}
public void FooTest()
{
// Setup
var fooMock = new Mock <Foo>();
fooMock.CallBase = true;
fooMock.Setup(o => o.GetBar()).Returns(new Bar());
var bar = ((IFoolery)fooMock.Object).DoStuffToBar();
Assert.NotNull(bar);
}
public void ReturnsIntPtr()
{
Mock <IFooPtr> mock = new Mock <IFooPtr>(MockBehavior.Strict);
IntPtr ret = new IntPtr(3);
mock.Setup(m => m.Get("a")).Returns(ret);
IntPtr ret3 = mock.Object.Get("a");
Assert.Equal(ret, mock.Object.Get("a"));
}
public void ShouldRaiseEventOnInteropInterface()
{
var app = new Mock <Microsoft.Office.Interop.Word.Application>();
var count = 0;
app.Object.DocumentOpen += doc => count++;
app.Raise(x => x.DocumentOpen += null, new Mock <Microsoft.Office.Interop.Word.Document>().Object);
Assert.Equal(1, count);
}
public void ShouldCreateMocksWithFactoryDefaultValue()
{
var repository = new MockRepository(MockBehavior.Loose)
{
DefaultValue = DefaultValue.Mock
};
var mock = repository.Create <IFoo>();
Assert.NotNull(mock.Object.Bar());
}
public void VerifiesSetterWithActionAndMatcher()
{
var mock = new Mock <IFoo>();
Assert.Throws <MockException>(() => mock.VerifySet(m => m.Value = It.IsAny <int>()));
mock.Object.Value = 2;
mock.VerifySet(m => m.Value = It.IsAny <int>());
mock.VerifySet(m => m.Value = It.IsInRange(1, 2, Range.Inclusive));
mock.VerifySet(m => m.Value = It.Is <int>(i => i % 2 == 0));
}
public void AsInterfaceVerifiesPropertySetWithExpressionAndMessage()
{
var disposable = new Mock <IDisposable>();
var mock = disposable.As <IBar>();
var e = Assert.Throws <MockException>(
() => mock.VerifySet(f => f.Value = It.IsAny <int?>(), "Nobody called .Value"));
Assert.True(e.Message.Contains("Nobody called .Value"));
Assert.True(e.Message.Contains("f.Value"));
}
public void ThrowsIfVerifiableExpectationNotCalledWithMessage()
{
var mock = new Mock <IFoo>();
mock.Setup(x => x.Submit()).Verifiable("Kaboom!");
var mex = Assert.Throws <MockVerificationException>(() => mock.Verify());
Assert.Contains("Kaboom!", mex.Message);
Assert.Equal(MockException.ExceptionReason.VerificationFailed, mex.Reason);
}
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 VerifiesOutWithExpression()
{
var mock = new Mock <IFoo>();
var expected = "ping";
Assert.Throws <MockException>(() => mock.Verify(m => m.EchoOut(out expected)));
mock.Object.EchoOut(out expected);
mock.Verify(m => m.EchoOut(out expected));
}
public void ShouldAllowFluentOnReadOnlyGetterProperty()
{
var target = Mock.Of <IFoo>(x => x.Bars == new[]
{
Mock.Of <IBar>(b => b.Id == "1"),
Mock.Of <IBar>(b => b.Id == "2"),
});
Assert.NotNull(Mock.Get(target));
Assert.Equal(2, target.Bars.Count());
}
public void ReturnsMockDefaultValueForLooseBehaviorOnInterface()
{
var mock = new Mock <IFoo>(MockBehavior.Loose)
{
DefaultValue = DefaultValue.Mock
};
var value = mock.Object.GetObject();
Assert.True(value is IMocked);
}
public void Test()
{
var mock = new Mock <IDisposable>().As <IComponent>();
mock.SetupAllProperties();
ISite site = new FooSite();
mock.Object.Site = site;
Assert.Same(site, mock.Object.Site);
}
