Mark Needham

Thoughts on Software Development

TDD: Rewriting/refactoring tests

with 2 comments

I’ve read several times about the dangers of the big rewrite when it comes to production code but I’ve recently been wondering whether or not we should apply the same rules when it comes to test code or not.

I worked with Raphael Speyer for a few weeks last year and on the code base we were working on he often spent some time rewriting tests originally written using rMock to use mockito which was the framework we were driving towards.

One of the benefits that he was able to get from doing this was that he had to understand the test in order to change it which enabled him to increase his understanding of how the code was supposed to work and identify anything that didn’t seem quite right.

I quite liked this idea at the time and while spending some time recently working with some tests which required quite a lot of setup and were testing several different things in the same test.

Unfortunately a few of them were failing and it was quite difficult to work out why that was.

My initial approach was to try and work my way through the tests inlining all the test code to start with and then extracting out irrelevant details to make the tests easier to understand.

Despite those attempts I was unable to work out why the test was failing so I worked out what the main things the test was trying to verify and then wrote tests from scratch for each of those cases.

I was able to write tests covering everything the original test did in several smaller tests in less time than I had spent trying to debug the original one and with a fair degree of confidence that I’m testing exactly the same thing.

As I see it the big danger of rewriting is that we’re always playing catch up with the current system which is still being worked on in production and we never quite catch up.

I’m not so sure this logic applies in this case because we’re only rewriting small bits of code which means that we can replace the original test very quickly.

My main driver when working with tests is to ensure that they’re easy to understand and make it easy to reason about the code so if I have to rewrite some tests to make that happen then I think it’s a fair trade off.

My initial approach would nearly always be to refactor the tests that are already there. Rewriting is something I’d look to do if I was really struggling to refactor effectively.

Written by Mark Needham

January 25th, 2010 at 10:06 pm

Posted in Testing

Tagged with

  • Pingback: Tweets that mention TDD: Rewriting/refactoring tests at Mark Needham -- Topsy.com

  • http://twitter.com/dbrock Daniel Brockman

    I think in general rewriting individual modules can often be a very good idea, even if “the big rewrite” is not.

    Just like when you make a typo it’s sometimes easier just to delete the whole word and do it over than to try to arrow your way into the word and fix the problem by shuffling letters around.

    Rewriting a whole module can be a very good opportunity to introduce a clean and isolated island of good code into a part of the system that you kind of dread working with.

    You can even quite safely replace a good portion of your whole system by rewriting it it chunks like this.