Pruebas y depuración de un script para garantizar estabilidad

1. Métodos para probar scripts

¡Bienvenidos a nuestra lección dedicada al proceso favorito de todo programador: depuración y pruebas! Si ya dominaste la creación de un bot genial con Selenium, es hora de aprender cómo convertirlo de un robot alocado en un ejecutor obediente que no solo funciona, sino que lo hace de manera estable. Porque no queremos que tu bot decida "tomarse un descanso" en el momento más importante.

Empecemos discutiendo varios métodos para probar tus scripts. Las pruebas son como una visita obligatoria al médico: nadie quiere, pero son indispensables. Incluso el script más brillante necesita ser probado para comprobar su robustez y confiabilidad. La buena noticia es que Python tiene muchas herramientas para ayudarte en esta tarea.

Pruebas Unitarias

Todo comienza con las pruebas unitarias. Son como pequeños relojes suizos que verifican cada engranaje de tu mecanismo. En Python, la biblioteca unittest es el estándar de facto para escribir pruebas unitarias. La idea principal es probar partes individuales o "unidades" de tu código de manera aislada.

import unittest
from my_selenium_script import my_function

class TestMyFunction(unittest.TestCase):

    def test_success_case(self):
        result = my_function("entrada esperada")
        self.assertEqual(result, "salida esperada")

unittest.main()

Este ejemplo sencillo ilustra cómo puedes verificar funciones individuales de tu código. Por supuesto, en la práctica no solo probarás los casos exitosos, sino también los límites y los datos incorrectos.

Pruebas de Integración

Cuando ya tienes confianza en cada "unidad", es hora de probar cómo interactúan entre sí. Las pruebas de integración, como una cita perfecta, muestran cómo funcionan los componentes individuales juntos. Aquí puedes usar las mismas bibliotecas, pero abordar las pruebas desde otro ángulo.

class TestIntegration(unittest.TestCase):

    def test_full_workflow(self):
        # Imagina que cada paso es una función de tu algoritmo
        open_page()
        fill_form()
        submit_form()
        self.assertTrue(check_results())

Las pruebas de integración pueden ser más complejas y tomar más tiempo, pero brindan la confianza de que todo el sistema funciona como un todo.

2. Depuración y corrección de errores

Ahora que hablamos de pruebas, vamos a sumergirnos en la parte más intrigante: la depuración. La depuración ocurre cuando tu bot decide improvisar y tú intentas devolverlo al guion.

Herramientas de depuración

Una herramienta increíble para depuración en Python es pdb. Te permite pausar la ejecución del script e inspeccionar su estado paso a paso. Vamos a ver un ejemplo:

import pdb

def some_function(value):
    pdb.set_trace()  # Aquí la ejecución se detendrá
    result = value + 1
    return result

some_function(3)

Al ejecutar este código, entrarás en un entorno interactivo donde puedes avanzar por el código, observar valores de variables, modificarlos e incluso continuar la ejecución del programa paso a paso. Esto facilita mucho la vida cuando tu script parece estar haciendo algo extraño.

Visualización del estado de la página

Para la depuración visual, es útil guardar capturas de pantalla de la página en cada etapa del script. Esto ayuda a ver qué elementos se muestran en pantalla y cómo se ve la página en el momento del error.

driver.save_screenshot("page_state.png")

Estrategias para encontrar y corregir errores

Lamentablemente, ningún depurador te mostrará dónde se cometió un error lógico fundamental en el código. Aquí es donde entran en juego las estrategias:

• Registro de logs: Agregar registros en todas partes. Como dijo alguien sabio, "Si no sabes qué está pasando con el código, es que tienes pocos logs". Usar la biblioteca logging ayuda a evitar llenar tu código con funciones print() y da más control.
• Leer el código en voz alta: A veces, tu cerebro resuelve problemas mejor si los expresas en voz alta. ¡Suena gracioso, pero funciona!
• División en módulos: Divide claramente las partes del código en módulos o funciones. Esto ayuda a identificar más fácilmente dónde ocurre una falla.

3. Análisis de tus scripts Selenium

Para crear un script confiable, es importante probar su funcionamiento en diferentes escenarios. A continuación, algunos ejemplos de tales escenarios:

Elementos faltantes en la página

Durante la depuración, es importante asegurarse de que todos los elementos necesarios estén presentes en la página y disponibles para interactuar. Usa el método find_elements() y verifica la longitud de la lista devuelta para evitar errores como NoSuchElementException.

elements = driver.find_elements_by_class_name("class_name")
if len(elements) == 0:
    logging.warning("Elementos no encontrados")
else:
    logging.info("Elementos encontrados con éxito")

Estados inesperados de la página

Por ejemplo, páginas con diferentes formas de carga o diferentes elementos que aparecen según las condiciones. El script debe estar listo para manejar estas situaciones.

try:
    special_offer = driver.find_element(By.ID, "special_offer")
    logging.info("Se encontró la oferta especial y se llevan a cabo acciones")
except NoSuchElementException:
    logging.info("La oferta especial no fue encontrada, continuamos sin ella")

Elementos variables en la página

Durante las pruebas, considera que en la misma página los elementos pueden cambiar (por ejemplo, diferentes banners, bloques de anuncios, etc.). Prueba el script teniendo en cuenta los diferentes estados de la página.

Pruebas en varios navegadores

Diferentes navegadores pueden procesar las páginas de forma distinta, por lo que para garantizar estabilidad, es útil probar el script en varios navegadores (por ejemplo, Chrome, Firefox, Edge). Selenium permite ejecutar pruebas en distintos navegadores a través de diferentes web drivers.

from selenium import webdriver

# Ejecución en Chrome
driver = webdriver.Chrome()

# Ejecución en Firefox
driver = webdriver.Firefox()

# Ejecución en Edge
driver = webdriver.Edge()

4. Automatización de las pruebas del script

Escribir pruebas utilizando unittest

Usa la biblioteca unittest para ejecutar automáticamente pruebas de diferentes partes de tu script. Esto te permitirá verificar regularmente el funcionamiento de cada 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 no encontrado en la página")

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

unittest.main()

Creación de conjuntos de pruebas con parámetros

Crea conjuntos de pruebas para verificar diferentes combinaciones de elementos y escenarios. Por ejemplo, puedes probar páginas con diferentes parámetros, como varias formas de datos en un formulario.

Pruebas de estabilidad y rendimiento

• Prueba la estabilidad del script con grandes volúmenes de datos: Asegúrate de que el script pueda manejar grandes cantidades de datos y funcionar durante mucho tiempo.
• Ejecuta pruebas regulares: Ejecuta pruebas regularmente para monitorear la estabilidad del script, especialmente si el sitio con el que trabajas se actualiza con frecuencia.
• Evalúa el rendimiento: Evita largos tiempos de espera y elementos lentos. Usa temporizadores para evaluar el tiempo de cada paso y optimízalos si es necesario.