In my previous post, I discussed the evolution of application testing from a standalone activity at the end of the development lifecycle to an automated, continuous quality engineering function embedded throughout the process. Quality Engineering sits at the intersection of automated testing, DevOps and Agile delivery.
Rapid advances in intelligent automation, analytics and AI have allowed organizations to significantly reduce cost while increasing quality and speed-to-market. Many companies have virtually eliminated manual and scripted testing and now apply precision testing to more accurately target what needs to be tested, allocating scarce resources intelligently. But while enterprises have been successful in automating repetitive tasks, they now aspire to automate core decision-making activities and enable truly touchless testing. Five major trends are driving this evolution:
- Real time, AI-driven monitoring and integration: Evolve from issues-based resolution to real-time monitoring and integration of any technology stack.
- Self-healing: Apply AI to testing to identify when a function has changed. Then, the test can automatically update itself to be relevant and not fail during execution.
- Applied analytics: Shift from “test data” to “test insights” through applied analytics. This allows companies to manage the exponential growth in data volumes and variety.
- Next-generation DevOps: Move beyond function or script-driven approaches towards autonomous frameworks that bring developers, customers and end-users together.
- Borderless organization: Build interconnected virtual teams comprising industry, business and technology experts aligned around a common business purpose.
Now, I’ll explore some ways my teams have been bringing self-healing to life. But let’s first come to a common understanding of what self-healing means in the context of testing and quality engineering.
<<< Start >>>
<<< End >>>
Traditional vs self-healing test automation tools
Traditional test automation tools use application models to define application components and objects and their attributes. These definitions are then used to identify and operate on the application components. When changes are introduced to an application, the components frequently change. This may happen intentionally (by a developer) or dynamically (by the application system or build process). These changes break traditional automation based on static definitions.
Intelligent technologies such as natural language processing and machine learning (ML) have evolved to the point where they can enable scripts to “learn” and adapt. Self-healing test automation tools apply AI and ML algorithms to dynamically adapt testing to changes in an application’s user interface (UI) or environments. They scan the application UI upon execution of tests to detect existing objects. Then, they match them to the application model previously created for the automated tests.
If any changes to the application are detected, technology exists that enables tests to change automatically. This capability is known as ‘self-healing’. So how does self-healing testing work? In the conventional record and play-back approach, if the user interface object property changes, the script would fail. But with self-healing, the property changes are auto-sensed and the internal scripts are self-healed during runtime. The Self-Healing Test Automation engine senses the user actions and captures the actions in English language steps that can be reviewed by the tester, and then plays it back using a selenium engine, mimicking the human user. The tool remaps the objects automatically and the test can be executed flawlessly without needing any human intervention. Accenture has embedded this self-healing capability into the Accenture Touchless Testing Platform for cloud native applications.
As testing increasingly become more “touchless”, you may be wondering about the impact on testers or Quality Engineers. It’s a good question, and I will explore this topic in my next blog.