Quando si tratta di automatizzare i test front-end, la scelta del linguaggio di programmazione ideale diventa estremamente cruciale. Python è uno di quei linguaggi che primeggia, grazie alla facilità d’uso e al vasto supporto della comunità.
Inoltre, il testing di automazione Python ti permette di sfruttare le capacità offerte da librerie e framework popolari come Selenium, pytest e Robot, tra gli altri. Utilizzare Selenium con Python aiuta a sfruttare al massimo le potenti capacità di automazione del browser di Selenium e la semplicità e l’estensibilità di Python. In generale, il testing di automazione Python è ampiamente utilizzato da tutti i QAs, specialmente con Selenium WebDriver.
In questo blog, approfondiremo le sfumature di Python da una prospettiva front-end. Gli apprendimenti di questo blog saranno utili per sfruttare le capacità di Python per automatizzare scenari front-end semplici e complessi.
Cos’è il testing di automazione Python?
Come suggerisce il nome, il testing di automazione Python è il processo di utilizzo di script Python per automatizzare i test. È uno dei linguaggi di programmazione più ricercati per l’automazione di compiti manuali e ripetitivi.
Un semplice esempio di test di automazione Python coinvolge l’utilizzo del framework pytest con Selenium per automatizzare i test front-end su una piattaforma di eCommerce. Puoi verificare la funzionalità di registrazione di un sito web di eCommerce e utilizzare la stessa sessione per navigare attraverso il sito e aggiungere gli elementi richiesti al carrello della spesa. Alla fine di questo test, avrai verificato le funzionalità di registrazione, accesso e carrello del sito di eCommerce.
Infine, puoi anche sfruttare Python per automatizzare l’amministrazione di sistema, automatizzare le email e compiti di elaborazione dati. Poiché Python è un prerequisito per i test automatizzati, ti preghiamo di fare riferimento al video qui sotto, che approfondisce l’installazione di Python.
Perché Python per i Test Automatizzati?
Ora che sappiamo perché i tester preferiscono Selenium con Python, vediamo alcune delle ragioni essenziali per scegliere Python per i test di automazione:
1. Ampia Gamma di Librerie e Framework
PyUnit (o unittest) è il framework di test predefinito per eseguire test unitari con Python. Anche se PyUnit è disponibile direttamente, Python supporta altri framework popolari come pytest, Behave, Robot, Lettuce e Nose2.
Tutti possono essere utilizzati in modo esaustivo con i framework Selenium e Playwright per automatizzare i test del browser web.
2. Esecuzione di Test Paralleli Super Facile
Il testing parallelo in Selenium e Python può essere utilizzato ampiamente per eseguire test di automazione del browser web su diverse combinazioni di browser e piattaforme. Anche se tutti i linguaggi supportati da Selenium supportano l’esecuzione di test in parallelo, è molto facile da usare con Python.
3. Linguaggio di Programmazione Multi-Paradigma
Python è un linguaggio di programmazione multi-paradigma. Pertanto, offre un supporto completo per la programmazione orientata agli oggetti e la programmazione strutturata. La maggior parte delle funzionalità in Python supporta la programmazione funzionale e la programmazione orientata agli aspetti. Python, insieme a Selenium, può essere utilizzato anche per testare siti web e applicazioni web in modo funzionale.
4. Tipizzazione Dinamica
Il linguaggio Python utilizza la tipizzazione dinamica e il binding tardivo (o risoluzione dinamica dei nomi) che collega i metodi e i nomi delle variabili durante l’esecuzione. Questa caratteristica è molto utile per l’automazione dei test in Python.
Python offre anche opzioni come Pyre (un controllore di tipo performante per Python 3) e Mypy, che sono controllori di tipo statico popolari. Con questi controllori, Python ti consente di combinare la potenza della tipizzazione dinamica e statica.
5. Web Scraping
Il web scraping con Python è il processo di estrazione di informazioni/dati significativi e utili dai siti web. È utilizzato principalmente per la ricerca accademica, l’analisi della concorrenza, l’aggregazione di contenuti e altro ancora.
Python offre una serie di librerie e framework, tra cui BeautifulSoup (bs4), Selenium, Puppeteer e Pyppeteer, che facilitano il compito di scraping dei contenuti dai siti web.
6. Reporting Potente e Senza Problemi
La reportistica nell’automazione dei test offre una maggiore visibilità sulle sfumature dell’esecuzione dei test (cioè, percentuale di test superati/falliti, ambiente di test, screenshot, ecc.). Report potenti che forniscono le informazioni giuste in forma concisa e comprensibile possono essere inviati ai membri del team necessari affinché siano a conoscenza dei progressi sul fronte dei test.
Come eseguire test di automazione in Python?
Ora che abbiamo esaminato l’importanza del test di automazione in Python, mettiamoci al lavoro eseguendo alcuni test. La nostra discussione si concentrerà principalmente sui test automatizzati frontali con Python.
Prima di iniziare con i test, impostiamo l’ambiente virtuale (venv), che aiuta a gestire meglio l’ambiente e le dipendenze. venv gioca un ruolo fondamentale nel fornire isolamento dai pacchetti installati nell’ambiente di base.
Esegui i comandi virtualenv venv e source venv/bin/activate nel terminale per creare l’ambiente virtuale. Tutte le dipendenze (o pacchetti Python), come pytest, selenium, ecc., necessarie per l’esecuzione del progetto sono disponibili nel file requirements.txt.
pytest-selenium
pytest-xdist
selenium>=4.6.0
urllib3==1.26.12
requests
py
Dipendenze
Le dipendenze possono essere installate eseguendo pip install -r requirements.txt nel terminale. Selenium v4.6.0 (o superiore) è installato come parte della procedura di installazione.
Per dimostrazione, eseguiremo semplici test Selenium Python con i framework pytest e PyUnit (o unittest). Se sei esperto in uno di questi framework, ti consigliamo di utilizzare i fixtures in Python e il Modello degli Oggetti di Pagina in Selenium Python per un miglioramento nella manutenzione dei test. Il pacchetto Selenium stesso non fornisce uno strumento o framework di test. Pertanto, utilizzeremo Selenium con pytest e PyUnit per automatizzare le interazioni con gli elementi sulla pagina web.
Scenario di Test
- Andare alla LambdaTest Selenium Playground.
- Trovare il link per inviare il modulo di input sulla pagina.
- Inserire le informazioni richieste sulla pagina.
- Invia i dettagli e verifica se le informazioni non sono state inviate con successo.
Implementazione (Framework pytest)
Qui di seguito è riportato lo script di test per il precedente scenario di test:
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()
Percorso del Codice
Per iniziare, importiamo prima i moduli necessari per l’implementazione dei test. Poiché stiamo utilizzando pytest, il modulo pytest è anche importato nel codice.
La classe WebDriverWait dal modulo selenium.webdriver.support.ui è importata in modo da poter utilizzare attese esplicite per scenari in cui gli elementi Web vengono localizzati dinamicamente. Il modulo expected_conditions fornisce un insieme di ExpectedConditions predefiniti in Selenium che possono essere utilizzati con attese esplicite.
Poiché gli elementi devono essere localizzati prima di eseguire qualsiasi azione, prima definiamo i localizzatori degli elementi richiesti. ID, Nome, XPath, Testo del collegamento, Testo parziale del collegamento, ecc., sono alcuni dei localizzatori web più comunemente usati che aiutano a trovare elementi all’interno del Document Object Model (DOM).
Puoi utilizzare gli strumenti di ispezione disponibili nativamente con il browser web o un plugin (o componente aggiuntivo) come POM Builder che rende facile trovare l’XPath/Selettore CSS degli WebElement.
Una volta identificato il localizzatore web, il relativo WebElement viene localizzato combinando il localizzatore con il metodo find_element() o find_elements() di Selenium Python. Il metodo find_element() restituisce un singolo WebElement, mentre find_elements() restituisce un elenco di WebElements che corrispondono ai criteri del localizzatore.
Come già detto, il setup_method() è un fixture pytest che fa parte dell’inizializzazione. Il metodo viene chiamato prima che ogni funzione di test venga implementata sotto la suddetta classe di test.
I test implementati possono essere eseguiti su Selenium installato sulla macchina locale così come sulla griglia Selenium online offerta dai test in cloud. LambdaTest è una piattaforma di esecuzione dei test alimentata dall’IA che ti consente di eseguire test automatizzati in Python su larga scala attraverso diversi browser e sistemi operativi. Offre numerosi vantaggi, i principali dei quali sono la riduzione della manutenzione, costi inferiori e un’esecuzione dei test accelerata.
Per quanto riguarda l’implementazione, l’unica modifica riguarda Selenium WebDriver, dove Remote WebDriver in Selenium viene istanziato durante l’esecuzione dei test su una cloud grid. Il Generatore di Capacità di Automazione aiuta a generare capacità per la combinazione di test destinata a essere utilizzata nei test.
In Selenium 4, le opzioni del browser vengono utilizzate al posto delle Desired Capabilities. Puoi consultare il blog sulle differenze tra Selenium 3 e Selenium 4 per sapere di più su ciò che è deprecato e su cosa è stato deprecato in Selenium 4.
Le variabili d’ambiente LT_USERNAME e LT_ACCESS_KEY possono essere ottenute dalle Impostazioni Account di LambdaTest > Password & Sicurezza. La combinazione, se passata insieme all’URL della grid di LambdaTest, aiuta ad eseguire test sulla cloud grid. Nel metodo test_enter_form_details(), prima navighiamo verso l’URL di test invocando il metodo driver.get().
Successivamente, la finestra del browser istanziata viene massimizzata poiché è considerata una delle migliori pratiche di Selenium.
Successivamente, l’elemento Input Form Submit viene localizzato utilizzando il metodo find_element() insieme al localizzatore XPath in Selenium. Una volta localizzato, il clic sul pulsante in Selenium viene invocato per simulare l’azione di clic sull’elemento del pulsante localizzato nel passaggio precedente.
Poiché tutti i passaggi del test coinvolgono la localizzazione degli elementi e l’esecuzione di azioni, ci concentriamo solo su alcuni metodi. L’approccio utilizzato per localizzare l’elemento company tramite il CSS Selector in Selenium è mostrato di seguito. Il send_keys() in Selenium WebDriver aiuta a inviare input di testo nell’elemento localizzato.
I menu a discesa sono ampiamente utilizzati sui siti web; pertanto, automatizzare le interazioni con i menu a discesa utilizzando Selenium diventa un requisito fondamentale per i tuoi casi di test. La classe Select del modulo selenium.webdriver.support.ui fornisce metodi che ti consentono di gestire i menu a discesa con Selenium.
Qui, viene creato un oggetto (cioè, country_dropdown) della classe Select con l’input impostato sul WebElement del menu a discesa localizzato con XPath. Il metodo select_by_visible_text() della classe Select aiuta a selezionare elementi con testo visibile che corrisponde alla stringa fornita (cioè, Stati Uniti).
Una volta che tutte le informazioni nel modulo sono state inserite e viene cliccato il pulsante Invia, aspettiamo fino a quando la stringa del messaggio di successo (predefinito: nascosto) diventa visibile nella pagina. Viene eseguita un’attesa esplicita con la ExpectedCondition (cioè, presenza dell’elemento localizzato) fino a quando il messaggio di successo non è presente nella pagina.
Viene sollevata un’asserzione se la stringa risultante non è presente nella pagina. Per l’esecuzione nel cloud, la variabile lambda-status è contrassegnata come passata/fallita a seconda dello stato di esecuzione.
Il fixture teardown_method() contiene l’implementazione per la pulizia delle risorse o dello stato dopo l’esecuzione dei test nella classe. La costruzione if __name__ == "__main__": garantisce che l’esecuzione del codice avvenga solo quando lo script viene eseguito direttamente. Il pytest.main() chiama il framework pytest che successivamente scopre ed esegue tutti i test abilitati (cioè, non contrassegnati come saltati) nello script.
Esecuzione del test (framework pytest)
Dopo aver impostato EXEC_PLATFORM su cloud, eseguire il seguente comando nel terminale per eseguire i test pytest sulla griglia cloud di LambdaTest:
pytest --verbose --capture=no tests/pytest/pytest_selenium_demo.py
Di seguito è riportata la schermata del dashboard dell’automazione Web di LambdaTest che indica che l’esecuzione del test è stata completata con successo:
Implementazione (framework PyUnit)
Lo script di test per lo scenario di test sopra menzionato utilizzando il framework PyUnit è situato in tests/pyunit/pyunit_selenium_demo.py.
La logica principale del test rimane invariata durante la migrazione da pytest al framework PyUnit (o unittest). Invece del modulo pytest, viene importato nel codice il modulo unittest. La classe del caso di test eredita da unittest.TestCase informa il modulo unittest che si tratta di un caso di test.
I fixtures di pytest setup_method()/teardown() sono simili ai metodi setUp()/tearDown() del framework PyUnit. I metodi setUp() e tearDown() consistono nell’implementazione il cui compito è l’inizializzazione e la deinizializzazione, rispettivamente.
Di seguito è riportato il codice boilerplate per eseguire il suite di test:
if __name__ == "__main__":
unittest.main()
Esecuzione dei Test (Framework PyUnit)
Dopo aver impostato EXEC_PLATFORM su cloud, invoca il seguente comando nel terminale per eseguire i test PyUnit sulla griglia cloud:
python tests/pyunit/pyunit_selenium_demo.py
Di seguito è mostrato uno screenshot del dashboard di automazione web di LambdaTest che indica che l’esecuzione del test è stata completata con successo:
Nel caso in cui tu voglia eseguire i test sopra menzionati su Selenium installato sulla macchina locale, basta impostare EXEC_PLATFORM su local, e sei pronto per l’esecuzione locale.
Principali Framework di Testing Python
Poiché Python supporta un numero di framework di automazione dei test, scegliere il framework giusto diventa estremamente cruciale per il tuo progetto. La scelta infatti getta le basi per un testing efficiente. Oltre alle capacità del framework, è anche necessario dare un’occhiata all’expertise interna con il framework in questione. Di seguito sono riportati alcuni dei migliori framework di testing Python:
PyUnit (unittest)
È il framework predefinito disponibile in Python. Come suggerisce il nome, è principalmente utilizzato per il testing unitario. PyUnit è ispirato al framework JUnit per Java e condivide una struttura e funzionalità simili.
Il framework unittest supporta anche la condivisione dell’automazione dei test per il setup e lo spegnimento dei test, l’indipendenza dei test dal framework di reportistica, e altro ancora. Supporta inoltre suite di test e casi di test in modo orientato agli oggetti. Ha anche un esecutore di test che è un componente responsabile dell’orchestrazione dell’esecuzione dei test.
pytest
È uno dei framework di automazione dei test più popolari per Python. Utilizza una sintassi meno verbosa e user-friendly per implementare i test. pytest può essere sfruttato per implementare test unitari così come test funzionali complessi per testare siti web e applicazioni web.
I test scritti utilizzando pytest sono molto più compatti, poiché il framework non richiede codice boilerplate. pytest ha funzionalità integrate che aiutano con la scoperta automatica dei moduli e delle funzioni di test.
Robot
Si tratta di un framework open-source basato su parole chiave in Python che viene principalmente utilizzato per l’Automazione dei Processi Robotici (RPA) e l’automazione dei test. Similmente al framework pytest, Robot è anche estensibile. L’utilizzo di una sintassi/parole chiave leggibili dall’essere umano riduce al minimo la curva di apprendimento coinvolta nell’apprendimento di Robot.
I test scritti in Robot vengono salvati con estensione .robot. Nel caso in cui si pianifichi di utilizzare Robot per test front-end, è possibile farlo con SeleniumLibrary, che è una libreria di test web per il Framework Robot. La libreria supporta una vasta gamma di parole chiave (Clicca Pulsante, Clicca Immagine, Apri Browser, Trascina e Rilascia, tra gli altri).
Nose2
È il successore di Nose ed è un framework di testing Python che estende le capacità del framework PyUnit (o unittest). È relativamente facile iniziare con Nose2 se si ha esperienza lavorativa precedente con unittest.
Il principale vantaggio di Nose2 rispetto a PyUnit è la disponibilità di un gran numero di plugin Nose integrati che rendono il testing più facile e veloce. I plugin in Nose2 aiutano nella parametrizzazione dei test, migliore organizzazione dei test, supporto per i fixtures, scoperta dei test e altro ancora.
Behave
È un framework Python utilizzato per lo Sviluppo Guidato dal Comportamento (BDD). I test si basano sulla sintassi Gherkin, che è basata sul formato Given-When-Then.
Dato che i test sono implementati in scenari e file di funzionalità, anche il personale non tecnico può far parte del processo di QA. SpecFlow (C#) e Cucumber (Java, JS, Ruby) sono alcuni degli altri framework BDD popolari.
Conclusione
Come visto finora, Python è di gran lunga il miglior linguaggio di scripting per l’automazione dei test. È relativamente facile iniziare con il testing di automazione in Python. La vasta gamma di framework di test può essere utilizzata per i test unitari, i test cross-browser e altro ancora. Fateci sapere qui sotto il vostro linguaggio di programmazione preferito per i test di Selenium e come lo valutate rispetto a Python, il re indiscusso per il testing automatizzato. Buon testing!
Source:
https://dzone.com/articles/python-automation-testing-with-examples