Als je het schrijven van toetsen hebt vermeden omdat ze een hele klus zijn, zou deze pytest-tutorial je van gedachten moeten doen veranderen. Pytest verwijdert het grootste deel van de ceremonie: er zijn geen klassen om van te erven en geen speciale beweringsmethoden om te onthouden. Een test kan uit slechts twee regels bestaan.

We bouwen een klein winkelwagentje en testen het stap voor stap. We hebben alles op Python 3.13 uitgevoerd met pytest 9.2, en de getoonde uitvoer is echt, hoewel we de bestandspaden en timingdetails hebben bijgesneden die op uw machine zullen verschillen.

Waarom pytest?

Python wordt geleverd met unittest, wat goed werkt, maar pytest is meestal de handigste keuze. Hier is dezelfde cheque in elk:

Pytest kan ook uw bestaande unittest tests uitvoeren, zodat u geleidelijk kunt overstappen. Het heeft ook een groot plug-in-ecosysteem, inclusief pytest-cov voor dekking en pytest-xdist voor parallelle runs.

Installeer pytest

Maak eerst een virtuele omgeving, zoals uitgelegd in onze tutorial over de virtuele Python-omgeving, en installeer deze vervolgens:

pip install pytest
pytest --version

# pytest 9.2.0

Maak een projectmap met twee bestanden, cart.py en test_cart.py. Pytest vindt tests automatisch door de naamgevingsregels te volgen: bestanden met de naam test_*.py of *_test.py, functies die beginnen met test en klassen die beginnen met Test. Als een test niet wordt opgepakt, is een verkeerde naamgeving het eerste dat moet worden gecontroleerd.

De code om te testen

# cart.py
class Cart:
    def __init__(self):
        self.items = []

    def add(self, name, price, qty=1):
        if qty < 1:
            raise ValueError("qty must be at least 1")
        self.items.append((name, price, qty))

    def total(self, discount=0):
        subtotal = sum(price * qty for _, price, qty in self.items)
        return round(subtotal * (1 - discount / 100), 2)

Je eerste testen

# test_cart.py
from cart import Cart

def test_empty_cart_is_free():
    assert Cart().total() == 0

Dat is een volledige test. Voer pytest uit vanuit de projectmap en rapporteert één geslaagde test. Als u een importfout krijgt, voert u deze uit als python -m pytest, waardoor de huidige map aan het importpad wordt toegevoegd.

Fouten bij het lezen

Dit is waar pytest echt schittert. Hier is een test met een opzettelijk verkeerde verwachte waarde:

def test_wrong_total():
    c = Cart()
    c.add("Keyboard", 1500)
    assert c.total() == 1400

En dit is wat het afdrukte toen we het uitvoerden:

    def test_wrong_total():
        c = Cart()
        c.add("Keyboard", 1500)
>       assert c.total() == 1400
E       assert 1500.0 == 1400
E        +  where 1500.0 = total()

FAILED fail_example.py::test_wrong_total - assert 1500.0 == 1400
============================== 1 failed in 0.12s ==============================

De > markeert de falende regel en de E regels tonen de werkelijke waarden. Je hoefde geen aangepast bericht toe te voegen, omdat pytest assert instructies herschrijft, zodat ze kunnen rapporteren wat ze hebben vergeleken. Hetzelfde geldt voor lijsten en woordenboeken, waarbij precies wordt aangegeven welke items verschillen.

Uitzonderingen testen

Foutafhandeling is ook gedrag en verdient tests. pytest.raises slaagt alleen als het blok de verwachte uitzondering oplevert:

import pytest

def test_rejects_zero_qty():
    with pytest.raises(ValueError, match="at least 1"):
        Cart().add("Pen", 10, qty=0)

Het optionele argument match controleert het bericht met behulp van een reguliere expressie, zodat een ander argument ValueError niet per ongeluk voorbijkomt. Lees onze handleiding over Python-uitzonderingsafhandeling voor meer informatie over hoe u dit soort fouten kunt melden en afhandelen.

Armaturen: herbruikbare opstelling

Bij de meeste tests moet eerst iets worden voorbereid. Een fixture is een functie die hierin voorziet. Versier het met @pytest.fixture, en elke test die het als argument noemt, krijgt het resultaat:

@pytest.fixture
def cart():
    c = Cart()
    c.add("Keyboard", 1500)
    c.add("Mouse", 500, qty=2)
    return c

def test_total(cart):
    assert cart.total() == 2500

Elke test krijgt standaard een nieuw winkelwagentje, dus tests kunnen elkaar niet beïnvloeden. Pytest koppelt de argumentnaam aan de naam van het armatuur, en u roept het armatuur nooit zelf aan. @pytest.fixture is een decorateur, wat we uitleggen in Python-decorateurs uitgelegd.

Opruimen met rendement

Gebruik yield in plaats van return als je achteraf moet opruimen. Code na yield wordt uitgevoerd wanneer de test is voltooid, zelfs als deze is mislukt:

@pytest.fixture
def temp_db():
    print("\nopen db")
    yield {"users": []}
    print("close db")

def test_db(temp_db):
    assert temp_db["users"] == []

