# Python # Unittest # Selenium # Automation
I dette innlegget skal vi se på hvordan du tester en webapplikasjon i Python for å kontrollere at funksjonaliteten er riktig. Whoa! Den setningen har en håndfull jargong: enhetstest, webapplikasjon og funksjonalitetstesting.
Vi så på enhetstesting Av Et Python-program i et tidligere innlegg. Vi oppfordrer deg til å gå gjennom det, hvis du ikke er kjent med enhetstesting.
Hva er en enhetstest?
Unit Er en minste testbar del av et program eller et program.
så, enhetstester brukes til å teste programmatisk hver testbar komponent.
du kan enhetstestere et backend-program eller et frontend-program, for eksempel et webprogram.
for et backend-program, vil du skrive en enhetstest for hver funksjon eller metode i koden, da de er logiske minste enheter.
For en frontend vil Du imidlertid identifisere forskjellig funksjonalitet du vil sjekke og skrive enhetstester tilsvarende.
I dette innlegget skal vi teste et frontend-program, nemlig en webapplikasjon.
hva er en webapplikasjon?
ethvert program som gjengir på en nettleser Som Chrome, Firefox eller Safari.
alle webapplikasjoner har en ting til felles — de er synlige for sluttbrukere EN HTML-side (Hypertext Markup Language). HTML ER bare et formateringsspråk for å beskrive hvordan ting skal organiseres. Det er bare en tekstfil.
Nettlesere får DENNE HTML-siden og tolker kodene (F.EKS. HODE, KROPP, HREF, TABELL, ETC.) for å vise en pen side til deg .
Webapplikasjoner fungerer i klient-serverarkitekturen – der webserveren er vert for innholdet du vil ha tilgang til, og nettleseren fungerer som klient.
Hva er funksjonalitetstesting?
som navnet tilsier, når du skriver funksjonell testing kode, er målet ditt å teste funksjonaliteten til programmet. Med andre ord vil du sørge for at programmet følger funksjonsspesifikasjonen.
det finnes andre typer tester, for eksempel ytelsestester, sikkerhetstester (penetrasjonstester) og brukertester.
funksjonstestkoden du skriver kan inkluderes i det som kalles en regresjonstest som utføres periodisk for å sikre at gammel funksjonalitet ikke brytes på grunn av ny utvikling.
på slutten av dette innlegget vil du forstå den komplette koden som er nevnt nedenfor.
ikke bli motløs hvis du føler at dette er for mye. Målet med dette innlegget er å dissekere dette og vise deg hvordan du kan forstå denne koden og deretter skrive din egen!
følgende diagram viser tilnærmingen på høyt nivå for automatisk å teste et webprogram (side).
for å skrive våre tester, bruker vi en test rammeverk kalt unittest. Det er veldig lik junit I Java eller nunit i. Net.
unittest lar deg gruppere initialiseringskoden din i en oppsettfunksjon og rydde opp kode tin en tearDown-funksjon.
følgende diagram viser den generelle tilnærmingen bak enhetstesting.
som du kan se fra diagrammet ovenfor, består en testpakke av ett eller flere testtilfeller.
et testtilfelle kan ha en eller flere tester. I dette innlegget skal vi fokusere på et testfall med en test. Vi vil vise på slutten hvordan du legger til flere tester i samme testtilfelle, samt oppretter en testpakke.
som nevnt tidligere har hvert testfall et oppsett (kjør i begynnelsen) og tearDown (kjør på slutten) metoder for å gjøre initialisering og rydde opp henholdsvis.
kodebiten ovenfor viser strukturen til en enhet testtilfelle.
Linje 1: Importer de nødvendige bibliotekene. I vårt tilfelle bruker vi selen og unittest biblioteker.
Linje 3: du oppretter en klasse Kalt MyTestCase som utvider unittest.TestCase klasse. Vi sier det unittest.TestCase er foreldreklassen og MyTestCase er barneklassen.
Linje 4: vi legger til vår initialiseringskode i oppsettmetoden. Du må bruke det nøyaktige metodenavnet for å la unittest vite at du legger til initialiseringskoden din her. Når du kjører dette testtilfellet, blir denne metoden utført først.
Linje 7: en prøvetest som vi vil inkludere i testsaken.
Linje 10: En annen prøvetest som vi har i vårt testfall.
Linje 16: vi legger til vår oppryddingskode i denne tearDown-metoden. Det motsatte av oppsettmetoden blir tearDown-metoden utført sist.
så rekkefølgen på metode påkalling er:
oppsett > test1 > test2 > … > tearDown
Linje 20: dette sier at hovedprogrammet starter fra dette stedet.
Linje 21: slik kjører du testsaken.
nå er det på tide for oss å få hendene på selve testen vi ønsket å gjøre. Recall, at vi ønsker å teste Om Google søkeboksen returnerer minst 5 resultater for et gitt søkeord.
La oss se på konfigurasjonsmetoden først:
I denne kodebiten lager vi Chrome-nettleserdriveren.
du må laste ned selenium Chrome driver herfra hvis du ikke har det allerede. I Skrivende stund Har Chrome også versjon 74. Siden Chrome-nettleseren min er versjon 73, lastet jeg ned versjon 73 for denne øvelsen.
Linje 2 og 3 opprett Chrome-alternativ og la selenium webdriver vite at vi ikke vil gjøre nettleseren synlig når vi kjører testen.
hvis du ikke legger til dette alternativet, blir testen fast på det punktet der nettleseren åpnes.
la Oss nå se på tearDown-metoden:
Vi rydder bare opp driveren ved å ringe quit () – metoden.
Til Slutt er det På tide å ta en titt på testen vi vil inkludere i denne testen. Husk at vi kan for å teste (hevde) hvis antall søkeresultater som returneres er større enn eller lik 5.
Linje 1: testmetoden starter med ordet «test».
Linje 3: Last Inn www.google.com nettside inn i sjåføren (Merk det selv.driveren er opprettet under oppsett tid).
Linje 6: Finn søkeboksen ETTER HTML-elementnavnet «q». DU må inspisere HTML-siden for å identifisere dette.
Linje 7: Gjør søkeboksen tom hvis det finnes standardverdier.
Linje 10: Fyll søkeboksen med søkestrengen «Automatisert Testing».
Linje 11: Send søket Til Google.
Linje 14: xpath identifisere Søkeresultat overskrifter.
Linje 17: Vent i 10 sekunder til Google-resultatsiden er lastet inn.
Linje 20: Få alle søkeresultatoverskrifter ved Å bruke XPath definert I Linje 14.
Linjene 25 Og 26: Søkeresultatoverskrifter er faktisk en liste, og vi itererer gjennom dem for å sende inn på skjermen. Vi har lagt disse to linjene for demonstrasjon formål. Vanligvis har testskript ikke utskriftsskjermbilder, da det ikke er noen tilgjengelig for å stirre på skjermen for å se slik utgang når den er automatisert.
Linje 30: Dette er den faktiske påstanden vi gjør. assertGreater er en metode definert i unittest.TestCase klasse som tillater oss å sjekke om noen utgang er større enn noen verdi.
unittest.TestCase faktisk gir oss et sett av slik metode for å sjekke likestilling, større enn, mindre enn, etc. avhengig av hva du vil hevde. Følgende diagram viser noen av de vanlige assert-metodene som er tilgjengelige.
som vist i begynnelsen, kan du skrive testcase ved å påkalle følgende i koden:
unittest.main()
i kommandolinjen kan du bare skrive inn filnavnet du brukte til å lagre testsaken.
python google_search_test.py
det kjører setUp (), deretter test_result_count () og til slutt tearDown ().
du bør se en utgang som ligner på følgende:
Hvis en test mislykkes, vil du se FEILMELDINGEN sammen med testmetoden som mislyktes.
Det er ditt første vellykkede Selenium / unittest Test Tilfelle. Gratulerer! Det er viktige milepæler.
Bonus
hvis du har steam, vil jeg oppfordre deg til å følge resten for å få enda dypere Inn I Selenium / unittest base web application automatisert testing.
la oss si at du vil teste om overskriften er lik «Google».
testkoden ser slik ut:
def test_header(self):
self.driver.get("http://www.google.com")
self.assertEqual("Google", self.driver.title)
Nå ser hele testsaken ut som følger:
class GoogleSearchTest(unittest.TestCase):
def setUp(self): def test_header(self): def test_result_count(self): def tearDown(self):
if __name__ == "__main__":
unittest.main()
La oss anta at de ovennevnte utskriftsskjermene er kommentert ut. Når du kjører det oppdaterte testsaken, bør du få en utgang som følger:
test_header (__main__.GoogleSearchTest) ... ok
test_result_count (__main__.GoogleSearchTest) ... ok----------------------------------------------------------------------
Ran 2 tests in 13.799s
OK
Det står at det kjørte to tester og begge er vellykkede.
La oss si at jeg endrer assertEqual-tilstanden i den første testen til følgende:
self.assertEqual("Microsoft", self.driver.title)
Hva tror du det ville skje her?
ja, du gjettet det riktig. Den første testen saken vil mislykkes som selv.driveren.tittelen er Lik Google, Ikke Microsoft.
du vil få en utgang som ligner på følgende:
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)
ovennevnte utgang sier at bare en test var vellykket og den mislyktes.
når du skriver testtilfeller for første gang, kan du støte på situasjoner som dette.
Forutsatt at testsaken er riktig, vil du identifisere feil i koden, og du vil få de respektive utviklerne til å fikse problemet og retest.
hvis denne feilen skjer i en regresjonstest, blir denne feilen introdusert på grunn av ny programvareutvikling gjort på toppen av den eksisterende kodebasen.
dette viser at det er noe galt med ny kodebase som må repareres for å sikre at den gamle funksjonaliteten fungerer. Igjen må utviklerne ta vare på det.
hva med å ha mange testtilfeller? La Oss si At Vi Har TestCase1 Og TestCase2, med hver har flere tester.
du kan opprette det som kalles en testpakke og kjøre den med en testløper som følger:
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(TestCase1))
suite.addTest(unittest.makeSuite(TestCase2))
runner = unittest.TextTestRunner()
runner.run(suite)
koden ovenfor vil kjøre alle testene I TestCase1 og deretter I TestCase2.
Det er det for i dag. Håper det hjelper.