Pytest - Kurzanleitung

Pytest ist ein Python-basiertes Testframework, mit dem Testcodes geschrieben und ausgeführt werden. In den heutigen Tagen der REST-Services wird pytest hauptsächlich für API-Tests verwendet, obwohl wir pytest verwenden können, um einfache bis komplexe Tests zu schreiben, dh wir können Codes schreiben, um API, Datenbank, Benutzeroberfläche usw. zu testen.

Vorteile von Pytest

Die Vorteile von Pytest sind wie folgt:

Pytest kann mehrere Tests gleichzeitig ausführen, wodurch die Ausführungszeit der Testsuite verkürzt wird.
Pytest hat seine eigene Methode, um die Testdatei und die Testfunktionen automatisch zu erkennen, wenn dies nicht ausdrücklich erwähnt wird.
Mit Pytest können wir eine Teilmenge der Tests während der Ausführung überspringen.
Mit Pytest können wir eine Teilmenge der gesamten Testsuite ausführen.
Pytest ist kostenlos und Open Source.
Aufgrund seiner einfachen Syntax ist pytest sehr einfach zu beginnen.

In diesem Tutorial erklären wir die Grundlagen des Pytests mit Beispielprogrammen.

In diesem Kapitel erfahren Sie, wie Sie pytest installieren.

Führen Sie den folgenden Befehl aus, um die Installation zu starten:

pip install pytest == 2.9.1

Wir können jede Version von pytest installieren. Hier ist 2.9.1 die Version, die wir installieren.

Führen Sie den folgenden Befehl aus, um die neueste Version von pytest zu installieren:

pip install pytest

Bestätigen Sie die Installation mit dem folgenden Befehl, um den Hilfeabschnitt von pytest anzuzeigen.

pytest -h

Wenn Sie pytest ausführen, ohne einen Dateinamen anzugeben, werden alle Dateien im Format ausgeführt test_*.py oder *_test.pyim aktuellen Verzeichnis und Unterverzeichnissen. Pytest identifiziert diese Dateien automatisch als Testdateien. Wircan Lassen Sie pytest andere Dateinamen ausführen, indem Sie sie explizit erwähnen.

Für Pytest sind zunächst die Namen der Testfunktionen erforderlich test. Funktionsnamen, die nicht vom Format sindtest*werden von pytest nicht als Testfunktionen betrachtet. Wircannot Lassen Sie pytest explizit jede Funktion berücksichtigen, die nicht mit beginnt test als Testfunktion.

Wir werden die Durchführung von Tests in unseren folgenden Kapiteln verstehen.

Jetzt beginnen wir mit unserem ersten Pytest-Programm. Wir werden zuerst ein Verzeichnis erstellen und dabei unsere Testdateien im Verzeichnis erstellen.

Befolgen wir die unten gezeigten Schritte -

Erstellen Sie ein neues Verzeichnis mit dem Namen automation und navigieren Sie in das Verzeichnis in Ihrer Befehlszeile.
Erstellen Sie eine Datei mit dem Namen test_square.py und fügen Sie den folgenden Code zu dieser Datei hinzu.

import math

def test_sqrt():
   num = 25
   assert math.sqrt(num) == 5

def testsquare():
   num = 7
   assert 7*7 == 40

def tesequality():
   assert 10 == 11

Führen Sie den Test mit dem folgenden Befehl aus:

pytest

Der obige Befehl generiert die folgende Ausgabe:

test_square.py .F
============================================== FAILURES 
==============================================
______________________________________________ testsquare 
_____________________________________________
   def testsquare():
   num=7
>  assert 7*7 == 40
E  assert (7 * 7) == 40
test_square.py:9: AssertionError
================================= 1 failed, 1 passed in 0.06 seconds 
=================================

Siehe die erste Zeile des Ergebnisses. Es zeigt den Dateinamen und die Ergebnisse an. F steht für einen Testfehler und Punkt (.) Für einen Testerfolg.

Darunter sehen wir die Details der fehlgeschlagenen Tests. Es wird angezeigt, bei welcher Aussage der Test fehlgeschlagen ist. In unserem Beispiel wird 7 * 7 auf Gleichheit mit 40 verglichen, was falsch ist. Am Ende sehen wir eine Zusammenfassung der Testausführung, 1 fehlgeschlagen und 1 bestanden.

Die Funktion tesequality wird nicht ausgeführt, da pytest sie nicht als Test betrachtet, da ihr Name nicht das Format hat test*.

