PyTest-Tutorial: Was ist, wie installiert man, Framework, Behauptungen

Was ist PyTest?

PyTest ist ein Test-Framework, das es Benutzern ermöglicht, Testcodes mit der Programmiersprache Python zu schreiben. Es hilft Ihnen, einfache und skalierbare Testfälle für Datenbanken, APIs oder UIs zu schreiben. PyTest wird hauptsächlich zum Schreiben von Tests für APIs verwendet. Es hilft, Tests von einfachen Unit-Tests bis hin zu com zu schreibenplex Funktionstests.

Warum PyTest verwenden?

Einige der Vorteile von Pytest sind

  • Aufgrund der einfachen und einfachen Syntax ist der Einstieg sehr einfach.
  • Kann Tests parallel ausführen.
  • Kann einen bestimmten Test oder eine Teilmenge von Tests ausführen
  • Tests automatisch erkennen
  • Überspringen Sie Tests
  • Open Source

So installieren Sie PyTest

Following ist ein Prozess zur Installation von PyTest:

Schritt 1) Sie können Pytest per installieren

pip install pytest==2.9.1

Sobald die Installation abgeschlossen ist, können Sie diese mit bestätigen

py.test -h

Dadurch wird die Hilfe angezeigt

Installieren Sie PyTest

Erster grundlegender PyTest

Jetzt lernen wir anhand eines einfachen PyTest-Beispiels, wie man Pytest verwendet.

Erstellen Sie einen Ordner „studie_pytest“. Wir werden unsere Testdateien in diesem Ordner erstellen.

Bitte navigieren Sie in Ihrer Befehlszeile zu diesem Ordner.

Erstellen Sie im Ordner eine Datei mit dem Namen test_sample1.py

Erster grundlegender PyTest

Fügen Sie den folgenden Code hinzu und speichern Sie ihn

import pytest
def test_file1_method1():
	x=5
	y=6
	assert x+1 == y,"test failed"
	assert x == y,"test failed"
def test_file1_method2():
	x=5
	y=6
	assert x+1 == y,"test failed" 

Führen Sie den Test mit dem Befehl aus

py.test

Sie erhalten die Ausgabe als

test_sample1.py F.
============================================== FAILURES ========================================
____________________________________________ test_sample1 ______________________________________
    def test_file1_method1():
    	x=5
    	y=6
       	assert x+1 == y,"test failed"
>      	assert x == y,"test failed"
E       AssertionError: test failed
E       assert 5 == 6
test_sample1.py:6: AssertionError

Erster grundlegender PyTest

Hier in test_sample1.py F.

F sagt Misserfolg

Punkt(.) sagt Erfolg.

Im Abschnitt „Fehler“ können Sie die fehlgeschlagene(n) Methode(n) und die Fehlerzeile sehen. Hier bedeutet x==y 5==6, was falsch ist.

Als nächstes lernen wir in diesem PyTest-Tutorial etwas über die Behauptung in PyTest.

Behauptungen in PyTest

Pytest-Behauptungen sind Prüfungen, die entweder den Status „Wahr“ oder „Falsch“ zurückgeben. Wenn in Python Pytest eine Behauptung in einer Testmethode fehlschlägt, wird die Ausführung dieser Methode dort gestoppt. Der verbleibende Code in dieser Testmethode wird nicht ausgeführt und Pytest-Behauptungen werden mit der nächsten Testmethode fortgesetzt.

Pytest Assert-Beispiele:

assert "hello" == "Hai" is an assertion failure.
assert 4==4 is a successful assertion
assert True is a successful assertion
assert False is an assertion failure.

Geht davon

assert x == y,"test failed because x=" + str(x) + " y=" + str(y)

Platzieren Sie diesen Code in test_file1_method1() anstelle der Behauptung

assert x == y,"test failed"

Wenn Sie den Test ausführen, wird der Fehler als angezeigt AssertionError: Test fehlgeschlagen x=5 y=6

Wie PyTest die Testdateien und Testmethoden identifiziert

