Building and maintaining automation can take time. Even with a code-free solution at hand that makes test automation easier and less time-consuming, a lot of work goes into building robust and scalable automation.
The good news is, with the right approach, a lot of time and effort can be saved. In this guide, we take you through key considerations in connection with your test automation reviews that can help ease the process.
Here’s what you’ll learn:
- Why review automation flows?
- Roles and responsibilities involved
- The technical review process in 6 steps
- What to review and how
Why review automation flows?
The primary goal of the automation review process is to assess if new flows have bugs or errors. If flows aren’t set up correctly, it can result in tests failing, even though the application under test is working as it should.
By following the best practices for building and reviewing test automation flows outlined in this guide, most errors can be avoided.
In addition to these guidelines, many enterprises will have rules and regulations they need to adhere to for security and compliance reasons. These are not outlined in this guide, but should be included in the process.
As a result of a thought-through, structured test automation review process, teams can expect more robust and scalable automation. As an additional benefit, going through the automation flow review process with your team will improve collaboration and enhance learning across functions. The process gives each person involved important insight into the test automation process and test automation results.
Read more: How to analyze test automation results
Overall, the flow review is critical for the following reasons:
- Ensures that critical defects in the flow are identified early
- Confirms that the new flow adheres to best practice guidelines for building automation
- Increases the stability and robustness of automation
- Helps achieve high reusability, making automation easier to maintain and scale
Roles and responsibilities
An important part of the review process is assigning roles and responsibilities in the team.
For the sake of simplicity, we have given each of these roles a name (in bold). Their official title may however be a different one (examples not in bold).
Their responsibilities are listed below each role:
- Creates the automation flow under review
- Fixes defects in the automation flow under review where necessary
Reviewers/Technical Peer/Team Lead
- Applies their subject-matter expertise
- Works on and reviews the project and identifies potential defects in the flow
Moderator/Module Lead/Team Lead
- Ensures efficiently run review meetings
- Mediates, if necessary, between the various points of view
- Is often the person upon whom the success of the review depends
Review Lead/Team Manager
- Holds the responsibility for the review
- Decides who will be involved in reviews and organizes when and where they will take place
To make sure that the review process has the intended effect, it’s important that the process is formalized. This means that it becomes a recurring part of the overall test automation process, and isn’t sacrificed during busy times. This is all the responsibility of the Review Lead.
- The Review Lead decides who will be involved in the review and organizes when and where it will take place.
- The Author will create the automation flow in Leapwork, as per requirements, and make the test stable enough for execution.
- The Author passes the test case on to the Reviewer.
- The Reviewer reviews the automation flow (see ‘What to Review’ for details) and provides the review comments to the Author.
- The Author incorporates the changes or discusses any challenges with the Reviewer in case of disagreement. The Moderator of the review can be consulted to get the issue resolved. Steps 2 and 3 may need revisiting hereafter.
- When there is an agreement between the Author and the Reviewer on quality, the flow is ready for publishing.
What to Review
Although not formally a part of the review process, the test automation building process is just as important in securing robust, scalable automation. For this reason, we’ve included best practices from before you start automating to after tests have been executed.
If you’re past the first stages in your process, then use these initial guidelines to improve your work on new automation flows in the future.
Before you automate
- Prioritize what to automate: Generally, tests that are highly repetitive, repeatable and valuable should be automated. Avoid automating tests that do not meet these criteria, as they will have a lower return on investment (ROI).
Is the test automation flow set up correctly?
- Does the test focus on one thing so it can run independently? Every automated test should be designed to test one specific thing. When tests are ‘independent’ in this way, it’s much easier to identify where the error is, if the test should fail.
- Does the flow contain duplicate blocks with the same functionality, and can these be wrapped as sub-flows for easier reusability? Reusability in test automation is about wrapping parts of an automation flow into a component that can be reused across test suites and teams. In the Leapwork Automation Platform, these components are called sub-flows. R
- How is test data managed? When working with test data, the following guidelines should be followed:
- Test data should be part of the main test flow only. Sub-flows should not include test data
- Data to sub-flows should be parameterized, this helps to increase sub-flow reusability
- Create test data first, and then execute the test. At the end of the test, delete the generated test data
- Does the automation solution account for dynamic elements? User interfaces of applications tend to change as they are developed. Automation platforms such as Leapwork come with built in functionality to deal with dynamic applications. Learn more here:
- Is the test automation environment affecting your test results? In some cases, the test might fail due to the test environment. To avoid this, keep an eye on the test environment and configurations during the review process.
Does the test automation flow execute as intended?
- Does the test verify what’s needed and fail if expected conditions aren’t met? The purpose of automated test cases is to assert various conditions. The tests should fail if the desired conditions aren’t met and pass if the desired conditions are met.
- Check the test for redundancy: Reduce redundancy, simplify the logic, and cut down on unnecessary loops in flows. Learn how here.
Are the test automation flows organized in a way that makes sense to the team?
- How are tests organized? With Leapwork, users can create and organize folders, flows, sub-flows, and the underlying elements in multiple ways, as these are logically separated and can be structured as per the user’s needs. Users can create a hierarchical folder structure and organize the flows and sub-flows easily with drag-and-drop functionality. It is best practice to agree on how to organize flows. See how here.
- Ensure consistency with naming conventions: Naming conventions secure a better overview of automation flows, so they can easily be understood by anyone. This makes it easier to reuse, change, and maintain automation flows and enables better collaboration.
- Incorporate the review process as a core part of your automation flow development process
- Ensure that the roles (Review Lead, Author, Reviewer and Moderator) are clear in the team
- Agree on the technical review process
- Follow the best practices for building and reviewing automation
- Review your review process at a relevant time to optimize the process and create additional best practices based on your experience
Learn more about how to build robust, maintainable, and scalable automation in our Best Practices Webinar Series.
Watch on-demand or sign up for our live sessions here.