8 Kinds of Work in Software Testing That “We Can Do, but Should Not Do”
In software testing, we often face a problem - many tasks are indeed things we can accomplish, and doing them may seem perfectly natural, yet in many cases these efforts yield very little. These range from over-automation to frequently running unnecessary regression tests, to name a few.
As technology evolves, the tools available to testers let us accomplish far more, but that does not mean every choice is a wise one. Some tasks, when done blindly, tend to undermine the things that truly matter - output, efficiency, maintainability, and so on.
This article lists eight pieces of work in testing that “we can do, but should not do”. Sometimes, taking a step back is the smarter choice.
1. Automating All Tests
You can: Modern test automation tools let us automate almost any test case - from every click in the user interface to every API call - all of which can technically be driven through automation.
But you shouldn’t: Just because test automation is feasible does not mean it is the best choice. For example:
A product’s user interface is highly dynamic, with designers adjusting it every week. If you choose to automate every test, the relevant automated tests risk breaking after each UI change.
In this case, manual testing may be more effective.
2. Using Overly Complex Locators in Automation Scripts
You can: In automation tools such as Selenium and Playwright, XPath and CSS selectors let us pinpoint even the deepest elements on a page.
But you shouldn’t: Overly complex locators tend to make tests fragile. For example:
Using a complex XPath to locate a menu often causes multiple tests to fail once the development team refactors the HTML structure, forcing the team to spend a great deal of time on fixes.
At this point, other approaches may be more effective for the stability of automated cases, such as agreeing with the development team to add a test-id attribute to elements.
3. Running the Full Regression Suite on Every Commit
You can: In modern CI/CD pipelines, every code commit can easily trigger a full regression run.
But you shouldn’t: In practice, this is often excessive. Imagine a small code fix triggering the entire regression suite, a process that may take several hours or even longer.
For teams that have not raised automation coverage to a certain level, running a full regression after each commit is an even worse nightmare. The better approach is still to stay on top of what changed and implement precise testing based on the changes and their impact.
4. Over-Mocking in API Testing
You can: Mocking API responses can greatly speed up testing and remove dependencies on external services.
But you shouldn’t: Over-mocking, however, cuts us off from the real environment. A large number of Mock APIs can indeed improve debugging and verification efficiency, but they depart from what genuine testing requires. Testing in real scenarios is indispensable, just as we cannot anticipate every exception.
5. Writing Extremely Detailed Bug Reports for Trivial Issues
You can: With the help of assistive testing tools, we can catch many small defects in the UI layer, in prompt messages, and the like, and we can write extremely thorough bug reports following case specifications.
But you shouldn’t: Not every minor issue deserves an exhaustive, blow-by-blow report. The purpose of finding a bug is ultimately to fix the bug, not the bug itself, and the value of bugs also varies in importance. I once analyzed what makes a good bug report in 【】 - the value of a bug report lies in being a channel for communicating with developers; the boilerplate text of the report itself has no value.
6. Using AI to Generate Test Cases Without Human Supervision
You can: Advances in AI have actually made it possible to use AI tools to rapidly generate large numbers of test cases from requirements documents, covering a wide range of scenarios.
But you shouldn’t: Today’s AI, however, especially for a specific business domain, lacks human contextual understanding and the combined information gathered through various internal communications, which can lead to redundant cases or to missing critical test cases.
7. Using Too Many Assertions in a Test
You can: Combining automation tools with AI, we can indeed verify a large number of fields, properties, and UI elements within a single test.
But you shouldn’t: Too many assertions, however, only make a test huge and complex and hard to debug. When some assertions fail, it often takes a great deal of effort to track down the cause.
8. Executing Tests on Every Possible Device and Browser Combination
You can: For compatibility testing, modern cross-browser and cross-device testing tools let us run tests across many operating systems and devices.
But you shouldn’t: Testing every possible combination is neither necessary nor practical. The focus should be on covering the key scenarios that users actually use. Moreover, developments in engineering such as responsive design have greatly reduced the risk of compatibility issues.
Conclusion
In software testing, “being able to do it” does not always mean it is the best choice. We need to find a balance between technical capability and practical feasibility. By avoiding these “because we can” pitfalls and building a lean, efficient, and genuinely valuable test suite, we contribute far more meaningfully to product quality assurance.
Welcome to follow QiuCao for a steady stream of more hands-on technical content on software quality!