Niciun dezvoltator bun nu implementează cod fără testare amănunțită. Testarea unitară este procesul de testare a modulelor individuale ale unui program mare.
Acest articol va discuta cum puteți efectua testarea unitară a codului dvs. folosind modulul Python unittest. În primul rând, să înțelegem care sunt tipurile de testare.
Când vine vorba de testare, există testarea manuală și testarea automată. Testarea manuală este o tehnică de testare în care oamenii efectuează testul manual după finalizarea dezvoltării. Testarea automatizată este o tehnică de testare în care programele efectuează automat testul și ne oferă rezultatele.
Ai fi înțeles că testarea manuală necesită timp și este greu de efectuat. Deci, dezvoltatorii scriu cod pentru efectuarea de teste (testare automată). Există diferite tipuri de testare în testarea automată. Unele dintre ele sunt testarea unitară, testarea de integrare, testarea de la capăt la capăt, testarea la stres, etc.,
Să vedem fluxul standard de testare.
- Scrieți sau actualizați codul.
- Scrieți sau actualizați teste pentru diferite cazuri pentru codul dvs.
- Rulați testele (fie manual, fie utilizând un test runner).
- Vezi rezultatele testului. Dacă există erori, remediați-le și repetați pașii.
Aici, vom discuta despre cel mai esențial și de bază tip de testare numit test unitar. Fără alte prelungiri, să ne aruncăm în tutorialul propriu-zis.
Cuprins
Ce este testarea unitară?
Testarea unitară este o tehnică de testare a unui bloc mic de cod independent. Codul de bloc mic va fi o funcție în majoritatea cazurilor. Cuvântul independent înseamnă că nu depinde de alte bucăți de cod din proiect.
Să presupunem că trebuie să verificăm dacă un șir este egal cu „tipstrick.ro” sau nu. Pentru asta, am scris o funcție care ia un argument și returnează dacă este egală cu „tipstrick.ro” sau nu.
def is_equal_to_geekflare(string): return string == "tipstrick.ro"
Funcția de mai sus nu are dependențe de niciun alt cod. Așadar, îl putem testa independent, dând diferite intrări. Piesa independentă de cod poate fi utilizată în întregul proiect.
Importanța testării unitare
În general, codul blocurilor independente poate fi utilizat în întregul proiect. Deci, trebuie să fie bine scris și testat. Testele unitare sunt testele folosite pentru a testa acele tipuri de blocuri independente de cod. Ce se întâmplă dacă nu folosim teste unitare pentru proiectul nostru?
Să presupunem că nu am testat blocuri mici de cod care sunt utilizate în cadrul proiectului. Toate celelalte teste, cum ar fi testele de integrare, testele end-to-end etc., care utilizează celelalte blocuri mici de cod pot eșua. Acest lucru rupe aplicația. De aceea, elementele de bază ale codului trebuie testate bine.
Acum, știm importanța testării unitare și a testelor unitare scrise pentru toate blocurile de cod independente. Deoarece am efectuat teste unitare, alte teste precum testele de integrare, testele end-to-end etc., nu vor eșua din cauza blocului independent de coduri.
În secțiunile următoare, vom vedea ce este modulul unittest Python și cum folosim modulul unittest pentru a scrie teste unitare în Python.
Notă: Presupunem că sunteți familiarizat cu clasele, modulele etc. Python. Dacă nu sunteți familiarizat cu conceptele intermediare Python, cum ar fi clase, module etc., s-ar putea să vă fie dificil să înțelegeți secțiunile următoare.
Ce este testul unitar Python?
Python unittest este un cadru de testare încorporat pentru a testa codul Python. Are un test runner, care ne permite să rulăm testele fără prea mult efort. Deci, putem folosi modulul unittest încorporat pentru testare fără a folosi modulele terțe. Dar, se schimbă în funcție de cerințele dvs. Modulul unittest încorporat este bun pentru a începe testarea în Python.
Trebuie să urmăm pașii de mai jos pentru a testa codul Python folosind modulul unittest.
#1. Scrie codul.
#2. Importați modulul test unitar.
#3. Creați un fișier începând cu testul de cuvinte cheie. De exemplu, test_prime.py. Cuvântul cheie test este folosit pentru a identifica fișierele de testare.
#4. Creați o clasă care extinde clasa unittest.TestCase.
#5. Scrieți metode (teste) în cadrul clasei. Fiecare metodă conține cazuri de testare diferite în funcție de cerințele dvs. Trebuie să denumim metoda începând cu cuvântul cheie test.
#6. Rulați testele. Putem rula testele în moduri diferite.
- Rulați comanda python -m unittest test_filename.py.
- Rulăm fișierele de testare ca fișierele Python generale cu comanda python test_filename.py. Pentru ca această metodă să funcționeze, trebuie să invocăm metoda principală a testului unitar din fișierul de testare.
- Și, în sfârșit, folosind descoperirea. Putem rula automat testele folosind comanda python -m unittest discover fără a menționa numele fișierului testului. Va găsi testele folosind convenția de denumire pe care am urmat-o. Deci, trebuie să denumim fișierele noastre de testare cu cuvântul cheie test la pornire.
În general, în timpul testării, comparăm rezultatul codului cu rezultatul așteptat. Deci, pentru a compara ieșirile unittest oferă diferite metode. Puteți găsi lista de funcții de comparare Aici.
Le poți înțelege cu ușurință, fără nicio dificultate. Sunt simpli.
Asta e multă teorie. Acum trebuie să intrăm în codificare.
Notă: Dacă aveți întrebări despre modulul test unitar, puteți accesa documentație și ștergeți-vă îndoielile. Fără alte întârzieri, să folosim modulul unittest.
Teste unitare în Python folosind unittest
Vom scrie mai întâi câteva funcții, apoi ne vom concentra pe scrierea testelor. Mai întâi, deschideți un folder în editorul de cod preferat. Și creați un fișier numit utils.py. Lipiți următorul cod în fișier.
import math
def is_prime(n):
if n < 0:
return 'Negative numbers are not allowed'
if n <= 1:
return False
if n == 2:
return True
if n % 2 == 0:
return False
for i in range(2, int(math.sqrt(n)) + 1):
if n % i == 0:
return False
return True
def cubic(a):
return a * a * a
def say_hello(name):
return "Hello, " + name
Avem trei funcții diferite în fișierul utils.py. Acum, trebuie să testăm fiecare funcție cu cazuri de testare diferite. Să scriem testele pentru prima funcție is_prime.
#1. Creați un fișier numit test_utils.py în folderul eșantion ca utils.py.
#2. Importați modulul utils și unittest.
#3. Creați o clasă cu numele TestUtils extinzând clasa unittest.TestCase. Numele clasei poate fi orice. Încercați să dați clasei un nume semnificativ.
#4. În interiorul clasei, scrieți o metodă numită test_is_prime care acceptă self ca argument.
#5. Scrieți diferite cazuri de testare cu argumente pentru is_prime și comparați rezultatul cu rezultatul așteptat.
#6. Exemplu de caz de testare self.assertFalse(utils.is_prime(1)).
#7. Ne așteptăm ca rezultatul is_prime(1) să fie fals în cazul de mai sus.
#8. Similar cu cazul de mai sus, vom testa diferite cazuri în funcție de funcția pe care o testăm.
Să vedem testele.
import unittest
import utils
class TestUtils(unittest.TestCase):
def test_is_prime(self):
self.assertFalse(utils.is_prime(4))
self.assertTrue(utils.is_prime(2))
self.assertTrue(utils.is_prime(3))
self.assertFalse(utils.is_prime(8))
self.assertFalse(utils.is_prime(10))
self.assertTrue(utils.is_prime(7))
self.assertEqual(utils.is_prime(-3),
"Negative numbers are not allowed")
if __name__ == '__main__':
unittest.main()
Invocăm metoda principală de unittest a modulului pentru a rula testele folosind comanda python filename.py. Acum, rulează testele.
Veți vedea rezultatul similar cu cel de mai jos.
$ python test_utils.py . ---------------------------------------------------------------------- Ran 1 test in 0.001s OK
Acum, încercați să scrieți cazurile de testare și pentru alte funcții. Gândiți-vă la diferite cazuri pentru funcții și scrieți teste pentru ele. Aruncă o privire la următoarele teste care sunt adăugate la clasa de mai sus.
...
class TestUtils(unittest.TestCase):
def test_is_prime(self):
...
def test_cubic(self):
self.assertEqual(utils.cubic(2), 8)
self.assertEqual(utils.cubic(-2), -8)
self.assertNotEqual(utils.cubic(2), 4)
self.assertNotEqual(utils.cubic(-3), 27)
def test_say_hello(self):
self.assertEqual(utils.say_hello("tipstrick.ro"), "Hello, tipstrick.ro")
self.assertEqual(utils.say_hello("Chandan"), "Hello, Chandan")
self.assertNotEqual(utils.say_hello("Chandan"), "Hi, Chandan")
self.assertNotEqual(utils.say_hello("Hafeez"), "Hi, Hafeez")
...
Am folosit doar câteva dintre funcțiile de comparare din modulul unittest. Puteți găsi lista completă Aici.
Am învățat cum să scriem teste unitare folosind modulul unittest. Acum, este timpul să vedem diferite moduri de a rula testele.
Cum să rulați teste folosind unittest
Am văzut deja o modalitate de a rula cazurile de testare în secțiunea de mai sus. Să vedem celelalte două moduri de a rula testele folosind modulul unittest.
#1. Folosind numele fișierului și modulul unittest.
În această metodă, vom folosi modulul unittest și numele fișierului pentru a rula testele. Comanda pentru a rula testele este python -m unittest filename.py. În cazul nostru, comanda pentru a rula testele este python -m unittest test_utils.py.
#2. Folosind metoda descoperire
Vom folosi metoda discover a modulului unittest pentru a detecta automat toate fișierele de testare și a le rula. Pentru a detecta automat fișierele de testare, trebuie să le denumim începând cu cuvântul cheie test.
Comanda pentru a rula testele folosind metoda discover este python -m unittest discover. Comanda va detecta toate fișierele ale căror nume încep cu test și le va executa.
Concluzie 👩💻
Testele unitare sunt teste de bază în lumea programării. Există o mulțime de alte teste în lumea reală. Încercați să le învățați o dată câte unul. Sper că acest tutorial vă ajută să scrieți teste de bază în Python folosind modulul unittest. Există biblioteci terță parte precum pytest, Robot Framework, nose, nose2, slash etc. Le puteți explora în funcție de cerințele proiectului dumneavoastră.
Testare fericită 😎
Ați putea fi, de asemenea, interesat de Întrebări și răspunsuri la interviu Python.