Shakeout Testing With Synthetics: A Test Environment Management Best Practice
Testing software is pretty easy, right? You build it to do a thing. Then you run a test to see if it does that thing. From there, it's just an uneventful push-button deploy and the only unanswered question is where you're going to spend your performance bonus for finishing ahead of schedule.
Wait. Is that not how it normally goes in the enterprise? You mean testing software is actually sort of complicated?
Enterprise-Grade Software Necessarily Fragments the Testing Strategy
I've just described software testing reduced to its most basic and broad mandate. This is how anyone first encounters software testing, perhaps in a university CS program or a coding bootcamp. You write "Hello World" and then execute the world's most basic QA script without even realizing that's what you're doing.
- Run HelloWorld.
- If it prints "Hello World," then pass.
- Else, fail.
That's the simplest it ever gets, however. Even a week later in your education, this will be harder. By the time you're a seasoned veteran of the enterprise, your actual testing strategy looks nothing like this.
How could it?
Your application is dozens of people working on millions of lines of code for tens of thousands of users. So if someone asked you "does it do what you programmed it to do," you'd start asking questions. For which users? In which timezone and on what hardware? In what language and under which configuration? You get the idea.
To address this complexity, the testing strategy becomes specialized.
- Developers write automated unit tests and integration tests.
- The QA department executes regression tests according to a script, and performs exploratory testing.
- The group has automated load tests, stress tests, and other performance evaluations.
- You've collaborated with the business on a series of sign-off or acceptance tests.
- The security folks do threat modeling and pen testing.
In the end, you have an awful lot of people doing an awful lot of stuff ahead of a release to see if the software not only does what you want it to, but also to see how it responds to adversity.
Sometimes the Most Obvious Part Gets Lost in the Shuffle
But somehow, in spite of all of this sophistication, application development organizations and programs can develop a blind spot. Let me come back to that in a moment, though. First, I want to talk about ships.
A massive ship is a notoriously hard thing to test. Unlike your family car, it seems unlikely that someone is going to put it up on a lift and run it through some simulated paces. And, while you could test all of its various components outside of the ship or while the ship is docked, that seems insufficient as well.
So you do something profound and, in retrospect, obvious.
You take it out on what's known as a shakedown cruise. This involves taking an actual ship out into the actual sea with an actual crew, and seeing how it actually performs in an abbreviated simulation of its normal duties. You test whether the ship is seaworthy by trying it out and seeing. Does it do what it was built to do?
In the world of software, we have a similar style of test. All of the other testing that I mentioned above is specialized, specific, and predictive of performance. But a shakeout test is observational and designed to answer the question, "how will this software behave when asked to do what it's supposed to do."
And it's amazing how often organizations overlook this technique.
Shakeout Testing Is Important
Shakeout testing serves some critical functions for any environment to which you deploy it. First and foremost, it offers a sanity test. You've just pushed a new version of your site. Is the normal stuff working, or have you deployed something that breaks critical path functionality? It answers the question, "do you need to do an emergency roll-back?"
But beyond that, it also helps you prioritize behavioral components of your system. If your shakeout testing all passes, but users report intermittent problems or lower priority cosmetic defects, you can make more informed decisions about prioritizing remediation (or not). The shakeout test, done right, tells you what's important and what isn't.
And, finally, it provides a baseline against which you can continuously evaluate performance. Do things seem to be slowing down? Is runtime behavior getting wonky? Re-run your shakeout testing and see if the results look a lot different.
Shakeout testing is your window into an environment's current, actual behavior.
Shakeout Testing Is Labor-Intensive, Especially With a Sophisticated Deployment Pipeline
Now, all of this sounds great, but understand that it comes with a cost. Of course it does -- as the saying goes, "there is no free lunch."
Shakeout testing is generally labor intensive, especially if you're going to be comprehensive about it. Imagine it for even a relatively simple and straightforward scenario like managing a bank account. Sure, you need to know if you can log in, check your balance, and such. But you're probably going to need to check this across all different sorts of bank accounts, each of which might have different features or workflows.
It quickly goes from needing to log in and poke around with an account to needing dozens of people to log in and poke around with their accounts. Oh, and in an environment like prod, you probably want to do as much of this in parallel as possible, so maybe that's hundreds or even thousands of man-hours.
This becomes time-consuming and expensive, with a lot of potential ROI for making it more efficient.
Low-Code, No-Code, and Synthetics: Helping Yourself
As detailed in the article above, a natural next step is to automate the shakeout testing. In fact, that's pretty much table stakes for implementing the practice these days. The standard way to do this would involve writing a bunch of scripts or application code to put your system through the paces.
This is certainly an improvement. You go from the impractical situation of needing an army of data entry people for each shakeout test run to needing a platoon of scripters who can work prior to deployment. This makes the effort more effective and more affordable.
But there's still a lot of cost associated with this approach. As you may have noticed, it isn't cheap to pay people to write and maintain code.
This is where the idea of low-code/no-code synthetics solutions come into play. It is actually possible to automate health checks for your system's underlying components that eliminate the need for a lot of your shakeout testing's end to end scripting.
You can have your sanity checks and your fit for purpose tests in any environment without brute force labor or brittle automation.
Shakeout Testing Has a Maturity Spectrum
If you don't yet do any shakeout testing, then you should start. If you haven't yet automated it, then you should automate it. And if you haven't yet moved away from code-intensive approaches to automation, you should do that.
But wherever you are on this spectrum, you should actively seek to move along it.
It is critically important to have an entire arsenal of tests that you run against your software as you develop and deploy it. It's irresponsible not to have these be both specialized and extensive. But as you do this, it's all too easy to lose track of the most basic kind of testing the I mentioned in the lead in to the post. Does the software do what we built it to do? And the more frequently and efficiently you can answer that, the better.
Contributor: Erik Dietrich
Erik Dietrich is a veteran of the software world and has occupied just about every position in it: developer, architect, manager, CIO, and, eventually, independent management and strategy consultant. This breadth of experience has allowed him to speak to all industry personas and to write several books and countless blog posts on dozens of sites.