public void ShouldRaiseEventWithFuncFourArgs()
{
var mock = new Mock <IAdder <string> >();
mock.Setup(add => add.Do(It.IsAny <string>(), It.IsAny <int>(), It.IsAny <bool>(), It.IsAny <string>()))
.Raises(m => m.Added += null, (string s, int i, bool b, string v) => new FooArgs {
Args = new object[] { s, i, b, v }
});
var raised = false;
mock.Object.Added += (sender, args) =>
{
raised = true;
Assert.True(args is FooArgs);
Assert.Equal("foo", ((FooArgs)args).Args[0]);
Assert.Equal(5, ((FooArgs)args).Args[1]);
Assert.Equal(true, ((FooArgs)args).Args[2]);
Assert.Equal("bar", ((FooArgs)args).Args[3]);
};
mock.Object.Do("foo", 5, true, "bar");
Assert.True(raised);
}
public void ThrowsIfVerifyVoidExactlyAndLessOrMoreThanNCalls()
{
var mock = new Mock <IFoo>();
mock.Object.Submit();
mock.Object.Submit();
mock.Object.Submit();
mock.Object.Submit();
var mex = Assert.Throws <MockException>(() => mock.Verify(foo => foo.Submit(), Times.Exactly(5)));
Assert.Equal(MockException.ExceptionReason.VerificationFailed, mex.Reason);
Assert.True(mex.Message.StartsWith(
"\nExpected invocation on the mock exactly 5 times, but was 4 times: foo => foo.Submit()"));
mock.Object.Submit();
mock.Verify(foo => foo.Submit(), Times.Exactly(5));
mock.Object.Submit();
mex = Assert.Throws <MockException>(() => mock.Verify(foo => foo.Submit(), Times.Exactly(5)));
Assert.Equal(MockException.ExceptionReason.VerificationFailed, mex.Reason);
Assert.True(mex.Message.StartsWith(
"\nExpected invocation on the mock exactly 5 times, but was 6 times: foo => foo.Submit()"));
}
public void ShouldReturnEmptyEnumerableObjectsOnLoose()
{
var mock = new Mock <IFoo>(MockBehavior.Loose);
Assert.NotNull(mock.Object.GetEnumerableObjects());
Assert.Equal(0, mock.Object.GetEnumerableObjects().Cast <object>().Count());
}
public void ShouldAllowFluentOnNonVirtualReadWriteProperty()
{
var target = Mock.Of <Dto>(x => x.Value == "foo");
Assert.NotNull(Mock.Get(target));
Assert.Equal("foo", target.Value);
}
public void ShouldSupportMethod()
{
var expected = new Mock <IBar>().Object;
var target = Mocks.Of <IFoo>().First(x => x.Find(It.IsAny <string>()) == expected);
Assert.Equal(expected, target.Find("3"));
}
public void ShouldOneOfWithPredicateCreateNewMock()
{
var target = Mock.Of <IFoo>(x => x.Name == "Foo");
Assert.NotNull(Mock.Get(target));
Assert.Equal("Foo", target.Name);
}
public void ThrowsIfVerifyVoidBetweenInclusiveAndLessFromOrMoreToCalls()
{
var mock = new Mock <IFoo>();
mock.Object.Submit();
var mex = Assert.Throws <MockException>(
() => mock.Verify(foo => foo.Submit(), Times.Between(2, 4, Range.Inclusive)));
Assert.Equal(MockException.ExceptionReason.VerificationFailed, mex.Reason);
Assert.True(mex.Message.StartsWith(
"\nExpected invocation on the mock between 2 and 4 times (Inclusive), but was 1 times: foo => foo.Submit()"));
mock.Object.Submit();
mock.Verify(foo => foo.Submit(), Times.Between(2, 4, Range.Inclusive));
mock.Object.Submit();
mock.Verify(foo => foo.Submit(), Times.Between(2, 4, Range.Inclusive));
mock.Object.Submit();
mock.Object.Submit();
mex = Assert.Throws <MockException>(
() => mock.Verify(foo => foo.Submit(), Times.Between(2, 4, Range.Inclusive)));
Assert.Equal(MockException.ExceptionReason.VerificationFailed, mex.Reason);
Assert.True(mex.Message.StartsWith(
"\nExpected invocation on the mock between 2 and 4 times (Inclusive), but was 5 times: foo => foo.Submit()"));
}
public void ConstructsClassWithNoDefaultConstructor()
{
var mock = new Mock <ClassWithNoDefaultConstructor>(MockBehavior.Default, "Hello", 26);
Assert.Equal("Hello", mock.Object.StringValue);
Assert.Equal(26, mock.Object.IntValue);
}
public void WhenUsingItIsForArgument_ThenSetsReturnValue()
{
var foo = Mock.Of <IFoo>(x => x.Do(It.Is <int>(i => i > 0)) == "foo");
Assert.Equal("foo", foo.Do(5));
Assert.Equal(default(string), foo.Do(-5));
}
public void WhenQueryingByProperties_ThenSetsThemDirectly()
{
var foo = Mock.Of <Foo>(x => x.Id == 1 && x.Value == "hello");
Assert.Equal(1, foo.Id);
Assert.Equal("hello", foo.Value);
}
public void WhenCombiningQueryingWithExplicitBoolean_ThenSetsBothProperties()
{
var target = Mock.Of <IFoo>(x => x.IsValid == true && x.Value == "foo");
Assert.True(target.IsValid);
Assert.Equal("foo", target.Value);
}
public void ThrowsIfVerifyGetGetBetweenInclusiveAndLessFromOrMoreToCalls()
{
var mock = new Mock <IFoo>();
var value = mock.Object.Value;
MockException mex = Assert.Throws <MockException>(
() => mock.VerifyGet(foo => foo.Value, Times.Between(2, 4, Range.Inclusive)));
Assert.Equal(MockException.ExceptionReason.VerificationFailed, mex.Reason);
value = mock.Object.Value;
mock.VerifyGet(foo => foo.Value, Times.Between(2, 4, Range.Inclusive));
value = mock.Object.Value;
mock.VerifyGet(foo => foo.Value, Times.Between(2, 4, Range.Inclusive));
value = mock.Object.Value;
value = mock.Object.Value;
mex = Assert.Throws <MockException>(() =>
mock.VerifyGet(foo => foo.Value, Times.Between(2, 4, Range.Inclusive)));
Assert.Equal(MockException.ExceptionReason.VerificationFailed, mex.Reason);
}
public void ShouldReturnDefaultForLooseBehaviorOnAbstract()
{
var mock = new Mock <Foo>(MockBehavior.Loose);
Assert.Equal(0, mock.Object.AbstractGet());
Assert.Null(mock.Object.GetObject());
}
public void ShouldOverrideDefaultBehavior()
{
var repository = new MockRepository(MockBehavior.Loose);
var mock = repository.Create <IFoo>(MockBehavior.Strict);
Assert.Equal(MockBehavior.Strict, mock.Behavior);
}
public void ShouldReturnEmptyArrayTwoDimensionsOnLoose()
{
var mock = new Mock <IFoo>(MockBehavior.Loose);
Assert.NotNull(mock.Object.GetArrayTwoDimensions());
Assert.Equal(0, mock.Object.GetArrayTwoDimensions().Length);
}
public void CallbackCalledWithEightArgumentsForNonVoidMethod()
{
var mock = new Mock <IFoo>();
string callbackArg1 = null;
string callbackArg2 = null;
string callbackArg3 = null;
string callbackArg4 = null;
string callbackArg5 = null;
string callbackArg6 = null;
string callbackArg7 = null;
string callbackArg8 = null;
mock.Setup(x => x.Execute(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>()))
.Callback((string s1, string s2, string s3, string s4, string s5, string s6, string s7, string s8) => { callbackArg1 = s1; callbackArg2 = s2; callbackArg3 = s3; callbackArg4 = s4; callbackArg5 = s5; callbackArg6 = s6; callbackArg7 = s7; callbackArg8 = s8; })
.Returns("foo");
mock.Object.Execute("blah1", "blah2", "blah3", "blah4", "blah5", "blah6", "blah7", "blah8");
Assert.Equal("blah1", callbackArg1);
Assert.Equal("blah2", callbackArg2);
Assert.Equal("blah3", callbackArg3);
Assert.Equal("blah4", callbackArg4);
Assert.Equal("blah5", callbackArg5);
Assert.Equal("blah6", callbackArg6);
Assert.Equal("blah7", callbackArg7);
Assert.Equal("blah8", callbackArg8);
}
public void ThrowsIfVerifyReturningBetweenInclusiveAndLessFromOrMoreToCalls()
{
var mock = new Mock <IFoo>();
mock.Object.Execute("");
MockException mex = Assert.Throws <MockException>(() =>
mock.Verify(foo => foo.Execute(""), Times.Between(2, 4, Range.Inclusive)));
Assert.Equal(MockException.ExceptionReason.VerificationFailed, mex.Reason);
mock.Object.Execute("");
mock.Verify(foo => foo.Execute(""), Times.Between(2, 4, Range.Inclusive));
mock.Object.Execute("");
mock.Verify(foo => foo.Execute(""), Times.Between(2, 4, Range.Inclusive));
mock.Object.Execute("");
mock.Object.Execute("");
mex = Assert.Throws <MockException>(
() => mock.Verify(foo => foo.Execute(""), Times.Between(2, 4, Range.Inclusive)));
Assert.Equal(MockException.ExceptionReason.VerificationFailed, mex.Reason);
}
public void ShouldSupportSettingDtoPropertyValue()
{
//var target = Mock.Of<IFoo>(x => x.Bar.Id == "foo");
var target = Mock.Of <Dto>(x => x.Value == "foo");
Assert.Equal("foo", target.Value);
}
public void ConstructsClassWithNoDefaultConstructorAndNullValue()
{
var mock = new Mock <ClassWithNoDefaultConstructor>(MockBehavior.Default, null, 26);
Assert.Equal(null, mock.Object.StringValue);
Assert.Equal(26, mock.Object.IntValue);
}
public void ThrowsIfVerifyVoidMethodWithExpressionFails()
{
var mock = new Mock <IFoo>();
var mex = Assert.Throws <MockException>(() => mock.Verify(f => f.Submit()));
Assert.Equal(MockException.ExceptionReason.VerificationFailed, mex.Reason);
}
public void ProvidesDefaultEnum()
{
var provider = new EmptyDefaultValueProvider();
var value = provider.ProvideDefault(typeof(IFoo).GetProperty("Platform").GetGetMethod());
Assert.Equal(default(PlatformID), value);
}
public void ProvidesDefaultBool()
{
var provider = new EmptyDefaultValueProvider();
var value = provider.ProvideDefault(typeof(IFoo).GetProperty("BoolValue").GetGetMethod());
Assert.Equal(default(bool), value);
}
public void ProvideEmptyQueryableObjects()
{
var provider = new EmptyDefaultValueProvider();
var value = provider.ProvideDefault(typeof(IFoo).GetProperty("QueryableObjects").GetGetMethod());
Assert.IsAssignableFrom <IQueryable>(value);
Assert.Equal(0, ((IQueryable)value).Cast <object>().Count());
}
public void ShouldCreateMockWithConstructorArgs()
{
var repository = new MockRepository(MockBehavior.Loose);
var mock = repository.Create <BaseClass>("foo");
Assert.Equal("foo", mock.Object.Value);
}
public void ShouldCreateMocksWithFactoryBehavior()
{
var repository = new MockRepository(MockBehavior.Loose);
var mock = repository.Create <IFormatProvider>();
Assert.Equal(MockBehavior.Loose, mock.Behavior);
}
public void ShouldOverrideDefaultBehaviorWithCtorArgs()
{
var repository = new MockRepository(MockBehavior.Loose);
var mock = repository.Create <BaseClass>(MockBehavior.Strict, "Foo");
Assert.Equal(MockBehavior.Strict, mock.Behavior);
Assert.Equal("Foo", mock.Object.Value);
}
public void ThrowsIfVerifyPropertySetWithExpressionFails()
{
var mock = new Mock <IFoo>();
var e = Assert.Throws <MockException>(() => mock.VerifySet(f => f.Value = It.IsAny <int?>()));
Assert.Equal(MockException.ExceptionReason.VerificationFailed, e.Reason);
}
public void ThrowsIfVerifyReturningMethodWithExpressionFails()
{
var mock = new Mock <IFoo>();
var mex = Assert.Throws <MockException>(() => mock.Verify(f => f.Execute("ping")));
Assert.Equal(MockException.ExceptionReason.VerificationFailed, mex.Reason);
}
public void MatchesEnumerableParameterValue()
{
var mock = new Mock <IFoo>();
mock.Setup(x => x.DoAddition(new int[] { 2, 4, 6 })).Returns(12);
Assert.Equal(12, mock.Object.DoAddition(new[] { 2, 4, 6 }));
}
public void ShouldSupportIndexer()
{
var target = Mocks.Of <IBaz>().First(x => x["3", It.IsAny <bool>()] == 10);
Assert.NotEqual(10, target["1", true]);
Assert.Equal(10, target["3", true]);
Assert.Equal(10, target["3", false]);
}
