#Python #Unittest #selen #Automation
i dette indlæg skal vi se på, hvordan man tester en internetapplikation i Python for at kontrollere funktionalitetens rigtighed. Hov! Denne sætning har en håndfuld jargon: enhedstest, internetapplikation og funktionalitetstest.
vi kiggede på enhedstestning af et Python-program i et tidligere indlæg. Vi opfordrer dig til at gennemgå det, hvis du ikke er bekendt med enhedstest.
Hvad er en enhedstest?
enhed er en mindste testbar del af et program eller en applikation.
så enhedstest bruges til programmatisk at teste hver testbar komponent.
du kan enhedstestere et backend-program eller et frontend-program, f.eks.
for et backend-program ville du skrive en enhedstest for hver funktion eller metode i koden, da de er logiske mindste enheder.
for en frontend vil du dog identificere forskellige funktioner, du vil kontrollere og skrive enhedstest i overensstemmelse hermed.
i dette indlæg skal vi enhedstest et frontend-program, nemlig en internetapplikation.
hvad er en hjemmeside?
ethvert program, der gengives på en internetsøgemaskine som f.eks.
alle internetapplikationer har en ting til fælles — de er synlige for slutbrugerne en HTML-side (hypertekst Markup Language). HTML er simpelthen et formateringssprog for at beskrive, hvordan tingene skal organiseres. Det er simpelthen en tekstfil.
søgere får denne HTML-side og fortolker tags (f.eks. hoved, krop, href, bord osv.) for at vise en smuk side til dig.
internetapplikationer fungerer i klientserverarkitekturen-hvor internetserveren er vært for det indhold, du vil have adgang til, og internetserveren fungerer som klienten.
hvad er funktionalitetstest?
som navnet antyder, når du skriver funktionel testkode, er dit mål at teste applikationens funktionalitet. Med andre ord vil du sikre dig, at applikationen følger den funktionelle specifikation.
der er andre typer tests såsom ydelsestest, sikkerhedstest (penetration) og test af brugeracceptbarhed.
den funktionelle testkode, du skriver, kan være inkluderet i det, der kaldes en regressionstest, der udføres med jævne mellemrum for at sikre, at Gammel funktionalitet ikke brydes på grund af ny udvikling.
i slutningen af dette indlæg forstår du den komplette kode, der er nævnt nedenfor.
vær ikke modløs, hvis du har lyst til, at dette er for meget. Målet med dette indlæg er at dissekere dette og vise dig, hvordan du kan forstå denne kode og derefter skrive din egen!
følgende diagram viser tilgangen på højt niveau til automatisk at teste en internetapplikation (side).
for at skrive vores test bruger vi en testramme kaldet unittest. Det ligner meget junit i Java eller nunit i .Net.
unittest giver dig mulighed for at gruppere din initialiseringskode i en installationsfunktion og rydde op kode tin en nedrivningsfunktion.
følgende diagram viser den overordnede tilgang bag enhedstest.
som du kan se fra ovenstående diagram, består en test suite af en eller flere test cases.
en testcase kan have en eller flere tests. I dette indlæg vil vi fokusere på en testsag med en test. Vi viser i slutningen, hvordan man tilføjer flere tests til den samme testsag samt opretter en testpakke.
som tidligere nævnt har hver testsag en opsætning (Kør i begyndelsen) og nedrivning (Kør i slutningen) metoder til henholdsvis initialisering og oprydning.
ovenstående kodestykke viser strukturen af en enhedstestcase.
linje 1: Importer de nødvendige biblioteker. I vores tilfælde bruger vi selen og unittest biblioteker.
linje 3: du opretter en klasse med navnet MyTestCase, der udvider unittest.TestCase klasse. Vi siger, at unittest.TestCase er forældreklasse, og MyTestCase er børneklasse.
linje 4: vi tilføjer vores initialiseringskode i opsætningsmetoden. Du skal bruge det nøjagtige metodenavn for at lade unittest vide, at du tilføjer din initialiseringskode her. Når du kører denne testsag, udføres denne metode først.
linje 7: en prøvetest, som vi vil medtage i testsagen.
linje 10: En anden prøvetest, som vi har i vores testsag.
linje 16: Vi tilføjer vores oprydningskode inde i denne nedrivningsmetode. Det modsatte af opsætningsmetode, nedrivningsmetode udføres sidst.
så rækkefølgen af metodeindkaldelse er:
opsætning > test1 > … > nedrivning
linje 20: Dette siger, at hovedprogrammet starter fra dette sted.
linje 21: Sådan kører du testsagen.
nu er det tid for os at få vores hænder på den faktiske test, vi ønskede at gøre. Husk, at vi vil teste, om Google-søgefeltet returnerer mindst 5 resultater for et givet søgeord.
lad os først se på opsætningsmetoden:
i dette kodestykke opretter vi Chrome-driveren.
du skal hente selen Chrome driveren herfra, hvis du ikke har det allerede. I skrivende stund har Chrome også version 74. Da min Chrome er version 73, hentede jeg version 73 til denne øvelse.
linje 2 og 3 Opret Chrome-indstilling, og lad selen-føreren vide, at vi ikke ønsker at synliggøre bro.sereren, når vi kører testen.
hvis du ikke tilføjer denne mulighed, sidder din test fast på det punkt, hvor bro.sereren åbnes.
lad os nu se på nedrivningsmetode:
vi rydder simpelthen chaufføren op ved at kalde Afslut() metode.
endelig er det tid til at se på den test, vi vil medtage i denne testsag. Husk at vi kan for at teste (hævde), hvis antallet af returnerede søgeresultater er større end eller lig med 5.
linje 1: testmetoden starter med ordet “test”.
linje 3: belastning www.google.com hjemmeside ind i driveren (Bemærk, at selv.driver oprettes under opsætningen tid).
linje 6: Find søgefeltet efter HTML-elementnavn”s”. Du skal inspicere HTML-siden for at identificere dette.
linje 7: gør søgefeltet tomt, hvis der er standardværdier.
linje 10: udfyld søgefeltet med søgestrengen “automatiseret test”.
linje 11: Indsend søgeforespørgslen til Google.
linje 14: sti, der identificerer overskrifter til søgeresultater.
linje 17: vent i 10 sekunder, indtil Google-resultatsiden er indlæst.
linje 20: få alle søgeresultatoverskrifter ved hjælp af den sti, der er defineret i linje 14.
linje 25 og 26: Søgeresultatoverskrifter er faktisk en liste, og vi gentager gennem dem for at udskrive på skærmen. Vi tilføjede disse to linjer kun til demonstrationsformål. Normalt har testskripter ikke udskrivningsskærme, da der ikke er nogen til rådighed til at stirre på skærmen for at se sådan output, når de automatiseres.
linje 30: Dette er den faktiske påstand, vi gør. assertGreater er en metode defineret i unittest.TestCase klasse, der giver os mulighed for at kontrollere, om noget output er større end værdien some.
unittest.TestCase giver os faktisk et sæt af en sådan metode til at kontrollere lighed, større end, mindre end osv. afhængigt af hvad du vil hævde. Følgende diagram viser nogle af de fælles hævde metoder til rådighed.
som vist i begyndelsen kan du skrive testcase ved at påberåbe dig følgende i din kode:
unittest.main()
i kommandolinjen kan du blot skrive det filnavn, du brugte til at gemme testsagen.
python google_search_test.py
det kører setUp(), derefter test_result_count() og endelig nedrivning().
du skal se et output svarende til følgende:
hvis en test mislykkes, vil du se fejlmeddelelsen sammen med testmetoden, der mislykkedes.
det er din første succesfulde selen/unittest Test Case. Tillykke! Det er vigtige milepæle.
Bonus
hvis du har dampen, vil jeg opfordre dig til at følge resten for at komme endnu dybere ind i selen/unittest base applikation automatiseret test.
lad os sige, at du vil teste, om overskriften er lig med “Google”.
testkoden ser ud som følger:
def test_header(self):
self.driver.get("http://www.google.com")
self.assertEqual("Google", self.driver.title)
nu ser hele vores test sag ud 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()
lad os antage, at ovenstående udskriftsskærme kommenteres. Når du kører den opdaterede testsag, skal du få et output som følger:
test_header (__main__.GoogleSearchTest) ... ok
test_result_count (__main__.GoogleSearchTest) ... ok----------------------------------------------------------------------
Ran 2 tests in 13.799s
OK
det siger, at det kørte to tests, og begge er vellykkede.
lad os sige, at jeg ændrer påstandenlige tilstand i den første test til følgende:
self.assertEqual("Microsoft", self.driver.title)
hvad tror du, der ville ske her?
ja, du gættede det rigtigt. Den første testsag vil mislykkes som selv.driver.titel er lig med Google, ikke Microsoft.
du får et output svarende til 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)
ovenstående output siger, at kun en test var vellykket, og den mislykkedes.
når du skriver dine testcases for første gang, kan du støde på situationer som denne.
hvis du antager, at din testsag er korrekt, identificerer du fejl i koden, og du får de respektive udviklere til at løse problemet og teste igen.
hvis denne fejl sker i en regressionstest, introduceres denne fejl på grund af ny programudvikling udført oven på den eksisterende kodebase.
dette viser, at der er noget galt med ny kodebase, der skal rettes for at sikre, at den gamle funktionalitet fungerer. Igen skal udviklerne tage sig af det.
hvad med at have mange testcases? Lad os sige, at vi har TestCase1 og TestCase2, hvor hver har flere tests.
du kan oprette det, der kaldes en testpakke, og køre den ved hjælp af en testløber som følger:
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(TestCase1))
suite.addTest(unittest.makeSuite(TestCase2))
runner = unittest.TextTestRunner()
runner.run(suite)
ovenstående kode kører alle testene i TestCase1 og derefter i TestCase2.
det er det for i dag. Håber det hjælper.