Standardmäßig identifiziert Pytest nur die Dateinamen, die mit beginnen Prüfung_ oder endend mit _Prüfung als Testdateien. Wir können jedoch auch andere Dateinamen explizit erwähnen (erklärt). later). Pytest benötigt zunächst die Namen der Testmethoden "prüfen.“ Alle anderen Methodennamen werden ignoriert, auch wenn wir ausdrücklich dazu auffordern, diese Methoden auszuführen.

Sehen Sie sich einige Beispiele für gültige und ungültige Pytest-Dateinamen an

test_login.py - valid
login_test.py - valid
testlogin.py -invalid
logintest.py -invalid

Hinweis: Ja, wir können pytest explizit bitten, testlogin.py und logintest.py auszuwählen

Sehen Sie sich einige Beispiele für gültige und ungültige Pytest-Testmethoden an

def test_file1_method1(): - valid
def testfile1_method1(): - valid
def file1_method1(): - invalid	

Hinweis: Auch wenn wir file1_method1() ausdrücklich erwähnen, führt Pytest diese Methode nicht aus.

Führen Sie mehrere Tests aus einer bestimmten Datei und mehreren Dateien aus

Derzeit haben wir im Ordner „studie_pytest“ eine Datei „test_sample1.py“. Angenommen, wir haben mehrere Dateien, sagen wir test_sample2.py, test_sample3.py. Um alle Tests für alle Dateien im Ordner und in den Unterordnern auszuführen, müssen wir lediglich den Befehl pytest ausführen.

py.test

Dadurch werden alle Dateinamen ausgeführt, die mit test_ beginnen und mit _test enden, in diesem Ordner und in den Unterordnern unter diesem Ordner.

Um Tests nur aus einer bestimmten Datei auszuführen, können wir py.test verwenden

py.test test_sample1.py

Führen Sie eine Teilmenge des gesamten Tests mit PyTest aus

Manchmal möchten wir nicht die gesamte Testsuite ausführen. Mit Pytest können wir spezifische Tests durchführen. Wir können es auf zwei Arten tun

  • Gruppierung von Testnamen nach Teilzeichenfolgenübereinstimmung
  • Gruppierung von Tests nach Markern

Wir haben bereits test_sample1.py. Erstellen Sie eine Datei test_sample2.py und fügen Sie den folgenden Code hinzu

def test_file2_method1():
	x=5
	y=6
	assert x+1 == y,"test failed"
	assert x == y,"test failed because x=" + str(x) + " y=" + str(y)
def test_file2_method2():
	x=5
	y=6
	assert x+1 == y,"test failed"

So haben wir derzeit

• test_sample1.py
• test_file1_method1()
• test_file1_method2()
• test_sample2.py
• test_file2_method1()
• test_file2_method2()

Option 1) Führen Sie Tests durch Teilzeichenfolgenabgleich durch

Hier müssen wir alle Tests ausführen, deren Name method1 enthält

py.test -k method1 -v
-k <expression> is used to represent the substring to match
-v increases the verbosity

Wenn Sie also py.test -k method1 -v ausführen, erhalten Sie Folgendeswing Folge

test_sample2.py::test_file2_method1 FAILED
test_sample1.py::test_file1_method1 FAILED

============================================== FAILURES ==============================================
_________________________________________ test_file2_method1 _________________________________________
    def test_file2_method1():
    	x=5
    	y=6
       	assert x+1 == y,"test failed"
>      	assert x == y,"test failed because x=" + str(x) + " y=" + str(y)
E       AssertionError: test failed because x=5 y=6
E       assert 5 == 6
test_sample2.py:5: AssertionError

_________________________________________ test_file1_method1 _________________________________________
    @pytest.mark.only
    def test_file1_method1():
    	x=5
    	y=6
       	assert x+1 == y,"test failed"
>      	assert x == y,"test failed because x=" + str(x) + " y=" + str(y)
E       AssertionError: test failed because x=5 y=6
E       assert 5 == 6
test_sample1.py:8: AssertionError

================================= 2 tests deselected by '-kmethod1' ==================================
=============================== 2 failed, 2 deselected in 0.02 seconds ===============================

Hier sieht man das Ende 2 Tests von '-kmethod1' abgewählt Das sind test_file1_method2 und test_file2_method2