Führen Sie nun den folgenden Befehl aus und sehen Sie das Ergebnis erneut -

pytest -v

-v erhöht die Ausführlichkeit.

test_square.py::test_sqrt PASSED
test_square.py::testsquare FAILED
============================================== FAILURES 
==============================================
_____________________________________________ testsquare 
_____________________________________________
   def testsquare():
   num = 7
>  assert 7*7 == 40
E  assert (7 * 7) == 40
test_square.py:9: AssertionError
================================= 1 failed, 1 passed in 0.04 seconds 
=================================

Jetzt ist das Ergebnis erklärender für den fehlgeschlagenen Test und den bestandenen Test.

Note - Der Befehl pytest führt alle Dateien des Formats aus test_* oder *_test im aktuellen Verzeichnis und Unterverzeichnissen.

In diesem Kapitel erfahren Sie, wie Sie eine einzelne Testdatei und mehrere Testdateien ausführen. Wir haben bereits eine Testdateitest_square.pyerstellt. Erstellen Sie eine neue Testdateitest_compare.py mit folgendem Code -

def test_greater():
   num = 100
   assert num > 100

def test_greater_equal():
   num = 100
   assert num >= 100

def test_less():
   num = 100
   assert num < 200

Um nun alle Tests aus allen Dateien (2 Dateien hier) auszuführen, müssen Sie den folgenden Befehl ausführen:

pytest -v

Mit dem obigen Befehl werden Tests von beiden ausgeführt test_square.py und test_compare.py. Die Ausgabe wird wie folgt generiert:

test_compare.py::test_greater FAILED
test_compare.py::test_greater_equal PASSED
test_compare.py::test_less PASSED
test_square.py::test_sqrt PASSED
test_square.py::testsquare FAILED
================================================ FAILURES 
================================================
______________________________________________ test_greater 
______________________________________________
   def test_greater():
   num = 100
>  assert num > 100
E  assert 100 > 100

test_compare.py:3: AssertionError
_______________________________________________ testsquare 
_______________________________________________
   def testsquare():
   num = 7
>  assert 7*7 == 40
E  assert (7 * 7) == 40

test_square.py:9: AssertionError
=================================== 2 failed, 3 passed in 0.07 seconds 
===================================

Verwenden Sie die folgende Syntax, um die Tests aus einer bestimmten Datei auszuführen:

pytest <filename> -v

Führen Sie nun den folgenden Befehl aus:

pytest test_compare.py -v

Der obige Befehl führt die Tests nur aus einer Datei aus test_compare.py. Unser Ergebnis wird sein -

test_compare.py::test_greater FAILED
test_compare.py::test_greater_equal PASSED
test_compare.py::test_less PASSED
============================================== FAILURES 
==============================================
____________________________________________ test_greater 
____________________________________________
   def test_greater():
   num = 100
>  assert num > 100
E  assert 100 > 100
test_compare.py:3: AssertionError
================================= 1 failed, 2 passed in 0.04 seconds 
=================================

In einem realen Szenario haben wir mehrere Testdateien und jede Datei hat eine Reihe von Tests. Die Tests decken verschiedene Module und Funktionen ab. Angenommen, wir möchten nur einen bestimmten Satz von Tests ausführen. Wie gehen wir vor?

Pytest bietet zwei Möglichkeiten, um die Teilmenge der Testsuite auszuführen.

Wählen Sie die auszuführenden Tests basierend auf der Teilzeichenfolgenübereinstimmung der Testnamen aus.
Wählen Sie die auszuführenden Testgruppen basierend auf den angewendeten Markierungen aus.

Wir werden diese beiden anhand von Beispielen in den folgenden Kapiteln erläutern.

Um die Tests auszuführen, die einen String in seinem Namen enthalten, können wir die folgende Syntax verwenden:

pytest -k <substring> -v

-k <substring> repräsentiert den Teilstring, nach dem in den Testnamen gesucht werden soll.

Führen Sie nun den folgenden Befehl aus:

pytest -k great -v

Dadurch werden alle Testnamen mit dem Wort ausgeführt ‘great’in seinem Namen. In diesem Fall sind sietest_greater() und test_greater_equal(). Siehe das Ergebnis unten.

test_compare.py::test_greater FAILED
test_compare.py::test_greater_equal PASSED
============================================== FAILURES 
==============================================
____________________________________________ test_greater 
____________________________________________
def test_greater():
num = 100
>  assert num > 100
E  assert 100 > 100
test_compare.py:3: AssertionError
========================== 1 failed, 1 passed, 3 deselected in 0.07 seconds 
==========================

