When someone asks “I have a big suite of manual tests; which tests (or worse, which test cases) should I automate?”, I often worry about several things.
The first thing is that focusing on test cases is often a pretty lousy way to think about testing. That’s because test cases are often cast in terms of following an explicit procedure in order to observe a specific result. At best, this confirms that the product can work if someone follows that procedure, and it also assumes that any result unobserved in the course of that procedure and after it is unimportant.
The trouble is that there are potentially infinite variations on the procedure, and many factors might make a difference in a test or in its outcome. Will people use the product in only one way? Will this specific data expose a problem? Might other data expose a problem that this data does not? Will a bug appear every time we follow this procedure? The test case often actively suppresses discovery. Test cases are not testing , and bugs don’t follow the test cases.
Second: testing is neither manual nor automated. A test cannot be automated. Elements of the procedure within the test (in particular, checks for specific facts) can be automated. But your test is not just the machine performing virtual key presses or comparing an output to some reference.
Your test is a process of activity and reasoning: analyzing risk; designing an experiment; performing the experiment; observing what happens before, during, and after the experiment; interpreting the results; and preparing and a relevant report. This depends on your human intentions, your mindset, and your skill set. Tools can help every activity along the way, but the test is something you do, not something the machine does.
Third: lots of existing test cases are shallow, pointless, out of date, ponderous, inefficient, cryptic, and unmotivated by risk. Often they are focused on the user interface, a level of the product that is often quite unfriendly to tools. Because the test cases exist, they are often pointlessly repeated, long after they have lost any power to find a bug. Why execute pointless test cases more quickly?
It might be a much better idea to create new automated checks that are focused on specific factors of the product, especially at low levels, with the goal of providing quick feedback to the developer. It might be a good idea to prepare those checks as a collaboration between the developer and the tester (or between two developers, one of whom is in the builder’s role, with the other taking on a testing role). It might be a good idea to develop those checks as part of the process of developing some code. And it might be a really good idea to think about tools in a way that goes far beyond faster execution of a test script.
So I encourage people to reframe the question. Instead of thinking what (existing) test cases should I automate? try thinking:
- What reason do we have for preserving these test cases at all? If we’re going to use tools effectively, why not design checks with tools in mind from the outset? What tool-assisted experiments could we design to help us learn about the product and discover problems in it?
- What parts of a given experiment could tools accelerate, extend, enhance, enable, or intensify?
- What do we want to cover? What product factors could we check? (A product factor is something that can be examined during a test, or that might influence the outcome of a test.)
- To what product factors (like data, or sequences, or platforms,…) could we apply tools to help us to induce variation into our testing?
- How could tools help us to generate representative, valid data and exceptional or pathological data?
- In experiments that we might perform on the product, how might tools help us make observations and recognize facts that might otherwise escape our notice? How can tools make invisible things visible?
- How can tools help us to generate lots of outcomes that we can analyze to find interesting patterns in the data? How can tools help us to visualize those outcomes?
- How could the tool help us to stress out the product; overwhelm it; perturb it; deprive it of things that it needs?
- How can developers make various parts of the system more amenable to being operated, observed, and evaluated with the help of tools?
- How might tools induce blindness to problems that we might be able to see without them?
- What experiments could we perform on the product that we could not perform at all without help from tools?
Remember: if your approach to testing is responsible, clever, efficient, and focused on discovering problems that matter, then tools will help you to find problems that matter in an efficient, clever, and responsible way. If you try to “automate” bad testing, you’ll find yourself doing bad testing faster and worse than you’ve ever done it before.
Learn about Rapid Software Testing