In the first post in this series I set the stage for a discussion of how testability can serve as a proxy or enabler for other, more directly desirable qualities in a software system. In this post I’d like to look at the first such quality, modularity.
Modularity is perhaps the most obvious quality to correlate with testability. Modularity is a bit like motherhood and apple pie, and we generally recognize it as a “good thing.” Most good developers instinctively foster modularity and reject non-modular designs, both because they’ve been taught that modularity is good and because they’ve learned through experience that it’s important for many, many reasons.
What do we mean by modularity? A simple definition of modularity is “breaking designs into pieces”, but that obviously misses important points. We don’t just pull a system into arbitrary pieces, but instead we create modules with specific qualities in order to support and foster the goals of whatever it is we’re building. A typical (and important) goal with modules is to have high internal cohesion and low external coupling. A highly cohesive module is one in which all of the module elements are related, work together, and are necessary for performing the work that the module does. A module with low coupling is one that doesn’t rely unnecessarily or too extensively on other modules.
There are plenty of ways to ways to discuss and even measure modularity in software designs,1 but for our purposes the basic concepts of cohesion and coupling suffice. So how does modular code – code structured as modules with high internal cohesion and low external coupling – correlate with testability? The short answer is that modular code is generally very testable, so let’s see how and why.
One way to see the relationship between testability and modularity is to recognize that modular code, by virtue of its low coupling, is easier to instantiate and execute in isolation. The fewer things (classes, services, whatever) that a module needs, the less work it is to write tests for it. That is, you simply have to type less for each test. Likewise, tests for modules with fewer external dependencies often execute more quickly – at least marginally so – because there’s less stuff to do for each test. The result is that developers can run the tests more often and will be more inclined to do so.
If you use mocks in your testing system, low coupling means that you generally have to design fewer mock objects (because your modules have fewer dependencies that need mocking). Moreover, your mocks will often be simpler because they won’t have to simulate interactions between far-flung dependencies.
The relationship between modularity and testability goes even deeper, though. Beyond the somewhat mechanical questions of instantiation times, test length, and so forth, there are serious cognitive problems associated with testing poorly-modularized code. The first of these problems is that your tests can end up testing the wrong thing. If a test for some bit of functionality has to invoke code in other modules, the success or failure of the test depends not just on the code under test but on all of those other modules. On some level this is unavoidable,2 but unnecessary dependencies unnecessarily increase the risk that the results you’re seeing for your tests are caused by faults in other modules. These kinds of external failures take time to debug, can distort tests as developers try to work around them, or – in the case of incorrectly passing tests – can mask actual defects.3 Ideally, the output from your tests should give you precise and unambiguous information about just the element under test, and reducing coupling helps developers approach that ideal.
A second way that poorly modularized code increases cognitive load for test developers is that it increases the state space with which a test developer needs to contend. For every external element that plays a role in a module’s functionality, the state space that needs to be considered for testing grows to include the potential states of that element. For example, if a test relies on the some global state managed by an external module – perhaps something like an application object managed by the GUI library – then test developers need to ensure that this external object is in the correct state when the test is executed. This means that no matter what other tests have been run, what order they’ve been run in, or their results, the test developer needs to ensure that this external state is acceptable. As external test dependencies grow, this management of external state can become a significant or even dominant aspect of test development. In other words, the more unnecessary dependencies a module has, the more time a developer will need to spend thinking about those dependencies rather than focusing on testing the functionality at hand. Babysitting unnecessary dependencies doesn’t generate information or value.4
So we can see that poorly modularized code is generally harder to test, and that’s good to know. But the goal of this series is to explore how testability reflects other qualities, not the other way around. How, then, can the testability of our code inform us about its modularity?
The important point is this: if you find that your code is easy to test, then that’s a good indication that your code is modular! If you sit down to write some tests and you find that your fixtures are easy to write, the extent of the tests is easy to define, and you don’t find that you’re constantly needing to consider distant side-effects, then you’re probably testing modular code. To carry on with the barometer metaphor, you’ve got high-pressure, and you can see blue skies and little white puffy clouds. It’s time for a picnic.
On the other hand, if your testing efforts involve lots of ceremony – instantiating objects, wiring them together, and bootstrapping subsystems – or if you feel like your really just shotgunning tests at the code rather than pinpointing the “obvious” testing points, then chances are that you’ve got some modularity issues.
Like I said, modularity is perhaps the most obvious quality that we can associate with testability. And the way to leverage testability in this case is to pay attention to what your testing efforts tell you. There’s a lot of information in the work involved in developing tests, and drawing insight from this work is a valuable doubling-up of that effort.
A corollary to this insight is that, when you find yourself having difficulty writing some tests, step back and ask yourself if these problems stem from poor modularity. Testing can be a bit repetitive, though often with minor tweaks, and this is a wonderful environment in which to find repeated bad patterns. And sometime consideration of these patterns will show where you might have an opportunity for better modularization of your code.
Operating systems and standard libraries are “other modules” by most measures ↩
Consider a test for a specific exception. If some dependency is throwing that exception and the function under test is, in fact, not throwing the exception, then the test is passing erroneously. ↩