Hier im Ergebnis sehen wir 3 abgewählte Tests. Dies liegt daran, dass diese Testnamen das Wort nicht enthaltengreat in ihnen.

Note - Der Name der Testfunktion sollte weiterhin mit 'test' beginnen.

In diesem Kapitel erfahren Sie, wie Sie die Tests mithilfe von Markern gruppieren.

Mit Pytest können wir Marker für Testfunktionen verwenden. Marker werden verwendet, um verschiedene Merkmale / Attribute zum Testen von Funktionen festzulegen. Pytest bietet viele integrierte Marker wie xfail, skip und parametrize. Außerdem können Benutzer ihre eigenen Markernamen erstellen. Marker werden auf die Tests mit der unten angegebenen Syntax angewendet -

@pytest.mark.<markername>

Um Marker zu verwenden, müssen wir import pytestModul in der Testdatei. Wir können unsere eigenen Markernamen für die Tests definieren und die Tests mit diesen Markernamen ausführen.

Um die markierten Tests auszuführen, können wir die folgende Syntax verwenden:

pytest -m <markername> -v

-m <Markername> repräsentiert den Markernamen der auszuführenden Tests.

Aktualisieren Sie unsere Testdateien test_compare.py und test_square.pymit dem folgenden Code. Wir definieren 3 Marker– great, square, others.

test_compare.py

import pytest
@pytest.mark.great
def test_greater():
   num = 100
   assert num > 100

@pytest.mark.great
def test_greater_equal():
   num = 100
   assert num >= 100

@pytest.mark.others
def test_less():
   num = 100
   assert num < 200

test_square.py

import pytest
import math

@pytest.mark.square
def test_sqrt():
   num = 25
   assert math.sqrt(num) == 5

@pytest.mark.square
def testsquare():
   num = 7
   assert 7*7 == 40

@pytest.mark.others
   def test_equality():
   assert 10 == 11

Führen Sie nun die als gekennzeichneten Tests aus othersFühren Sie den folgenden Befehl aus:

pytest -m others -v

Siehe das Ergebnis unten. Es wurden die 2 als gekennzeichneten Tests ausgeführtothers.

test_compare.py::test_less PASSED
test_square.py::test_equality FAILED
============================================== FAILURES
==============================================
___________________________________________ test_equality
____________________________________________
   @pytest.mark.others
   def test_equality():
>  assert 10 == 11
E  assert 10 == 11
test_square.py:16: AssertionError
========================== 1 failed, 1 passed, 4 deselected in 0.08 seconds
==========================

In ähnlicher Weise können wir auch Tests mit anderen Markern durchführen - großartig, vergleiche

Fixtures sind Funktionen, die vor jeder Testfunktion ausgeführt werden, auf die sie angewendet werden. Fixtures werden verwendet, um einige Daten in die Tests einzuspeisen, z. B. Datenbankverbindungen, zu testende URLs und Eingabedaten. Anstatt für jeden Test den gleichen Code auszuführen, können wir den Tests eine Fixture-Funktion hinzufügen, die ausgeführt wird und die Daten vor dem Ausführen jedes Tests an den Test zurückgibt.

Eine Funktion wird durch -

@pytest.fixture

Eine Testfunktion kann ein Gerät verwenden, indem der Name des Geräts als Eingabeparameter angegeben wird.

Erstellen Sie eine Datei test_div_by_3_6.py und fügen Sie den folgenden Code hinzu

import pytest

@pytest.fixture
def input_value():
   input = 39
   return input

def test_divisible_by_3(input_value):
   assert input_value % 3 == 0

def test_divisible_by_6(input_value):
   assert input_value % 6 == 0

Hier haben wir eine Fixture-Funktion namens input_value, die die Eingabe für die Tests liefert. Um auf die Fixture-Funktion zugreifen zu können, müssen die Tests den Fixture-Namen als Eingabeparameter angeben.

Pytest, während der Test ausgeführt wird, sieht den Namen des Geräts als Eingabeparameter. Anschließend wird die Fixture-Funktion ausgeführt und der zurückgegebene Wert wird im Eingabeparameter gespeichert, der vom Test verwendet werden kann.

Führen Sie den Test mit dem folgenden Befehl aus:

pytest -k divisible -v

