MockRepository

Create a new instance of MockRepository

Moves the entire MockRepository to use ordered recording.

This call is only valid during the recording phase.  This call affects all mock objects that were created from this repository.

The orderring is ended when the returned IDisposable’s Dispose() method is called.

[Test]
public void CallMethodOnObject()
{
    IDemo demo = (IDemo)mocks.CreateMock(typeof(IDemo));
    //Moving to ordered mocking.
    using(mocks.Ordered()
    {
        demo.VoidNoArg();
        demo.IntNoArg();
    }
    //Must exit the ordering before calling
    mocks.ReplayAll();
    //If we would try to call them in any other order, the test would fail
    demo.VoidNoArg();
    demo.IntNoArg();
}

Moves the entire MockRepository to use unordered recording (the default).

This call is only valid during the recording phase.  This call affects all mock objects that were created from this repository.

[Test]
public void CallMethodOnObject()
{
    IDemo demo = (IDemo)mocks.CreateMock(typeof(IDemo));
    //Moving to ordered mocking.
    using(mocks.Ordered()
    {
        demo.VoidNoArg();
        using(mocks.Unordered()
        {
            demo.VoidNoArg();
            demo.IntNoArg();
        }
        demo.IntNoArg();
    }
    //Must exit the ordering before calling
    mocks.ReplayAll();
    //The expectations we set up is:
    // 1. demo.VoidNoArgs();
    // 2. in any order:
    //      1. demo.VoidNoArg();
    //      2. demo.IntNoArg();
    // 3. demo.IntNoArg();
    demo.VoidNoArg();
    demo.IntNoArg();
    demo.VoidNoArg();
    demo.IntNoArg();
}

Create a mock object with strict semantics.  Strict semantics means that any call that wasn’t explicitly recorded is considered an error and would cause an exception to be thrown.

Create a mock object with dynamic semantics.  Dynamic semantics means that any call that wasn’t explicitly recorded is accepted and a null or zero is returned (if there is a return value).

Create a mock object with from a class that defaults to calling the class methods if no expectation is set on the method.

Moves a single mock object to the replay state.  This method cannot be called from inside an ordering.

Moves the mocked object back to record state.  This works on mock objects regardless of state.  You can (and it’s recommended) to run Verify() before you use this method, but it’s not neccecary.

Note

This will remove all the current expectations from the mock repository.

Verifies that all expectations has been met for a single mock object.  After calling this method and action taken on the mock object would result in an exception even if the object is a dynamic mock.

Gets the method options for the last call on mockedInstance

Handles a method call for a mock object.

Moves all the mock objects in the repository to replay state.

Note

This method will skip any mock object that you’ve manually moved to replay state by calling Replay

Verifies that all the expectations on all mock objects in the repository are met.

Note

This method skip any mock objects that you’ve manually verified using Verify

Exception safety

If an unexpected exception has been thrown (which would fail the test) and the Repository still have unsatisfied expectations, this method will cause another exception, that may mask the real cause.  If this happens to you, you may need to avoid the using statement until you figure out what is wrong: The using statement:

using(MockRepository mocks = new MockRepository())
{
    // Some action that cause an unexpected exception
    // which would cause unsatisfied expectation and cause
    // VerifyAll() to fail.
}

The unrolled using statement

MockRepository mocks = new MockRepository())
//The afore mentioned action
mocks.VerifyAll()//won't occur if an exception is thrown

This way you can get the real exception from the unit testing framework.