Versuchen Sie, mit verschiedenen Kombinationen zu laufen, wie zum Beispiel:

py.test -k method -v - will run all the four methods
py.test -k methods -v – will not run any test as there is no test name matches the substring 'methods'

Option 2) Führen Sie Tests nach Markern durch

Mit Pytest können wir mithilfe der Pytest-Marker @pytest.mark verschiedene Attribute für die Testmethoden festlegen. Um Markierungen in der Testdatei zu verwenden, müssen wir Pytest in die Testdateien importieren.

Hier wenden wir unterschiedliche Markernamen auf Testmethoden an und führen spezifische Tests basierend auf Markernamen durch. Wir können die Markierungen für jeden Testnamen definieren, indem wir verwenden

@pytest.mark.<name>.			

Wir definieren die Marker set1 und set2 für die Testmethoden und führen den Test mit den Markernamen aus. Aktualisieren Sie die Testdateien wie folgtwing Code

test_sample1.py

import pytest
@pytest.mark.set1
def test_file1_method1():
	x=5
	y=6
	assert x+1 == y,"test failed"
	assert x == y,"test failed because x=" + str(x) + " y=" + str(y)

@pytest.mark.set2
def test_file1_method2():
	x=5
	y=6
	assert x+1 == y,"test failed"

test_sample2.py

import pytest
@pytest.mark.set1
def test_file2_method1():
	x=5
	y=6
	assert x+1 == y,"test failed"
	assert x == y,"test failed because x=" + str(x) + " y=" + str(y)

@pytest.mark.set1
def test_file2_method2():
	x=5
	y=6
	assert x+1 == y,"test failed"

Wir können den markierten Test ausführen

py.test -m <name>
-m <name> mentions the marker name

Führen Sie py.test -m set1 aus. Dadurch werden die Methoden test_file1_method1, test_file2_method1, test_file2_method2 ausgeführt.

Wenn Sie py.test -m set2 ausführen, wird test_file1_method2 ausgeführt.

Führen Sie Tests parallel mit Pytest durch

Normalerweise verfügt eine Testsuite über mehrere Testdateien und Hunderte von Testmethoden, deren Ausführung viel Zeit in Anspruch nimmt. Mit Pytest können wir Tests parallel ausführen.

Dazu müssen wir zunächst pytest-xdist durch Ausführen installieren

pip install pytest-xdist

Führen Sie Tests parallel mit Pytest durch

Sie können jetzt Tests durchführen

py.test -n 4

-N führt die Tests mit mehreren Workern aus. Im obigen Befehl gibt es 4 Worker, die den Test ausführen.

Pytest-Geräte

Fixtures werden verwendet, wenn wir vor jeder Testmethode Code ausführen möchten. Anstatt also bei jedem Test denselben Code zu wiederholen, definieren wir Fixtures. Normalerweise werden Fixtures verwendet, um Datenbankverbindungen zu initialisieren, die Basis zu übergeben usw

Eine Methode wird durch Markieren mit als Pytest-Fixture markiert

@pytest.fixture

Eine Testmethode kann ein Pytest-Fixture verwenden, indem sie das Fixture als Eingabeparameter angibt.

Erstellen Sie eine neue Datei test_basic_fixture.py mit following Code

import pytest
@pytest.fixture
def supply_AA_BB_CC():
	aa=25
	bb =35
	cc=45
	return [aa,bb,cc]

def test_comparewithAA(supply_AA_BB_CC):
	zz=35
	assert supply_AA_BB_CC[0]==zz,"aa and zz comparison failed"

def test_comparewithBB(supply_AA_BB_CC):
	zz=35
	assert supply_AA_BB_CC[1]==zz,"bb and zz comparison failed"

def test_comparewithCC(supply_AA_BB_CC):
	zz=35
	assert supply_AA_BB_CC[2]==zz,"cc and zz comparison failed"

Hier

  • Wir haben ein Fixture namens „supply_AA_BB_CC“. Diese Methode gibt eine Liste mit 3 Werten zurück.
  • Wir haben 3 Testmethoden, die jeden der Werte vergleichen.

