Huh. Shouldn’t that title be “If it isn’t tested, it’s not going to work”?
I’m asserting something slightly different here – in fact, two things. The first can be stated thus:
“In order for a system to ‘work’ correctly, and to defined parameters, test cases for all plausible conditions must be documented, crafted – and passed – before the system is considered to ‘work’.”
The second is a slightly more philosophical take on the question of what a “working system” is:
“An instantiated system – including software, hardware, data and wetware components – may be considered to be ‘working’ if both its current state, and all known plausible future states from the working state have been anticipated, documented and appropriately tested.”
Let’s deal with these one by one, starting with the first.
Case 1 – a complete test suite
I may have given away the basis for my thinking by the phrasing in the subtitle above. What I think we need to be looking for, when we’re designing a system, is what we should be doing ensuring that we have a test case for every plausible condition. I considered “possible” here, but I think that may be going too far: for most systems, for instance, you don’t need to worry too much about meteor strikes. This is an extension of the Agile methodology dictum: “a feature is not ‘done’ until it has a test case, and that test case has been passed.” Each feature should be based on a use case, and a feature is considered correctly implemented when the test cases that are designed to test that feature are all correctly passed.
It’s too easy, however, to leave it there. Defining features is, well not easy, but something we know how to do. “When a user enters enters a valid username/password combination, the splash-screen should appear.” “When a file has completed writing, a tick should appear on the relevant icon.” “If a user cancels the transaction, no money should be transferred between accounts.” The last is a good one, in that it deals with an error condition. In fact, that’s the next step beyond considering test cases for features that implement functionality to support actions that are desired: considering test cases to manage conditions that arise from actions that are undesired.
The problem is that many people, when designing systems, only consider one particular type of undesired action: accidental, non-malicious action. This is the reason that you need to get security folks in when you’re designing your system, and the related test cases. In order to ensure that you’re reaching all plausible conditions, you need to consider intentional, malicious actions. A system which has not considered these and test for these cannot, in my opinion, be said truly to be “working”.
Case 2 – the bigger systems picture
I write fairly frequently about the importance of systems and systems thinking, and one of the interesting things about a system, from my point of view, is that it’s arguably not really a system until it’s up and running: “instantiated”, in the language I used in my definition above.
Case 2 dealt, basically, with test cases and the development cycle. That, by definition, is before you get to a fully instantiated system: one which is operating in the environment for which it was designed – you really, really hope – and is in situ. Part of it may be quiescent, and that is hopefully as designed, but it is instantiated.
A system has a current state; it has a set of defined (if not known) past states; and a set of possible future states that it can reach from there. Again, I’m not going to insist that all possible states should be considered, for the same reasons I gave above, but I think that we do need to talk about all known plausible future states.
These types of conditions won’t all be security-related. Many of them may be more appropriately thought of as to do with assurance or resilience. But if you don’t get the security folks in, and early in the planning process, then you’re likely to miss some.
Here’s how it works. If I am a business owner, and I am relying on a system to perform the tasks for which it was designed, then I’m likely to be annoyed if some IT person comes to me and says “the system isn’t working”. However, if, in response to my question, “and did it fail due to something we had considered in our design and deployment of the system” is “yes”, then I’m quite lightly to move beyond annoyed to a state which, if we’re honest, the IT person could easily have considered, nay predicted, and which is closer to “incandescent” than “contented”.
Because if we’d considered a particular problem – it was “known”, and “plausible” – then we should have put in place measures to deal with it. Some of those will be preventative measures, to stop the bad thing happening in the first place, and others will be mitigations, to deal with the effects of the bad thing that happened. And there may also be known, plausible states for which we may consciously decide not to prepare. If I’m a small business owner in Weston-super-mare, then I may be less worried about industrial espionage than if I’m a multi-national. Some risks aren’t worth the bother, and that’s fine.
To be clear: the mitigations that we prepare won’t always be technical. Let’s say that we come up with a scenario where an employee takes data from the system on a USB stick and gives it to a competitor. It may be that we can’t restrict all employees from using USB sticks with the system, so we have to rely on legal recourse if that happens. If, in that case, we call in the relevant law enforcement agency, then the system is working as designed if that was our plan to deal with this scenario.
Another point is that not all future conditions can be reached from the current working state, and if they can’t, then it’s fair to decide not to deal with them. Once a TPM is initialised, for instance, taking it back to its factory state basically requires to reset it, so any system which is relying on it has also been reset.
What about the last bit of my definition? “…[A]nticipated, documented and appropriately tested.” Well, you can’t test everything fully. Consider that the following scenarios are all known and plausible for your system:
- a full power-down for your entire data centre;
- all of your workers are incapacitate by a ‘flu virus;
- your main sysadmin is kidnapped;
- an employee takes data from the system on a USB stick and gives it to a competitor.
You’re really not going to want to test all of these. But you can at least perform paper exercises to consider what steps you should take, and also document them. You might ensure that you know which law enforcement agency to call, and what the number is, for instance, instead of actually convincing an employee to leak information to a competitor and then having them arrested.
Testing isn’t just coming up with tests for desired use cases. It’s not even good enough just to prepare for accidental undesired use cases on top of that. We need to consider malicious use cases, too. And testing in development isn’t good enough either: we need to test with live systems, in situ. Because if we don’t, something, somewhere, is going to go wrong.
And you really don’t want to be the person telling your boss that, “well, we thought it might, but we never tested it.”
1 – “wetware” is usually defined as human components of a system (as here), but you might have non-human inputs (from animals or aliens), or even from fauna, I suppose.
2 – “woodware”?
3 – because I, for one, need a bit of a mental run-up to the second one.
4 – preferably the cynical, suspicious types.
5 – if not necessarily regularly: people often confuse the two words. A regular customer may only visit once a year, but always does it on the same day, whereas a frequent customer may visit on average once a week, but may choose a different day each week.
6 – how is this relevant? It’s not.
7 – yes, I know: Schrödinger’s cat, quantum effects, blah, blah.
8 – Short version: if the IT person says “it broke, and it did it in a way we had thought of before”, then I’m going to be mighty angry.
9 – I grew up nearby. Windy, muddy, donkeys.
10 – which might, plausibly, also be based in Weston-super-mare, though I’m not aware of any.
11 – this is, I think, probably at least bordering on the unethical, and might get you in some hot water with your legal department, and possibly some other interested parties.
12 – your competitor might be pleased, though, so there is that.