Het uitvoeren van -s om de afgedrukte uitvoer weer te geven, bevestigde dat de bestelling open was, test en vervolgens werd gesloten.

Armatuurbereik en conftest.py

Standaard wordt een armatuur eenmaal per test uitgevoerd. Voor dure instellingen, zoals een database of browser, verander je de levensduur ervan met scope:

Plaats de apparaten die door verschillende bestanden worden gebruikt in een bestand met de naam conftest.py. Pytest laadt het automatisch, zodat tests de armaturen kunnen gebruiken zonder te importeren. Wees echter voorzichtig met gedeelde scopes, omdat een wijziging die door de ene test wordt aangebracht, naar de volgende kan lekken.

Parametriseren: één test, veel invoer

In plaats van een test voor elke waarde te kopiëren, vermeldt u de gevallen:

@pytest.mark.parametrize("discount, expected", [
    (0, 2500),
    (10, 2250),
    (100, 0),
])
def test_discount(cart, discount, expected):
    assert cart.total(discount) == expected

Elke rij wordt zijn eigen test, en je kunt dit zien in de uitgebreide uitvoer van onze run van het volledige bestand:

test_cart.py::test_total PASSED                        [ 16%]
test_cart.py::test_discount[0-2500] PASSED             [ 33%]
test_cart.py::test_discount[10-2250] PASSED            [ 50%]
test_cart.py::test_discount[100-0] PASSED              [ 66%]
test_cart.py::test_rejects_zero_qty PASSED             [ 83%]
test_cart.py::test_empty_cart_is_free PASSED           [100%]

============================== 6 passed in 0.05s ==============================

Als één rij mislukt, worden de andere nog steeds uitgevoerd en vertelt de naam u precies welke waarden het probleem hebben veroorzaakt. Merk op dat we parametriseren hebben gecombineerd met het armatuur cart. Als u waarden wilt kiezen die waarschijnlijk bugs zullen opleveren, gebruikt u grenswaardeanalyse.

Handige inbouwarmaturen

Pytest bevat diverse kant-en-klare armaturen. Deze twee zijn vooral handig, en beide zijn geslaagd in onze run:

def test_write_report(tmp_path):
    report = tmp_path / "report.txt"
    report.write_text("passed")
    assert report.read_text() == "passed"

def read_mode():
    return os.environ.get("APP_MODE", "dev")

def test_mode(monkeypatch):
    monkeypatch.setenv("APP_MODE", "staging")
    assert read_mode() == "staging"

tmp_path geeft elke test een unieke tijdelijke map, zodat tests nooit echte bestanden raken. monkeypatch verandert omgevingsvariabelen of attributen, en maakt de wijziging ongedaan wanneer de test eindigt. Een andere nuttige is capsys, waarin de afgedrukte uitvoer wordt vastgelegd, zodat u deze kunt controleren.

Markeringen: overslaan en xfail

Markeringen voegen labels en gedrag toe aan tests:

@pytest.mark.skip(reason="payment sandbox is down")
def test_payment():
    assert False

@pytest.mark.xfail(reason="floating point")
def test_rounding():
    assert 0.1 + 0.2 == 0.3

skip voert de test helemaal niet uit. xfail voert het uit, maar verwacht een mislukking, dus een bekend probleem vernietigt je build niet. Met de andere extra tests in hetzelfde bestand, is onze run samengevat als 3 passed, 1 skipped, 1 xfailed. Die afrondingstest faalt overigens echt: in de drijvende-kommaberekening is 0,1 + 0,2 niet precies 0,3. Gebruik pytest.approx(0.3) bij het vergelijken van decimalen.

Je kunt ook je eigen markeringen maken, zoals @pytest.mark.slow, en alleen die met pytest -m slow uitvoeren, of ze weglaten met -m "not slow". Registreer aangepaste markeringen in uw configuratiebestand om waarschuwingen te voorkomen.

Handige opdrachtregelvlaggen

Pytest uitvoeren in CI

Tests zijn het meest waardevol als ze bij elke wijziging automatisch worden uitgevoerd. Een minimale GitHub Actions-taak ziet er als volgt uit:

steps:
  - uses: actions/checkout@v4
  - uses: actions/setup-python@v5
    with:
      python-version: "3.13"
  - run: pip install -r requirements.txt
  - run: python -m pytest

Pytest wordt afgesloten met een code die niet nul is wanneer tests mislukken, waardoor de pijplijn stopt. Wij hebben dit workflowbestand niet uitgevoerd, dus pas het aan uw project aan. In onze GitHub Actions CI/CD-handleiding worden de details uitgelegd. Pytest werkt ook goed voor browsertests, zoals blijkt uit onze Selenium Python-tutorial en Page Object Model-tutorial.

Tot slot

Je hebt nu wat je nodig hebt voor de meeste Python-testsuites: duidelijke beweringen, armaturen voor de installatie, parametrisering voor variaties en een paar vlaggen voor snelheid. Begin klein. Kies een functie waarin u onlangs een bug heeft opgelost en schrijf eerst een test voor die bug. Als je niet zeker weet wat je op elk niveau moet testen, lees dan over unit- versus integratietesten.

Veelgestelde vragen

Blijf leren