In Part1 of this series I have showed you how to create a very simple mock object by hand. In this post I will show you how to use RhinoMocks to create the mock and how to verify this. This post is intended as basic advice, and won’t cover any advanced RhinoMocks topics, just the basic setup/replay/verify steps.
When working with almost any mock framework there are 3 things: Setup, expectation recording and verifying that the expectations where met.
That means, first you tell the mock object what calls to expect. Then you let the method under test do it’s magic and afterwards you let the mock verify that all expected calls where made.
You can get very precise on what to expect and how to expect it, but that will be covered in the next part of this series.
The hand-made mock from Part1 would translate to a test like this when using RhinoMocks:
[Test] public void ServiceWatcherNotifiesUser() { var repository = new MockRepository(); var notifier = repository.StrictMock<IErrorNotifier>();notifier.NotifyOfServiceDown();
repository.ReplayAll();
var watcher = new HttpServiceWatcher(notifier); watcher.ObserveService();
repository.VerifyAll(); }
The main things here:
We start the repository and then request a IErrorNotifier object from it.
var repository = new MockRepository(); var notifier = repository.StrictMock<IErrorNotifier>();
The mock object (notifier) is in record mode now, all calls we do to the object aren’t actually executed but will be expected afterwards.
So if we want NotifyOfServiceDown to be called once we simply call it while in record mode:
notifier.NotifyOfServiceDown();
After having set up all expectations in record mode, we tell the Mockrepository to go to replay mode:
repository.ReplayAll();
The mock object still doesn’t do anything. But it expects what we setup in replay. If the watcher calls methods that weren’t specified in replay mode the mock will throw exceptions at us.
Now we construct the object under test:
var watcher = new HttpServiceWatcher(notifier);
And note that we pass the mock object instead of an actual implementation of IErrorNotifier.
Now we call the method under test just as we would normally:
watcher.ObserveService();
That leaves us with only one step left, we tell the repository to verify all mocks that where created and it will throw Exceptions if mocks didn’t get called or did get called too often.
repository.VerifyAll();
Although this is just a very basic example of how to use RhinoMocks, you are able to see the benefits from this. You could write the HttpServiceWatcher class without having to write any concrete IErrorNotifier implementations. You can just concentrate on the HttpServiceWatcher instead of worrying how the underlying Service is going to work.
In the next part I’ll be covering how to make some fancier things with RhinoMocks like returning values and verifying that passed parameters meet certain criteria.
The source code is available through my SVN repository:
svn checkout https://office.pixelpoint.at:8443/svn/tigraine/UnitTesting/trunk UnitTesting –username guest
Notice that all dependencies are also in the svn, so you don’t need to get RhinoMocks or nUnit yourself.