Agile software testing – removing the delivery bottleneck

The agile manifesto transformed software development. However, testing has lagged behind and is often remarkably unagile. In this blog, we see how agile testing transforms the SDLC and removes the delivery bottlenecks.

Agile development encompasses a wide range of methodologies including Scrum, XP, and Lean SW development. They all follow the tenets of the Agile Manifesto, first published some 2 decades ago. These development approaches all focus on frequent releases following short development sprints. At the end of each sprint, the client reviews the prototype and decides if it is getting closer to what is needed. Unfortunately, testing has tended to lag behind, often making it a delivery bottleneck. So, how can agile software testing help? Well, first we have to understand the problem is with the current approach.

Un-agile software testing

Traditionally, testing is the final stage before the software is delivered. The developers deliver a new build for testing then have to wait for it to be signed off. Test automation helps because it speeds up regression and UI testing. However, creating test scripts is a really slow process, so most teams only automate a fraction of their tests. Also, if the UI has changed between releases, the test engineers have to waste days fixing all the tests. Therefore, testing becomes the major bottleneck in the software delivery lifecycle.

Towards agile software testing

Test automation is the solution to agile software testing. If you automate all your testing, then tests can run 24 hours a day, speeding up the process dramatically. However, there are two significant obstacles to this. These are the difficulty in writing test scripts and the need for ongoing test maintenance.

Test creation

Writing test scripts is a long and laborious process. Each script is a miniature software development project. It has to be written piece by piece, and thoroughly tested and debugged at every stage. It then has to be optimized to work cross-browser, often requiring a significant rewrite. So, even a simple test may take days to write.

Test maintenance

Test scripts are notoriously fragile. Change just a couple of lines of CSS and you end up breaking all your tests. This is because test scripts use JavaScript selectors in order to find the correct element on a page. Changing the CSS or refactoring the UI code can lead to all these selectors changing. In the worst case, your scripts now selects the wrong element and the failure only appears many steps later. As a result, test automation engineers spend more time on test maintenance than test creation.

Autonomous agile software testing

So, the solution to agile software testing is to build an autonomous test agent. Here at Functionize, we have built just such a system. Our intelligent test agent takes test plans written in plain English and converts them into fully-functional autonomous tests. It then uses our custom AI to ensure these tests self-heal, slashing the requirement for maintenance. Let’s look at how it does this.

Intelligent test creation

Our NLP engine uses natural language processing to create your tests. You pass it a set of test plans in Plain English. It then parses these and models them against your UI. Effectively, it uses the test plans to learn how your UI works. The system then converts each plan into a test that automatically works cross-browser and cross-platform. To give a feel for how efficient this is, NLP engine can create, model and deploy 100 tests in just 6 days. By contrast, Selenium takes 74 days.

Self-healing tests

ML engine the brains of our intelligent test agent. This uses a combination of AI techniques to comprehensively model and learns how your UI works. The upshot is, routine changes to CSS styles, UI layout, button names, etc. won’t break your tests. As an example, your UX designer decides to make the “Purchase” button more prominent. They move it further up the page, change the text to “Buy Now” and change the design. With Selenium, each of these changes will break every test that interacts with that button. But our system is more like a human tester. It sees that the button has moved and changed but knows that it is still the same one.

Achieving agile software testing

The upshot of the above is that Functionize enables autonomous agile software testing. Test creation is so fast that your test team can achieve 100% automated test coverage. Tests don’t break, so the time needed to complete a round of testing is slashed. And our system integrates with all major CI/CD toolchains. Consequently, testing is no longer a bottleneck in your release process.