The dominant trend in modern software delivery is the move away from deploying big releases on an infrequent basis in favor of deploying smaller releases with much greater frequency. But shortening development schedules puts pressure on everyone to deliver faster in order to meet sprint deadlines. And of course, you can’t sacrifice quality.
The result has been a sharp focus on automation technologies and process automation, including those that can help validate application features in shorter time frames. That’s where automated testing comes in.
Automated testing is a software testing technique in which scripts are developed to repeatedly validate an application’s functionality. While not all tasks lend themselves well to automation, the more features and functionality you can cover with automated techniques, the more likely you are to make your deadlines.
This post provides an overview of the ways in which automated testing strategies can benefit software development organizations, as well as a look at some of the excellent Python libraries that can be used to build reusable scripts.
Get Started: Install Test Automation Tools With This Ready-To-Use Python Environment
If you’d like to try out the test automation tools in this blog post, the simplest way is to install the Test Automation Python environment for Windows, Mac or Linux.
This environment contains a version of Python and all the Python packages you’ll need for test automation in this tutorial:
- setuptools 51.2.0
In order to download these ready-to-use builds you will need to create an ActiveState Platform account. Just use your GitHub credentials or your email address to register. Signing up is easy! And it unlocks the ActiveState Platform’s many benefits for you.
For Windows users, run the following at a CMD prompt to automatically download and install our CLI, the State Tool along with the Test Automation runtime into a virtual environment:
powershell -Command "& $([scriptblock]::Create((New-Object Net.WebClient).DownloadString('https://platform.activestate.com/dl/cli/install.ps1'))) -activate-default Pizza-Team/Test-Automation"
For Linux or Mac users, run the following to automatically download and install our CLI, the State Tool along with the Test Automation runtime into a virtual environment:
sh <(curl -q https://platform.activestate.com/dl/cli/install.sh) --activate-default Pizza-Team/Test-Automation
The Benefits of Automated Testing
It goes without saying that testing is critical for ensuring software quality. Typically organizations use either manual testing, automated testing, or (more commonly) a mix of both. But prioritizing automated testing over manual testing results in a number of benefits, including:
- Eliminate Human Error – Anything that is done manually is subject to human error, and software testing is no exception. It only makes sense that the likelihood of human error increases along with the complexity of the test case.
Automated testing removes human error from the equation. Test scripts can be run repeatedly against a code base, yielding accurate results each time.
- Increase Test Coverage – Manual testing is much more time consuming than automated testing. As such, teams are forced to prioritize which features and use cases are most important to focus on for the application’s viability. With automated testing, however, there is less overhead, which means organizations do not have to pick and choose what gets tested.
As the application evolves, a development and/or QA team can add additional test scripts to their automated testing suite, thereby increasing the percentage of features that are fully validated with each application build.
- Find Bugs Sooner – Automated test scripts are executed as part of the application build process via a CI/CD pipeline. So, as developers commit changes to their code base, they can run the entire automated test suite to ensure that no existing features have been broken in the process. If a build fails due to not passing a test case, the developer who introduced the bug will receive immediate feedback regarding the problem.
Bugs are less expensive to fix when they are found earlier in the development process. For example, less refactoring will likely be required if bugs are caught earlier rather than towards the end of a major implementation. In addition, this protects the delivery schedule by reducing the likelihood that major issues will survive late into the development cycle.
How to do Automated Testing using Python
With the aforementioned advantages in mind, let’s explore automated application testing using Python. Due to its gentle learning curve, Python can be an appealing choice for organizations with QA personnel who are attempting to transition from manual testing to automated test script development. There are also many Python testing libraries and frameworks which can help simplify the process. Let’s take a look at a few.
Selenium is an open-source browser automation framework for validating web application features across various browsers and platforms. An extremely popular framework, Selenium maintains support for many of the major web browsers. It works with most major operating systems (Windows, Mac OS, Linux, and Solaris), and it contains bindings for most popular programming languages including Python (specifically version 3.5 and above).
Selenium works by allowing developers to automate tasks within various web browsers through the utilization of browser-specific drivers. These web drivers allow developers to leverage Selenium’s functionality to test common browser interactions such as logging in to a web application, clicking buttons and links, and filling in forms. Getting started is as easy as installing the Selenium Python bindings and downloading the drivers for the browsers in which you wish to test your application.
Robot is another open-source framework for Python developers who are implementing an automated testing strategy. The Robot framework, which is hosted on GitHub, is extremely well-maintained and well-documented, which provides some assurance that this route will be supported for years to come.
The Robot framework can be leveraged for acceptance testing, acceptance Test-Driven Development (TDD), behavior-driven development, and Robotic Process Automation (RPA). Test cases can be keyword-driven, data-driven, or behavior-driven, which enables teams to stay organized and maintain test case readability. It is also highly flexible and has a public API that you can use for building custom testing tools. If you want to investigate this framework further, check out how to build good test cases using Robot.
Python’s venerable pytest package is a testing framework for developing scalable tests in an easy and readable manner. It is capable of building tests that satisfy both simple and complex test cases, and it’s installable via pip.
Python’s pytest library provides detailed assertion analysis that allows for the use of simple assert statements. In addition, pytest is equipped to recognize files in the same directory with the following naming conventions:
For example, consider the following test scripts that are stored in the same directory:
return x * 2
assert multiply_by_two(4) == 8
return x + 7
assert add_seven(1) == 10
Both of these test scripts can be run by executing the pytest command from the host directory. They provide insight into test failures and also simplify the process of developing test suites.
Here is the output of our hypothetical scenario:
============================= test session starts =============================
platform win32 — Python 3.7.4, pytest-6.1.0, py-1.9.0, pluggy-0.13.1
collected 2 items
sample_test.py . [ 50%]
test_sample2.py F [100%]
================================== FAILURES ===================================
_______________________________ test_add_seven ________________________________
> assert add_seven(1) == 10
E assert 8 == 10
E + where 8 = add_seven(1)
=========================== short test summary info ===========================
FAILED test_sample2.py::test_add_seven – assert 8 == 10
========================= 1 failed, 1 passed in 0.26s =========================
Test Automation: Key Takeaways
Automated testing provides software organizations with several benefits that are critical to the development of high-quality applications despite shortened development cycles. These include:
- Eliminating the risk of inevitable human error in organizations that are heavily-reliant on manual testing processes.
- In comparison to testing manually, automating the testing process means that tests can be run with greater frequency and in less time. This allows development and QA personnel to expand their test strategy and increase overall test coverage.
- Automated testing increases software quality and reduces the likelihood of bugs that threaten the delivery schedule. By enabling organizations to test early and often, bugs can be found sooner, when they are less expensive to fix.
Finally, with the availability of numerous high-quality Python testing libraries, Python is an excellent option for developing a thorough and impactful automated testing strategy.