kronosapiens.github.io - To Unit Test or not to Unit Test

To Unit Test or not to Unit Test

Kronosapiens.github.io Spined HTML

To Unit Test or not to Unit Test AbacusWell-nighTo Unit Test or not to Unit Test Apr 24, 2014 It seems like some pebbles has been stirred up virtually the issue of unit testing and the role that unit tests should play in a developer’s overall TDD strategy. After reading through some writings on ‘con’ side, I’m finding the issue very thought-provoking, specifically in regards to the relationship of unit tests and code design. Before moving on though, let’s yank a stardom between the unstipulated concept of TDD (writing tests to help you pinpoint your needs and diamond your program) and unit testing (testing specifically of models and model methods). These are often lumped together, and many people think of TDD only as unit testing. This is not necessarily the case, and, as I’ll try to finger out, this conflation may be the rationalization of the current debate. When I was taught TDD, the accent was on using unit tests to help you diamond your methods – by specifying the method’s environment, inputs, and outputs beforehand, you create a sketch of the method, which you then fill in by unquestionably writing the code. Reading through Sandi Metz’s typesetting helped momentum this point home. She wrote well-nigh how well-designed lawmaking should be easy to test – if you find yourself struggling to write tests for some matriculation or method, then you need to re-think that method. What I took from all this is that writing tests first helps you write concise, efficient code, and that hard-to-test methods are a mark versus the method, not the testing framework. This anti-TDD movement (if we can undeniability it a ‘movement’… perhaps it’s increasingly of a gesture, or a thought – and again, referring to the unit-testing-style of TDD) seems to be coming lanugo on this philosophy, at least to the extent that it has wilt ideology. The crux of their snooping seems to be that the accent on unit testing has created incentives for people to artificially break lanugo their lawmaking into simple methods purely to aid in testing. Implied here is that a larger, increasingly ramified method is what the using truly needed, and that the ‘ideal’ lawmaking is stuff sacrificed and turned into too many too-small helpers. James O Coplien makes the point that a single algorithm, if written as many small methods, will unquestionably be increasingly troublemaking to understand than a single, larger method, due to the difficulty of pursuit the trace and understanding the contexts in which every helper method is called. James goes on to talk well-nigh how visitor policies virtually testing coverage has been incentivizing people to unravel up lawmaking into easily-testable chunks, which pushes up testing coverage but reduced overall comprehensibility. He drives the point home with the pursuit thoughtful exhortation: If you find your testers splitting up functions to support the testing process, you’re destroying your system tracery and lawmaking comprehension withal with it. Test at a coarser level of granularity. This makes sense, and is in line with DHH’s critique. DHH comes lanugo versus unit testing as stuff over-emphasized in relation to things like full-length and integration tests, the ‘coarser levels of granularity’ that James talks about. DHH seems to take the position that tests should be oriented virtually the user’s experience, not so much the verification of details of implementation. This is starting to make sense, but there’s something unsettling still. What well-nigh the cadre purpose of unit testing – that is, to make it easier to find bugs in the code? With a full suite of unit tests, it seems as though it would be much easier to pinpoint and fix bugs. With a coarser set of tests, we would expect that developers would have to work harder to fix lightweight tests, since the failures would be occurring at a lower level than the tests. It would seem that by foregoing unit tests, we are setting ourselves up for a longer and painful debugging process, if and when (but mostly when) bugs arise. The response to that, I would expect, is that developers should prepare for that debugging process. The idea seems to be that developers should plan on debugging their methods in the sparsity of tests, and that methods don’t necessarily need to be specified by a test suite. Methods can transpiration as necessary to implement the features stuff built. Beyond features, they have no substance. In a sense, then, all methods can be seen as private methods. Further, a strong developer would not need unit tests to debug methods – they would have a sufficiently strong grasp of their language to think things through. As a young developer, I’ve found unit tests very helpful in towers my models, but I can imagine how a senior developer might find unit tests increasingly tedious than helpful. But won’t that wrack-up up in our faces? Wont unit tests save us hours of hunting lanugo bugs?  Isn’t the whole point of testing to save time (and money?).  Not necessarily. James goes on to make a number of points versus unit tests. First, he points out that tests that never goof (or at least, once a method has been written to pass them) wilt deadweight in your test suite. Those methods aren’t failing, and will never goof (unless they are re-written) – and as such, those tests tell you nothing. He advises developers to delete any test that hasn’t failed in over a year. Then, he explains how, given the complexity of on object-oriented application, “test coverage” becomes a meaningless metric  because it is untellable to test for every possible combination of events, plane if you “test” every line.Pursuitthat line of reasoning, unit tests can wilt distractions, diverting sustentation yonder from problems in higher-level design. That said, I’m still not entirely convinced. Something I revere well-nigh designing lawmaking is how well-written vital functions can be reused in new contexts. Designing virtually features instead of virtually units seems as though it would lead to increasingly sloppiness at the unit level, reducing the overall quality of the codebase and making future transpiration difficult. That said, if I were to take the opposite position, I could say that leaving flexibility at the unit level is a good thing, considering it allows a unconfined deal of room to experiment with new methods and algorithms without having to edit any existing tests. James sooner comes virtually and acknowledges the importance of unit-level specificity, and advocates for making assertions well-nigh methods, in lieu of unquestionably testing them. Assertions are not something I have wits with, so I can’t scuttlebutt increasingly on that. All this makes sense. But there seems to be some lingering contradictions. On one hand, TDD on the unit level helps alimony methods small, simple, and ostensibly increasingly reusable. On the other, TDD on the unit level creates an incentive to artificially chop up logical units into troublemaking (albeit hands testable) atoms. The ravages is these are two sides of the same forge – and the rencontre becomes discerning when chopping up a ramified method into simpler helper functions is a step towards clarity, or a step away. It seems like the wordplay is to stop seeing test coverage and the simplicity of a test suite as a perfect metric for lawmaking quality, but rather as one among many measurements and signals that must be taken into account. Every project will differ, and unit tests should play an therefrom variegated role. As with all worthwhile ideas, unit-level TDD seems to contain within itself a contradiction – unit testing can both help you organize your ideas and diamond quality lawmaking at the lowest levels of your application, and incentivize you to unravel up your lawmaking into troublemaking atoms to conform to out-of-touch expectations virtually test coverage. This contradiction should be undisputed – it is the sign of a good idea. Within the contradiction is wisdom, and rather than oppose for one ‘correct’ interpretation or another, we should engage with that contradiction, hold the tension, and learn from it. Comments Please enable JavaScript to view the comments powered by Disqus. Abacus Abacus kronovet@gmail.com kronosapiens kronosapiens I'm Daniel Kronovet, a data scientist living in Tel Aviv.