public void Assert_InvokedTwiceWithExpectedOnce_ThrowsException()
{
var mockContext = new MockContext <IFoo>();
var fooMock = new FooMock(mockContext);
fooMock.Execute("SomeValue");
fooMock.Execute("SomeValue");
Assert.Throws <MockException>(() => mockContext.Assert(f => f.Execute("SomeValue"), Invoked.Once));
}
public void Assert_ExpectedExactly3TimesAnd2TimesInvoked_ThrowsException()
{
var mockContext = new MockContext <IFoo>();
var fooMock = new FooMock(mockContext);
fooMock.Execute("SomeValue");
fooMock.Execute("SomeValue");
Assert.Throws <MockException>(() => mockContext.Assert(f => f.Execute("SomeValue"), Invoked.Exactly(3)));
}
public void Assert_Twice_IsVerified()
{
var mockContext = new MockContext <IFoo>();
var fooMock = new FooMock(mockContext);
fooMock.Execute("SomeValue");
fooMock.Execute("SomeValue");
mockContext.Assert(f => f.Execute("SomeValue"));
}
public void Assert_ExpectedExactly3TimesAnd3TimesInvoked_IsVerified()
{
var mockContext = new MockContext <IFoo>();
var fooMock = new FooMock(mockContext);
fooMock.Execute("SomeValue");
fooMock.Execute("SomeValue");
fooMock.Execute("SomeValue");
mockContext.Assert(f => f.Execute("SomeValue"), Invoked.Exactly(3));
}
public void Arrange_ChangeException()
{
var mockContext = new MockContext <IFoo>();
var fooMock = new FooMock(mockContext);
mockContext.Arrange(f => f.Execute(The <int> .IsAnyValue)).Throws <System.ArgumentNullException>();
Assert.Throws <System.ArgumentNullException>(() => fooMock.Execute(1));
mockContext.Arrange(f => f.Execute(The <int> .IsAnyValue)).Throws <System.ArgumentOutOfRangeException>();
Assert.Throws <System.ArgumentOutOfRangeException>(() => fooMock.Execute(1));
}
public void Arrange_ChangeReturnValue()
{
var mockContext = new MockContext <IFoo>();
var fooMock = new FooMock(mockContext);
mockContext.Arrange(f => f.Execute()).Returns("1");
Assert.Equal("1", fooMock.Execute());
mockContext.Arrange(f => f.Execute()).Returns("2");
Assert.Equal("2", fooMock.Execute());
}
public void Arrange_ChangeCallback()
{
int firstResult = 0;
int secondResult = 0;
var mockContext = new MockContext <IFoo>();
var fooMock = new FooMock(mockContext);
mockContext.Arrange(f => f.Execute(The <int> .IsAnyValue)).Callback <int>(i => firstResult = i);
fooMock.Execute(1);
mockContext.Arrange(f => f.Execute(The <int> .IsAnyValue)).Callback <int>(i => secondResult = i);
fooMock.Execute(2);
Assert.Equal(1, firstResult);
Assert.Equal(2, secondResult);
}
public void Arrange_CallBackFourArguments_InvokesCallback()
{
var mockContext = new MockContext <IFoo>();
var fooMock = new FooMock(mockContext);
int firstResult = 0;
int secondResult = 0;
int thirdResult = 0;
int fourthResult = 0;
mockContext.Arrange(
f => f.Execute(The <int> .IsAnyValue, The <int> .IsAnyValue, The <int> .IsAnyValue, The <int> .IsAnyValue))
.Callback <int, int, int, int>(
(i1, i2, i3, i4) =>
{
firstResult = i1;
secondResult = i2;
thirdResult = i3;
fourthResult = i4;
});
fooMock.Execute(1, 2, 3, 4);
Assert.Equal(1, firstResult);
Assert.Equal(2, secondResult);
Assert.Equal(3, thirdResult);
Assert.Equal(4, fourthResult);
}
public void Arrange_ThrowsNothing_CancelsThrows()
{
var expected = Guid.NewGuid().ToString();
var mockContext = new MockContext <IFoo>();
var fooMock = new FooMock(mockContext);
mockContext.Arrange(f => f.Execute(The <string> .IsAnyValue))
.Returns(expected)
.Throws <InvalidOperationException>();
Assert.Throws <InvalidOperationException>(() => fooMock.Execute("abc"));
mockContext.Arrange(f => f.Execute(The <string> .IsAnyValue)).ThrowsNothing();
var actual = fooMock.Execute("abc");
Assert.Equal(expected, actual);
}
public void Arrange_ExceptionFactory_ThrowsException()
{
var mockContext = new MockContext <IFoo>();
var fooMock = new FooMock(mockContext);
mockContext.Arrange(f => f.Execute("SomeValue")).Throws(() => new InvalidOperationException());
Assert.Throws <InvalidOperationException>(() => fooMock.Execute("SomeValue"));
}
public void Assert_InvokedOnceExpectedOnce_IsVerified()
{
var mockContext = new MockContext <IFoo>();
var fooMock = new FooMock(mockContext);
fooMock.Execute("SomeValue");
mockContext.Assert(f => f.Execute("SomeValue"), Invoked.Once);
}
public void Assert_WithValidMatchPredicate_IsVerified()
{
var mockContext = new MockContext <IFoo>();
var fooMock = new FooMock(mockContext);
fooMock.Execute("SomeValue");
mockContext.Assert(f => f.Execute(The <string> .Is(s => s.StartsWith("Some"))), Invoked.Once);
}
public void Assert_IsAnyValue_IsVerified()
{
var mockContext = new MockContext <IFoo>();
var fooMock = new FooMock(mockContext);
fooMock.Execute("SomeValue");
mockContext.Assert(f => f.Execute(The <string> .IsAnyValue), Invoked.Once);
}
public void Assert_NeverWhenInvoked_ThrowsException()
{
var mockContext = new MockContext <IFoo>();
var fooMock = new FooMock(mockContext);
fooMock.Execute("SomeValue");
Assert.Throws <MockException>(() => mockContext.Assert(f => f.Execute("SomeValue"), Invoked.Never));
}
public void Assert_WithInvalidMatchPredicate_ThrowsException()
{
var mockContext = new MockContext <IFoo>();
var fooMock = new FooMock(mockContext);
fooMock.Execute("SomeValue");
Assert.Throws <MockException>(()
=> mockContext.Assert(f => f.Execute(The <string> .Is(s => s == "AnotherValue")), Invoked.Once));
}
public void Assert_StringEmpty_IsVerified()
{
var mockContext = new MockContext <IFoo>();
var fooMock = new FooMock(mockContext);
fooMock.Execute(string.Empty);
mockContext.Assert(f => f.Execute(string.Empty));
}
public void Execute_MethodCallInInvocation_IsVerified()
{
var mockContext = new MockContext <IFoo>();
var fooMock = new FooMock(mockContext);
string[] strings = { "SomeValue", "AnotherValue" };
fooMock.Execute(strings.First(s => s.StartsWith("Some")));
}
public void Execute_NoArrangement_ReturnsDefaultValue()
{
var mockContext = new MockContext <IFoo>();
var fooMock = new FooMock(mockContext);
string?result = fooMock.Execute();
Assert.Equal(default(string), result);
}
public void Arrange_ReturnsWithNoArguments_InvokesGetResult()
{
var mockContext = new MockContext <IFoo>();
var fooMock = new FooMock(mockContext);
mockContext.Arrange(f => f.Execute()).Returns(() => "This");
var result = fooMock.Execute();
Assert.Equal("This", result);
}
public void Arrange_CallBackOneArgument_InvokesCallback()
{
var mockContext = new MockContext <IFoo>();
var fooMock = new FooMock(mockContext);
int callBackResult = 0;
mockContext.Arrange(f => f.Execute(The <int> .IsAnyValue)).Callback <int>(s => callBackResult = s);
fooMock.Execute(1);
Assert.Equal(1, callBackResult);
}
public void Arrange_ReturnsWithFourArguments_InvokesGetResult()
{
var mockContext = new MockContext <IFoo>();
var fooMock = new FooMock(mockContext);
mockContext.Arrange(
f =>
f.Execute(
The <string> .IsAnyValue,
The <string> .IsAnyValue,
The <string> .IsAnyValue,
The <string> .IsAnyValue))
.Returns <string, string, string, string>((a, b, c, d) => "This" + a + b + c + d);
fooMock.Execute(1, 2, 3, 4);
var result = fooMock.Execute(" is", " really", " cool", "!");
Assert.Equal("This is really cool!", result);
}
public void Arrange_CallBackNoArguments_InvokesCallback()
{
var mockContext = new MockContext <IFoo>();
var fooMock = new FooMock(mockContext);
bool isCalled = false;
mockContext.Arrange(f => f.Execute()).Callback(() => isCalled = true);
fooMock.Execute();
Assert.True(isCalled);
}
public void Arrange_ReturnsWithOneArgument_InvokesGetResult()
{
var mockContext = new MockContext <IFoo>();
var fooMock = new FooMock(mockContext);
mockContext.Arrange(f => f.Execute(The <string> .IsAnyValue)).Returns <string>(a => "This" + a);
var result = fooMock.Execute(" is");
Assert.Equal("This is", result);
}
public void Execute_ArrengedReturnValue_ReturnsValue()
{
var mockContext = new MockContext <IFoo>();
var fooMock = new FooMock(mockContext);
mockContext.Arrange(f => f.Execute()).Returns("SomeValue");
var result = fooMock.Execute();
Assert.Equal("SomeValue", result);
}
public void Execute_ArrangedRuturnValue_ArrayElementContraintSupport()
{
var mockContext = new MockContext <IFoo>();
var fooMock = new FooMock(mockContext);
var inputData = new byte[] { 1, 2, 3, 4, 5 };
mockContext.Arrange(
f => f.Execute(The <byte[]> .Is(a => a[4] == 5)))
.Returns <byte[]>(a => a);
var result = fooMock.Execute(inputData);
Assert.Equal(inputData, result);
}
public void Execute_ArrangedRuturnValue_ArrayLengthContraintSupport()
{
var mockContext = new MockContext <IFoo>();
var fooMock = new FooMock(mockContext);
var inputData = Enumerable.Repeat((byte)1, 10).ToArray();
mockContext.Arrange(
f => f.Execute(The <byte[]> .Is(a => a.Length < 20)))
.Returns <byte[]>(a => a);
var result = fooMock.Execute(inputData);
Assert.Equal(inputData, result);
}
public void Arrange_SimulatousReturnAndCallback()
{
string firstResult = "";
var mockContext = new MockContext <IFoo>();
var fooMock = new FooMock(mockContext);
mockContext.Arrange(f => f.Execute(The <string> .IsAnyValue)).Returns("hi");
mockContext.Arrange(f => f.Execute(The <string> .IsAnyValue)).Callback <string>(i => firstResult = i);
var result = fooMock.Execute("hello");
Assert.Equal("hi", result);
Assert.Equal("hello", firstResult);
}
public void Arrange_CallBackTwoArguments_InvokesCallback()
{
var mockContext = new MockContext <IFoo>();
var fooMock = new FooMock(mockContext);
int firstResult = 0;
int secondResult = 0;
mockContext.Arrange(f => f.Execute(The <int> .IsAnyValue, The <int> .IsAnyValue)).Callback <int, int>(
(i, i1) =>
{
firstResult = i;
secondResult = i1;
});
fooMock.Execute(1, 2);
Assert.Equal(1, firstResult);
Assert.Equal(2, secondResult);
}
public void Execute_ArrangedReturnValue_ReturnsValueUsingLambda()
{
var mockContext = new MockContext <IFoo>();
var fooMock = new FooMock(mockContext);
var outerVariable = " works";
mockContext.Arrange(f => f.Execute(The <string> .IsAnyValue)).Returns <string>(
a =>
{
var r = a + outerVariable + "!";
return(r);
});
var result = fooMock.Execute("It");
Assert.Equal("It works!", result);
}