public void Test_Call_To_Unknown_Method_Should_Fail()
{
// Arrange
var stub = new StubILogWriter();
var mock = new Mock<ILogWriter>(stub, MockBehavior.Strict);
// Act
Assert.Throws<VerificationException>(() => ((ILogWriter) stub).Write(42),
"Strict mock should fail because of unknown method call.");
}
public void Verify_Write_With_Invalid_Arguments_Never_Called()
{
// Arrange
var stub = new StubILogWriter();
var mock = new Mock<ILogWriter>(stub);
// Act
((ILogWriter)stub).Write("42");
// Assert
mock.Verify(lw => lw.Write(""), Times.Never());
}
public void Test_Call_To_Known_Method_Should_Not_Fail()
{
// Arrange
var stub = new StubILogWriter();
var mock = new Mock<ILogWriter>(stub, MockBehavior.Strict);
mock.Setup(lw => lw.Write(It.IsAny<int>()));
// Act
((ILogWriter)stub).Write(42);
mock.Verify();
}
public void Test_Verify_Succeeds_If_Correct_Method_Calls()
{
// Arrange
var stub = new StubILogWriter();
var mock = stub.AsMock();
// Act
((ILogWriter)stub).Write("42");
// Assert
mock.Verify(lw => lw.Write(It.IsAny<string>()));
}
public void Test_Verify_With_One_Func(Expression<Func<ILogWriter, int>> action,
Expression<Func<ILogWriter, int>> verificationExpression, Times times)
{
// Arrange
var stub = new StubILogWriter();
var mock = new Mock<ILogWriter>(stub);
// Act
action.Compile()(stub);
// Assert
mock.Verify(verificationExpression, times);
}
public void Test_Verify_Method_Fails_If_Wrong_Method_Was_Called()
{
// Arrange
var stub = new StubILogWriter();
var mock = new Mock<ILogWriter>(stub);
// Act
((ILogWriter)stub).Write("42");
// Assert
Assert.Throws<VerificationException>(
() => mock.Verify(lw => lw.ToString()));
}
public void Test_VerifyAll_With_One_Action(Expression<Action<ILogWriter>> action,
Expression<Action<ILogWriter>> verificationExpression, Times times)
{
// Arrange
var stub = new StubILogWriter();
var mock = new Mock<ILogWriter>(stub);
mock.Setup(verificationExpression, times);
// Act
action.Compile()(stub);
// Assert
mock.Verify();
}
public void Test_WriteLine_Calls_Write_With_Appropriate_Argument()
{
// Arrange
var stub = new StubILogWriter();
var mock = stub.AsMock();
var logger = new Logger(stub);
// Act
logger.Write("Hello, logger!");
// Assert
// Checking that Write method was called with appropriate argument
mock.Verify(lw => lw.Write("Hello, logger!"));
}
public void Test_WriteLine_Calls_Write_With_Any_Of_String()
{
// StubILogWriter : StubBase<ILogWriter>, ILogWriter
// Arrange
var stub = new StubILogWriter();
Mock<ILogWriter> mock = stub.AsMock();
var logger = new Logger(stub);
// Act
logger.Write("Hello, logger!");
// Assert
// Checking that Write method of the ILogWriter was called
mock.Verify(lw => lw.Write(It.IsAny<string>()));
}
public void Test_Verify_Method_Fails_If_Required_Method_Was_Not_Called()
{
// Arrange
var stub = new StubILogWriter();
var mock = new Mock<ILogWriter>(stub);
// Act
((ILogWriter)stub).Write("42");
mock.Verify(lw => lw.Write(It.IsAny<string>()));
// Assert
Assert.Throws<VerificationException>(
() => mock.Verify(lw => lw.Write("")));
}
public void Test_WriteLine_Called_Exactly_Once()
{
// Arrange
var stub = new StubILogWriter();
var mock = stub.AsMock();
var logger = new Logger(mock.Object);
// Act
logger.Write("Hello, logger!");
// Assert
// We could check, that particular method calls specified number of times
mock.Verify(lw => lw.Write(It.IsAny<string>()),
Times.Once());
}
public void Logger_Write_Calls_For_Enter_Method()
{
// Arrange
var stub = new StubILogWriter();
var customObserver = new CustomObserver();
// Providing custom observer to the stub
stub.InstanceObserver = customObserver;
// Act
ILogWriter logWriter = stub;
logWriter.Write("Message");
// Assert
Assert.That(customObserver.CalledMethodName,
Is.StringContaining("ILogWriter.Write"));
Assert.That(customObserver.CalledMethodArgument, Is.EqualTo("Message"));
}
public void Test_Unexpected_Call_Should_Fail_To_Method_With_Another_Argument_Value()
{
// Arrange
var stub = new StubILogWriter();
ILogWriter logWriter = stub;
var mock = new Mock<ILogWriter>(stub, MockBehavior.Strict);
mock.Setup(lw => lw.Write(2));
mock.Setup(lw => lw.Write(3));
// Act
logWriter.Write(2);
logWriter.Write(3);
Assert.Throws<VerificationException>(() => logWriter.Write(5),
"Unexpected method should fail with strict mode.");
}
public void Test_Event_Occurred_When_Observed_Method_Calls()
{
// Arrange
var mock = new StubILogWriter();
var actualObserver = new FakesCustomStubObserver(mock);
MethodInfo methodCalled = null;
object[] arguments = null;
actualObserver.MethodCalled += (e, ea) => { methodCalled = ea.Method; arguments = ea.Arguments; };
// Act
((ILogWriter)mock).Write(1, "2");
// Assert
Assert.IsNotNull(methodCalled, "MethodCalled event handler should be called.");
Assert.That(methodCalled.Name, Is.EqualTo("Write"));
Assert.IsNotNull(arguments, "MethodCall event handler should fill arguments.");
CollectionAssert.AreEquivalent(new object[]{1, "2"}, arguments);
}
public void Test_WriteLine_Calls_Write_With_Setup_Method()
{
// Arrange
var stub = new StubILogWriter();
var mock = stub.AsMock();
mock.Setup(lw => lw.Write(It.IsAny<string>()));
mock.Setup(lw => lw.Write(It.IsAny<int>()));
var logger = new Logger(mock.Object);
// Act
logger.Write("Hello, logger!");
logger.Write(42);
// Assert
// We're not explicitly stated what we're expecting.
// mock.Setup expectations would be use.
mock.Verify();
}
public void Sampe()
{
var mock = new StubILogWriter();
mock.WriteRInt32 = n => 42;
//int exptected = 0;
//mock.WriteInt32 = n =>
// {
// //
// exptected = n;
// Console.WriteLine(n == 42);
// };
ILogWriter logWriter = (ILogWriter) mock;
var expected = logWriter.WriteR(12312);
//logWriter.Write(42);
Assert.That(expected, Is.EqualTo(42));
}
public void Test_Stub_Observer_Contains_Valid_Argument_And_Method_Info()
{
// Arrange
var mock = new StubILogWriter();
var stubObserver = new StubObserver();
mock.InstanceObserver = stubObserver;
// Act
((ILogWriter)mock).Write("Foo");
// Assert
var calls = stubObserver.GetCalls();
CollectionAssert.IsNotEmpty(calls, "Should be at least one call to the observer.");
var callInfo = calls[0];
Assert.That(callInfo.GetArguments()[0], Is.EqualTo("Foo"),
"Mocked method should be called with 'Foo' argument.");
Assert.That(callInfo.StubbedMethod.Name, Is.EqualTo("Write"),
"ILogWriter.Write method should be called.");
}
public void Test_WriteLine_Never_Calls_Write_Int()
{
// Arrange
var stub = new StubILogWriter();
var mock = stub.AsMock();
var logger = new Logger(mock.Object);
// Act
logger.Write("Hello, logger");
// Assert
mock.Verify(lw => lw.Write(It.IsAny<int>()), Times.Never());
}
public void Test_Write_Int_Calls_Write_With_Argument_In_Specific_Interval()
{
// Arrange
var stub = new StubILogWriter();
var mock = stub.AsMock();
var logger = new Logger(mock.Object);
// Act
logger.Write(42);
// Assert
mock.Verify(lw => lw.Write(It.IsInRange(40, 50)));
}
public void Test_WriteLine_Will_Fail_With_Strict_Mode()
{
// Arrange
var stub = new StubILogWriter();
var mock = stub.AsStrictMock();
mock.Setup(lw => lw.Write("Foo"));
// Act
var logger = new Logger(mock.Object);
logger.Write("Foo");
// logger.Write will call logWriter.Write,
// but we do not expect this, thats why logger.Write will fail!
Assert.Throws<VerificationException>(() => logger.Write("Hello, Logger"));
}
public void Test_Verify_With_Sequence_Of_Actions(
List<Expression<Action<ILogWriter>>> actions,
Expression<Action<ILogWriter>> verificationExpression, Times times)
{
// Arrange
var stub = new StubILogWriter();
var mock = new Mock<ILogWriter>(stub);
// Act
foreach (var a in actions)
{
a.Compile()(stub);
}
// Assert
mock.Verify(verificationExpression, times);
}