Der obige Befehl generiert das folgende Ergebnis:

test_div_by_3_6.py::test_divisible_by_3 PASSED
test_div_by_3_6.py::test_divisible_by_6 FAILED
============================================== FAILURES
==============================================
________________________________________ test_divisible_by_6
_________________________________________
input_value = 39
   def test_divisible_by_6(input_value):
>  assert input_value % 6 == 0
E  assert (39 % 6) == 0
test_div_by_3_6.py:12: AssertionError
========================== 1 failed, 1 passed, 6 deselected in 0.07 seconds
==========================

Der Ansatz hat jedoch seine eigene Einschränkung. Eine in einer Testdatei definierte Fixture-Funktion hat nur innerhalb der Testdatei einen Gültigkeitsbereich. Wir können dieses Gerät nicht in einer anderen Testdatei verwenden. Um ein Fixture für mehrere Testdateien verfügbar zu machen, müssen wir die Fixture-Funktion in einer Datei namens conftest.py definieren.conftest.py wird im nächsten Kapitel erklärt.

Wir können die Fixture-Funktionen in dieser Datei definieren, um sie für mehrere Testdateien zugänglich zu machen.

Erstellen Sie eine neue Datei conftest.py und fügen Sie den folgenden Code hinzu -

import pytest

@pytest.fixture
def input_value():
   input = 39
   return input

Bearbeiten Sie die test_div_by_3_6.py um die Befestigungsfunktion zu entfernen -

import pytest

def test_divisible_by_3(input_value):
   assert input_value % 3 == 0

def test_divisible_by_6(input_value):
   assert input_value % 6 == 0

Erstellen Sie eine neue Datei test_div_by_13.py - -

import pytest

def test_divisible_by_13(input_value):
   assert input_value % 13 == 0

Jetzt haben wir die Dateien test_div_by_3_6.py und test_div_by_13.py unter Verwendung der in definierten Vorrichtung conftest.py.

Führen Sie die Tests aus, indem Sie den folgenden Befehl ausführen:

pytest -k divisible -v

Der obige Befehl generiert das folgende Ergebnis:

test_div_by_13.py::test_divisible_by_13 PASSED
test_div_by_3_6.py::test_divisible_by_3 PASSED
test_div_by_3_6.py::test_divisible_by_6 FAILED
============================================== FAILURES
==============================================
________________________________________ test_divisible_by_6
_________________________________________
input_value = 39
   def test_divisible_by_6(input_value):
>  assert input_value % 6 == 0
E  assert (39 % 6) == 0
test_div_by_3_6.py:7: AssertionError
========================== 1 failed, 2 passed, 6 deselected in 0.09 seconds
==========================

Bei den Tests wird nach einem Gerät in derselben Datei gesucht. Da das Gerät nicht in der Datei gefunden wird, wird in der Datei conftest.py nach dem Gerät gesucht. Beim Auffinden wird die Fixture-Methode aufgerufen und das Ergebnis an das Eingabeargument des Tests zurückgegeben.

Die Parametrisierung eines Tests wird durchgeführt, um den Test für mehrere Eingabesätze auszuführen. Wir können dies tun, indem wir den folgenden Marker verwenden -

@pytest.mark.parametrize

Kopieren Sie den folgenden Code in eine Datei mit dem Namen test_multiplication.py - -

import pytest

@pytest.mark.parametrize("num, output",[(1,11),(2,22),(3,35),(4,44)])
def test_multiplication_11(num, output):
   assert 11*num == output

Hier multipliziert der Test eine Eingabe mit 11 und vergleicht das Ergebnis mit der erwarteten Ausgabe. Der Test hat 4 Eingabesätze mit jeweils 2 Werten - einer ist die Zahl, die mit 11 multipliziert werden soll, und der andere ist das erwartete Ergebnis.

Führen Sie den Test aus, indem Sie den folgenden Befehl ausführen:

Pytest -k multiplication -v

Der obige Befehl generiert die folgende Ausgabe:

test_multiplication.py::test_multiplication_11[1-11] PASSED
test_multiplication.py::test_multiplication_11[2-22] PASSED
test_multiplication.py::test_multiplication_11[3-35] FAILED
test_multiplication.py::test_multiplication_11[4-44] PASSED
============================================== FAILURES
==============================================
_________________ test_multiplication_11[3-35] __________________
num = 3, output = 35
   @pytest.mark.parametrize("num, output",[(1,11),(2,22),(3,35),(4,44)])
   def test_multiplication_11(num, output):
