Două moduri de a eșua
Un test poate raporta o problemă în două moduri, iar diferența constă în ce se întâmplă după:
Un assert care eșuează ridică AssertionError, iar asta oprește testul în care se află — verificările scrise după el nu mai rulează niciodată. Acesta este comportamentul de oprire rapidă (fail-fast) și este cel pe care îl ai în mod implicit.
Ca să raportezi o problemă și să continui verificările, pune fiecare verificare în propria funcție test_. Testele sunt independente: un test care eșuează nu îl oprește pe următorul, așa că o singură rulare poate raporta mai multe probleme deodată.
Un assert poate avea și un mesaj: assert got == want, "explanation". Textul este afișat deasupra valorilor comparate atunci când verificarea eșuează.
Teste separate: raportează și continuă
Când vrei să verifici mai multe cazuri la rând, dă fiecărui caz propria funcție de test. Un caz greșit este raportat, iar cazurile de după el sunt verificate în continuare.
Astfel, o singură rulare pytest îți arată toate stricăciunile — nu doar primul caz greșit.
Vezi toate cazurile greșite deodată
Această funcție add ignoră b, așa că toate cele trei verificări eșuează. Deoarece fiecare verificare este un test separat, toate cele trei blocuri de eșec apar într-o singură rulare, iar rezumatul spune 3 failed. Scrise ca trei assert-uri într-un singur test, doar primul ar fi fost raportat.
Ieșire: program Python complet
# add are o eroare: ignoră b.
def add(a, b):
return a
def test_add_two_and_two():
assert add(2, 2) == 4
def test_add_two_and_three():
assert add(2, 3) == 5
def test_add_ten_and_one():
assert add(10, 1) == 11
Un assert eșuat oprește testul
Uneori o verificare eșuată înseamnă că restul testului nu poate funcționa. Un caz tipic: testul pregătește mai întâi o valoare, apoi o examinează. Dacă pregătirea a mers deja prost, examinarea ar fi inutilă sau chiar ar provoca o eroare.
Aici assert-ul cu oprire rapidă este exact ce îți trebuie. El încheie testul chiar în acel punct, iar verificările de după el nu mai rulează niciodată — și tocmai acesta este scopul.
Oprește-te înainte de verificările inutile
split_words are o eroare (împarte după caracterul greșit), așa că se întoarce 1 parte în loc de 3. Primul assert eșuează cu mesajul număr de părți: 1, se așteptau 3 - nu le pot verifica și oprește testul — nu se mai ajunge la verificarea primei părți de mai jos.
Ieșire: program Python complet
# split_words are o eroare: împarte după ";" în loc de ",".
def split_words(s):
return s.split(";")
def test_split():
parts = split_words("one,two,three")
assert len(parts) == 3, f"număr de părți: {len(parts)}, se așteptau 3 - nu le pot verifica"
# Nu se ajunge niciodată aici cât timp eroarea există.
assert parts[0] == "one"
Mesaje la verificările booleene
Pentru un răspuns simplu de tip da sau nu nu există o pereche got și want — verifici cu assert chiar valoarea: assert is_even(4) eșuează când apelul returnează False.
Mesajul de după virgulă este opțional, dar la o valoare booleană simplă merită scris: fără el, eșecul arată doar apelul care a returnat False; cu el, eșecul spune și ce înseamnă asta.
Mesaje simple
Două verificări booleene simple cu mesaje simple, ambele într-un singur test. Aici amândouă trec, așa că mesajele nu apar, iar rularea afișează 1 passed.
Ieșire: program Python complet
def is_even(n):
return n % 2 == 0
def test_is_even():
assert is_even(4), "4 ar trebui să fie par"
assert not is_even(3), "3 nu ar trebui să fie par"