Skip to main content

Are mocks/fakes reusuable?

Programming 101 states:
Don't copy and paste code. If you find yourself doing something repetitive then do it right so you can reuse the same code. Functions, classes and even separate files all serve this end.

Now that I'm writing tests all the time I often find myself creating Mocks. Mocks are where you tell code to use a pretend version of some functionality instead of the real one. It could be because the real one does something you don't want in your tests (writes files, reads a database) or it could be that you've got some messy legacy code you can't to pull into your tests (yet). There's other reasons too but you get the idea.

So if I make a Mock version of a class it makes sense to try and share that with everyone else that might be trying to test with that same class. Or does it?

That assumption has some serious flaws that I'm only now starting to understand. And here's a few:

Behaviour you need to test may be completely different to the next guy

So I might be doing a mock file reader. And I might just want to send it some text just to get my code moving and doing stuff. But the next guy might be dealing with something far more critical and wants to simulate all the error conditions of a file being missing, failing to read, failing part way through a read, etc etc.

So if we're both developing using the same mock and re-examine my code in a few weeks I'm going to find this horribly complex tool of which I'm only using the most simple part there of. Now no doubt there's some great work in this complex mock and it may be very useful for future testing work. But for my little class that just wants to read some text it's complete overkill and potentially makes my tests more complicated to understand than they need to be.

All is not lost at this point. I could use inheritance to have my simple mock a parent of the advanced mock and break things down that way. But it's possibly I could very quickly write a brand new mock and ignore the advanced one in shared code. Since my mock may be no more than a handful of lines of code that may be the appropriate approach. To create a mock that is not shared with all the other tests.

You may be writing a complex fake as a library interface

Now even though it's complex it's still going to be limited and focused to what areas your code needs to be tested for. If it's shared with another project/executable that needs to talk to the same library there may be very little overlap. Again this can lend to an overly complex interface. It can get worse if your code is dealing with the 2.2 library and the other is still using the 1.8 library.

But of course if there is significant overlap on complex interaction then it makes perfect sense to share that code. So there's no hard and fast rules here.

You're mocking out legacy code

For me this is a common reason to mock. But may prove to be best reason not to share mocks. Essentially you need a long term goal of not mocking this code. It may not always work out. If the legacy code in question never changes then it may never end up being something you can pull into tests.

So since the long term goal is to remove the need for mocks you're only encouraging tests to keep using the mocks by sharing them. If a mock is already a complex suite of interactions and fake behaviour and you need to add some new behaviour it's not going to occur to you that it may be easier to use the real production code. The mock will continue to grow and be implemented long after the production code it's mocking has changed and its true usefulness has expired.

So after all this I'm still learning how to make mocks. Writing my own at least seems pretty quick and easy even without a mocking framework like gmock or cmock. But it's been a hard and slow lesson to learn that I shouldn't be aiming to put all this work into a kind of mock library.

Popular posts from this blog

When Agile is not common sense

It's been about 8 years since I got my Agile training from James Grenning and started an Agile Pilot with my team. Right from the start I was super keen and got people practising TDD and Pair Programming even though I didn't really know if that effort would pay off. I just knew we had lots of problems with the old way so I wanted to embrace the new.

So I'd run my own little sessions with the broader team in Sydney sharing Agile concepts and ideas. Giving us a chance to discuss things and keep learning long after James had left. But often I would present new ideas and a few people in the group would respond "oh of course, that's just common sense". Initially I thought it was great as they were embracing these ideas as valuable even though it was not what we were doing before. But after a while I started to get frustrated because they we're not really listening. If some small part of a concept fit nicely with their "common sense" then they took th…

Setting up Fitnesse on Ubuntu in 7 steps

Some pretty basic steps but just to make sure it's here for everyone to see. Setting up fitnesse and running the jar is easy enough. Just go to and get started and do it on your desktop just to see it in action. But for me that wasn't good enough I wanted it to run as service on ubuntu.

I stole a few tricks from how ubuntu runs jenkins and setup fitnesse a similar way.

1. Create a user and group for fitnesse (optional)
I didn't do this because I wanted tomcat, jenkins and fitnesse all running as the same user. Call it laziness to avoid any permissions classing but it doesn't change the process that you need to create or choose what user you're going to make it run as. Don't make it run as your user or root!

2. Download the jar file and place it in /usr/share/fitnesse
Make the folder too of course. It can belong to root as long as the fitnesse user has read access

3. Create the folder to run in at /var/lib/fitnesse
Fitnesse user needs write…


So most of the tests I'm writing now in Fitnesse are using RestFixture. Being able to do all this black box style testing has helped me get a lot of tests up and running without having to change the existing code base. Now I've taken a step future with my own little fork so I can use scenarios and build nice BDD style scripts. But first I want to give me own quick guide to using RestFixture

Step 1: Installing
You can dive straight in by grabbing the latest jar files for RestFixture here
If you know what you're doing can get the nodep version to work nicely along side other libraries you may be including in Fitnesse. But I grabbed the 'full' version and unzipped it into a RestFixture folder alongside my FitNesseRoot folder.
Step 2: Write your first test
I took advantage of the built in Fitnesse api as a basic test and wrote a page called RestFixture with the following contents
!define TEST_SYSTEM {slim} !path RestFix…