How to approach unittesting and TDD (using python + nose)

Question

I have been trying to get the hang of TDD and unit testing (in python, using nose) and there are a few basic concepts which I'm stuck on. I've read up a lot on the subject but nothing seems to address my issues - probably because they're so basic they're assumed to be understood.

1. The idea of TDD is that unit tests are written before the code they test. Unit test should test small portions of code (e.g. functions) which, for the purposes of the test, are self-contained and isolated. However, this seems to me to be highly dependent on the implementation. During implementation, or during a later bugfix it may become necessary to abstract some of the code into a new function. Should I then go through all my tests and mock out that function to keep them isolated? Surely in doing this there is a danger of introducing new bugs into the tests, and the tests will no longer test exactly the same situation?

2. From my limited experience in writing unit tests, it appears that completely isolating a function sometimes results in a test that is longer and more complicated than the code it is testing. So if the test fails all it tells you is that there is either a bug in the code or in the test, but its not obvious which. Not isolating it may mean a much shorter and easier to read test, but then its not a unit test...

3. Often, once isolated, unit tests seem to be merely repeating the function. E.g. if there is a simple function which adds two numbers, then the test would probably look something like assert add(a, b) == a + b. Since the implementation is simply return a + b, what's the point in the test? A far more useful test would be to see how the function works within the system, but this goes against unit testing because it is no longer isolated.

4. My conclusion is that unit tests are good in some situations, but not everywhere and that system tests are generally more useful. The approach that this implies is to write system tests first, then, if they fail, isolate portions of the system into unit tests to pinpoint the failure. The problem with this, obviously, is that its not so easy to test corner cases. It also means that the development is not fully test driven, as unit tests are only written as needed.

So my basic questions are:

1. Should unit tests be used everywhere, however small and simple the function?
2. How does one deal with changing implementations? I.e. should the implementation of the tests change continuously too, and doesn't this reduce their usefulness?
3. What should be done when the test gets more complicated than the code its testing?
4. Is it always best to start with unit tests, or is it better to start with system tests, which at the start of development are much easier to write?

Answer 1

Regarding your conclusion first: both unit tests and system tests (integration tests) both have their use, and are in my opinion just as useful. During development I find it easier to start with unit tests, but for testing legacy code I find your approach where you start with the integration tests easier. I don't think there's a right or wrong way of doing this, the goal is to make a safetynet that allows you to write solid and well tested code, not the method itself.

1. I find it useful to think about each function as an API in this context. The unit test is testing the API, not the implementation. If the implementation changes, the test should remain the same, this is the safety net that allows you to refactor your code with confidence. Even if refactoring means taking part of the implementation out to a new function, I will say it's ok to keep the test as it is without stubbing or mocking the part that was refactored out. You will probably want a new set of tests for the new function however.
2. Unit tests are not a holy grail! Test code should be fairly simple in my opinion, and it should be little reason for the test code itself to fail. If the test becomes more complex than the function it tests, it probably means you need to refactor the code differently. An example from my own past: I had some code that took some input and produced some output stored as XML. Parsing the XML to verifying that the output was correct caused a lot of complexity in my tests. However realizing that the XML-representation was not the point, I was able to refactor the code so that I could test the output without messing with the details of XML.
3. Some functions are so trivial that a separate test for them adds no value. In your example you're not really testing your code, but that the '+' operator in your language works as expected. This should be tested by the language implementer, not you. However that function won't need to get very much more complex before adding a test for it is worthwhile.

In short, I think your observations are very relevant and point towards a pragmatic approach to testing. Following some rigorous definition too closely will often get in the way, even though the definitions themselves may be necessary for the purpose of having a way to communicate about the ideas they convey. As said, the goal is not the method, but the result; which for testing is to have confidence in your code.

Answer 2

1) Should unit tests be used everywhere, however small and simple the function?

No. If a function has no logic in it (if, while-loops, appends, etc...) there's nothing to test.

This means that an add function implemented like:

def add(a, b):
    return a + b

It doesn't have anything to test. But if you really want to build a test for it, then:

assert add(a, b) == a + b    # Worst test ever!

is the worst test one could ever write. The main problem is that the tested logic must NOT be reproduced in the testing code, because:

• If there's a bug in there it will be reproduced as well.
• You're no more testing the function but that a + b works in the same way in two different files.

So it would make more sense something like:

assert add(1, 2) == 3

But once again, this is just an example, and this add function shouldn't even be tested.

2) How does one deal with changing implementations?

It depends on what changes. Keep in mind that:

• You're testing the API (roughly speaking, that for a given input you get a specific output/effect).
• You're not repeating the production code in your testing code (as explained before).

So, unless you're changing the API of your production code, the testing code will not be affacted in any way.

3) What should be done when the test gets more complicated than the code its testing?

Yell at whoever wrote those tests! (And re-write them).

Unit tests are simple and don't have any logic in them.

4a) Is it always best to start with unit tests, or is it better to start with system tests?

If we are talking about TDD than one shouldn't even have this problem, because even before writing one little tiny function the good TDD developer would've written unit tests for it.

If you have already working code without tests whatsoever, I'd say that unit tests are easier to write.

4b) Which at the start of development are much easier to write?

Unit tests! Because you don't even have the root of your code, how could you write system tests?