>  assert 11*num == output
E  assert (11 * 3) == 35
test_multiplication.py:5: AssertionError
============================== 1 failed, 3 passed, 8 deselected in 0.08 seconds
==============================

In diesem Kapitel lernen wir die Skip- und Xfail-Tests in Pytest kennen.

Betrachten Sie nun die folgenden Situationen:

Ein Test ist aus bestimmten Gründen für einige Zeit nicht relevant.
Eine neue Funktion wird implementiert und wir haben bereits einen Test für diese Funktion hinzugefügt.

In diesen Situationen haben wir die Möglichkeit, den Test nicht zu bestehen oder die Tests zu überspringen.

Pytest führt den xfailed-Test aus, wird jedoch nicht als Teil der fehlgeschlagenen oder bestandenen Tests betrachtet. Details dieser Tests werden nicht gedruckt, selbst wenn der Test fehlschlägt (denken Sie daran, dass pytest normalerweise die fehlgeschlagenen Testdetails druckt). Wir können xfail-Tests mit dem folgenden Marker durchführen:

@pytest.mark.xfail

Das Überspringen eines Tests bedeutet, dass der Test nicht ausgeführt wird. Wir können Tests mit dem folgenden Marker überspringen:

@pytest.mark.skip

Später, wenn der Test relevant wird, können wir die Markierungen entfernen.

Bearbeiten Sie die test_compare.py Wir müssen bereits die Markierungen xfail und skip einfügen -

import pytest
@pytest.mark.xfail
@pytest.mark.great
def test_greater():
   num = 100
   assert num > 100

@pytest.mark.xfail
@pytest.mark.great
def test_greater_equal():
   num = 100
   assert num >= 100

@pytest.mark.skip
@pytest.mark.others
def test_less():
   num = 100
   assert num < 200

Führen Sie den Test mit dem folgenden Befehl aus:

pytest test_compare.py -v

Bei der Ausführung generiert der obige Befehl das folgende Ergebnis:

test_compare.py::test_greater xfail
test_compare.py::test_greater_equal XPASS
test_compare.py::test_less SKIPPED
============================ 1 skipped, 1 xfailed, 1 xpassed in 0.06 seconds
============================

In einem realen Szenario wird eine neue Version des Codes, sobald sie zur Bereitstellung bereit ist, zuerst in einer Pre-Prod / Staging-Umgebung bereitgestellt. Dann läuft eine Testsuite darauf.

Der Code kann nur dann für die Produktion bereitgestellt werden, wenn die Testsuite erfolgreich ist. Wenn es einen Testfehler gibt, egal ob einer oder mehrere, ist der Code nicht produktionsbereit.

Was ist daher, wenn wir die Ausführung der Testsuite kurz nach n fehlgeschlagenen Tests beenden möchten? Dies kann im Pytest mit maxfail erfolgen.

Die Syntax zum Stoppen der Ausführung der Testsuite kurz nach n fehlgeschlagenen Tests lautet wie folgt:

pytest --maxfail = <num>

Erstellen Sie eine Datei test_failure.py mit dem folgenden Code.

import pytest
import math

def test_sqrt_failure():
   num = 25
   assert math.sqrt(num) == 6

def test_square_failure():
   num = 7
   assert 7*7 == 40

def test_equality_failure():
   assert 10 == 11

Alle 3 Tests schlagen beim Ausführen dieser Testdatei fehl. Hier stoppen wir die Ausführung des Tests nach einem Fehler selbst durch -

pytest test_failure.py -v --maxfail = 1

test_failure.py::test_sqrt_failure FAILED
=================================== FAILURES
=================================== _______________________________________
test_sqrt_failure __________________________________________
   def test_sqrt_failure():
   num = 25
>  assert math.sqrt(num) == 6
E  assert 5.0 == 6
E  + where 5.0 = <built-in function sqrt>(25)
E  + where <built-in function sqrt>= math.sqrt
test_failure.py:6: AssertionError
=============================== 1 failed in 0.04 seconds
===============================

Im obigen Ergebnis können wir sehen, dass die Ausführung bei einem Fehler gestoppt wird.

Standardmäßig führt pytest Tests in sequentieller Reihenfolge durch. In einem realen Szenario verfügt eine Testsuite über eine Reihe von Testdateien und jede Datei über eine Reihe von Tests. Dies führt zu einer großen Ausführungszeit. Um dies zu überwinden, bietet uns pytest die Möglichkeit, Tests parallel durchzuführen.

