Bij het automatiseren van front-end tests is het kiezen van de ideale programmeertaal uiterst cruciaal. Python is zo’n taal die bovenaan de lijst staat, dankzij het gebruiksgemak en uitgebreide communityondersteuning.
Bovendien stelt Python-automatiseringstests je in staat om gebruik te maken van de mogelijkheden die worden geboden door populaire bibliotheken en frameworks zoals Selenium, pytest en Robot, onder andere. Het gebruik van Selenium met Python helpt bij het optimaal benutten van de krachtige browserautomatiseringsmogelijkheden van Selenium en de eenvoud en uitbreidbaarheid van Python. Over het algemeen wordt Python-automatiseringstests veel gebruikt door kwaliteitsborging overal, vooral met Selenium WebDriver.
In deze blog zullen we diep ingaan op de subtiliteiten van Python vanuit een front-end perspectief. De inzichten van deze blog zullen nuttig zijn bij het benutten van de Python-mogelijkheden voor het automatiseren van eenvoudige en complexe front-end scenario’s.
Wat Is Python-automatiseringstesten?
Zoals de naam al aangeeft, is Python-automatiseringstesten het proces van het gebruiken van Python-scripts voor het automatiseren van tests. Het is een van de meest gevraagde programmeertalen voor de automatisering van handmatige en repetitieve taken.
Een eenvoudig voorbeeld van Python-automatiseringstesten omvat het gebruik van het pytest-framework met Selenium om front-end tests op een eCommerce-platform te automatiseren. U kunt de registratiefunctie van een eCommerce-website verifiëren en dezelfde sessie gebruiken om door de site te navigeren en vereiste items aan het winkelwagentje toe te voegen. Tegen het einde van deze test heeft u de registratie-, login- en winkelwagenfunctionaliteiten van de eCommerce-website geverifieerd.
Ten slotte kunt u Python ook gebruiken voor het automatiseren van systeembeheer, e-mails en gegevensverwerkings taken. Aangezien Python een vereiste is voor geautomatiseerde tests, raadpleeg de onderstaande video die diep ingaat op de installatie van Python.
Waarom Python voor Geautomatiseerd Testen?
Nu we weten waarom testers Selenium met Python verkiezen, laten we eens kijken naar enkele essentiële redenen om Python te kiezen voor automatiseringstesten:
1. Breed scala aan bibliotheken en frameworks
PyUnit (of unittest) is het standaard testframework voor het uitvoeren van unit tests met Python. Hoewel PyUnit direct beschikbaar is, ondersteunt Python andere populaire frameworks zoals pytest, Behave, Robot, Lettuce en Nose2.
Ze kunnen allemaal uitgebreid worden gebruikt met Selenium en Playwright-frameworks voor het automatiseren van webbrowsertests.
2. Zeer eenvoudige parallelle testuitvoering
Parallel testen in Selenium en Python kunnen uitgebreid worden gebruikt om webbrowsertesten over verschillende combinaties van browsers en platforms uit te voeren. Hoewel alle talen die door Selenium worden ondersteund parallelle testuitvoering ondersteunen, is het erg makkelijk te gebruiken met Python.
3. Meertalige Programmeertaal
Python is een meertalige programmeertaal. Daarom is er volledige ondersteuning voor objectgeoriënteerd programmeren en gestructureerd programmeren. Een groot deel van de functies in Python ondersteunt functioneel programmeren en aspectgeoriënteerd programmeren. Python, samen met Selenium, kan ook worden gebruikt om websites en webapplicaties functioneel te testen.
4. Dynamisch Typing
De Python-taal maakt gebruik van dynamisch typen en laat binden (of dynamische naamresolutie) die de methoden en variabelenamen tijdens de uitvoering bindt. Deze functie is erg handig voor Python-testautomatisering.
Python biedt ook opties zoals Pyre (een performante typechecker voor Python 3) en Mypy, die populaire statische typecheckers zijn. Met deze checkers laat Python u de kracht van dynamisch en statisch typen combineren.
5. Web Scraping
Web scraping met Python is het proces van het extraheren van zinvolle en nuttige informatie/gegevens van websites. Het wordt voornamelijk gebruikt voor academisch onderzoek, concurrentieanalyse, inhoudsaggregatie en meer.
Python biedt een aantal bibliotheken en frameworks, namelijk BeautifulSoup (bs4), Selenium, Puppeteer en Pyppeteer, die het gemakkelijker maken om inhoud van websites te schrapen.
6. Krachtige en Probleemloze Rapportage
Rapportage in testautomatisering biedt een groter inzicht in de nuances van testuitvoering (d.w.z. percentage van geslaagde/fallende tests, testomgeving, screenshots, enz.). Krachtige rapporten die de juiste informatie in een beknopte en begrijpelijke vorm geven, kunnen naar de benodigde belanghebbenden (in het team) worden gestuurd, zodat zij op de hoogte zijn van de voortgang op het gebied van testen.
Hoe voer je Python-automatiseringstests uit?
Nu we de belangrijkheid van Python-automatiseringstests hebben bekeken, laten we onze handen vuilmaken door enkele tests uit te voeren. Onze discussie zal zich voornamelijk richten op front-end geautomatiseerd testen met Python.
Voordat we beginnen met de tests, laten we de virtuele omgeving (venv) instellen, die helpt om de omgeving en afhankelijkheden beter te beheren. venv speelt een cruciale rol bij het bieden van isolatie van de pakketten die in de basisomgeving zijn geïnstalleerd.
Voer de opdrachten virtualenv venv en source venv/bin/activate in de terminal uit om de virtuele omgeving te creëren. Alle afhankelijkheden (of Python-pakketten), zoals pytest, selenium, enz., die nodig zijn voor de uitvoering van het project, zijn beschikbaar in het requirements.txt bestand.
pytest-selenium
pytest-xdist
selenium>=4.6.0
urllib3==1.26.12
requests
py
Afhankelijkheden
De afhankelijkheden kunnen worden geïnstalleerd door pip install -r requirements.txt in de terminal uit te voeren. Selenium v4.6.0 (of hoger) wordt geïnstalleerd als onderdeel van de installatieprocedure.
Ter illustratie zouden we eenvoudige Selenium Python-tests uitvoeren met de pytest- en PyUnit (of unittest) frameworks. Als u bekend bent met een van deze frameworks, wordt het aanbevolen om fixtures in Python te gebruiken en het Pagina Object Model in Selenium Python voor verbeterd onderhoud van de tests. Het Selenium-pakket zelf biedt geen testtool of framework. Daarom zouden we Selenium gebruiken met pytest en PyUnit voor het automatiseren van interacties met de elementen op de webpagina.
Testscenario
- Navigeer naar de LambdaTest Selenium Playground.
- Zoek de koppeling ‘Input Form Submit’ op de pagina.
- Voer de vereiste informatie in op de pagina.
- Verzend de gegevens en controleer of de informatie niet succesvol is verzonden.
Implementatie (pytest Framework)
Hieronder staat het testscript voor het bovenstaande testscenario:
import os
import pytest
from os import environ
import time
from selenium.webdriver import ChromeOptions
from selenium.webdriver.support.ui import WebDriverWait
from selenium import webdriver
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.ui import Select
from selenium.webdriver.common.by import By
exec_platform = os.getenv('EXEC_PLATFORM')
time_sleep = 2
########################## Locators #########################
xSubmitForm = "//a[.='Input Form Submit']"
xInpName = "//input[@id='name']"
cInpName = "#name"
xInpEmail = "//form[@id='seleniumform']//input[@name='email']"
xInpPassword = "//input[@name='password']"
cssCompany = "#company"
cWebName = "#websitename"
xInpCountry = "//select[@name='country']"
xInpCity = "//input[@id='inputCity']"
cssAddress1 = "[placeholder='Address 1']"
cssAddress2 = "[placeholder='Address 2']"
cssInpState = "#inputState"
cssInpZip = "#inputZip"
cssInpButton = ".bg-lambda-900"
nameSearchBox = "search"
class TestFormInput:
def setup_method(self):
if exec_platform == 'cloud':
username = environ.get('LT_USERNAME', None)
access_key = environ.get('LT_ACCESS_KEY', None)
ch_options = webdriver.ChromeOptions()
lt_options = {}
lt_options["build"] = "Build: Getting Started with Selenium PyTest"
lt_options["project"] = "Project: Getting Started with Selenium PyTest"
lt_options["name"] = "Test: Getting Started with Selenium PyTest"
lt_options["browserName"] = "Chrome"
lt_options["browserVersion"] = "latest"
lt_options["platformName"] = "macOS Sonoma"
lt_options["geoLocation"] = "US"
lt_options["console"] = "error"
lt_options["w3c"] = True
lt_options["headless"] = False
ch_options.set_capability('LT:Options', lt_options)
gridURL = "https://{}:{}@hub.lambdatest.com/wd/hub".format(username, access_key)
self.driver = webdriver.Remote(
command_executor = gridURL,
options = ch_options
)
elif exec_platform == 'local':
ch_options = ChromeOptions()
self.driver = webdriver.Chrome(options=ch_options)
def test_enter_form_details(self):
resultant_str = "Thanks for contacting us, we will get back to you shortly."
driver = self.driver
driver.get("https://www.lambdatest.com/selenium-playground/")
# Commented once the tests are executed in non-headless mode
driver.maximize_window()
wait = WebDriverWait(driver, 5)
try:
element = driver.find_element(By.XPATH, xSubmitForm)
element.click()
elem_name = driver.find_element(By.XPATH, xInpName)
elem_name.send_keys("Testing")
time.sleep(time_sleep)
elem_email = driver.find_element(By.XPATH, xInpEmail)
elem_email.send_keys("[email protected]")
time.sleep(time_sleep)
elem_pass = driver.find_element(By.XPATH, xInpPassword)
elem_pass.send_keys("password")
time.sleep(time_sleep)
elem_comp = driver.find_element(By.CSS_SELECTOR, cssCompany)
elem_comp.send_keys("LambdaTest")
elem = driver.find_element(By.CSS_SELECTOR, cWebName)
elem.send_keys("https://wwww.lambdatest.com")
country_dropdown = Select(driver.find_element(By.XPATH, xInpCountry))
country_dropdown.select_by_visible_text("United States")
time.sleep(time_sleep)
elem = driver.find_element(By.XPATH, xInpCity)
elem.send_keys("San Jose")
time.sleep(time_sleep)
elem = driver.find_element(By.CSS_SELECTOR, cssAddress1)
elem.send_keys("Googleplex, 1600 Amphitheatre Pkwy")
time.sleep(time_sleep)
elem = driver.find_element(By.CSS_SELECTOR, cssAddress2)
elem.send_keys("Mountain View, CA 94043")
time.sleep(time_sleep)
elem = driver.find_element(By.CSS_SELECTOR, cssInpState)
elem.send_keys("California")
time.sleep(time_sleep)
elem = driver.find_element(By.CSS_SELECTOR, cssInpZip)
elem.send_keys("94088")
time.sleep(time_sleep)
# Click on the Submit button
submit_button = driver.find_element(By.CSS_SELECTOR, cssInpButton)
submit_button.click()
time.sleep(2)
try:
element = wait.until(
EC.presence_of_element_located((By.CSS_SELECTOR, ".success-msg"))
)
assert resultant_str in element.text, f"'{resultant_str}' not found in the specified element."
except Exception as e:
if exec_platform == 'cloud':
driver.execute_script("lambda-status=failed")
pytest.fail(f"Text '{resultant_str}' not found: {str(e)}")
time.sleep(2)
except Exception as e:
# Catch other exceptions
print(f"Failed: Input Form Demo, generic exception - {e}")
if exec_platform == 'cloud':
driver.execute_script("lambda-status=failed")
if exec_platform == 'cloud':
driver.execute_script("lambda-status=passed")
print(f"PyTest Demo: Test Passed")
def teardown_method(self):
if (self.driver != None):
# self.driver.close()
self.driver.quit()
if __name__ == "__main__":
pytest.main()
Code Walkthrough
Om te beginnen importeren we eerst de nodige modules die nodig zijn voor de uitvoering van tests. Aangezien we pytest gebruiken, wordt ook de pytest-module geïmporteerd in de code.
De klasse WebDriverWait van de module selenium.webdriver.support.ui wordt geïmporteerd zodat we expliciete wachttijden kunnen gebruiken voor scenario’s waarin WebElements dynamisch worden gelokaliseerd. De module expected_conditions biedt een reeks vooraf gedefinieerde ExpectedConditions in Selenium die kunnen worden gebruikt met expliciete wachttijden.
Aangezien de elementen moeten worden gelokaliseerd voordat we enige actie uitvoeren, definiëren we eerst de elementlocators van de vereiste elementen. ID, Naam, XPath, Linktekst, Deeltijd Linktekst, enzovoort, zijn enkele van de veelgebruikte weblocators die je helpen elementen binnen het Document Object Model (DOM) te vinden.
Je kunt de inspectietools gebruiken die standaard beschikbaar zijn in de webbrowser of een plugin (of add-on) zoals POM Builder die het gemakkelijk maakt om de XPath/CSS-selector van WebElements te vinden.
Zodra de weblocator is geïdentificeerd, worden de respectieve WebElement(en) gelokaliseerd door de locator te combineren met de find_element() of find_elements() methode van Selenium Python. De find_element() methode retourneert een enkele WebElement, terwijl find_elements() een lijst van WebElements retourneert die overeenkomen met de locatorcriteria.
Zoals eerder vermeld, is de setup_method() een pytest fixture die deel uitmaakt van de initialisatie. De methode wordt aangeroepen voordat elke testfunctie wordt geïmplementeerd onder de genoemde testklasse.
De tests die worden uitgevoerd, kunnen worden uitgevoerd op Selenium dat op de lokale machine is geïnstalleerd, evenals op de online Selenium grid die wordt aangeboden door cloudtesting. LambdaTest is een door AI aangedreven testuitvoeringsplatform waarmee je Python-geautomatiseerde tests op schaal kunt uitvoeren in verschillende browsers en besturingssystemen. Het biedt een aantal voordelen, waarvan de belangrijkste zijn verminderd onderhoud, lagere kosten en versnelde testuitvoering.
Wat de implementatie betreft, is de enige verandering gerelateerd aan Selenium WebDriver, waarbij Remote WebDriver in Selenium wordt geïnstantieerd bij het uitvoeren van tests op een cloud grid. De Automation Capabilities Generator helpt bij het genereren van mogelijkheden voor de testcombinatie die bedoeld is om te worden gebruikt in de tests.
In Selenium 4 worden browseropties gebruikt in plaats van Gewenste Capaciteiten. U kunt de blog over de verschillen tussen Selenium 3 en Selenium 4 bekijken om meer te weten te komen over wat verouderd is in Selenium 4.
De omgevingsvariabelen LT_USERNAME en LT_ACCESS_KEY kunnen worden verkregen uit uw LambdaTest Accountinstellingen > Wachtwoord & Beveiliging. De combinatie, wanneer samen met de LambdaTest grid-URL doorgegeven, helpt bij het uitvoeren van tests op het cloud grid. In de methode test_enter_form_details(), navigeren we eerst naar de test-URL door de driver.get() methode aan te roepen.
Vervolgens wordt het geïnstantieerde browser venster gemaximaliseerd omdat dit wordt beschouwd als een van de beste praktijken van Selenium.
Vervolgens wordt het invoerelement voor het formulier gezocht met behulp van de find_element() methode samen met de XPath-locator in Selenium. Eenmaal gevonden, wordt de knopklik in Selenium aangeroepen om de klikactie op het knopelement uit te voeren dat in de eerdere stap is gevonden.
Aangezien alle teststappen het lokaliseren van elementen en het uitvoeren van acties omvatten, richten we ons alleen op een paar methoden. De benadering die wordt gebruikt voor het lokaliseren van het bedrijfselement via de CSS-selector in Selenium wordt hieronder getoond. De send_keys() in Selenium WebDriver helpt bij het verzenden van tekstinvoer in het gelokaliseerde element.
Dropdowns worden veel gebruikt op websites; daarom wordt het automatiseren van interacties met dropdowns met behulp van Selenium een absolute must voor uw testgevallen. De Select-klasse van de selenium.webdriver.support.ui-module biedt methoden waarmee u dropdowns kunt behandelen met Selenium.
Hier wordt een object (d.w.z. country_dropdown) van de Select-klasse gemaakt met de input ingesteld op het dropdown-WebElement dat is gelokaliseerd met XPath. De select_by_visible_text()-methode van de Select-klasse helpt bij het selecteren van items met zichtbare tekst die overeenkomt met de opgegeven string (d.w.z. Verenigde Staten).
Zodra alle informatie in het formulier is ingevoerd en de Verzenden-knop is geklikt, wachten we tot de succesmeldingstekst (standaard: verborgen) zichtbaar is op de pagina. Er wordt een expliciete wachttijd met de ExpectedCondition (d.w.z. aanwezigheid van gelokaliseerd element) uitgevoerd totdat de succesmelding niet op de pagina staat.
Er wordt een assertie gegenereerd als de resulterende string niet op de pagina aanwezig is. Voor uitvoering in de cloud wordt de lambda-status-variabele gemarkeerd als geslaagd/mislukt afhankelijk van de status van de uitvoering.
De teardown_method()-fixture bevat de implementatie voor het opruimen van resources of de status na uitvoering van de tests in de klasse. De constructie if __name__ == "__main__": zorgt ervoor dat de code-uitvoering alleen wordt uitgevoerd wanneer het script rechtstreeks wordt uitgevoerd. De pytest.main() roept het pytest-framework aan dat vervolgens alle ingeschakelde (d.w.z. niet gemarkeerd als overgeslagen) tests in het script ontdekt en uitvoert.
Testuitvoering (pytest Framework)
Na het instellen van EXEC_PLATFORM op cloud, roep je het volgende commando aan in de terminal om pytest-tests uit te voeren op het LambdaTest-cloudrooster:
pytest --verbose --capture=no tests/pytest/pytest_selenium_demo.py
Hieronder zie je een screenshot van het LambdaTest Web Automatiseringsdashboard waaruit blijkt dat de testuitvoering succesvol was:
Implementatie (PyUnit-framework)
De testscript voor het bovengenoemde testschema met behulp van het PyUnit-framework bevindt zich in de tests/pyunit/pyunit_selenium_demo.py.
De kernlogica van de test blijft ongewijzigd bij de overstap van pytest naar het PyUnit (of unittest) framework. In plaats van de pytest-module wordt de unittest-module geïmporteerd in de code. De testgevalklasse is afgeleid van de unittest.TestCase die de unittest-module informeert dat dit een testgeval is.
pytest-fixtures setup_method()/teardown() zijn vergelijkbaar met de setUp()/tearDown()-methoden van het PyUnit-framework. De setUp() en tearDown()-methoden bestaan uit implementaties die verantwoordelijk zijn voor respectievelijk initialisatie en de-initialisatie.
Hieronder wordt de standaard code weergegeven om de testsuite uit te voeren:
if __name__ == "__main__":
unittest.main()
Testuitvoering (PyUnit Framework)
Na het instellen van EXEC_PLATFORM op cloud, roep het volgende commando aan in de terminal om PyUnit-tests uit te voeren op het cloud grid:
python tests/pyunit/pyunit_selenium_demo.py
Hieronder wordt een screenshot weergegeven van het LambdaTest Web Automation-dashboard dat aangeeft dat de testuitvoering succesvol was:
Als je de bovenstaande tests wilt uitvoeren op Selenium geïnstalleerd op de lokale machine, stel eenvoudigweg EXEC_PLATFORM in op lokaal, en je bent klaar voor de lokale uitvoering.
Top Python-testframeworks
Aangezien Python ondersteuning biedt voor verschillende testautomatiseringsframeworks, is het kiezen van het juiste framework uiterst cruciaal voor jouw project. De keuze legt eigenlijk de basis voor efficiënte tests. Naast de mogelijkheden van het framework, moet je ook kijken naar de interne expertise met het genoemde framework. Hieronder volgen enkele van de beste Python-testframeworks:
PyUnit (unittest)
Het is het standaardframework dat beschikbaar is in Python. Zoals de naam al aangeeft, wordt het voornamelijk gebruikt voor unit tests. PyUnit is geïnspireerd op het JUnit-framework voor Java en deelt een vergelijkbare structuur en functionaliteit.
Het unittest-framework ondersteunt ook testautomatisering voor het delen van setup- en shutdown-code voor tests, onafhankelijkheid van de tests van het rapportageframework, en meer. Het ondersteunt ook test suites en test cases op een objectgeoriënteerde manier. Het heeft ook een testrunner die verantwoordelijk is voor het coördineren van de uitvoering van tests.
pytest
Het is een van de meest populaire testautomatiseringsframeworks voor Python. Het gebruikt een minder uitgebreide en gebruiksvriendelijke syntax voor het implementeren van tests. pytest kan worden ingezet voor het implementeren van unit tests en complexe functionele tests voor het testen van websites en webapplicaties.
Tests geschreven met pytest zijn veel compacter, omdat het framework geen standaardcode vereist. pytest heeft ingebouwde functies die helpen bij het automatisch ontdekken van testmodules en -functies.
Robot
Het is een op Python gebaseerd open-source framework voor robotgestuurde automatisering dat voornamelijk wordt gebruikt voor Robot Process Automation (RPA) en testautomatisering. Net als het pytest-framework is Robot ook uitbreidbaar. Het gebruik van menselijk leesbare syntax/keywords minimaliseert de leercurve die gepaard gaat met het leren van Robot.
Tests die in Robot zijn geschreven, worden opgeslagen met een .robot-extensie. Als je van plan bent om Robot te gebruiken voor front-end tests, kun je dit doen met de SeleniumLibrary, dat is een webtestbibliotheek voor het Robot Framework. De bibliotheek ondersteunt een uitgebreid scala aan keywords (Klik op knop, Klik op afbeelding, Open browser, Sleep en zet neer, onder andere).
Nose2
Het is de opvolger van Nose en is een Python-testframework dat de mogelijkheden van het PyUnit (of unittest) framework uitbreidt. Het is relatief eenvoudig om aan de slag te gaan met Nose2 als je eerder ervaring hebt met unittest.
Het belangrijkste voordeel van Nose2 ten opzichte van PyUnit is de beschikbaarheid van een groot aantal ingebouwde Nose-plugins die het testen gemakkelijker en sneller maken. Plugins in Nose2 helpen bij testparameterisatie, betere organisatie van tests, fixtureondersteuning, testontdekking en meer.
Behave
Het is een Python-framework dat wordt gebruikt voor Gedragsgestuurde ontwikkeling (BDD). De tests zijn gebaseerd op de Gherkin-syntaxis, die is gebaseerd op het Gegeven-Wanneer-Dan-formaat.
Aangezien de tests worden geïmplementeerd in scenario- en featurebestanden, kunnen zelfs niet-technisch personeel deel uitmaken van het QA-proces. SpecFlow (C#) en Cucumber (Java, JS, Ruby) zijn enkele van de andere populaire BDD-frameworks.
Conclusie
Zoals tot nu toe te zien is, is Python verreweg de beste scripttaal voor testautomatisering. Het is relatief eenvoudig om te beginnen met Python-automatiseringstesten. Het brede scala aan testframeworks van Python kan worden gebruikt voor unittesten, cross-browser testen en meer. Laat hieronder weten wat uw voorkeursprogrammeertaal is voor Selenium-testen en hoe u deze beoordeelt ten opzichte van Python, de onbetwiste koning voor automatiseringstesten. Veel testplezier!
Source:
https://dzone.com/articles/python-automation-testing-with-examples