Jede Testfunktion verfügt über ein Eingabeargument, dessen Name mit einem verfügbaren Gerät übereinstimmt. Pytest ruft dann die entsprechende Fixture-Methode auf und die zurückgegebenen Werte werden im Eingabeargument gespeichert, hier die Liste [25,35,45]. Jetzt werden die Listenelemente in Testmethoden für den Vergleich verwendet.

Führen Sie nun den Test durch und sehen Sie sich das Ergebnis an

 py.test test_basic_fixture
test_basic_fixture.py::test_comparewithAA FAILED                                                                                                                                                                                       
test_basic_fixture.py::test_comparewithBB PASSED                                                                                                                                                                                       
test_basic_fixture.py::test_comparewithCC FAILED
                                                                                                                                                                                       
============================================== FAILURES ==============================================
_________________________________________ test_comparewithAA _________________________________________
supply_AA_BB_CC = [25, 35, 45]
    def test_comparewithAA(supply_AA_BB_CC):
    	zz=35
>   	assert supply_AA_BB_CC[0]==zz,"aa and zz comparison failed"
E    AssertionError: aa and zz comparison failed
E    assert 25 == 35
test_basic_fixture.py:10: AssertionError

_________________________________________ test_comparewithCC _________________________________________
supply_AA_BB_CC = [25, 35, 45]
    def test_comparewithCC(supply_AA_BB_CC):
    	zz=35
>   	assert supply_AA_BB_CC[2]==zz,"cc and zz comparison failed"
E    AssertionError: cc and zz comparison failed
E    assert 45 == 35
test_basic_fixture.py:16: AssertionError
================================= 2 failed, 1 passed in 0.05 seconds =================================

Der Test test_comparewithBB ist bestanden, da zz=BB=35, und die verbleibenden 2 Tests sind fehlgeschlagen.

Die Fixture-Methode hat nur innerhalb der Testdatei, in der sie definiert ist, einen Gültigkeitsbereich. Wenn wir versuchen, auf das Fixture in einer anderen Testdatei zuzugreifen, erhalten wir die Fehlermeldung Fixture „supply_AA_BB_CC“ nicht gefunden für die Testmethoden in anderen Dateien.

Um dasselbe Fixture für mehrere Testdateien zu verwenden, erstellen wir Fixture-Methoden in einer Datei namens conftest.py.

Sehen wir uns dies anhand des folgenden PyTest-Beispiels an. Erstellen Sie 3 Dateien conftest.py, test_basic_fixture.py, test_basic_fixture2.py mit dem folgendenwing Code

conftest.py

import pytest
@pytest.fixture
def supply_AA_BB_CC():
	aa=25
	bb =35
	cc=45
	return [aa,bb,cc]

test_basic_fixture.py

import pytest
def test_comparewithAA(supply_AA_BB_CC):
	zz=35
	assert supply_AA_BB_CC[0]==zz,"aa and zz comparison failed"

def test_comparewithBB(supply_AA_BB_CC):
	zz=35
	assert supply_AA_BB_CC[1]==zz,"bb and zz comparison failed"

def test_comparewithCC(supply_AA_BB_CC):
	zz=35
	assert supply_AA_BB_CC[2]==zz,"cc and zz comparison failed"

test_basic_fixture2.py

import pytest
def test_comparewithAA_file2(supply_AA_BB_CC):
	zz=25
	assert supply_AA_BB_CC[0]==zz,"aa and zz comparison failed"

def test_comparewithBB_file2(supply_AA_BB_CC):
	zz=25
	assert supply_AA_BB_CC[1]==zz,"bb and zz comparison failed"

def test_comparewithCC_file2(supply_AA_BB_CC):
	zz=25
	assert supply_AA_BB_CC[2]==zz,"cc and zz comparison failed"

pytest sucht zuerst in der Testdatei nach dem Fixture. Wenn es nicht gefunden wird, sucht es in conftest.py

Führen Sie den Test mit py.test -k test_comparewith -v aus, um das folgende Ergebnis zu erhalten

