2.3. Simple Test Example

Unlike unittest, pytest allows writing test functions without classes:

def add(a, b): return a + b

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

This chunk introduces the concept of simple testing in pytest. In contrast to the unittest framework, which requires test cases to be organized into classes, pytest allows us to write test functions directly. Here, the add function is defined, which takes two parameters and returns their sum. The test_add function is a test that checks if the add function works correctly by asserting that adding 1 and 2 returns 3.

Think of testing like checking if a recipe is correct. Instead of writing a long report (like in unittest), you can just quickly taste-test the dish (like in pytest) to check if it tastes good. In this case, you are directly asking, 'Does this dish (the function) taste good when I combine these flavors (the inputs)?'

Fixtures provide setup and teardown mechanisms through decorators:

import pytest

@pytest.fixture def sample_list(): return [1, 2, 3]

def test_sum(sample_list): assert sum(sample_list) == 6

This chunk explains how to use fixtures in pytest, which are reusable pieces of code that can set up some context or state for tests. The @pytest.fixture decorator is used to define a fixture named sample_list, returning a simple list of numbers. The test_sum function uses this fixture to assert that the sum of the numbers in sample_list equals 6. This allows for organized and DRY (Don't Repeat Yourself) testing code.

Envision you're setting up for a game. Before starting, you need to lay out the game board (the fixture). All players gather around the table with the pieces ready. The actual games (tests) can now begin smoothly because everything is set up properly—a perfect example of using a fixture to prepare for success!

@pytest.mark.parametrize("a,b,expected", [(1,2,3), (4,5,9), (10,10,20)]) def test_add_param(a, b, expected): assert add(a, b) == expected

This chunk introduces parameterized tests, a powerful feature in pytest that allows a single test function to be called multiple times with different arguments. The @pytest.mark.parametrize decorator is used to specify multiple sets of inputs and expected outcomes for the test_add_param function. Each tuple represents different inputs for add, allowing for thorough validation of the function against various scenarios.

Imagine you are testing different combinations of ingredients for a smoothie. Instead of making each smoothie one at a time and checking the taste, you prepare several recipes at once (like the parameterized tests). You mix, taste, and verify, ensuring that every recipe is tested efficiently!

Plugins add capabilities like coverage reports (pytest-cov), parallel test runs (pytest-xdist), and more.

The final chunk emphasizes the extensibility of pytest through plugins. pytest has a vibrant ecosystem where plugins can add additional functionalities to the testing framework. For example, plugins can automate the creation of coverage reports to see how much of your code is tested (with pytest-cov), or run tests in parallel to save time (with pytest-xdist). This flexibility allows developers to tailor the testing experience to their needs.

Think of pytest plugins like adding apps to your smartphone. Each app gives your phone new capabilities—like navigating (maps), ordering food, or chatting with friends. Similarly, by using plugins with pytest, you enhance your testing framework, making it more versatile and capable of handling various tasks without being limited to just the built-in functionalities.

--