Dazu müssen wir zuerst das pytest-xdist-Plugin installieren.

Installieren Sie pytest-xdist, indem Sie den folgenden Befehl ausführen:

pip install pytest-xdist

Jetzt können wir Tests mithilfe der Syntax ausführen pytest -n <num>

pytest -n 3

-n <num> führt die Tests mit mehreren Workern aus, hier ist es 3.

Wir werden keinen großen Zeitunterschied haben, wenn nur wenige Tests ausgeführt werden müssen. Es ist jedoch wichtig, wenn die Testsuite groß ist.

Wir können die Details der Testausführung in einer XML-Datei generieren. Diese XML-Datei ist hauptsächlich in Fällen nützlich, in denen wir ein Dashboard haben, das die Testergebnisse projiziert. In solchen Fällen kann die XML-Datei analysiert werden, um die Details der Ausführung abzurufen.

Wir werden nun die Tests von test_multiplcation.py ausführen und die XML durch Ausführen generieren

pytest test_multiplication.py -v --junitxml="result.xml"

Jetzt können wir sehen, dass result.xml mit den folgenden Daten generiert wird -

<?xml version = "1.0" encoding = "utf-8"?>
<testsuite errors = "0" failures = "1"
name = "pytest" skips = "0" tests = "4" time = "0.061">
   <testcase classname = "test_multiplication"          
      file = "test_multiplication.py"
      line = "2" name = "test_multiplication_11[1-11]"
      time = "0.00117516517639>
   </testcase>
   
   <testcase classname = "test_multiplication"    
      file = "test_multiplication.py"
      line = "2" name = "test_multiplication_11[2-22]"
      time = "0.00155973434448">
   </testcase>

   <testcase classname = "test_multiplication" 
      file = "test_multiplication.py"
      line = "2" name = "test_multiplication_11[3-35]" time = "0.00144290924072">
      failure message = "assert (11 * 3) == 35">num = 3, output = 35

         @pytest.mark.parametrize("num,
         output",[(1,11),(2,22),(3,35),(4,44)])
            
         def test_multiplication_11(num, output):> 
         assert 11*num == output
         E assert (11 * 3) == 35

         test_multiplication.py:5: AssertionErro
      </failure>
   </testcase>
   <testcase classname = "test_multiplication" 
      file = "test_multiplication.py"
      line = "2" name = "test_multiplication_11[4-44]"
      time = "0.000945091247559">
   </testcase>
</testsuite>

Hier das Etikett <testsuit> Zusammenfassend gibt es 4 Tests und die Anzahl der Fehler ist 1.

Das Tag <testcase> gibt die Details jedes ausgeführten Tests an.
Das <failure> -Tag gibt die Details des fehlgeschlagenen Testcodes an.

In diesem Pytest-Tutorial haben wir die folgenden Bereiche behandelt:

Pytest installieren ..
Identifizieren von Testdateien und Testfunktionen.
Ausführen aller Testdateien mit pytest –v.
Ausführen einer bestimmten Datei mit pytest <Dateiname> -v.
Führen Sie Tests durch, indem Sie den Teilstring mit pytest -k <substring> -v übereinstimmen.
Führen Sie Tests basierend auf den Markern pytest -m <Markername> -v aus.
Erstellen von Fixtures mit @ pytest.fixture.
conftest.py ermöglicht den Zugriff auf Geräte aus mehreren Dateien.
Parametrisierungstests mit @ pytest.mark.parametrize.
Xfailing-Tests mit @ pytest.mark.xfail.
Überspringen von Tests mit @ pytest.mark.skip.
Beenden Sie die Testausführung bei n Fehlern mit pytest --maxfail = <num>.
Parallele Ausführung von Tests mit pytest -n <num>.
Generieren von Ergebnis-XML mit pytest -v --junitxml = "result.xml".

Dieses Tutorial führte Sie in das Pytest-Framework ein. Jetzt sollten Sie in der Lage sein, Tests mit pytest zu schreiben.

Als gute Praxis -

Erstellen Sie verschiedene Testdateien basierend auf der zu testenden Funktionalität / dem zu testenden Modul.
Geben Sie Testdateien und -methoden aussagekräftige Namen.
Haben Sie genügend Marker, um die Tests anhand verschiedener Kriterien zu gruppieren.
Verwenden Sie bei Bedarf Vorrichtungen.