test_basic_fixture.py::test_comparewithAA FAILED  
test_basic_fixture.py::test_comparewithBB PASSED 
test_basic_fixture.py::test_comparewithCC FAILED 
test_basic_fixture2.py::test_comparewithAA_file2 PASSED 
test_basic_fixture2.py::test_comparewithBB_file2 FAILED 
test_basic_fixture2.py::test_comparewithCC_file2 FAILED

Pytest parametrisierter Test

Der Zweck der Parametrisierung eines Tests besteht darin, einen Test anhand mehrerer Argumentsätze auszuführen. Wir können dies durch @pytest.mark.parametrize tun.

Wir werden dies anhand des folgenden PyTest-Beispiels sehen. Hier übergeben wir 3 Argumente an eine Testmethode. Diese Testmethode fügt die ersten beiden Argumente hinzu und vergleicht sie mit dem dritten Argument.

Erstellen Sie die Testdatei test_addition.py mit dem folgenden Code

import pytest
@pytest.mark.parametrize("input1, input2, output",[(5,5,10),(3,5,12)])
def test_add(input1, input2, output):
	assert input1+input2 == output,"failed"

Hier akzeptiert die Testmethode 3 Argumente: Eingabe1, Eingabe2, Ausgabe. Es fügt input1 und input2 und comp hinzuares gegen den Ausgang.

Lassen Sie uns den Test mit py.test -k test_add -v ausführen und das Ergebnis sehen

test_addition.py::test_add[5-5-10] PASSED                                                                                                                                                                                              
test_addition.py::test_add[3-5-12] FAILED                                                                                                                                                                                              
============================================== FAILURES ==============================================
__________________________________________ test_add[3-5-12] __________________________________________
input1 = 3, input2 = 5, output = 12
    @pytest.mark.parametrize("input1, input2, output",[(5,5,10),(3,5,12)])
    def test_add(input1, input2, output):
>   	assert input1+input2 == output,"failed"
E    AssertionError: failed
E    assert (3 + 5) == 12
test_addition.py:5: AssertionError

Sie können sehen, dass die Tests zweimal ausgeführt wurden – einer prüfte 2+5 ==5 und der andere prüfte 10+3 ==5

test_addition.py::test_add[5-5-10] BESTANDEN

test_addition.py::test_add[3-5-12] FEHLGESCHLAGEN

Pytest Xfail / Tests überspringen

Es wird Situationen geben, in denen wir keinen Test ausführen möchten oder a Testfall ist für einen bestimmten Zeitpunkt nicht relevant. In solchen Situationen haben wir die Möglichkeit, den Test mit Xfail zu bestehen oder die Tests zu überspringen

Der xfailed-Test wird ausgeführt, aber nicht als teilweise fehlgeschlagener oder bestandener Test gezählt. Wenn dieser Test fehlschlägt, wird kein Traceback angezeigt. Wir können Tests mit xfail ausführen

@pytest.mark.xfail.

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

@pytest.mark.skip.

Bearbeiten Sie test_addition.py mit dem folgenden Code

import pytest
@pytest.mark.skip
def test_add_1():
	assert 100+200 == 400,"failed"

@pytest.mark.skip
def test_add_2():
	assert 100+200 == 300,"failed"

@pytest.mark.xfail
def test_add_3():
	assert 15+13 == 28,"failed"

@pytest.mark.xfail
def test_add_4():
	assert 15+13 == 100,"failed"

def test_add_5():
	assert 3+2 == 5,"failed"

def test_add_6():
	assert 3+2 == 6,"failed"

Hier

  • test_add_1 und test_add_2 werden übersprungen und nicht ausgeführt.
  • test_add_3 und test_add_4 sind xfailed. Diese Tests werden ausgeführt und sind Teil von xfailed-Tests (bei Testfehler) oder xpassed-Tests (bei bestandenem Test). Es gibt keine Rückverfolgung für Fehler.
  • test_add_5 und test_add_6 werden ausgeführt und test_add_6 meldet einen Fehler mit Traceback, während test_add_5 erfolgreich ist

Führen Sie den Test mit py.test test_addition.py -v aus und sehen Sie sich das Ergebnis an

test_addition.py::test_add_1 SKIPPED
test_addition.py::test_add_2 SKIPPED
test_addition.py::test_add_3 XPASS
test_addition.py::test_add_4 xfail
test_addition.py::test_add_5 PASSED
test_addition.py::test_add_6 FAILED

