How to Automate Regression Testing with Python

In the ever-evolving landscape of software development, ensuring the stability and reliability of your application with each code change is paramount. One of the most efficient ways to achieve this is by implementing regression testing. Regression testing helps ensure that new code changes do not introduce defects into previously working functionality. Automating regression tests not only saves time but also increases the reliability of your software.

In this article, we will explore how to automate regression testing using Python. We will cover various techniques, libraries, and frameworks that will enable you to streamline your regression testing process and integrate it with your CI/CD pipeline for continuous quality assurance.

Understanding Regression Testing

1.1 What is Regression Testing?

Regression testing refers to the process of running a set of tests to verify that recent code changes have not negatively affected the existing functionality of the software. It ensures that the software still works as expected after enhancements, bug fixes, or other changes have been made to the codebase.

Regression tests typically cover:

• Core functionality: Verifying that critical features of the application still function correctly.
• Previous bugs: Ensuring that bugs that were fixed earlier remain fixed.
• New functionality: Ensuring that new features do not interfere with the old ones.

1.2 Why Automate Regression Testing?

Automation of regression testing is crucial due to several reasons:

• Time-saving: Manually testing each part of the application can be time-consuming. Automation allows for quick reruns of tests.
• Consistency: Automated tests eliminate human error and ensure that tests are executed in exactly the same way every time.
• Scalability: As your codebase grows, running automated regression tests ensures that you can scale your testing process accordingly.
• Continuous Integration/Continuous Deployment (CI/CD): Automated regression tests can be seamlessly integrated into your CI/CD pipeline, ensuring that every change to the codebase is validated quickly.

Setting Up the Environment for Automated Regression Testing in Python

Before diving into the code, let's ensure that the necessary tools and libraries are installed. Python offers various libraries to automate testing, and for regression testing, we will primarily focus on unittest, pytest, and Selenium.

2.1 Install Python and Required Libraries

If you don't already have Python installed, download and install it from the official website: Python Downloads.

Once Python is installed, create a virtual environment to manage dependencies:

source regression-env/bin/activate  # On Windows: regression-env\Scripts\activate

Install necessary libraries:

• pytest: A popular testing framework that offers a simple syntax and powerful features for running tests.
• unittest: Python's built-in testing library that is also used for writing and running tests.
• selenium: A powerful web testing tool for automating browser-based applications, useful for testing web applications in regression.

2.2 Setting Up WebDriver for Selenium

If you plan to perform browser automation with Selenium, you will need to download a WebDriver compatible with the browser you intend to use.

For example, for Chrome, download ChromeDriver and make sure it matches the version of Google Chrome you are using. Place the driver in a directory that is included in your system's PATH.

Writing Your First Automated Regression Test with Python

3.1 Using unittest for Basic Regression Tests

Python's built-in unittest library is great for simple, structured test cases. Let's start by writing a basic test suite for a function that calculates the sum of two numbers.

Example: calculator.py

    return a + b

def subtract(a, b):
    return a - b

Test Case: test_calculator.py

from calculator import add, subtract

class TestCalculator(unittest.TestCase):

    def test_add(self):
        self.assertEqual(add(3, 4), 7)
        self.assertEqual(add(-1, 1), 0)
        self.assertEqual(add(0, 0), 0)

    def test_subtract(self):
        self.assertEqual(subtract(5, 3), 2)
        self.assertEqual(subtract(3, 3), 0)
        self.assertEqual(subtract(3, 5), -2)

if __name__ == "__main__":
    unittest.main()

Running the Tests

To run the tests, simply execute the following command in the terminal:

The output will show if all tests pass or fail, providing a simple feedback mechanism.

3.2 Using pytest for More Advanced Features

While unittest is excellent for structured tests, pytest offers more features and a more flexible syntax, which makes it ideal for more complex test scenarios. Here's how you can rewrite the previous test cases using pytest.

Test Case: test_calculator.py (with pytest)

from calculator import add, subtract

def test_add():
    assert add(3, 4) == 7
    assert add(-1, 1) == 0
    assert add(0, 0) == 0

def test_subtract():
    assert subtract(5, 3) == 2
    assert subtract(3, 3) == 0
    assert subtract(3, 5) == -2

Running the Tests

With pytest, running the tests is even simpler:

pytest will automatically detect any functions starting with test_ and execute them. It will display a clean output with detailed information about any failures or successes.

Incorporating Selenium for Web Application Regression Testing

For web applications, Selenium is an excellent tool for automating regression tests. Here, we'll create a simple regression test for a login page.

4.1 Setting Up Selenium WebDriver

First, let's import the necessary libraries and set up the Selenium WebDriver:

from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
import unittest

class TestLoginPage(unittest.TestCase):

    def setUp(self):
        self.driver = webdriver.Chrome(executable_path="path_to_chromedriver")

    def test_login(self):
        driver = self.driver
        driver.get("http://example.com/login")

        username = driver.find_element(By.NAME, "username")
        password = driver.find_element(By.NAME, "password")
        login_button = driver.find_element(By.NAME, "login")

        username.send_keys("user1")
        password.send_keys("password123")
        login_button.click()

        assert "Dashboard" in driver.title

    def tearDown(self):
        self.driver.quit()

if __name__ == "__main__":
    unittest.main()

4.2 Running Selenium Tests

To run the Selenium regression tests, execute the following command:

This test will open a browser window, navigate to the login page, enter credentials, and verify that the page redirects to the dashboard.

Integrating Regression Tests with CI/CD Pipelines

5.1 Continuous Integration (CI)

By integrating your regression tests into a CI pipeline, you can ensure that your tests are automatically executed every time changes are made to the codebase. Tools like Jenkins, GitHub Actions, and GitLab CI can be used to run Python-based tests in an automated fashion.

For instance, with GitHub Actions , you can create a .github/workflows/test.yml file:

on: [push]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v2

      - name: Set up Python
        uses: actions/setup-python@v2
        with:
          python-version: '3.9'

      - name: Install dependencies
        run: |
          python -m pip install --upgrade pip
          pip install -r requirements.txt

      - name: Run tests
        run: |
          pytest

This configuration ensures that every push to the repository triggers a test run.

5.2 Continuous Deployment (CD)

You can extend your CI pipeline to deploy your application automatically to different environments after successful testing. For example, if all tests pass, you can trigger the deployment to a staging or production environment using Jenkins or other tools.

Conclusion

Automating regression testing with Python is a powerful way to ensure the quality and stability of your software. By leveraging Python's built-in unittest module, the flexible pytest framework, and the browser automation capabilities of Selenium, you can efficiently automate regression tests for both backend and web applications.

Additionally, by integrating your tests into a CI/CD pipeline, you can ensure that regression testing is continuously executed as part of the development process, allowing you to catch bugs early and maintain the integrity of your codebase.

Automated regression testing is not just a technical necessity; it is a critical aspect of modern software development that enables teams to deliver robust and high-quality products with confidence.

View Product