The new frontier of Automated Testing is Machine Learning

The long wave of artificial intelligence also affects test automation

In the DevOps era, the discussion about integration between the Dev(eloper) and Op(eration) worlds is often lively. The emphasis is almost always on automating builds, unit tests, and releases. But in a context where development cycles are getting shorter, where releases are released directly into production, manual testing risks becoming a bottleneck.

The hard life of testing to keep up with increasing complexity and change.

On the other hand, test automation, which prescribes both the development and release of scripts, should legitimately be included in the cycle. But since it is not about new features, it is taken for granted, often being left out of the plans. The result is that it becomes more and more difficult to keep automation scripts aligned with the versions of the application, and an unaligned test is an unusable test. Also, we must not forget that all phases of the SDLC (Software Development Life Cycle) must be tested, so whenever we talk about Continuous Development and Continuous Integration, we must introduce the concept of Continuous Testing.

This image has an empty alt attribute; its file name is Continuous_testing_loop-1024x462.png — Continuous testing in DevOps

The message here is that at the base of the concept of evidence automation lies a problem: to create them we need engineers. The tools for testing automation are so many now that there are also Anaconda-style distributions that claim to integrate them. The situation now in QA is that of a sort of DevOps smoked edge, where complicated test cases are developed with heterogeneous sets of tools such as Cucumber , Jenkins , and even ad-hoc scripting languages like Pickle . The problem now is that we need developers to test (not just develop) new code.

But if DevOps has the mission of integrating the entire development cycle, how is it possible that testing has become just another phase of development? The reason lies in the fact that the frameworks and tools used (first of all, Selenium), do not have any kind of intelligence within them. It follows that although they are very effective in automation, they are only good for a developer.

The “Third Wave”: that is, Artificial Intelligence and Continuous Testing

Today, most GUIs (Graphical User Interfaces) are developed with Javascript and Node.js, and automated tests are mostly implemented with frameworks like Selenium and Appium. The problem with those approaches is that they require a lot of scripting, are often difficult to maintain, and are difficult to keep up with the ongoing releases and changes that come with them.

The introduction of Machine Learning in automated testing presents some crucial points:

Automatic test generation: the basic principle is not different from “burning” with Selenium, with the difference that in this case, the tool generates executable functional test steps. Some tools like functionalize they also allow you to generate runnable tests from test books written in natural language, using NLP technology.
Self healing: One of the most innovative concepts of these technologies is the ability to autonomously adapt tests to interface changes. For the most difficult cases (eg, changing both the position and label of a button), allow the user to change the behavior interactively, sometimes even with a single click.
No scripts: the test is generated transparently, without the need to develop any code.
Multi-browser and multi-device: State-of-the-art tools allow us to create tests that run on different platforms, which is now a must.
Zero or minimal maintenance: Thanks to automatic generation and self-healing, it is possible to create tests that keep up with developments and releases without bloodshed.

the main players

functionalize

Functionize bills itself as the “first completely autonomous test platform”. The most interesting feature is the autonomous creation of tests from a list of tests written in natural language, through NLP. Tests are built with lots of clickable screenshots, the platform “fits” the app via machine learning algorithms and becomes more resistant to design changes as the number of runs grows. You can see a presentation of the most interesting features here below.