============================================== FAILURES ==============================================
_____________________________________________ test_add_6 _____________________________________________
    def test_add_6():
>   	assert 3+2 == 6,"failed"
E    AssertionError: failed
E    assert (3 + 2) == 6
test_addition.py:24: AssertionError

================ 1 failed, 1 passed, 2 skipped, 1 xfailed, 1 xpassed in 0.07 seconds =================

Ergebnisse XML

Wir können Testergebnisse im XML-Format erstellen, die wir zur weiteren Verarbeitung usw. an Continuous-Integration-Server weiterleiten können. Dies kann durch erfolgen

py.test test_sample1.py -v –junitxml=“result.xml“

Die result.xml zeichnet das Ergebnis der Testausführung auf. Nachfolgend finden Sie ein Beispiel für result.xml

<?xml version="1.0" encoding="UTF-8"?>
<testsuite errors="0" failures="1" name="pytest" skips="0" tests="2" time="0.046">
   <testcase classname="test_sample1" file="test_sample1.py" line="3" name="test_file1_method1" time="0.001384973526">
     <failure message="AssertionError:test failed because x=5 y=6 assert 5 ==6">
    @pytest.mark.set1
    def test_file1_method1():
    	x=5
    	y=6
       	assert x+1 == y,"test failed"
>      	assert x == y,"test failed because x=" + str(x) + " y=" + str(y)
E       AssertionError: test failed because x=5 y=6
E       assert 5 == 6
         test_sample1.py:9: AssertionError
    </failure>
   </testcase>
   <testcase classname="test_sample1" file="test_sample1.py" line="10" name="test_file1_method2" time="0.000830173492432" />
</testsuite>

Aus können wir insgesamt zwei Tests sehen, von denen einer fehlgeschlagen ist. Darunter ist die De zu sehentails zu jedem ausgeführten Test unter dem Tag .

Pytest Framework Testen einer API

Jetzt erstellen wir ein kleines Pytest-Framework, um eine API zu testen. Die hier verwendete API ist kostenlos von https://reqres.in/. Diese Website dient lediglich der Bereitstellung einer testbaren API. Diese Website speichert unsere Daten nicht.

Hier werden wir einige Tests schreiben

  • Auflistung einiger Benutzer
  • Mit Benutzern anmelden

Erstellen Sie die folgenden Dateien mit dem angegebenen Code

conftest.py – verfügt über ein Fixture, das die Basis-URL für alle Testmethoden bereitstellt

import pytest
@pytest.fixture
def supply_url():
	return "https://reqres.in/api"

test_list_user.py – enthält die Testmethoden zum Auflisten gültiger und ungültiger Benutzer

  • test_list_valid_user testet den gültigen Benutzerabruf und überprüft die Antwort
  • test_list_invaliduser testet auf ungültigen Benutzerabruf und überprüft die Antwort
import pytest
import requests
import json
@pytest.mark.parametrize("userid, firstname",[(1,"George"),(2,"Janet")])
def test_list_valid_user(supply_url,userid,firstname):
	url = supply_url + "/users/" + str(userid)
	resp = requests.get(url)
	j = json.loads(resp.text)
	assert resp.status_code == 200, resp.text
	assert j['data']['id'] == userid, resp.text
	assert j['data']['first_name'] == firstname, resp.text

def test_list_invaliduser(supply_url):
	url = supply_url + "/users/50"
	resp = requests.get(url)
	assert resp.status_code == 404, resp.text

test_login_user.py – enthält Testmethoden zum Testen der Anmeldefunktionalität.

  • test_login_valid testet den gültigen Anmeldeversuch mit zmail und das Passwort
  • test_login_no_password testet den ungültigen Anmeldeversuch ohne Übergabe des Passworts
  • test_login_no_email testet den ungültigen Anmeldeversuch, ohne e zu bestehenmail.
