Test e debug dello script per garantire stabilità

1. Metodi di testing degli script

Benvenuti alla nostra lezione dedicata al processo preferito da tutti i programmatori: il debug e il testing! Se avete già imparato a creare un fantastico bot con Selenium, è arrivato il momento di scoprire come trasformarlo da un robot pazzo in un fedele esecutore che non solo funziona, ma lo fa in modo stabile. Non vorrete certo che il vostro bot, nel momento cruciale, decida di "riposarsi".

Iniziamo discutendo dei vari metodi di testing dei vostri script. Il testing è come una visita obbligatoria dal medico: nessuno lo desidera, ma bisogna farlo. Anche lo script più brillante ha bisogno di essere testato per robustezza e affidabilità. La buona notizia è che in Python ci sono molti strumenti per aiutarti in questo compito.

Unit-test

Tutto inizia con gli unit-test. Sono come piccoli orologi svizzeri che controllano ogni ingranaggio del tuo meccanismo. In Python, la libreria unittest è lo standard de facto per scrivere unit-test. L'idea principale è quella di testare singoli "unit" o parti del codice in isolamento.

import unittest
from my_selenium_script import my_function

class TestMyFunction(unittest.TestCase):

    def test_success_case(self):
        result = my_function("input previsto")
        self.assertEqual(result, "output previsto")

unittest.main()

Questo esempio semplice illustra come puoi testare le singole funzioni del tuo codice. Ovviamente, in pratica controllerai non solo i successi, ma anche casi limite e input non validi.

Test di integrazione

Quando puoi già contare su ogni "unit", è il momento di verificare come interagiscono tra loro. I test di integrazione, come un appuntamento perfetto, mostrano come i singoli componenti lavorano insieme. Anche qui puoi usare le stesse librerie, ma avvicinarti al testing da un'altra prospettiva.

class TestIntegration(unittest.TestCase):

    def test_full_workflow(self):
        # Immagina che ogni passo sia una chiamata della tua funzione nell'algoritmo
        open_page()
        fill_form()
        submit_form()
        self.assertTrue(check_results())

I test di integrazione possono essere più complessi e richiedere più tempo, ma ti danno la sicurezza che l’intero sistema funzioni come un tutto unico.

2. Debug e correzione degli errori

Ora che abbiamo parlato di testing, immergiamoci nella parte più intrigante: il debug. Il debug è quando il tuo bot decide di improvvisare e tu cerchi di riportarlo sul copione.

Strumenti di debug

Uno strumento fantastico per il debug in Python è pdb. Permette di mettere in pausa l'esecuzione dello script ed esaminare il suo stato passo dopo passo. Diamo un’occhiata a un esempio:

import pdb

def some_function(value):
    pdb.set_trace()  # Qui l'esecuzione sarà sospesa
    result = value + 1
    return result

some_function(3)

Eseguendo questo codice, entrerai in un ambiente interattivo dove potrai camminare nel codice, osservare i valori delle variabili, modificarli e continuare l'esecuzione del programma passo dopo passo. Questo semplifica molto la vita quando il tuo script sembra comportarsi in modo strano.

Visualizzazione dello stato della pagina

Per il debug visivo è utile salvare schermate della pagina a ogni passo dello script. Questo aiuta a vedere quali elementi sono visualizzati sullo schermo e come appare la pagina nel momento dell’errore.

driver.save_screenshot("stato_pagina.png")

Strategie per trovare e correggere gli errori

Purtroppo, nessun debugger ti mostrerà dove si trova un errore fondamentale nella logica del codice. Qui entrano in gioco alcune strategie:

• Logging: Aggiungi logging ovunque. Come ha detto qualcuno saggio, "se non sai cosa sta succedendo nel codice, significa che non hai abbastanza log". Usare il modulo logging aiuta a non ingombrare il tuo codice con funzioni print() e ti dà più controllo.
• Leggere il codice ad alta voce: A volte la mente risolve meglio se esponi cosa fa il codice. Sembra buffo, ma funziona!
• Dividere in moduli: Dividi chiaramente il codice in moduli o funzioni. Questo permette di scoprire più facilmente dove si è verificato il problema.

3. Analisi dei tuoi script Selenium

Per creare uno script affidabile è importante testarlo in diversi scenari. Ecco alcuni esempi di tali scenari:

Assenza di elementi sulla pagina

Durante il debug è fondamentale verificare che tutti gli elementi necessari siano presenti sulla pagina e accessibili per l’interazione. Usa il metodo find_elements() e controlla la lunghezza della lista restituita per evitare errori di tipo NoSuchElementException.

elements = driver.find_elements_by_class_name("class_name")
if len(elements) == 0:
    logging.warning("Elementi non trovati")
else:
    logging.info("Elementi trovati con successo")

Stati imprevisti della pagina

Ad esempio, pagine con diversi stati di caricamento o elementi che appaiono in base a certe condizioni. Lo script deve essere pronto a gestire tali situazioni.

try:
    special_offer = driver.find_element(By.ID, "special_offer")
    logging.info("Trovato un'offerta speciale, eseguo azioni")
except NoSuchElementException:
    logging.info("Offerta speciale non trovata, continuo senza di essa")

Elementi variabili sulla pagina

Durante i test, considera che sulla stessa pagina gli elementi possono cambiare (es. diversi banner, blocchi pubblicitari ecc.). Testa lo script considerando i diversi stati della pagina.

Test su diversi browser

I vari browser possono elaborare le pagine in modi diversi, quindi per garantire stabilità è utile testare lo script su più browser (es. Chrome, Firefox, Edge). Utilizza Selenium per eseguire test su diversi browser tramite diversi web driver.

from selenium import webdriver

# Esecuzione su Chrome
driver = webdriver.Chrome()

# Esecuzione su Firefox
driver = webdriver.Firefox()

# Esecuzione su Edge
driver = webdriver.Edge()

4. Automazione del testing degli script

Scrivere test utilizzando unittest

Usa la libreria unittest per eseguire automaticamente test su diverse parti del tuo script. Questo ti consente di verificare regolarmente il funzionamento di ciascun elemento.

import unittest
from selenium import webdriver

class SeleniumTest(unittest.TestCase):
    def setUp(self):
        self.driver = webdriver.Chrome()
        self.driver.get("https://example.com")

    def test_element_presence(self):
        driver = self.driver
        element = driver.find_element_by_id("submit_button")
        self.assertIsNotNone(element, "Elemento non trovato sulla pagina")

    def tearDown(self):
        self.driver.quit()

unittest.main()

Creare un set di test con parametri

Crea set di test per verificare varie combinazioni di elementi e scenari. Ad esempio, puoi testare pagine con diversi parametri, come differenti forme di dati in un modulo di input.

Test di stabilità e performance

• Verifica stabilità dello script con grandi volumi di dati: Assicurati che lo script sia in grado di gestire grandi volumi di dati e lavorare per lunghi periodi.
• Esegui test regolari: Effettua test regolarmente per monitorare la stabilità dello script, specialmente se il sito con cui lavori viene aggiornato frequentemente.
• Valuta le performance: Evita lunghe attese e elementi lenti. Usa timer per valutare il tempo di esecuzione di ogni passo e ottimizzali se necessario.