Software testing is as old as software itself. However, the strategies, tools and processes that software delivery teams use to assure the quality of software are always changing. If you haven’t taken a look at the latest types of software testing, you might be missing out on some important strategies for making testing and QA faster and more efficient. Here’s a primer on modern software testing practices.
What Is Software Testing?
As anyone who has ever written code knows, software is a tricky thing. For a variety of reasons, code often does unexpected things when you run it. Your code could contain bugs that cause an application behavior problem. Your compiler might do something unexpected when it builds the code. There could be unexpected environment variables that cause strange behavior.
Software testing is the art and science of testing software to check for these and other problems that could cause software to behave in an unexpected or unacceptable way. In most cases, the main purpose of software tests is to ensure that IT teams discover problems within their applications before they impact end users.
There are many different types and categories of software tests, from performance and usability testing to security and load testing. Generally speaking, the software testing trends described below apply to all of these types of testing.
Shift-Left and Shift-Right Testing
One recent trend in software testing is so-called shift-left and shift-right testing.
Traditionally, software testing was performed near the “middle” of the software delivery pipeline: after your application had been built, but before it was released into production.
With shift-left testing, systematic tests begin earlier, as soon as code is written. And with shift-right testing, testing continues once software is in production in order to identify performance or usability problems that may be impacting your end users.
These software testing strategies build off of the broader shift-left and shift-right concepts associated with DevOps.
Speaking of DevOps, another important trend in software testing in recent years has been the embrace of so-called QAOps.
Whereas DevOps emphasizes close collaboration between developers and IT Ops departments, QAOps brings software test engineers into the fold by encouraging them, too, to coordinate with developers and ITOps engineers. The goal of QAOps is to make software testing (and quality assurance more generally) a fully integrated part of the software delivery pipeline, rather than a “siloed” operation.
QAOps hasn’t gained as large a following as some of the other DevOps offshoots, like DevSecOps. But it does represent an important new strategy for optimizing quality assurance operations.
Test automation is not an entirely new idea within the world of software testing. Test automation frameworks like Selenium have been around since the mid-2000s. What has changed today, however, is that automation has become the primary end goal for most QA teams.
This is true for two main reasons. First, the past decade has seen the explosion of automated testing frameworks designed to make it easy to write and run tests automatically, instead of having to have human engineers execute each one manually. Second, the demand for ever-faster software delivery ushered in by the DevOps movement means that, in many cases, automation is the only way for QA processes to keep pace with the rest of the software delivery pipeline.
It’s worth noting that few organizations achieve complete test automation. For most, automating something like 70% of tests is a realistic goal. Certain tests, such as usability tests that involve monitoring how users interact with an application or react to a new interface, are best performed manually.
AI and Software Testing
AI is everywhere these days, and software testing is no exception. While there are a number of potential ways to apply AI to software tests, two stand out as approaches that are increasingly being adopted in the real world.
First is AI-powered “self healing” for automated test scripts. Using AI tools, QA teams are writing automated tests that can reconfigure themselves automatically to make a failed test run successfully, or respond to a configuration change within the test environment.
Second, AI-driven analytics are becoming more and more important for interpreting test data. That’s only natural: As automated testing makes it possible to run more and more tests at once, and as applications become ever-more complex, interpreting test results manually is less and less feasible. In response, software testing vendors are now beginning to offer tools that use AI to help understand test data.
Integration of Different Types of Software Testing
As I noted earlier, software testing can be broken down into several distinct categories, like performance testing, usability testing and security testing.
Traditionally, different teams, tools and methodologies were associated with each type of testing. But, today, the lines between the various testing disciplines are blurring. Given the enormous complexity and degree of dependency of modern applications, it often does not make sense to try to perform each type of test in isolation.
For example, load testing (which involves testing how well your application responds to heavy demand) goes hand-in-hand with protecting your organization from DDoS attacks (a type of cyberattack that attempts to overwhelm applications with traffic or other requests). Thus, load testing and security testing are converging around this area.
As another example, it’s hard to separate performance testing from usability testing--users don’t like applications that don’t perform adequately.
For these reasons, software testing as a whole is becoming a more integrated affair. Instead of specializing in one type of testing, QA engineers are now responsible for covering it all.
DevOps, AI and other important trends of the past decade have exerted significant impact on software testing. IT teams today are automating more tests than ever, while also striving to test earlier and more often. It's important to consider all types of software testing to determine which one (or ones) will work best for your organization.