Here at MindK, we rely heavily on building a test automation (TA) strategy as it leads to maximum testing ROI (Return on Investment) on our clients’ projects. Practice shows that many of the benefits of automation testing discussed in our other article may backfire without a robust strategy in place. So, in this article we are going to:
- highlight the risks of not having a test automation strategy;
- list the main goals of the TA strategy;
- share tips on how to build a strategy; and
- show what a test automation strategy looks like.
Now let’s dive deeper.
The cost of thinking small: what are the risks of having no test automation strategy?
One of the most common mistakes with automation testing is going for the immediate benefits and forgetting about the bigger picture. As a result, many teams abandon their automation efforts after a while and go back to manual testing, which is bad. The main reason for that is an unstructured and reckless approach to test automation. Here is what the lack of a test automation strategy can lead to:
- Wrong testing automation technology chosen and a low-quality end result. Without a well-defined test automation strategy, you risk selecting an incorrect test automation solution. The approach to choosing a tool should be profound and built around the software product you are developing and the overall goals of the project. In the event that the team doesn’t take time to analyze the environment and technology and make a plan around it, applying the wrong tool to the project may look like trying to squeeze an elephant into the trunk of a Volkswagen Beetle.
- No potential ROI. In general, more and more clients agree that test automation is a great approach, but they may be hesitant to invest in both financial and human efforts. Uncertainty regarding the expenses of developing and maintaining a test automation system, particularly when budgets and schedules are constrained, might raise concerns about how much value it provides. This is where the test automation strategy shines. It is developed, taking into account the real business value it can bring to the project. If there is no value, then it doesn’t really matter how many test automation efforts were made.
- Lack of focus. First of all, it’s not possible to automate each and every scenario on the project. Moreover, in most cases, it’s even irrelevant and unnecessary. For these and other reasons (like lack of resources), the testing scope is often squeezed. In this light, you need to have a clear-cut answer on which scripts are of high priority because of business value and which ones should be eliminated. Without knowing or having anything similar in the strategy, the team lacks focus, which leads to wrong decisions, lost time, and an unreasonable waste of resources.
Now that we’ve defined the potential challenges the project team may face without a test automation strategy, it’s time to talk about what exactly test automation strategy is and which goals it pursues.
Thinking big with test automation strategy: what are the objectives?
A test automation strategy is an approach that consists of a set of reusable automated scripts and defines the overall plan of project automation. In short, a test automation strategy is an instrument to create a bigger and more considered vision of test automation applications.
The main goals of the test automation strategy are:
- determine the overall plan of test automation with a great focus on not only its capabilities, but also risks and limitations;
- communicate all the objectives and plans that are expected as a result of applying test automation.
- discuss the scope of test automation coverage;
- pick up appropriate automated testing tools that suit the project and build test automation infrastructure; and
- analyze the results of test automation after the work is done.
A test strategy is made specifically for one project and takes all its peculiarities into account. A correct test automation strategy ensures higher ROI, better test coverage, more comprehensive testing, and increased reliability of tests. A smart automation strategy allows a company to stay on top of the market and produce higher-quality products.
Now that you understand the value and goals of a test automation strategy, it’s time to review the steps that we at MindK use personally to build a working test automation strategy tailored to the project goals. You can use these steps when building a test automation strategy for your own project.
How to build a test automation strategy step by step
Step 1. Set automation goals and high-priority cases.
Your first step to any successful project is careful planning. Same for automation testing. If you can’t or don’t need to automate everything, be smart about your priorities if you are focusing on high ROI. That’s why the most important thing at this stage is to define the scope of testing.
Repetitive, mundane, and time-consuming activities are the easiest points to automate. At the same time, only the most valuable cases justify the investments. Pay attention to test cases that:
- are critical from a business point of view;
- carry a high risk of failure;
- have to be executed repeatedly;
- involve large data sets;
- tests different browsers/environment/devices/operating systems (OSs);
- can’t be executed manually or take a lot of time;
- result in a clear Pass/Fail; and
- check stable features.
With all that in mind, tests that can provide the most value when automated involve:
- Unit tests: they have the highest ROI and should ideally form the backbone of your automation testing strategy. Developers can write unit tests to check the smallest pieces of their code and find bugs on their own.
- Integration/API testing: as modern applications rely heavily on APIs (Application Programming Interfaces), testing them allows you to validate the app’s behavior and business logic. It makes sense to automate as many of your API tests as possible. Prioritize cases that require regular testing. Identify where the changes to the code can affect the API functionality and target those areas.
- Regression tests: finding out that the feature you’ve used for ages stopped working after an update is one of the things that can make anybody go ballistic. Each time new functionality is introduced into your app, you need to check whether it breaks the existing features. Regressions should be your next priority, as they return investments after each successful build.
- Cross-browser tests: it’s hard to guarantee your software works correctly on all devices/OS/browsers/screen resolutions with manual testing alone. To increase the ROI from test automation, check only the most common combinations your target audience uses and focus on high-risk features.
- Data-driven tests: entering every possible combination of correct/incorrect username and password manually is extremely tedious. But with automation tools, generating this data is quick and simple. Automated testing can be used to generate massive amounts of quality data for manual tests.
Take into account that automating the unit interface (UI or GUI) tests is highly impractical. These tests are expensive, require heavy maintenance, and return the highest number of false positives or negatives.
Automation testing pyramid
At the same time, there are tests that are not worth test automation efforts, like:
- tests that will be executed a single time (except for the data-driven and regression tests);
- UX tests;
- tests without clear Pass/Fail results;
- tests based on visual perception;
- tests that cover raw and unstable functionality;
- ad hoc and exploratory testing allowing one to check the system based on your knowledge of its internal workings and experience;
- testing the anti-automation features (for instance, CAPTCHA); and
- testing native features on Android/iOS devices, as their security measures hinder automation.
Business priorities change over time and stable features tend to have fewer bugs, so you should periodically reconsider which cases should remain on your automation list.
Step 2. Hire a test automation expert or a team
This step is relevant for those who don’t have an internal team of TA engineers, so if this isn’t about you – feel free to move on to step 3. After you’ve decided on a set of cases you need to test, it’s time to build a team to assist with the execution.
Hiring an automation engineer can be a hard nut to crack, especially if you want them to be capable of building multi-faceted scripts. Here are a few tips that can reduce the number of difficulties down the road:
- Pay attention to whether the TA specialist determines what cases should be automated. As we already mentioned, automating all cases is a terrible approach that will simply complicate management and make execution results less insightful. A good TA engineer is capable of evaluating which cases are crucial for automation, those that could be automated in the future, and those that should remain manual entirely.
- Give preference to engineers experienced with a variety of tools. You lose diversity and independence by having a TA specialist devoted to the advantage of one or a limited number of tools. A good TA engineer should be open to new test automation tools and up-to-date on the latest solutions, both open-source and commercial.
- Describe your requirements. You must be aware of what you are looking for. Instead of merely reviewing engineer CVs, identify the type of test you want to run and ensure a candidate is well-versed in this area.
Here at MindK, we help companies that lack experience in test automation to receive all the benefits that come with it. We offer three types of test automation services to fit your individual needs and project requirements – test automation-as-a-service, test automation consulting, and QA team augmentation. Check out more about what we can do for you on our Test Automation service page.
Step 3. Choose the right testing tool and frameworks
When you have a team to move forward with and a list of cases that should be covered, it’s important to select the right technologies. You, together with your TA engineer, must choose one of the several test automation tools. That can be a challenging process. To choose the right test automation framework for your project, you must first completely grasp your project’s needs.
Think about your tech stack. The tool must support the programming languages used on the project as well as the operating systems your testers are comfortable with.
In the case of mobile apps, you’ll also have to consider the supported platforms. If you target two platforms (for example, iOS and Android), you can either choose a tool that supports both iOS and Android (like Selenium, Appium) or uses separate testing suites (for example, Robotium for Android, UI Automation for iOS).
If your project is written in JS, consider using it for test automation as well. If you have a solution using another programming language, Java, for example, it’s better to use that. It’s not critical, but this technique doesn’t grow your tech stack and helps you to ease into the process while helping to avoid unanticipated complications.
Check if the tool has the right balance between ease of use and advanced features (depending on your requirements and the team’s skill).
Analyze whether the tool provides comprehensive reports to help QA engineers trace the point of failure and share the results with stakeholders.
Consider your budget. There is a great number of tools you can choose from, both open-source and commercial. The latter often provide better support and educational resources. If you’re ready to spend money on a commercial tool, you can start a free trial and experiment with a small project before buying the full package.
There are two types of licenses associated with commercial tools. Development licenses limit the number of machines on which you can write the scripts. Runtime licenses do the same for executing the scripts. With a commercial tool, you’ll need to buy both to automate your tests. With an open-source tool, you get both for free.
The last things to consider are customer support, the availability of training resources, and whether the tool integrates with your Continuous Integration (CI) suite and project management software.
On our projects, we sometimes end up building a custom test framework based on a free open-source tool like Selenium. First of all, creating a custom testing framework gives full control of your testing process. The result is easier maintenance, better scalability, and a large open-source community for support. Second, it doesn’t cost the client an arm and a leg.
Step 4. Identify risks and limitations
Risk analysis is, of course, a vital aspect of project planning in general, but it is especially significant for test automation as well. The risk analysis is carried out by compiling a list of possible risks that are qualified with the following information:
- Description of the possible risk.
- Severity: answers the question of what happens if the risk happens and how it influences the project.
- Probability: explaining what the chances are.
- Risk mitigation: describing what can be done to reduce or prevent the risk.
- Estimated cost: predicting the cost of mitigating and ignoring the risk.
Example of test automation risk analysis
Step 5. Set up test automation environment
The testing environment is a collection of software and hardware required to run tests. Setting things up correctly is the foundation of a good testing session.
An automated test environment eliminates the need for manual provisioning, configuration, and data management. It also assures that all processes associated with and related to software development testing are seamless and fully integrated. Here’s a quick checklist for preparing your environment for automated testing:
- Make sure all the needed equipment is available and the system has all the applications needed for testing. It’s important to also make sure that the team knows how to use all the apps needed for successfully navigating the environment.
- Examine the availability of standard datasets. Remember that test data should be obtained prior to the script running; otherwise, the test will take too long to complete.
- Assign the task of maintaining the environment to a specific member of the team. This team member will be in charge of the servers, hardware, and software.
- Make sure that the test environment is always available to the team. In case the test environment is shared with the development team, the departments need to have their own time periods. Otherwise, it will end up with misleading test results and damage the entire process.
- Ensure that connectivity has been established upfront. This is especially significant if you deal with a sophisticated environmental configuration.
Step 6. Design and execute the tests
Once you’ve developed your automation strategy and picked the right tools, start writing the scripts. There are a few industry best practices we follow at MindK when writing and executing TA scripts to increase automation testing ROI:
- Adopt Behavior-Driven Development (BDD). This approach to software development helps engineers and stakeholders be on the same page.
While designing an app, the team writes requirements in the form of user stories: I as a [role] want [feature], so that [reason]. This allows the whole development team to see the product through the user’s eyes and better understand how to build and test it.
BDD makes your application more testable by breaking the system into independent features. A user story itself provides an acceptance test that shows whether the feature fulfills its intended purpose.
- Use Page Object Pattern in GUI tests. The primary goal of automation is to save time. Updating the scripts and resolving conflicts shouldn’t take longer than the time saved on automating your tests.
With the Page Object Pattern, you separate the code that interacts with the UI from the test logic and wraps it in PageObjects (app-specific API). This results in less time needed to adapt tests to the UI changes, simplifying the maintenance. Page object pattern complements behavior-driven development. It decreases code duplication and increases test readability.
- Run tests in parallel. To increase the testing speed, it’s often necessary to run your scripts in parallel. Selenium Grid, for example, allows testing across several machines with different combinations of browsers and operating systems. You can integrate Selenium Grid with Jenkins and other CI development tools. The tests can be triggered automatically and their results stored together with the relevant tasks.
- Data-drive your tests. A data-driven approach to test automation allows us to reuse automated test scripts. New cases can be generated by changing the data stored in external files. To get the most out of this approach, parametrize both the input data and the expected output data.
- Set up reporting. Following the execution of a set of tests, it’s important to set up reporting so that the team can see test automation results in an easy and understandable manner.
Step 7. Maintain the testing suite
Without proper maintenance, automation scripts tend to break when some part of the app changes. That’s why proper planning is crucial for automated testing. You can save a lot of money in the long run if you select the test cases that would stay relevant in the future and insulate your scripts against possible changes. Here’s what can be done to improve test maintenance:
- Create small test cases to make maintenance easier. For example, to check a confirm your order button, manual testers log into the app, navigate to the shopping cart, fill in all the necessary data and only then press the button. Such huge cases won’t work for automated tests. It’s better to break them into smaller cases, each focused on one objective. So pressing the button would be separated from navigation and so on.
This way, tiny changes to the system won’t break the whole chain of actions. Later, you can combine these small tests into complex workflows.
- Keep the right balance between unit, API, and GUI tests. Remember, UI-dependent tests are extremely sensitive to changes. One of the ways to make them less brittle is to use the page object pattern we mentioned earlier. It would make your automation scripts easier to maintain.
- Apply the TestOps approach. Consider a testing framework that constantly tests and verifies the product at various levels. A test framework that not only integrates automated tests into the CI/CD pipeline, but also keeps the entire testing environment running. It is all possible with DevOps-style automation for QA. It’s called TesOps.
TestOps is an approach that encourages close collaboration across QA, development, and operations teams in order to lower development costs, while maintaining quality.
TestOps connects the test framework with technologies such as, for example, Selenium, Docker, BrowserStack, and Jenkins, to ensure that tests are as robust as possible while using the least amount of time. The primary concept is to combine all of the tools and frameworks into a pipeline in order to detect failures early in the process and respond to them quickly.
Unfortunately, many companies realize they have trouble with maintenance when it’s already too late. They face a choice: to continue losing money on inefficient scripts or rethink their approach to automation. So, don’t be one of them and think of maintenance in advance.
What does a test automation strategy look like: MindK example
There is no standard one-size-fits-all template for test automation strategy. It can be displayed in any way, like a document, presentation, mindmap, or similar. The more important thing is the information it comprises. Let’s review an automation test strategy example made for one of our clients.
The client came to us for help with test automation having three main goals – improving system stability and reliability, minimizing testing time and human effort, and increasing quality in the long run.
We’ve analyzed the project and signed out the test scripts that are in and out of the test automation scope. As a result, the high-priority test automation scope involved API and UI test scripts.
After it was done, we analyzed the technology of the project and came up with a test automation approach both for API and UI test scripts separately. The API testing approach, for example, involves test automation coverage details, the tools used, the implementation process, and limitations.
In addition to these, we considered the reporting process in the test automation strategy beforehand. The test reports provide information regarding the quality of test automation. That’s why their role is paramount in analyzing the performance.
In addition to this, we’ve created a tailor-made test automation architecture diagram to show how the test automation runs from start to finish and documented the test execution post-processing guidelines.
For example, if any failed case appears during the test execution, the QA engineer finds out what exactly caused it and takes appropriate actions. If the reason for the failed case is a system bug, then the QA engineer reports the problem to the development team. If there is a problem with the test script (for example, some changes were made in the system functionality), then the QA engineer fixes the test script code and re-runs the test execution.
If you’re facing any problems with test automation, our team can analyze your current approach and suggest the best course of action. When you’re ready to talk, just drop a line on our contact form.