#Python #Unittest #Selenium #Automation
i det här inlägget kommer vi att titta på hur man testar en webbapplikation i Python för att kontrollera funktionalitetens korrekthet. Whoa! Den meningen har en handfull jargong: enhetstest, webbapplikation och funktionstestning.
vi tittade på enhetstestning av ett Python-program i ett tidigare inlägg. Vi uppmuntrar dig att gå igenom det, om du inte är bekant med enhetstestning.
Vad är ett enhetstest?
enheten är en minsta testbar del av ett program eller en applikation.
så, enhetstester används för att programmatiskt testa varje testbar komponent.
du kan testa ett backend-program eller ett frontend-program som en webbapplikation.
för ett backend-program skulle du skriva ett enhetstest för varje funktion eller metod i koden eftersom de är logiska minsta enheter.
men för en frontend kommer du att identifiera olika funktioner som du vill kontrollera och skriva enhetstester i enlighet därmed.
i det här inlägget kommer vi att testa ett frontend-program, nämligen en webbapplikation.
vad är en webbapplikation?
alla program som gör på en webbläsare som Chrome, Firefox eller Safari.
alla webbapplikationer har en sak gemensamt – de är synliga för slutanvändarna en HTML-sida (Hypertext Markup Language). HTML är helt enkelt ett formateringsspråk för att beskriva hur saker ska organiseras. Det är helt enkelt en textfil.
webbläsare får denna HTML-sida och tolkar taggarna (t.ex. huvud, kropp, href, tabell etc.) för att visa en vacker sida för dig.
webbapplikationer fungerar i klient-serverarkitekturen-där webbservern är värd för innehållet du vill komma åt och webbläsaren fungerar som klient.
vad är funktionstestning?
som namnet antyder, när du skriver funktionstestkod, är ditt mål att testa programmets funktionalitet. Med andra ord vill du se till att applikationen följer funktionsspecifikationen.
det finns andra typer av tester som prestandatester, säkerhetstester (penetration) och användaracceptabilitetstester.
funktionstestkoden du skriver kan ingå i det som kallas ett regressionstest som körs regelbundet för att se till att Gammal funktionalitet inte bryts på grund av ny utveckling.
i slutet av detta inlägg kommer du att förstå den fullständiga koden som nämns nedan.
var inte nedslagen om du känner att det här är för mycket. Målet med detta inlägg är att dissekera detta och visa dig hur du kan förstå den här koden och sedan skriva din egen!
följande diagram visar högnivåmetoden för att automatiskt testa en webbapplikation (sida).
för att skriva våra tester använder vi ett testramverk som heter unittest. Det är mycket lik junit i Java eller nunit i .Net.
unittest låter dig gruppera din initialiseringskod i en inställningsfunktion och städa upp koden tin en tearDown-funktion.
följande diagram visar det övergripande tillvägagångssättet bakom enhetstestning.
som du kan se från ovanstående diagram består en testsvit av ett eller flera testfall.
ett testfall kan ha en eller flera tester. I det här inlägget kommer vi att fokusera på ett testfall med ett test. Vi kommer att visa i slutet hur man lägger till fler tester i samma testfall samt skapar en testsvit.
som tidigare nämnts har varje testfall en inställning (kör i början) och nedkoppling (kör i slutet) metoder för att göra initialisering och städa upp respektive.
ovanstående kodavsnitt visar strukturen för ett enhetstestfall.
rad 1: importera nödvändiga bibliotek. I vårt fall använder vi selen och unittest bibliotek.
rad 3: du skapar en klass som heter MyTestCase som sträcker unittest.TestCase klass. Vi säger Det unittest.TestCase är föräldraklassen och MyTestCase är barnklassen.
rad 4: vi lägger till vår initialiseringskod i installationsmetoden. Du måste använda det exakta metodnamnet för att låta unittest veta att du lägger till din initialiseringskod här. När du kör det här testfallet körs den här metoden först.
rad 7: ett provtest som vi vill inkludera i testfallet.
linje 10: Ett annat provtest som vi har i vårt testfall.
linje 16: vi lägger till vår rensningskod i denna tearDown-metod. Motsatsen till installationsmetoden, nedkoppling metod blir exekveras den sista.
så, ordningen för metod åkallan är:
setUp > test1 > test2 > … > nedkoppling
linje 20: Detta säger att huvudprogrammet startar från denna plats.
rad 21: Så här kör du testfallet.
nu är det dags för oss att få tag på det faktiska testet vi ville göra. Minns, att vi vill testa om Googles sökruta returnerar minst 5 resultat för ett visst sökord.
Låt oss först titta på installationsmetoden:
i det här kodavsnittet skapar vi Chrome-webbläsarens drivrutin.
du måste ladda ner selenium Chrome-drivrutinen härifrån om du inte redan har det. När detta skrivs har Chrome också version 74. Eftersom min Chrome-webbläsare är version 73 laddade jag ner version 73 för den här övningen.
Linje 2 och 3 Skapa Chrome-alternativ och låt selenium webdriver veta att vi inte vill göra webbläsaren synlig när vi kör testet.
om du inte lägger till det här alternativet fastnar ditt test vid den punkt där webbläsaren öppnas.
låt oss nu titta på tearDown-metoden:
vi rensar helt enkelt föraren genom att ringa quit () – metoden.
slutligen är det dags att ta en titt på testet vi vill inkludera i detta testfall. Minns att vi kan för att testa (hävda) om antalet sökresultat som returneras är större än eller lika med 5.
rad 1: testmetoden börjar med ordet ”test”.
rad 3: belastning www.google.com webbsida i föraren (notera att själv.drivrutinen skapas under installationstiden).
rad 6: Leta reda på sökrutan med HTML-elementnamn ”q”. Du måste inspektera HTML-sidan för att identifiera detta.
rad 7: gör sökrutan tom om det finns några standardvärden.
rad 10: Fyll i sökrutan med söksträngen ”automatiserad testning”.
rad 11: skicka sökfrågan till Google.
rad 14: XPath identifiera Sökresultatrubriker.
rad 17: vänta i 10 sekunder tills Googles resultatsida laddas.
rad 20: hämta alla sökresultatrubriker med hjälp av XPath som definieras i rad 14.
linjerna 25 och 26: Sökresultatrubriker är faktiskt en lista och vi itererar genom dem för att mata ut på skärmen. Vi lade till dessa två linjer endast för demonstrationsändamål. Vanligtvis har testskript inte utskriftsskärmar eftersom det inte finns någon tillgänglig att stirra på skärmen för att se sådan utmatning när den automatiseras.
Linje 30: Detta är det faktiska påståendet vi gör. assertGreater är en metod definierad i unittest.TestCase klass som tillåter oss att kontrollera om någon utgång är större än något värde.
unittest.TestCase ger oss faktiskt en uppsättning sådan metod för att kontrollera jämlikhet, större än, mindre än etc. beroende på vad du vill hävda. Följande diagram visar några av de vanliga assert-metoderna som finns tillgängliga.
som visas i början kan du skriva testfallet genom att åberopa följande i din kod:
unittest.main()
i kommandoraden kan du helt enkelt skriva filnamnet du använde för att spara testfallet.
python google_search_test.py
den Kör setUp (), sedan test_result_count () och slutligen tearDown ().
du bör se en utgång som liknar följande:
om något test misslyckas ser du felmeddelandet tillsammans med testmetoden som misslyckades.
det är ditt första framgångsrika selen / unittest testfall. Grattis! Det är en viktig milstolpe.
Bonus
om du har ångan, skulle jag uppmuntra dig att följa resten för att bli ännu djupare i Selenium/unittest base web application automatiserad testning.
låt oss säga att du vill testa om rubriken är lika med ”Google”.
testkoden ser ut som följer:
def test_header(self):
self.driver.get("http://www.google.com")
self.assertEqual("Google", self.driver.title)
nu ser hela vårt testfall ut som följer:
class GoogleSearchTest(unittest.TestCase):
def setUp(self): def test_header(self): def test_result_count(self): def tearDown(self):
if __name__ == "__main__":
unittest.main()
låt oss anta att ovanstående utskriftsskärmar kommenteras. När du kör det uppdaterade testfallet ska du få en utgång enligt följande:
test_header (__main__.GoogleSearchTest) ... ok
test_result_count (__main__.GoogleSearchTest) ... ok----------------------------------------------------------------------
Ran 2 tests in 13.799s
OK
det står att det körde två tester och båda är framgångsrika.
låt oss säga att jag ändrar påståendet i det första testet till följande:
self.assertEqual("Microsoft", self.driver.title)
vad tror du att det skulle hända här?
Ja, du gissade rätt. Det första testfallet kommer att misslyckas som själv.drivrutin.titeln är lika med Google, inte Microsoft.
du kommer att få en utgång som liknar följande:
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)
ovanstående utgång säger att endast ett test lyckades och misslyckades.
när du skriver dina testfall för första gången kan du stöta på situationer som denna.
förutsatt att ditt testfall är korrekt kommer du att identifiera fel i koden och du får respektive utvecklare att åtgärda problemet och testa igen.
om detta fel inträffar i ett regressionstest introduceras detta fel på grund av ny mjukvaruutveckling som görs ovanpå den befintliga kodbasen.
detta visar att det är något fel med ny kodbas som behöver fixas för att se till att den gamla funktionaliteten fungerar. Återigen måste utvecklarna ta hand om det.
vad sägs om att ha många testfall? Låt oss säga att vi har TestCase1 och TestCase2, var och en har flera tester.
du kan skapa det som kallas en testsvit och köra den med en testlöpare enligt följande:
suite = unittest.TestSuite()
suite.addTest(unittest.makeSuite(TestCase1))
suite.addTest(unittest.makeSuite(TestCase2))
runner = unittest.TextTestRunner()
runner.run(suite)
ovanstående kod kommer att köra alla tester i TestCase1 och sedan i TestCase2.
det är det för idag. Hoppas det hjälper.