Hi everyone, my name is Andrew and this talk will be about unit testing in general, and mocking in particular. 

Traditionally, unit testing means verifying a piece of code in isolation – and in real life it’s kind of a hard thing to do, because, you know, components communicate with each other, your methods call other methods, create objects, fire events... So testing something in isolation becomes a difficult task. 

And that’s where mocking comes to rescue. And I have a question for you: how many people in this room actually use any kind of mocking in their tests? [Some 60% raised hands.] Ok, cool, quite a few.

And how many write unit tests? [About 90% raised hands.] Wow, that's great!



But before digging into details of how to use mocking, I’d like to talk a little bit about why you might want to do that.



And the root of all problems is dependencies. Everything depends on something else, the method you test most likely calls other methods, and if you don't isolate your dependencies, then a test failure could actually be a bug in some other place.

So there may be false negatives in the tests: a test fails, it’s not a bug in your code, but you still need to spend time investigating this.

On the other hand, if you mock out other components, bugs in those components don’t affect your tests. You simply tell – hey, if this method is called asking for a list of customers from the database, then return this hardcoded list, or, say, if that method is called to send out emails then don’t send anything, just skip it, and so on.

By isolating dependencies you don’t test, you make sure that a failure in a test would certainly mean a bug in your code.



...and tests become faster. If you verify the code that eventually writes to a database or reads from a file, or if you need to verify some UI code but it gets its data from a service tier, anything like that – such tests are usually slow.

Get a few hundreds of them, and they can easily make you not running unit tests before every checkin, just because it takes so much time.

But if you use mocking, you isolate everything you don’t test. You hoodwink your System Under Test into thinking it's still writing to a file or retrieving data from another layer, while in fact it would communicate with fake objects. And they would either skip calls or return some predefined things. And it would give you fast tests.



Then, you can test scenarios that are hard to reproduce. Perhaps you want to make sure the application will not crash in case of OutOfMemoryException. Or maybe you need to test how your code behaves if network is not available. All stuff like that. With mocking, it's easy – you set up a mock which throws SomethingBadHappenedException and then make sure the code handles it gratefully.

You no longer need to unplug your computer to test how your program would work if there’s no internet. Such a relief! Instead, you set up a mock that throws TimeoutException or something and use it in your test. So, without much effort, mock objects allow you to test scenarios that, well, rarely happen in real life.



And, finally, you can test incomplete solutions.

That's a common scenario: you are crafting a piece of code that needs to interact with someone elses code, everything is being developed in parallel. Or, one team is writing a component, another team is writing another one, and proper testing can be done only when both are finished.

With mocking you can test just your own part, and you don’t need to wait for another team. You just say: if my code calls this guy then return this hardcoded data, or do nothing, or throw an exception... And then you can test your code as like that another component had already been written.



So, mocking is about decoupling the System Under Test from its dependencies, to get all those benefits you see on the slide. 

You have fast tests because the code you test doesn't really talks to a database or calls other tier. Instead, such calls are either ignored or predefined data gets returned.

You don't have dependencies, and so you don't spend time chasing test failures that happen because of bugs in other components. Your tests find bugs in your code, not elsewhere. 

You no longer depend on other teams or other people even if your code will finally use their components - everybody can fully test their own code without waiting for others.

And you can test scenarios that rarely happen in real life.

As I said, in order to isolate your code from some dependency, you create a special object that would imitate that dependency. Such object, surprisingly, is called mock object and there’s a great article on Wikipedia, if you’re new to mocking this is probably the place where you should start. 

So, as now we know where to find all theory, let’s look at mocking on .NET.

There are several mocking frameworks available and I picked up five of them that look most promising. Here on the slide, the sizes of the logos kind of correlate with the amount of users each framework has. Rhino Mocks is the most popular one, almost 50% of all people that use any kind of mocking, use Rhino. Then goes Moq with about 30%, and then go other frameworks.

They’re all different, some are open source and some are not, most are free but one is quite not free, some are more powerful than others, they use different approaches for calls interception, they have different syntaxes – and what we’re going to do now is to look and compare all of them. Compare the APIs, look at how they work internally, look at things that some frameworks can do while others cannot.



So we’re going to start with a simple, real life example that is touching a hot cooker.

Here on the slide you see the code and a use case scenario. So you touch a cooker and if it appears to be hot, BurnException gets thrown by your hand, and then you scream. Sounds kind of simple, eh?

But in fact it’s a really complicated scenario with a lot of dependencies.

