Bei der Automatisierung von Front-End-Tests ist die Auswahl der idealen Programmiersprache äußerst entscheidend. Python ist eine solche Sprache, die aufgrund ihrer Benutzerfreundlichkeit und umfangreichen Community-Unterstützung ganz oben auf der Liste steht.
Zusätzlich ermöglicht es Python-Automatisierungstests, die Fähigkeiten der beliebten Bibliotheken und Frameworks wie Selenium, pytest und Robot, unter anderem, zu nutzen. Die Verwendung von Selenium mit Python hilft dabei, die leistungsstarken Browserautomatisierungsfunktionen von Selenium optimal zu nutzen und von der Einfachheit und Erweiterbarkeit von Python zu profitieren. Insgesamt wird Python-Automatisierungstests von QAs auf der ganzen Welt weit verbreitet eingesetzt, insbesondere mit Selenium WebDriver.
In diesem Blog werden wir tief in die Feinheiten von Python aus einer Front-End-Perspektive eintauchen. Die Erkenntnisse dieses Blogs werden nützlich sein, um die Fähigkeiten von Python zur Automatisierung einfacher sowie komplexer Front-End-Szenarien zu nutzen.
Was ist Python-Automatisierungstest?
Wie der Name schon sagt, ist Python-Automatisierungstest der Prozess, Python-Skripte zur Automatisierung von Tests zu verwenden. Es ist eine der meistgesuchten Programmiersprachen für die Automatisierung manueller und repetitiver Aufgaben.
Ein einfaches Beispiel für die Python-Automatisierungstests besteht darin, das pytest-Framework mit Selenium zu nutzen, um Frontend-Tests auf einer E-Commerce-Plattform zu automatisieren. Sie können die Registrierungsfunktionalität einer E-Commerce-Website überprüfen und dieselbe Sitzung verwenden, um sich auf der Website zu bewegen und erforderliche Artikel zum Warenkorb hinzuzufügen. Am Ende dieses Tests haben Sie die Registrierungs-, Login- und Warenkorb-Funktionalitäten der E-Commerce-Website überprüft.
Zuletzt können Sie Python auch für die Automatisierung von Systemadministration, E-Mails und Datenaufgaben nutzen. Da Python eine Voraussetzung für automatisierte Tests ist, verweisen Sie bitte auf das untenstehende Video, das ausführlich die Installation von Python behandelt.
Warum Python für automatisierte Tests?
Nun, da wir wissen, warum Tester Selenium mit Python bevorzugen, werfen wir einen Blick auf einige der wesentlichen Gründe, Python für die Automatisierungstests zu wählen:
1. Breites Spektrum an Bibliotheken und Frameworks
PyUnit (oder unittest) ist das Standard-Testframework für die Durchführung von Einheitstests mit Python. Obwohl PyUnit sofort verfügbar ist, unterstützt Python auch andere beliebte Frameworks wie pytest, Behave, Robot, Lettuce und Nose2.
All diese können umfassend mit den Selenium- und Playwright-Frameworks für die Automatisierung von Webbrowser-Tests verwendet werden.
2. Sehr einfache parallele Testausführung
Paralleles Testen in Selenium und Python kann umfangreich genutzt werden, um Webbrowser-Automatisierungstests über verschiedene Kombinationen von Browsern und Plattformen durchzuführen. Obwohl alle von Selenium unterstützten Sprachen die parallele Testausführung unterstützen, ist es mit Python sehr einfach zu verwenden.
3. Mehrparadigmen-Programmiersprache
Python ist eine Mehrparadigmen-Programmiersprache. Daher gibt es volle Unterstützung für objektorientierte Programmierung und strukturierte Programmierung. Ein Großteil der Funktionen in Python unterstützt funktionale Programmierung und aspektorientierte Programmierung. Python kann zusammen mit Selenium auch für die funktionale Prüfung von Websites und Webanwendungen verwendet werden.
4. Dynamische Typisierung
Die Python-Sprache verwendet dynamische Typisierung und späte Bindung (oder dynamische Namensauflösung), die die Methoden und Variablennamen während der Ausführung bindet. Diese Funktion ist sehr praktisch für die Python-Testautomatisierung.
Python bietet auch Optionen wie Pyre (ein leistungsstarker Typenprüfer für Python 3) und Mypy, die beliebte statische Typenprüfer sind. Mit diesen Prüfern ermöglicht Python Ihnen, die Vorteile von dynamischer und statischer Typisierung zu kombinieren.
5. Web-Scraping
Web-Scraping mit Python ist der Prozess des Extrahierens von sinnvollen und nützlichen Informationen/Daten von Websites. Es wird hauptsächlich für wissenschaftliche Forschung, Wettbewerbsanalysen, Inhaltsaggregation und mehr verwendet.
Python bietet eine Reihe von Bibliotheken und Frameworks, nämlich BeautifulSoup (bs4), Selenium, Puppeteer und Pyppeteer, die die Aufgabe des Extrahierens von Inhalten von Websites erleichtern.
6. Leistungsstarkes und problemloses Reporting
Die Berichterstattung in der Testautomatisierung ermöglicht eine bessere Sichtbarkeit der Feinheiten der Testausführung (z. B. Prozentsatz der bestandenen/fehlgeschlagenen Tests, Testumgebung, Screenshots usw.). Leistungsstarke Berichte, die die richtigen Informationen in prägnanter und verständlicher Form liefern, können an die erforderlichen Interessengruppen (im Team) gesendet werden, damit sie über den Fortschritt auf dem Testfront informiert sind.
Wie führe ich Python-Automatisierungstests durch?
Nachdem wir die Bedeutung von Python-Automatisierungstests betrachtet haben, lassen Sie uns einige Tests durchführen. Unsere Diskussion wird sich hauptsächlich um Front-Testing-Automatisierungstests mit Python drehen.
Bevor wir mit den Tests beginnen, richten wir die virtuelle Umgebung (venv) ein, die dabei hilft, die Umgebung und Abhängigkeiten besser zu verwalten. venv spielt eine wichtige Rolle bei der Bereitstellung von Isolation von den in der Basenumgebung installierten Paketen.
Führen Sie die Befehle virtualenv venv und source venv/bin/activate im Terminal aus, um die virtuelle Umgebung zu erstellen. Alle Abhängigkeiten (oder Python-Pakete) wie pytest, selenium usw., die für die Projekt ausführung erforderlich sind, sind in der requirements.txt-Datei verfügbar.
pytest-selenium
pytest-xdist
selenium>=4.6.0
urllib3==1.26.12
requests
py
Abhängigkeiten
Die Abhängigkeiten können installiert werden, indem Sie pip install -r requirements.txt im Terminal auslösen. Selenium v4.6.0 (oder höher) wird als Teil des Installationsverfahrens installiert.
Zur Demonstration würden wir einfache Selenium-Python-Tests mit den pytest- und PyUnit- (oder unittest-)Frameworks ausführen. Wenn Sie mit einem dieser Frameworks vertraut sind, wird empfohlen, Fixtures in Python und das Page Object Model in Selenium Python für eine verbesserte Wartung der Tests zu verwenden. Das Selenium-Paket selbst bietet kein Testwerkzeug oder Framework. Daher würden wir Selenium mit pytest und PyUnit verwenden, um Interaktionen mit den Elementen auf der Webseite zu automatisieren.
Test-Szenario
- Navigieren Sie zur LambdaTest Selenium Playground.
- Suchen Sie den Input Form Submit-Link auf der Seite.
- Geben Sie die erforderlichen Informationen auf der Seite ein.
- Senden Sie die Details und überprüfen Sie, ob die Informationen nicht erfolgreich übermittelt wurden.
Implementierung (pytest Framework)
Hier ist das Testskript für das obige Testszenario:
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
Um zu beginnen, importieren wir zuerst die erforderlichen Module für die Implementierung der Tests. Da wir pytest verwenden, wird das pytest-Modul auch in den Code importiert.
Die Klasse WebDriverWait aus dem Modul selenium.webdriver.support.ui wird importiert, damit wir explizite Wartezeiten für Szenarien verwenden können, in denen WebElements dynamisch gefunden werden. Das Modul expected_conditions bietet eine Reihe vordefinierter ExpectedConditions in Selenium, die mit expliziten Wartezeiten verwendet werden können.
Da die Elemente lokalisiert werden müssen, bevor wir eine Aktion ausführen, definieren wir zunächst die Element-Lokatoren der erforderlichen Elemente. ID, Name, XPath, Link-Text, Teil-Link-Text usw. sind einige der weit verbreiteten Web-Lokatoren, die Ihnen dabei helfen, Elemente im Document Object Model (DOM) zu finden.
Sie können entweder die Inspektionswerkzeuge verwenden, die nativ im Webbrowser verfügbar sind, oder ein Plugin (oder Add-On) wie POM Builder nutzen, das es Ihnen erleichtert, den XPath/CSS-Selektor von WebElements zu finden.
Sobald der Web-Lokator identifiziert ist, werden die entsprechenden WebElement(s) lokalisiert, indem der Lokator mit der find_element() oder find_elements()-Methode von Selenium Python kombiniert wird. Die find_element()-Methode gibt ein einzelnes WebElement zurück, während find_elements() eine Liste von WebElements zurückgibt, die den Lokator-Kriterien entsprechen.
Wie bereits erwähnt, ist setup_method() eine pytest-Fixture, die Teil der Initialisierung ist. Die Methode wird aufgerufen, bevor jede Testfunktion unter der genannten Testklasse implementiert wird.
Die implementierten Tests können sowohl auf Selenium, das auf dem lokalen Rechner installiert ist, als auch auf dem Online Selenium Grid durchgeführt werden, das vom Cloud-Testing angeboten wird. LambdaTest ist eine KI-gestützte Testausführungsplattform, die es Ihnen ermöglicht, Python-automatisierte Tests in großem Umfang über verschiedene Browser und Betriebssysteme hinweg auszuführen. Es bietet eine Reihe von Vorteilen, wobei die wichtigsten die reduzierte Wartung, geringere Kosten und beschleunigte Testausführung sind.
Was die Implementierung betrifft, so ist die einzige Änderung im Zusammenhang mit Selenium WebDriver, dass Remote WebDriver in Selenium instanziiert wird, wenn Tests auf einem Cloud-Grid ausgeführt werden. Der Automation Capabilities Generator hilft dabei, Fähigkeiten für die Testkombination zu generieren, die in den Tests verwendet werden sollen.
In Selenium 4 werden Browseroptionen anstelle von Desired Capabilities verwendet. Sie können sich den Blog zu den Unterschieden zwischen Selenium 3 und Selenium 4 ansehen, um mehr darüber zu erfahren, was in Selenium 4 veraltet ist und was nicht mehr unterstützt wird.
Die Umgebungsvariablen LT_USERNAME und LT_ACCESS_KEY können in Ihren LambdaTest-Kontoeinstellungen unter Passwort & Sicherheit abgerufen werden. Die Kombination, die zusammen mit der LambdaTest-Grid-URL übergeben wird, hilft bei der Ausführung von Tests auf dem Cloud-Grid. Im test_enter_form_details()-Methode navigieren wir zuerst zur Test-URL, indem wir die driver.get()-Methode aufrufen.
Dann wird das instanziierte Browserfenster maximiert, da dies als bewährte Praxis in Selenium gilt.
Dann wird das Eingabeformular-Submit-Element mithilfe der find_element()-Methode zusammen mit dem XPath-Locator in Selenium gefunden. Sobald es gefunden wurde, wird der Klick auf die Schaltfläche in Selenium aufgerufen, um die Klickaktion auf dem zuvor gefundenen Schaltflächenelement zu simulieren.
Da alle Testschritte das Auffinden von Elementen und das Ausführen von Aktionen beinhalten, konzentrieren wir uns nur auf einige Methoden. Der Ansatz zum Auffinden des Unternehmenselements über den CSS-Selektor in Selenium wird unten gezeigt. Das send_keys() in Selenium WebDriver hilft dabei, Texteingaben im gefundenen Element zu senden.
Dropdowns werden auf Websites weit verbreitet verwendet; daher wird die Automatisierung von Interaktionen mit Dropdowns mithilfe von Selenium zu einem absoluten Muss für Ihre Testfälle. Die Select-Klasse des selenium.webdriver.support.ui-Moduls bietet Methoden, mit denen Sie Dropdowns mit Selenium handhaben können.
Hier wird ein Objekt (d. h. country_dropdown) der Select-Klasse erstellt, wobei die Eingabe auf das Dropdown-WebElement mit XPath gesetzt ist. Die Methode select_by_visible_text() der Select-Klasse hilft dabei, Elemente mit sichtbarem Text auszuwählen, die mit dem angegebenen String übereinstimmen (d. h. Vereinigte Staaten).
Nachdem alle Informationen im Formular eingegeben wurden und die Schaltfläche Senden geklickt wurde, warten wir, bis die Erfolgsmeldung (standardmäßig versteckt) auf der Seite sichtbar ist. Ein explizites Warten mit der ExpectedCondition (d. h. Präsenz des lokalisierten Elements) wird durchgeführt, bis die Erfolgsmeldung nicht auf der Seite ist.
Ein assert wird ausgelöst, wenn der resultierende String nicht auf der Seite vorhanden ist. Für die Ausführung in der Cloud wird die Variable lambda-status je nach Ausführungsstatus als bestanden/fehlgeschlagen markiert.
Das Fixture teardown_method() enthält die Implementierung zum Aufräumen von Ressourcen oder Zustand nach der Ausführung der Tests in der Klasse. Die Anweisung if __name__ == "__main__": stellt sicher, dass der Code nur ausgeführt wird, wenn das Skript direkt ausgeführt wird. Der Aufruf von pytest.main() ruft das pytest-Framework auf, das dann alle aktivierten (d. h. nicht als übersprungen markierten) Tests im Skript entdeckt und ausführt.
Testausführung (pytest Framework)
Nachdem Sie EXEC_PLATFORM auf cloud gesetzt haben, rufen Sie den folgenden Befehl in der Konsole auf, um pytest-Tests auf dem LambdaTest-Cloud-Grid auszuführen:
pytest --verbose --capture=no tests/pytest/pytest_selenium_demo.py
Hier ist der Screenshot des LambdaTest Web Automation-Dashboards, der anzeigt, dass die Testausführung erfolgreich war:
Implementierung (PyUnit Framework)
Das Testszenario-Skript für das oben genannte Test Szenario unter Verwendung des PyUnit Frameworks befindet sich in tests/pyunit/pyunit_selenium_demo.py.
Die Kernlogik des Tests bleibt unverändert, wenn Sie von pytest auf das PyUnit (oder unittest) Framework migrieren. Anstelle des pytest Moduls wird das unittest Modul in den Code importiert. Die Testfallklasse wird von unittest.TestCase abgeleitet, um dem unittest-Modul mitzuteilen, dass dies ein Testfall ist.
pytest-Fixtures setup_method()/teardown() sind ähnlich den setUp()/tearDown() Methoden des PyUnit-Frameworks. Die setUp() und tearDown() Methoden bestehen aus Implementierungen, deren Verantwortung die Initialisierung bzw. Deinitialisierung ist.
Nachfolgend finden Sie den Mustercode zum Ausführen des Test-Suites:
if __name__ == "__main__":
unittest.main()
Testausführung (PyUnit Framework)
Nachdem EXEC_PLATFORM auf cloud gesetzt wurde, rufen Sie den folgenden Befehl in der Konsole auf, um PyUnit-Tests auf dem Cloud-Grid auszuführen:
python tests/pyunit/pyunit_selenium_demo.py
Hier ist ein Screenshot des LambdaTest Web Automation-Dashboards, der anzeigt, dass die Testausführung erfolgreich war:
Wenn Sie die obigen Tests auf Selenium ausführen möchten, der auf dem lokalen Rechner installiert ist, setzen Sie einfach EXEC_PLATFORM auf local, und Sie sind bereit für die lokale Ausführung.
Top Python Test-Frameworks
Da Python eine Vielzahl von Testautomatisierungs-Frameworks unterstützt, ist die Auswahl des richtigen Frameworks äußerst wichtig für Ihr Projekt. Die Wahl legt tatsächlich den Grundstein für effizientes Testen. Neben den Fähigkeiten des Frameworks müssen Sie auch die interne Expertise mit dem genannten Framework betrachten. Hier sind einige der besten Python-Test-Frameworks:
PyUnit (unittest)
Es ist das Standardframework in Python. Wie der Name schon sagt, wird es hauptsächlich für Unittests verwendet. PyUnit ist vom JUnit-Framework für Java inspiriert und teilt eine ähnliche Struktur und Funktionalität.
Das unittest-Framework unterstützt auch die Testautomatisierung, den Austausch von Einrichtungs- und Abschaltcode für Tests, die Unabhängigkeit der Tests vom Berichterstattungsrahmen und mehr. Es unterstützt auch Test-Suiten und Testfälle auf eine objektorientierte Weise. Es verfügt auch über einen Testrunner, der für die Orchestrierung der Testdurchführung verantwortlich ist.
pytest
Es ist eines der beliebtesten Testautomatisierungs-Frameworks für Python. Es verwendet eine weniger umfangreiche und benutzerfreundliche Syntax zur Implementierung von Tests. pytest kann für die Implementierung von Unit-Tests sowie komplexen funktionalen Tests für die Prüfung von Websites und Webanwendungen genutzt werden.
Tests, die mit pytest geschrieben wurden, sind wesentlich kompakter, da das Framework keinen Boilerplate-Code erfordert. pytest verfügt über integrierte Funktionen, die bei der automatischen Erkennung von Testmodulen und -funktionen helfen.
Robot
Es handelt sich um ein schlüsselwortgesteuertes Open-Source-Python-Framework, das hauptsächlich für die Robot Process Automation (RPA) und Testautomatisierung verwendet wird. Ähnlich wie das pytest-Framework ist Robot erweiterbar. Die Verwendung einer leicht verständlichen Syntax/Keywords minimiert die Lernkurve beim Erlernen von Robot.
Tests, die in Robot geschrieben sind, werden mit der Erweiterung .robot gespeichert. Wenn Sie Robot für Frontend-Tests verwenden möchten, können Sie dies mit der SeleniumLibrary tun, die eine Webtestbibliothek für das Robot Framework ist. Die Bibliothek unterstützt eine umfangreiche Palette von Schlüsselwörtern (Button klicken, Bild klicken, Browser öffnen, Drag and Drop und andere).
Nose2
Es ist der Nachfolger von Nose und ist ein Python-Test-Framework, das die Fähigkeiten des PyUnit (oder unittest) Frameworks erweitert. Es ist relativ einfach, mit Nose2 zu beginnen, wenn Sie bereits Erfahrung mit unittest haben.
Der größte Vorteil von Nose2 gegenüber PyUnit ist die Verfügbarkeit einer großen Anzahl von integrierten Nose-Plugins, die das Testen erleichtern und beschleunigen. Plugins in Nose2 helfen bei der Testparameterisierung, der besseren Organisation von Tests, der Unterstützung von Fixtures, der Testentdeckung und mehr.
Behave
Es handelt sich um ein Python-Framework, das für Behavior-Driven Development (BDD) verwendet wird. Die Tests basieren auf der Gherkin-Syntax, die auf dem Given-When-Then-Format basiert.
Da die Tests in Szenario- und Feature-Dateien implementiert sind, können sogar nicht-technische Personen am QA-Prozess teilnehmen. SpecFlow (C#) und Cucumber (Java, JS, Ruby) sind einige der anderen beliebten BDD-Frameworks.
Abschluss
Wie bisher gesehen, ist Python bei weitem die beste Skriptsprache für die Testautomatisierung. Es ist relativ einfach, mit der Python-Automatisierungstestung zu beginnen. Seine breite Palette von Test-Frameworks kann für Unittests, Cross-Browser-Tests und mehr verwendet werden. Lassen Sie uns unten wissen, welche bevorzugte Programmiersprache Sie für das Selenium-Testing haben und wie Sie sie im Vergleich zu Python bewerten, dem unbestrittenen König für die automatisierte Testung. Frohes Testen!
Source:
https://dzone.com/articles/python-automation-testing-with-examples