Intermediate¶

Level: Intermediate ~ Level: Advanced

Fixture¶

If many of your tests share the same dependency, pytest provide a convenient way to facilitate such situation: fixture.

Readings¶

• The official site has a brief introduction and some very good examples, it's advised for you to read and try out the examples by yourself.
• https://docs.pytest.org/en/7.1.x/how-to/fixtures.html#how-to-fixtures A more detailed explanation of more usages.
• https://docs.pytest.org/en/7.1.x/reference/fixtures.html#reference-fixtures elaborates more on fixture availability and instantiation order topics.

Try this out¶

Here is a very simple case to show how to use fixtures.

Setup the files as below:

.
├── cats.py
└── test_cats.py

1
2
3
4
5
6
7
8
9

class Cat:
    def eats(self, food: str) -> bool:
        return food in ["cookies", "candies", "fish", "apples"]

    def drinks(self, drink: str) -> bool:
        return drink in ["milk", "water", "juice"]

    def chase(self, thing: str) -> bool:
        return thing in ["mouse", "cat", "bird", "laser pointer"]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

def test_cat_eats():
    cat = Cat()
    assert cat.eats("fish")

def test_cat_drinks():
    cat = Cat()
    assert not cat.drinks("coffee")

def test_cat_chases():
    cat = Cat()
    assert not cat.chases("fish")

In the highlighted lines in test_cats.py, we need to create the instance of Cat multiple times.

Let's rewrite the test with a fixture. We need to create a new file conftest.py.

.
├── conftest.py
├── cats.py
└── test_cats.py

1
2
3
4
5
6
7

import pytest
from cats import Cat


@pytest.fixture
def cat():
    return Cat()

1
2
3
4
5
6
7
8
9

class Cat:
    def eats(self, food: str) -> bool:
        return food in ["cookies", "candies", "fish", "apples"]

    def drinks(self, drink: str) -> bool:
        return drink in ["milk", "water", "juice"]

    def chase(self, thing: str) -> bool:
        return thing in ["mouse", "cat", "bird", "laser pointer"]

1
2
3
4
5
6
7
8

def test_cat_eats(cat):
    assert cat.eats("fish")

def test_cat_drinks(cat):
    assert not cat.drinks("coffee")

def test_cat_chases(cat):
    assert not cat.chases("fish")

With a fixture, we can directly use the name of the fixture as an argument of our test function.

Now let's add more test cases using pytest.mark.parametrize introduced in the previous tutorial.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

import pytest


@pytest.mark.parametrize(
    "food, result",
    [
        ("fish", True),
        ("cookies", True),
        ("laptop", False),
    ],
)
def test_cat_eats(food, result, cat):
    assert cat.eats(food) == result


@pytest.mark.parametrize(
    "drink, result",
    [
        ("milk", True),
        ("water", True),
        ("coffee", False),
    ],
)
def test_cat_drinks(drink, result, cat):
    assert cat.drinks(drink) == result


@pytest.mark.parametrize(
    "thing, result",
    [
        ("cat", True),
        ("mouse", True),
        ("crocodile", False),
    ],
)
def test_cat_chases(thing, result, cat):
    assert cat.chases(thing) == result

Now, run pytest:

$ pytest test_cat.py

collecting ...
 test_cat.py ✓✓✓         100% ██████████

Results (0.03s):
      9 passed

You perhaps have a sense of what fixtures is capable now, there are some further practice you can continue to do by yourself.

Further Practice¶

• Write a simple fixture
• Use multiple fixtures
• Use fixtures inside fixtures
• Autouse a fixture
• Write fixtures with different scopes
• Setup and teardown
• Parametrize fixtures

Mock and Monkeypatch¶

mock and monkeypatch are frequently used if some actions are not expected to run during tests. For example, creating real payloads, connecting to external services, or access some environments which won't exist in the testing environment.

Readings¶

• The official unittest - mock introduces how to use the mock library to write tests.
• Pytest - Monkeypatch provides how to use monkeypatch to mock modules and environments.