#Python #Unittest #Selenium #Automation
in dit bericht gaan we kijken hoe we een webapplicatie in Python kunnen testen om de juistheid van de functionaliteit te controleren. Whoa! Die zin heeft een handvol jargon: unit test, webapplicatie, en functionaliteit testen.
we hebben gekeken naar unit testen van een Python programma in een vorige post. Wij raden u aan om door te gaan, als u niet bekend bent met unit testen.
Wat is een eenheidstest?
eenheid is een kleinste testbare deel van een programma of een toepassing.
dus worden eenheidstests gebruikt om elk testbaar onderdeel programmatisch te testen.
u kunt een backend-programma of een frontend-programma zoals een webtoepassing unit testen.
voor een backend programma zou je een unit test schrijven voor elke functie of methode in de code omdat het logische kleinste eenheden zijn.
echter, voor een frontend, zult u verschillende functionaliteit identificeren die u wilt controleren en eenheidstests dienovereenkomstig schrijven.
in dit bericht gaan we een frontend programma testen, namelijk een webapplicatie.
Wat is een webtoepassing?
elke toepassing die wordt weergegeven in een webbrowser zoals Chrome, Firefox of Safari.
alle webtoepassingen hebben één ding gemeen — ze zijn zichtbaar voor eindgebruikers een HTML-pagina (Hypertext Markup Language). HTML is gewoon een opmaaktaal om te beschrijven hoe dingen moeten worden georganiseerd. Het is gewoon een tekstbestand.
Browsers krijgen deze HTML-pagina en interpreteren de tags (bijvoorbeeld HEAD, BODY, href, TABLE, etc.) om u een mooie pagina te laten zien.
webtoepassingen werken in de client-serverarchitectuur, waarbij de webserver de inhoud host die u wilt openen en de webbrowser fungeert als de client.
Wat is functionaliteitstesten?
zoals de naam al aangeeft, is het doel van het schrijven van functional testing code om de functionaliteit van de applicatie te testen. Met andere woorden, u wilt ervoor zorgen dat de toepassing volgt de functionele specificatie.
er zijn andere soorten tests zoals prestatietests, veiligheids – (penetratie) tests en gebruikerstests.
de functional test code die u schrijft kan worden opgenomen in een zogenaamde regressietest die periodiek wordt uitgevoerd om er zeker van te zijn dat oude functionaliteit niet wordt verbroken door nieuwe ontwikkeling.
aan het einde van dit bericht zult u de volledige code hieronder begrijpen.
wees niet ontmoedigd als je het gevoel hebt dat dit te veel is. Het doel van dit bericht is om dit te ontleden en laten zien hoe je deze code kunt begrijpen en dan schrijf je eigen!
het volgende diagram toont de aanpak op hoog niveau om een webapplicatie automatisch te testen (pagina).
om onze tests te schrijven, gebruiken we een test framework genaamd unittest. Het lijkt erg op junit in Java of nunit in.Net.
unittest stelt u in staat om uw initialisatiecode te groeperen in een setUp-functie en om code op te schonen in een tearDown-functie.
het volgende diagram toont de algemene aanpak achter unit testing.
zoals u kunt zien in het bovenstaande diagram, bestaat een test suite uit een of meer testcases.
een testcase kan een of meer tests hebben. In deze post, we gaan om zich te concentreren op een test case met een test. We zullen aan het einde laten zien hoe u meer tests aan dezelfde testcase kunt toevoegen en een testsuite kunt maken.
zoals eerder vermeld, heeft elk testcase een setUp (run at the beginning) en tearDown (run at the end) methoden om respectievelijk initialisatie en opschonen uit te voeren.
het bovenstaande codefragment toont de structuur van een unit test case.
Regel 1: importeer de benodigde bibliotheken. In ons geval gebruiken we selenium en unittest bibliotheken.
regel 3: U maakt een klasse aan met de naam MyTestCase die unittest uitbreidt.TestCase klasse. We zeggen dat unittest.TestCase is de ouderklasse en MyTestCase is de kindklasse.
regel 4: we voegen onze initialisatiecode toe aan de installatiemethode. Je moet de exacte methodenaam gebruiken om unittest te laten weten dat je hier je initialisatiecode toevoegt. Wanneer u deze testcase uitvoert, wordt deze methode eerst uitgevoerd.
regel 7: een voorbeeldtest die we in het testgeval willen opnemen.
regel 10: Een andere monstertest die we hebben in onze testcase.
regel 16: we voegen onze opschooncode toe aan deze tearDown methode. Het tegenovergestelde van setUp methode, tearDown methode wordt uitgevoerd de laatste.
dus, de volgorde van de methode aanroep is:
setUp > test1 > test2 > … > tearDown
regel 20: Dit zegt dat het hoofdprogramma vanaf deze plaats begint.
regel 21: zo voer je de TestCASE uit.
nu is het tijd voor ons om onze handen te krijgen op de werkelijke test die we wilden doen. Terugroepen, dat we willen testen of Google search box geeft ten minste 5 resultaten voor een bepaald zoekwoord.
laten we eerst eens kijken naar de installatiemethode:
In dit codefragment maken we het Chrome-browserstuurprogramma.
u moet het selenium Chrome-stuurprogramma hier downloaden als u het nog niet hebt. Vanaf Dit schrijven heeft Chrome ook Versie 74. Aangezien mijn Chrome-browser versie 73 is, heb ik Versie 73 gedownload voor deze oefening.
regel 2 en 3 creëer Chrome optie en laat selenium webdriver weten dat we de browser niet zichtbaar willen maken wanneer we de test uitvoeren.
als u deze optie niet toevoegt, blijft uw test steken op het punt waar de browser wordt geopend.
laten we nu eens kijken naar de tearDown methode:
We gewoon opruimen van de bestuurder door te bellen quit() methode.
tenslotte is het tijd om een kijkje te nemen naar de test die we in deze testcase willen opnemen. Bedenk dat we kunnen testen (beweren) of het aantal geretourneerde zoekresultaten groter is dan of gelijk is aan 5.
Regel 1: de testmethode begint met het woord “test”.
regel 3: Laden www.google.com webpagina in de driver (merk op dat zelf.driver wordt gemaakt tijdens de installatietijd).
regel 6: Zoek het zoekvak op HTML-elementnaam “q”. U moet de HTML-pagina inspecteren om dit te identificeren.
regel 7: Maak het zoekvak leeg voor het geval er standaardwaarden zijn.
regel 10: vul het zoekveld in met de zoekterm “Automated Testing”.
regel 11: stuur de zoekopdracht naar Google.
regel 14: XPath identificeert de kop van het zoekresultaat.
regel 17: wacht 10 seconden totdat de Google resultaatpagina is geladen.
regel 20: haal alle koppen van zoekresultaten op met behulp van het XPath dat is gedefinieerd in regel 14.
regels 25 en 26: De koppen van het zoekresultaat zijn eigenlijk een lijst en we herhalen ze om in het scherm uit te voeren. We hebben deze twee regels alleen voor demonstratiedoeleinden toegevoegd. Meestal hebben testscripts geen afdrukschermen, omdat er niemand beschikbaar is om naar het scherm te staren om dergelijke uitvoer te zien wanneer deze geautomatiseerd is.
regel 30: Dit is de werkelijke bewering die we doen. assertGreater is een methode gedefinieerd in unittest.TestCase klasse die ons in staat stelt om te controleren of sommige output groter is dan de sommige waarde.
unittest.TestCase in feite biedt ons een reeks van dergelijke methode om gelijkheid te controleren, groter dan, minder dan, enz. afhankelijk van wat je wilt beweren. De volgende grafiek toont een aantal van de gemeenschappelijke assert methoden beschikbaar.
zoals aan het begin te zien is, kunt u de TestCASE schrijven door het volgende aan te roepen in uw code:
unittest.main()
in de opdrachtregel kunt u eenvoudig de bestandsnaam typen die u hebt gebruikt om de TestCASE op te slaan.
python google_search_test.py
het draait setUp (), dan test_result_count () en tenslotte tearDown ().
u zou een uitvoer moeten zien die vergelijkbaar is met de volgende uitvoer::
als een test mislukt, ziet u het foutbericht samen met de testmethode die is mislukt.
dit is uw eerste succesvolle Selenium / unittest Test Case. Gefeliciteerd! Het zijn belangrijke mijlpalen.
Bonus
als je de steam hebt, zou ik je aanmoedigen om de rest te volgen om nog dieper in Selenium/unittest basis web applicatie geautomatiseerd testen te komen.
stel dat je wilt testen of de kop gelijk is aan “Google”.
de testcode ziet er als volgt uit:
def test_header(self):
self.driver.get("http://www.google.com")
self.assertEqual("Google", self.driver.title)
nu ziet onze hele testcase er als volgt uit:
class GoogleSearchTest(unittest.TestCase):
def setUp(self): def test_header(self): def test_result_count(self): def tearDown(self):
if __name__ == "__main__":
unittest.main()
laten we aannemen dat de bovenstaande printschermen zijn becommentarieerd. Wanneer u de bijgewerkte testcase uitvoert, moet u een uitvoer als volgt krijgen:
test_header (__main__.GoogleSearchTest) ... ok
test_result_count (__main__.GoogleSearchTest) ... ok----------------------------------------------------------------------
Ran 2 tests in 13.799s
OK
er staat dat het twee tests heeft uitgevoerd en beide succesvol zijn.
stel dat ik de assertEqual condition in de eerste test verander naar de volgende:
self.assertEqual("Microsoft", self.driver.title)
wat denk je dat er hier zou gebeuren?
Ja, je hebt het goed geraden. De eerste testcase zal falen als zelf.stuurprogramma.titel is gelijk aan Google, niet Microsoft.
u krijgt een uitvoer die vergelijkbaar is met de volgende:
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)
de bovenstaande uitvoer zegt dat slechts één test succesvol was en de mislukte.
wanneer u uw testcases voor de eerste keer schrijft, kunt u situaties als deze tegenkomen.
aannemende dat uw testcase correct is, zult u bugs in de code identificeren en zult u de respectievelijke ontwikkelaars zover krijgen om het probleem op te lossen en opnieuw te testen.
als deze fout optreedt in een regressietest, wordt deze bug geà ntroduceerd door nieuwe softwareontwikkeling bovenop de bestaande codebasis.
dit toont aan dat er iets mis is met de nieuwe codebasis die gerepareerd moet worden om er zeker van te zijn dat de oude functionaliteit werkt. Nogmaals, de ontwikkelaars moeten ervoor zorgen.
hoe zit het met het hebben van veel testcases? Laten we zeggen dat we TestCase1 en TestCase2 hebben, waarbij elk een aantal tests heeft.
u kunt een zogenaamde test suite maken en deze als volgt uitvoeren met behulp van een test runner:
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(TestCase1))
suite.addTest(unittest.makeSuite(TestCase2))
runner = unittest.TextTestRunner()
runner.run(suite)
de bovenstaande code zal alle tests in TestCase1 en vervolgens in TestCase2 uitvoeren.
dat is het voor vandaag. Hopelijk helpt dat.