#Python # Unittest # Selenium # Automation
ebben a bejegyzésben megvizsgáljuk, hogyan lehet egységtesztelni egy webes alkalmazást Pythonban a funkcionalitás helyességének ellenőrzése érdekében. Whoa! Ez a mondat egy maroknyi zsargont tartalmaz: unit teszt, webes alkalmazás és funkcionalitás tesztelés.
egy korábbi bejegyzésben egy Python programot teszteltünk. Javasoljuk, hogy menjen át rajta, ha nem ismeri az egység tesztelését.
mi az egység teszt?
egység EGY program vagy alkalmazás legkisebb tesztelhető része.
tehát az egységteszteket az egyes tesztelhető alkatrészek programozható tesztelésére használják.
egységesen tesztelhet egy backend programot vagy egy frontend programot, például egy webes alkalmazást.
egy háttérprogram esetében egységtesztet írna a kód minden funkciójára vagy metódusára, mivel ezek logikai legkisebb egységek.
azonban a frontend, akkor azonosítja a különböző funkciókat szeretné ellenőrizni, és írjon egység tesztek ennek megfelelően.
ebben a bejegyzésben egy frontend programot fogunk tesztelni, nevezetesen egy webes alkalmazást.
mi az a webes alkalmazás?
minden olyan alkalmazás, amely egy webböngészőben, például Chrome, Firefox vagy Safari.
minden webes alkalmazásnak van egy közös vonása — a végfelhasználók számára egy HTML (Hypertext Markup Language) oldal látható. A HTML egyszerűen egy formázási nyelv, amely leírja, hogyan kell megszervezni a dolgokat. Ez egyszerűen egy szöveges fájl.
a böngészők megkapják ezt a HTML oldalt, és értelmezik a címkéket (pl. fej, test, HREF, táblázat stb.) annak érdekében, hogy egy szép oldalt mutasson neked.
a webalkalmazások az ügyfél-kiszolgáló architektúrában működnek — ahol a webkiszolgáló tárolja az elérni kívánt tartalmat, a webböngésző pedig kliensként működik.
mi a funkcionalitás tesztelése?
ahogy a neve is mutatja, amikor funkcionális tesztelési kódot ír, a cél az alkalmazás funkcionalitásának tesztelése. Más szavakkal, meg kell győződnie arról, hogy az alkalmazás követi a funkcionális specifikációt.
vannak más típusú tesztek, például teljesítménytesztek, biztonsági (penetrációs) tesztek és felhasználói elfogadhatósági tesztek.
az Ön által írt funkcionális tesztkód szerepelhet az úgynevezett regressziós tesztben, amelyet rendszeresen hajtanak végre annak érdekében, hogy megbizonyosodjon arról, hogy a régi funkciók nem törnek el az új fejlesztés miatt.
a bejegyzés végén meg fogja érteni az alább említett teljes kódot.
ne csüggedjen, ha úgy érzi, hogy ez túl sok. Ennek a bejegyzésnek az a célja, hogy ezt boncolgassa, és megmutassa, hogyan értheti meg ezt a kódot, majd írja meg a sajátját!
az alábbi ábra a webes alkalmazás (oldal) automatikus tesztelésének magas szintű megközelítését mutatja.
tesztjeink megírásához egy unittest nevű tesztkeretet használunk. Nagyon hasonlít a junit-hoz a Java-ban vagy a nunit-hoz a .Net-ben.
unittest lehetővé teszi, hogy csoportosítsa az inicializáló kódot egy beállítási funkcióba, és tisztítsa meg a kódot tin a tearDown függvény.
az alábbi ábra az egységtesztelés általános megközelítését mutatja.
mint látható a fenti ábrán, a teszt suite áll egy vagy több teszt esetek.
egy tesztesetnek lehet egy vagy több tesztje. Ebben a bejegyzésben egy tesztesetre fogunk összpontosítani egy teszttel. A végén megmutatjuk, hogyan lehet több tesztet hozzáadni ugyanahhoz a tesztesethez, valamint létrehozni egy tesztcsomagot.
mint korábban említettük, minden tesztesetnek van egy setUp (Futtatás az elején) és a tearDown (futás a végén) módszere az inicializáláshoz és a tisztításhoz.
a fenti kódrészlet egy egységteszt-eset szerkezetét mutatja.
1.sor: importálja a szükséges könyvtárakat. A mi esetünkben selenium és unittest könyvtárakat használunk.
3.sor: létrehoz egy mytestcase nevű osztályt, amely kiterjeszti az unittest-et.TestCase osztály. Azt mondjuk, hogy unittest.A TestCase a szülő osztály, a MyTestCase pedig a gyermek osztály.
4.sor: az inicializálási kódot hozzáadjuk a beállítási módszerhez. A pontos metódusnevet kell használnia, hogy az unittest tudja, hogy itt adja hozzá az inicializálási kódot. Amikor futtatja ezt a tesztesetet, ez a módszer kerül végrehajtásra először.
7. sor: minta teszt, amelyet be akarunk vonni a teszt esetébe.
10.sor: egy másik minta teszt, amely a tesztesetben van.
16. sor: ebben a lebontási módszerben adjuk hozzá a tisztítási kódot. Az ellenkezője a beállítási módszer, tearDown módszer lesz végrehajtva az utolsó.
tehát a módszer meghívásának sorrendje:
beállítás > test1 > test2 > … > letépés
20.sor: Ez azt mondja, hogy a fő program erről a helyről indul.
21.sor: így futtatja a tesztesetet.
itt az ideje, hogy rátegyük a kezünket a tényleges tesztre, amelyet meg akartunk csinálni. Visszahívás, hogy tesztelni akarjuk, hogy a Google keresőmezője legalább 5 találatot ad-e vissza egy adott keresési kulcsszóra.
nézzük meg először a beállítási módszert:
ebben a kódrészletben létrehozzuk a Chrome böngésző illesztőprogramját.
innen kell letöltenie a selenium Chrome illesztőprogramot, ha még nem rendelkezik vele. Az írás óta a Chrome rendelkezik a 74-es verzióval is. Mivel a Chrome böngészőm a 73-as verzió, letöltöttem a 73-as verziót ehhez a gyakorlathoz.
a 2.és 3. sor létrehozza a Chrome opciót, és tudatja a selenium webdriverrel, hogy nem akarjuk láthatóvá tenni a böngészőt a teszt futtatásakor.
ha nem adja hozzá ezt az opciót, a teszt elakad azon a ponton, ahol a böngésző megnyílik.
most nézzük meg a lebontási módszert:
mi egyszerűen tisztítsák meg a vezető hívja quit () módszer.
Végül itt az ideje, hogy megnézzük azt a tesztet, amelyet ebbe a tesztesetbe szeretnénk belefoglalni. Emlékezzünk arra, hogy tesztelhetjük (állíthatjuk), ha a visszaadott keresési eredmények száma nagyobb vagy egyenlő 5-tel.
1.sor: a vizsgálati módszer a “teszt”szóval kezdődik.
3. sor: terhelés www.google.com weboldal a vezető (vegye figyelembe, hogy önálló.az Illesztőprogram a beállítási idő alatt jön létre).
6. sor: Keresse meg a keresőmezőt HTML elem neve alapján “q”. Ennek azonosításához meg kell vizsgálnia a HTML oldalt.
7. sor: ürítse ki a keresőmezőt, ha vannak alapértelmezett értékek.
10.sor: töltse ki a keresőmezőt az “automatizált tesztelés”Keresési karakterlánccal.
11.sor: küldje el a keresési lekérdezést a Google-nak.
14. sor: XPath a keresési eredmények címsorainak azonosítása.
17.sor: várjon 10 másodpercet, amíg a Google találati oldala betöltődik.
20. sor: az összes keresési eredmény fejlécét a 14. sorban meghatározott XPath használatával szerezheti be.
25. és 26. sor: A keresési eredmények címsorai valójában egy lista, amelyet végigjárunk, hogy kimenjünk a képernyőre. Ezt a két sort csak demonstrációs célokra adtuk hozzá. Általában a teszt szkriptek nem rendelkeznek nyomtatási képernyőkkel, mivel senki sem áll rendelkezésre a képernyő bámulására, hogy automatizált állapotban lássa az ilyen kimenetet.
30.sor: ez a tényleges állítás, amit csinálunk. assertGreater egy meghatározott módszer unittest.TestCase osztály, amely lehetővé teszi számunkra, hogy ellenőrizze, ha néhány kimenet nagyobb, mint a néhány értéket.
unittest.TestCase valójában ad nekünk egy sor ilyen módszer, hogy ellenőrizze az egyenlőség, nagyobb, kevesebb, mint, stb. attól függően, hogy mit akar állítani. Az alábbi táblázat bemutatja a rendelkezésre álló általános assert módszereket.
amint az elején látható, a tesztesetet az alábbiak meghívásával írhatja be a kódjába:
unittest.main()
a parancssorba egyszerűen beírhatja a teszteset mentéséhez használt fájlnevet.
python google_search_test.py
futtatja a setUp(), majd a test_result_count() és végül a tearDown () függvényt.
a következőhöz hasonló kimenetet kell látnia:
ha bármelyik teszt sikertelen, akkor a sikertelen üzenet jelenik meg a sikertelen tesztmódszerrel együtt.
ez az első sikeres szelén / unittest teszt esetében. Gratulálok! Ez egy fontos mérföldkő.
bónusz
ha van steam, azt javasoljuk, hogy kövesse a többit annak érdekében, hogy még mélyebben szelén/unittest base webes alkalmazás automatizált tesztelés.
tegyük fel, hogy tesztelni szeretné, hogy a címsor megegyezik-e a “Google” – val.
a tesztkód a következőképpen néz ki:
def test_header(self):
self.driver.get("http://www.google.com")
self.assertEqual("Google", self.driver.title)
most az egész tesztesetünk a következőképpen néz ki:
class GoogleSearchTest(unittest.TestCase):
def setUp(self): def test_header(self): def test_result_count(self): def tearDown(self):
if __name__ == "__main__":
unittest.main()
tegyük fel, hogy a fenti nyomtatási képernyők kommentálva vannak. A frissített teszteset futtatásakor a következő kimenetet kell kapnia:
test_header (__main__.GoogleSearchTest) ... ok
test_result_count (__main__.GoogleSearchTest) ... ok----------------------------------------------------------------------
Ran 2 tests in 13.799s
OK
azt mondja, hogy két tesztet futtattak, és mindkettő sikeres volt.
tegyük fel, hogy az első tesztben megváltoztatom az assertEqual feltételt a következőre:
self.assertEqual("Microsoft", self.driver.title)
mit gondolsz, mi fog történni itt?
igen, jól találtad ki. Az első teszt eset önmagában kudarcot vall.sofőr.a cím megegyezik a Google-val, nem a Microsofttal.
a következőhöz hasonló kimenetet kap:
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)
a fenti kimenet azt mondja,hogy csak egy teszt volt sikeres, a sikertelen.
amikor először írja meg a teszteseteket, ilyen helyzetekkel találkozhat.
feltételezve, hogy a teszt eset helyes, azonosítani fogja a hibákat a kódban, és megkapja a megfelelő fejlesztőket, hogy javítsák ki a problémát és teszteljék újra.
ha ez a hiba regressziós tesztben történik, akkor ez a hiba a meglévő kódbázis tetején végzett új szoftverfejlesztés miatt kerül bevezetésre.
ez azt mutatja, hogy valami nincs rendben az új kódbázissal, amelyet javítani kell, hogy megbizonyosodjon arról, hogy a régi funkció működik. A fejlesztőknek ismét gondoskodniuk kell róla.
mi lenne, ha sok teszteset lenne? Tegyük fel, hogy van TestCase1 és TestCase2, mindegyiknek több tesztje van.
létrehozhatja az úgynevezett tesztcsomagot, és futtathatja azt egy tesztfutó segítségével az alábbiak szerint:
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(TestCase1))
suite.addTest(unittest.makeSuite(TestCase2))
runner = unittest.TextTestRunner()
runner.run(suite)
a fenti kód futtatja az összes tesztet a TestCase1-ben, majd a TestCase2-ben.
ennyi mára. Remélem, ez segít.