Many programmers believe that tests have special permission to repeat themselves, arguing that this repetition makes those tests "simpler" or "easier to read". I challenge that claim in this free preview article at The jbrains Experience, where members get personalized consulting and answers to their questions.
I recently encountered a code base in which someone had applied the Golden Master technique, but done so in a way I find risky, so I wanted to warn you against letting this happen in your code. This code exhibits a bad idea that probably started out as a good idea or seemed like a good idea at the time. This makes it plausible-but-risky, and this is where a lot of legacy code comes from.
Today I'd like to share an example of a tiny cohesion risk. I leave it to you to evaluate the severity of the risk and the appropriateness of the refactoring. I like to deal with risks when they are small enough that their impact, while painful, probably won't kill.
If you want reuse, you have to make it happen. Fortunately, you don't need to be psychic; it's enough to start by removing duplication, which makes opportunities for reuse easier to spot. Let me show you an example from code I'm working on to generate Nginx server block configurations I need to support some pretty URLs.
In "What Is Functional Programming?" I spotted a nice example of how duplication in tests leads to a suggestion to improve the design.
When you use relative include paths in your code, you bind each source code file to its current location in the project's file layout. You relegate yourself to having to run it from a very specific location on the file system. You generally make it unnecessarily difficult to automate running your application (or its tests) outside your development environment, such as in platform-as-a-service environments. You make things like Docker not just helpful, but necessary.
No matter what one writes, no matter how carefully one tries to articulate it, a non-trivial segment of the readership will interpret it differently from what one intended. So it has gone with "Integrated Tests are a Scam". I'd like to address some common differences of interpretation.
The entry point. Sometimes it's
main(). Sometimes it's an extension point in some complicated framework. Most importantly, it is the border where Their Stuff runs Your Stuff. When I see entry points in other applications, I don't see a lot of evidence of having thought about the design much. It becomes a kind of junk drawer for code. This happens especially when programmers are working in environments they don't feel particularly comfortable in. (I don't know where to put things, so I'll put them here, since that seems to work.)
You might have noticed dependency injection gaining popularity in recent years. You might also have noticed some notable figures (I'm thinking of Kevlin Henney) who appear to be bad-mouthing dependency injection, when really they are simply taking away what they feel is a veneer of mystery from the term.1 I must say that I appreciate their doing so without pretentious use of the annoying word "demystifying". (Simply ignore my own "demystifying" article by most certainly not clicking here). While on a three-hour-long car trip it occurred to me—some would say much too late—that injecting dependencies, particularly through the constructor, acts precisely like partially applying functions. This leads to a couple of potentially useful conclusions:
I consider it categorically unfair to interpret what Kevlin writes or Chris Oldwood writes as "bad-mouthing" the concept of dependency injection, but unfortunately, a careless reading of their work might suggest that in the mind of the careless reader. They mostly object to coining a new term for an old idea, with which I agree. Even so, dependency injection remains known as a term of art, so I just want to roll with it.↩