Just imagine how complicated it is. If there’s someone in the room who knows anatomy well, feel free to correct me, but basically it works like that.

Your body is crammed with special receptors called nociceptors for stuff like pain. So, you’ve touched the hot cooker and high temperature gets detected by thermal nociceptors, they emit electrical signals that go from the hand up to the spinal cord and then divide. One part retraces to jerk back the hand. Another part goes further up to a special zone of the brain where the signal gets analyzed, you identify the problem, another signal goes to your mouth and you scream.

[Test]

public void ShouldScreamIfBurned()

{

    //arrange

    //act

    //assert

}

[Test]

public void ShouldScreamIfBurned()

{

    //arrange

    var mockery = new Mockery();

    var hand = mockery.NewMock<Hand>();

    var mouth = mockery.NewMock<Mouth>();

    Expect.On(hand).Method("Touch").Will(Throw.Exception(new BurnException()));

    Expect.On(mouth).Method("Scream");

    //act

    //assert

}

[Test]

public void ShouldScreamIfBurned()

{

    //arrange

    var mockery = new Mockery();

    var hand = mockery.NewMock<Hand>();

    var mouth = mockery.NewMock<Mouth>();

    Expect.On(hand).Method("Touch").Will(Throw.Exception(new BurnException()));

    Expect.On(mouth).Method("Scream");

    //act

    var person = new Person(hand, mouth);

    person.TouchCooker(new Cooker());

    //assert

    mockery.VerifyAllExpectationsHaveBeenMet();

}

[Test]

public void ShouldScreamIfBurned()

{

    //arrange

    var hand = new Mock<Hand>();

    var mouth = new Mock<Mouth>();

    hand.Setup(x => x.Touch(It.IsAny<Cooker>())).Throws(new BurnException());

    //act

    var person = new Person(hand.Object, mouth.Object);

    person.TouchCooker(new Cooker());

    //assert

    mouth.Verify(x => x.Scream());

}

[Test]

public void ShouldScreamIfBurned()

{

    ...

    hand.Setup(x => x.Touch(AnyCooker)).Throws(new BurnException());

    ...

}

private Cooker AnyCooker

{

    get { return It.IsAny<Cooker>(); }

}

[Test]

public void ShouldScreamIfBurned()

{

    //arrange

    var hand = MockRepository.GenerateStub<Hand>();

    var mouth = MockRepository.GenerateMock<Mouth>();

    hand.Stub(x => x.Touch(null)).IgnoreArguments().Throw(new BurnException());

    //act

    var person = new Person(hand, mouth);

    person.TouchCooker(new Cooker());

    //assert

    mouth.AssertWasCalled(x => x.Scream());

}

[Test, Isolated]

public void ShouldScreamIfBurned()

{

    //arrange

    var hand = Isolate.Fake.Instance<Hand>();

    var mouth = Isolate.Fake.Instance<Mouth>();

    Isolate.WhenCalled(() => hand.Touch(null)).WillThrow(new BurnException());

    Isolate.Swap.NextInstance<Hand>().With(hand);

    Isolate.Swap.NextInstance<Mouth>().With(mouth);

    //act

    var person = new Person();

    person.TouchCooker(new Cooker());

    //assert

    Isolate.Verify.WasCalledWithAnyArguments(() => mouth.Scream());

}

public class Timer

{

    private int _ticks;

    public void Tick()

    {

        if (DateTime.Now == DateTime.MaxValue)

            throw new  Exception("End of time!");

        _ticks++;

    }

}

[TestFixture]

public class MockDateTimeTests

{

    [Test, Isolated]

    public void TestTimer()

    {

        Isolate.WhenCalled(() => DateTime.Now).WillReturn(DateTime.MaxValue);

        var timer = new Timer();

        timer.Tick();

    }

}

[Test]

public void MouthShouldScreamIfBurned()

{

    //arrange

    var hand = new SHand {TouchCooker = (anyCooker) => {throw new BurnException();}};

    bool screamed = false;

    var mouth = new SMouth {MouthScream = () => { screamed = true; }};

    //act

    var person = new Person(hand, mouth);

    person.TouchCooker(new Cooker());

    //assert

    Assert.That(screamed, Is.True, "If hand burned, mouth should scream.");

}

So, thank you for your attention, and now - questions!

[There were a bunch of questions but I don't really remember them well... If you think your question and my answer are worth putting here, please drop me a line at andreister | AT |gmail | DOT | com and I'll be glad to add them.

As for the question about fast typing - I was using R# Live Templates, here's an example for NMock2:



The ppt itself  is available here.]