import pytest
import requests
import json
def test_login_valid(supply_url):
	url = supply_url + "/login/" 
	data = {'email':'test@test.com','password':'something'}
	resp = requests.post(url, data=data)
	j = json.loads(resp.text)
	assert resp.status_code == 200, resp.text
	assert j['token'] == "QpwL5tke4Pnpja7X", resp.text

def test_login_no_password(supply_url):
	url = supply_url + "/login/" 
	data = {'email':'test@test.com'}
	resp = requests.post(url, data=data)
	j = json.loads(resp.text)
	assert resp.status_code == 400, resp.text
	assert j['error'] == "Missing password", resp.text

def test_login_no_email(supply_url):
	url = supply_url + "/login/" 
	data = {}
	resp = requests.post(url, data=data)
	j = json.loads(resp.text)
	assert resp.status_code == 400, resp.text
	assert j['error'] == "Missing email or username", resp.text

Führen Sie den Test mit py.test -v aus

Sehen Sie sich das Ergebnis an als

test_list_user.py::test_list_valid_user[1-George] PASSED                                                                                                                                                                               
test_list_user.py::test_list_valid_user[2-Janet] PASSED                                                                                                                                                                                
test_list_user.py::test_list_invaliduser PASSED                                                                                                                                                                                        
test_login_user.py::test_login_valid PASSED                                                                                                                                                                                            
test_login_user.py::test_login_no_password PASSED                                                                                                                                                                                      
test_login_user.py::test_login_no_email PASSED

Aktualisieren Sie die Tests und probieren Sie verschiedene Ausgaben aus

Zusammenfassung

In diesem PyTest-Tutorial haben wir es behandelt

  • Installieren Sie Pytest mit pip installieren pytest=2.9.1
  • Einfaches Pytest-Programm und führen Sie es mit dem Befehl py.test aus.
  • Behauptungsanweisungen, „asser x==y“, geben entweder „True“ oder „False“ zurück.
  • Wie Pytest Testdateien und -methoden identifiziert.
  • Testdateien beginnend mit Prüfung_ oder endend mit _Prüfung
  • Testmethoden beginnend mit Test
  • Der Befehl py.test führt alle Testdateien in diesem Ordner und seinen Unterordnern aus. Um eine bestimmte Datei auszuführen, können wir den Befehl py.test verwenden
  • Führen Sie eine Teilmenge der Testmethoden aus
  • Gruppierung von Testnamen nach Teilzeichenfolge Matching.py.test -k -v führt alle Tests aus in seinem Namen.
  • Führen Sie den Test mit Markern aus. Markieren Sie die Tests mit @pytest.mark. und führen Sie die Tests mit pytest -m aus um Tests auszuführen, die als markiert sind .
  • Führen Sie Tests parallel durch
  • Installieren Sie pytest-xdist mit pip install pytest-xdist
  • Führen Sie Tests mit py.test -n NUM aus, wobei NUM die Anzahl der Arbeiter ist
  • Erstellen Sie Fixture-Methoden, um Code vor jedem Test auszuführen, indem Sie die Methode mit @pytest.fixture markieren
  • Der Geltungsbereich einer Fixture-Methode liegt in der Datei, in der sie definiert ist.
  • Auf eine Fixture-Methode kann über mehrere Testdateien hinweg zugegriffen werden, indem sie in der Datei conftest.py definiert wird.
  • Eine Testmethode kann auf ein Pytest-Fixture zugreifen, indem sie es als Eingabeargument verwendet.
  • Parametrisierung von Tests, um sie anhand mehrerer Eingabesätze auszuführen.
    @pytest.mark.parametrize(“Eingabe1, Eingabe2, Ausgabe”,[(5,5,10),(3,5,12)])
    def test_add(Eingabe1, Eingabe2, Ausgabe):
    Behauptung Eingabe1+Eingabe2 == Ausgabe, fehlgeschlagen
    führt den Test mit den Eingaben (5,5,10) und (3,5,12) durch.
  • Überspringen/xfail-Tests mit @pytets.mark.skip und @pytest.mark.xfail
  • Erstellen Sie Testergebnisse im XML-Format, die ausgeführte Testde abdeckentails mit py.test test_sample1.py -v –junitxml=“result.xml“
  • Ein Beispiel-Pytest-Framework zum Testen einer API