Objective

In this unit, you will learn about the importance of testing in software development and how to write and run tests for your Python code using pytest. By the end of this unit, you should be able to write unit tests using pytest and understand how to interpret the results of those tests.

Introduction to Testing

Testing is a crucial part of software development that helps ensure that your code works as expected. By writing tests, you can verify that your code behaves correctly under various conditions and inputs. This not only helps catch bugs early but also makes it easier to maintain and extend your code in the future.

Unit testing is the process of testing individual components of your code in isolation from the rest of the program. In this unit, we'll focus on unit testing using the popular testing framework pytest.

Writing Unit Tests with pytest

pytest is a popular third-party testing framework that provides a more concise and flexible way to write tests.

You can install it using pip:

pip install pytest

Here's a basic example of how you might write tests using pytest:

def add(x, y):
    return x + y

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

In this example, we've defined a simple function add and a test function test_add that checks if the function works correctly. With pytest, you can use plain assert statements, making the tests more readable.

The assert statement simply checks if the condition that follows is true. If the condition is false, then an exception is raised and the program is terminated.

As you can see in this example, testing will generally involve checking the output or functionality of one or more functions. That means writing good unit tests starts with organizing your program into functions that perform specific, well-defined tasks that can be easily tested.

Running Tests with pytest

To run the tests, you can simply execute the command pytest in your terminal. pytest will automatically discover and run all the test functions in your project that are prefixed with test_.

NOTE pytest will discover all files in your project folder that have a prefix of test_ or a suffix of _test. Otherwise, you can run pytest on a specific file using the syntax pytest <filename>.

Within each file, pytest will automatically execute all functions that are prefixed with test_.

Interpreting Results

pytest provides a detailed summary of how many tests passed and failed. Failed tests will include details about what went wrong, helping you identify and fix issues in your code.

Advanced Features

pytest also offers many advanced features, such as:

• Fixtures: Reusable testing components.
• Parameterized Testing: Running the same test with different input values.
• Plugins: Extending pytest with additional functionalities.

You can explore these features in the official pytest documentation.

Testing Methodology

Most software developers will tell you that testing is part art and part science. It takes practice and patience to learn how to write your code so that it's well organized and easily testable.

In general, writing good unit tests includes the following process:

1. Identify Testable Components: Look at your program and identify functions or methods that can be tested in isolation.
2. Write Tests with pytest: Write tests for those components using pytest. Consider different scenarios and edge cases.
3. Run and Interpret Tests: Run your tests and interpret the results. If any tests fail, investigate why and fix the underlying issues in your code.
4. Refactor and Repeat: As you continue to develop your program, keep writing tests for new components and refactor existing tests as needed.

Testing is an ongoing process that continues throughout the development lifecycle. By investing in writing and maintaining tests, you'll build more robust and maintainable code.

Project: Write Tests for Your Turtle Drawing Program

For this project, we'll write a simple drawing program and add unit tests to test its functionality.

Let's start with a familiar program to draw a shape based on the number of sides that were passed in.

In a new project folder, let's create a new file called main.py with the following code:

# main.py

import turtle

def draw_shape(sides):
    angle = 360 / sides
    for _ in range(sides):
        turtle.forward(100)
        turtle.left(angle)
        
    # Return the angle so we can test if it was calculated correctly
    return angle

def main():
    sides = int(input("Enter the number of sides for the shape (3 or more): "))
    if sides < 3:
        print("Number of sides must be 3 or more.")
        return

    turtle.speed(1)
    draw_shape(sides)
    turtle.done()

if __name__ == "__main__":
    main()

This program asks the user for the number of sides and then draws the corresponding shape using the Turtle graphics library.

Now, let's write some unit tests for the draw_shape function. In the same project folder, create a new file called test_shapes.py with the following code:

# test_shapes.py

from main import draw_shape
import turtle

def test_line():
    turtle.reset()
    angle = draw_shape(2)
    assert angle == 180
    assert turtle.heading() == 0

def test_triangle():
    turtle.reset()
    angle = draw_shape(3)
    assert angle == 120
    assert turtle.heading() == 0
    
def test_square():
    turtle.reset()
    angle = draw_shape(4)
    assert angle == 90
    assert turtle.heading() == 0
    
def test_pentagon():
    turtle.reset()
    angle = draw_shape(5)
    assert angle == 72
    assert turtle.heading() == 0

These tests draw shapes with different numbers of sides and then checks the expected angle and that the turtle's heading is back to its original position, which should be the case if the shape is closed.

To run the tests, run the following command in your project folder:

pytest

pytest will automatically discover and run all the test functions in your project that are prefixed with test_. If all tests pass, you'll see a summary indicating success. If any tests fail, pytest will provide details about what went wrong, helping you identify and fix issues in your code.

By writing tests for your code, you ensure that it behaves as expected under various conditions. And while testing graphical output can be complex, you can still write meaningful tests to verify the logic of your code. This helps ensure that your code behaves as expected and makes it easier to maintain and extend in the future.

In the next unit, we'll switch gears a bit and explore how to manage and collaborate on code projects using Git and GitHub.