#Python #Unittest #Selenium #Automation
în acest post, vom analiza modul de testare a unității o aplicație web în Python pentru a verifica corectitudinea funcționalității. Whoa! Această propoziție are o mână de jargon: test de unitate, aplicație web și testare a funcționalității.
ne-am uitat la unitatea de testare a unui program Python într-un post anterior. Vă încurajăm să treceți prin ea, dacă nu sunteți familiarizați cu testarea unității.
ce este un test unitar?
unitatea este cea mai mică parte testabilă a unui program sau a unei aplicații.
deci, testele unitare sunt utilizate pentru a testa programatic fiecare componentă testabilă.
puteți testa un program de backend sau un program de frontend, cum ar fi o aplicație web.
pentru un program de backend, ar scrie un test de unitate pentru fiecare funcție sau metodă în codul ca acestea sunt cele mai mici unități logice.
cu toate acestea, pentru o interfață, veți identifica diferite funcționalități pe care doriți să le verificați și să scrieți teste unitare în consecință.
în această postare, vom testa un program frontend, și anume o aplicație web.
ce este o aplicație web?
orice aplicație care face pe un browser web, cum ar fi Chrome, Firefox sau Safari.
toate aplicațiile web au un lucru în comun — sunt vizibile pentru utilizatorii finali o pagină HTML (Hypertext Markup Language). HTML este pur și simplu un limbaj de formatare pentru a descrie modul în care lucrurile ar trebui să fie organizate. Este pur și simplu un fișier text.
browserele primesc această pagină HTML și interpretează etichetele (de exemplu, cap, corp, HREF, tabel etc.) pentru a vă arăta o pagină frumoasă.
aplicațiile Web funcționează în arhitectura client-server — unde serverul web găzduiește conținutul pe care doriți să îl accesați și browserul web acționează ca client.
ce este testarea funcționalității?
după cum sugerează și numele, atunci când scrieți cod de testare funcțională, obiectivul dvs. este de a testa funcționalitatea aplicației. Cu alte cuvinte, doriți să vă asigurați că aplicația respectă specificațiile funcționale.
există și alte tipuri de teste, cum ar fi testele de performanță, testele de securitate (penetrare) și testele de acceptabilitate ale utilizatorului.
codul de test funcțional pe care îl scrieți poate fi inclus în ceea ce se numește test de regresie care este executat periodic pentru a vă asigura că funcționalitatea veche nu este ruptă din cauza dezvoltării noi.
la sfârșitul acestui post, veți înțelege codul complet menționat mai jos.
nu vă descurajați dacă simțiți că acest lucru este prea mult. Scopul acestei postări este de a diseca acest lucru și de a vă arăta cum puteți înțelege acest cod și apoi să vă scrieți propriul!
următoarea diagramă arată abordarea la nivel înalt pentru a testa automat o aplicație web (pagină).
pentru a scrie testele noastre, folosim un cadru de testare numit unittest. Este foarte similar cu junit în Java sau nunit în .Net.
unittest vă permite să grupați codul de inițializare într-o funcție de configurare și să curățați codul tin o funcție tearDown.
următoarea diagramă prezintă abordarea generală din spatele testării unității.
după cum puteți vedea din diagrama de mai sus, o suită de testare constă din unul sau mai multe cazuri de testare.
un caz de testare poate avea unul sau mai multe teste. În acest post, ne vom concentra pe un caz de testare cu un singur test. Vom arăta la final cum să adăugați mai multe teste la același caz de testare, precum și să creați o suită de testare.
așa cum am menționat mai devreme, fiecare caz de testare are o configurare (rula la început) și tearDown (rula la sfârșitul) metode pentru a face inițializare și curăța respectiv.
fragmentul de cod de mai sus arată structura unui caz de testare unitate.
linia 1: importați bibliotecile necesare. În cazul nostru, folosim biblioteci selenium și unittest.
linia 3: creați o clasă numită mytestcase care extinde unittest.Clasa TestCase. Noi spunem că unittest.TestCase este clasa părinte și mytestcase este clasa copil.
Linia 4: adăugăm codul nostru de inițializare în metoda de configurare. Trebuie să utilizați numele exact al metodei pentru a anunța unittest că adăugați codul de inițializare aici. Când executați acest caz de testare, această metodă este executată mai întâi.
Linia 7: un test de probă pe care dorim să îl includem în cazul testului.
linia 10: Un alt test de probă pe care îl avem în cazul nostru de testare.
linia 16: adăugăm codul nostru de curățare în această metodă tearDown. Opusul metodei de configurare, metoda tearDown este executată ultima.
deci, ordinea invocării metodei este:
configurare > test1 > test2 > … > tearDown
linia 20: aceasta spune că programul principal pornește din acest loc.
linia 21: acesta este modul în care executați cazul de testare.
acum este timpul să punem mâna pe testul real pe care am vrut să-l facem. Reamintim că dorim să testăm dacă google search box returnează cel puțin 5 rezultate pentru un anumit cuvânt cheie de căutare.
să ne uităm mai întâi la metoda de configurare:
în acest fragment de cod, creăm driverul browserului Chrome.
trebuie să descărcați driverul selenium Chrome de aici dacă nu îl aveți deja. Începând cu această scriere, Chrome are și versiunea 74. Deoarece browserul meu Chrome este versiunea 73, am descărcat versiunea 73 pentru acest exercițiu.
Linia 2 și 3 creează opțiunea Chrome și anunță selenium webdriver că nu dorim să facem browserul vizibil atunci când rulăm testul.
dacă nu adăugați această opțiune, testul dvs. se blochează în punctul în care se deschide browserul.
acum să ne uităm la metoda tearDown:
pur și simplu curățăm șoferul apelând metoda quit ().
în cele din urmă, este timpul să aruncăm o privire asupra testului pe care dorim să îl includem în acest caz de testare. Reamintim că putem pentru a testa (afirma) dacă numărul de rezultate de căutare returnate este mai mare sau egal cu 5.
linia 1: Metoda de testare începe cu cuvântul „test”.
linia 3: Încărcați www.google.com pagina web în driver (rețineți că auto.driverul este creat în timpul instalării).
linia 6: Localizați caseta de căutare după numele elementului HTML”q”. Trebuie să inspectați pagina HTML pentru a identifica acest lucru.
Linia 7: Faceți caseta de căutare goală în cazul în care există valori implicite.
linia 10: completați caseta de căutare cu șirul de căutare „testare automată”.
linia 11: trimiteți interogarea de căutare la Google.
linia 14: XPath identificarea titlurilor rezultatelor căutării.
linia 17: așteptați 10 secunde până când pagina de rezultate Google este încărcată.
linia 20: obțineți toate titlurile rezultatelor căutării utilizând XPath definit în linia 14.
liniile 25 și 26: Titlurile rezultatelor căutării sunt de fapt o listă și le repetăm pentru a ieși pe ecran. Am adăugat aceste două linii doar în scop demonstrativ. De obicei, scripturile de testare nu au ecrane de imprimare, deoarece nu există nimeni disponibil să privească ecranul pentru a vedea o astfel de ieșire atunci când este automatizat.
linia 30: Aceasta este afirmația reală pe care o facem. assertGreater este o metodă definită în unittest.Clasa TestCase care ne permite să verificăm dacă o anumită ieșire este mai mare decât o anumită valoare.
unittest.TestCase ne oferă de fapt un set de astfel de metode pentru a verifica egalitatea, mai mare decât, mai mică decât etc. în funcție de ceea ce doriți să afirmați. Următoarea diagramă prezintă unele dintre metodele comune assert disponibile.
după cum se arată la început, puteți scrie cazul de testare invocând următoarele în codul dvs:
unittest.main()
în linia de comandă puteți introduce pur și simplu numele fișierului pe care l-ați folosit pentru a salva cazul de testare.
python google_search_test.py
se execută setUp(), apoi test_result_count() și în cele din urmă tearDown().
ar trebui să vedeți o ieșire similară cu următoarea:
dacă orice test eșuează, veți vedea mesajul FAIL împreună cu metoda de testare care nu a reușit.
acesta este primul dvs. test de seleniu/unittest de succes. Felicitări! Este un reper important.
Bonus
dacă aveți steam, v-aș încuraja să urmați restul pentru a obține și mai adânc în testarea automată a aplicației web Selenium/unittest base.
să presupunem că doriți să testați dacă titlul este egal cu „Google”.
codul de testare arată după cum urmează:
def test_header(self):
self.driver.get("http://www.google.com")
self.assertEqual("Google", self.driver.title)
acum, întregul nostru caz de testare arată după cum urmează:
class GoogleSearchTest(unittest.TestCase):
def setUp(self): def test_header(self): def test_result_count(self): def tearDown(self):
if __name__ == "__main__":
unittest.main()
să presupunem că ecranele de imprimare de mai sus sunt comentate. Când executați cazul de testare actualizat, ar trebui să obțineți o ieșire după cum urmează:
test_header (__main__.GoogleSearchTest) ... ok
test_result_count (__main__.GoogleSearchTest) ... ok----------------------------------------------------------------------
Ran 2 tests in 13.799s
OK
se spune că a efectuat două teste și ambele au succes.
să presupunem că am schimba condiția asertequal în primul test la următoarele:
self.assertEqual("Microsoft", self.driver.title)
ce crezi că s-ar întâmpla aici?
da, ai ghicit bine. Primul caz de testare va eșua ca sine.șofer.titlul este egal cu Google, nu Microsoft.
veți obține o ieșire similară cu următoarea:
test_header (__main__.GoogleSearchTest) ... FAIL
test_result_count (__main__.GoogleSearchTest) ... ok
====================================================================
FAIL: test_header (__main__.GoogleSearchTest)
--------------------------------------------------------------------
Traceback (most recent call last):
File "google_search_test.py", line 19, in test_header
self.assertEqual("Microsoft", self.driver.title)
AssertionError: 'Microsoft' != 'Google'
- Microsoft
--------------------------------------------------------------------
Ran 2 tests in 14.011s
FAILED (failures=1)
rezultatul de mai sus spune că un singur test a avut succes și a eșuat.
când scrieți cazurile de testare pentru prima dată, puteți întâlni situații de acest gen.
presupunând că cazul dvs. de testare este corect, veți identifica erori în cod și veți obține dezvoltatorii respectivi să remedieze problema și să retesteze.
dacă această eroare se întâmplă într-un test de regresie, acest bug este introdus din cauza dezvoltării de software nou făcut pe partea de sus a bazei de cod existente.
acest lucru arată că există ceva în neregulă cu noua bază de cod care trebuie remediată pentru a vă asigura că vechea funcționalitate funcționează. Din nou, dezvoltatorii trebuie să aibă grijă de ea.
Ce zici de a avea multe cazuri de testare? Să presupunem că avem TestCase1 și TestCase2, fiecare având mai multe teste.
puteți crea ceea ce se numește o suită de testare și rulați-l folosind un alergător de testare, după cum urmează:
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(TestCase1))
suite.addTest(unittest.makeSuite(TestCase2))
runner = unittest.TextTestRunner()
runner.run(suite)
codul de mai sus va rula toate testele în TestCase1 și apoi în TestCase2.
asta e pentru ziua de azi. Sper că vă ajută.