With the move to agile methodologies such as Scrum, Kanban and SAFe, there is a need to develop and test software faster than ever, in smaller increments. This helps reduce the schedule and conceptual risk with longer delivery cycles. Users get to see the software more quickly and are able to provide useful feedback before too much investment has been made.
However in a typical 2-3 week sprint or or iteration, there is insufficient time to manually test all of the changes in the application using traditional manual scripted tests. So companies are using and improving test automation to handle the regression testing of the application, to ensure that changes made in that sprint have not degraded functionality elsewhere.
In general, automated testing will be conducted in multiple layers of the application:
- Unit Testing – this is where individual functions and modules are directly tested in code.
- Service Testing – this is where specific API endpoints are tested. Each endpoint may cover multiple modules and functions
- UI Testing – this is most familiar to manual testers, and involves simulating user interaction in the user interface. Typically such tests will cover specific scenarios and encompass multiple services in a single test.
One of the challenges of test automation is that the approach and skillset to create reliable automated tests is often quite different to that needed by manual testers.
Why Companies Fail Implementing Test Automation
There are many different tools and platforms available to automate testing. Some are designed to be used by web developers and programmers during the creation of the application, whilst others are designed to be used by less technical users who may be more familiar with the application as a whole and the use cases it is supposed to be addressing.
Some of the main reasons that companies fail to successfully implement automated testing are as follows:
- Trying to automate every single page in the application, no matter how complex or how often that page is actually used.
- Letting developers create a custom test automation “framework” that is too complicated and is not maintainable by anyone other than its creator.
- Not measuring the Return on Investment (ROI) for each automated test, resulting in more time spent automating a test than time saved running it.
- Not planning for changes to the application being tested. Maintenance is the Achilles heel of automated testing. When an application changes, humans can adapt easily, whereas automated test scripts may end up being obsolete.
How To Maximize the ROI of Improving Test Automation
A common metaphor in software testing is the “testing pyramid”:
This illustrates clearly how the benefits different types of testing can be measured:
- Unit tests typically test well-defined modules and functions at the code level. These tests are able to cover a large number of use cases, test the system quickly with different data combinations, and generally don’t require updating when the application changes.
- Service tests typically cover the web services and APIs used by the application to retrieve/update data and also to interact with third party systems. Like unit tests the interfaces are well defined, the tests are easy to write and maintain and they don’t change frequently.
- Finally, the UI needs to be tested, and this is often the focus of automated testing, but it is costly and time consuming to automate, and the tests require frequent updating every time the application is updated.
As you can see, it makes more sense to automate the unit and service layers as much as possible, and only automate the UI where you know the interface is relatively stable. In addition, you should make sure that all the complex business rules and calculations are adequately tested by unit/service tests, with the UI tests just verifying that the user experience is working as expected.
Rapise from Inflectra is a game changing test automation platform. It encompasses both API/service testing as well as UI testing, and can mix both kinds of test in the same scenario. In addition, its low-code interface and use of dynamic, intelligent object locators means that business users can record basic automation scripts that will be reliable and resilient, even when the application changes. As a result, Rapise cuts down the cost of automation by 80% as compared to traditional automated testing technologies.
Since Rapise’s low-code approach allows business users to create and execute automated tests, it reduces the barrier to automation and allows functional experts to be self-sufficient in test automation for the first time.
Improving Test Automation Based on Risk
Even when you have an intelligent and adaptive automation platform like Rapise, one of the challenges is that running a large scale set of UI tests can take several hours, in part because of the speed of the application’s UI itself. In addition, as companies adopt DevOps and Continuous Integration / Continuous Deployment, you may be releasing code drops every hour to production. That means you need a way to reduce the time needed to execute the minimum number of tests that validate the system is ready to release.
One of the best ways of doing this is by using an approach called “Risk Based Testing”. With this methodology, you are using an understanding of the risks introduced into the application with every code change to determine which parts of the application need testing.
Benefits of Using Appsurify With Rapise
One company that is providing an innovative solution in the Risk Based Testing world is Appsurify. Their product uses Artificial Intelligence (AI) to dynamically scan the most recent code changes in every build and dynamically determine which UI tests need to be executed to cover all the possible risks.
When you use Appsurify with a test automation tool like Rapise, you are able to reduce the total testing time by 90%. In addition, because you are executing just the Rapise automated tests that matter, you can develop more sophisticated, deeper testing methods since you know that you will have the necessary time to execute them.
Conclusion
As we need to reduce the time to market without sacrificing quality, tools like Rapise and Appsurify can be used together to reduce the total testing time, increase quality, and reduce risk while improving test automation.