Curso de Selenium

Entender cómo WebDriver comunica el test con el navegador mediante comandos estandarizados.

Diferenciar cliente Selenium, driver, navegador, sesión, capabilities, options y remote endpoint.

Revisar el ciclo de vida de una sesión WebDriver desde creación hasta cierre.

Evitar crear y destruir navegadores sin control en cada paso de prueba.

Configurar `ChromeOptions`, `FirefoxOptions`, `EdgeOptions` o equivalentes.

Gestionar navegadores locales y remotos.

Entender diferencias entre ejecución local, headless, Grid y servicios cloud.

Revisar compatibilidad de lenguaje, binding, versión de navegador y runtime.

Documentar arquitectura de ejecución del framework.

Taller: inspeccionar sesión WebDriver, capabilities y configuración efectiva del navegador.

Crear proyecto Selenium en Java con Maven o Gradle cuando el stack elegido sea JVM.

Crear proyecto Selenium en Python con Pytest, virtualenv, Poetry o herramienta equivalente.

Crear proyecto Selenium en C# con NUnit, xUnit, MSTest o stack corporativo.

Crear proyecto Selenium en JavaScript/TypeScript con npm, Mocha, Jest o framework de test elegido.

Evitar mezclar ejemplos de varios lenguajes sin una estructura común de aprendizaje.

Definir carpetas para tests, pages, components, fixtures, data, utils, config y reports.

Configurar dependencias, versiones y scripts de ejecución.

Añadir configuración por entorno: local, CI, Grid, staging y preproducción.

Crear test de humo para validar instalación.

Taller: construir proyecto base Selenium en el lenguaje seleccionado por la empresa.

Entender el problema histórico de gestionar ChromeDriver, GeckoDriver, EdgeDriver y versiones compatibles.

Usar Selenium Manager para automatizar la resolución de drivers y navegadores cuando encaja en el entorno.

Configurar entornos corporativos con proxy, restricciones de descarga, repositorios internos o ejecución offline.

Evitar fallos de pipeline por versiones de driver no controladas.

Revisar cuándo conviene fijar versiones manualmente.

Diagnosticar errores de driver, navegador, permisos y binarios no encontrados.

Gestionar navegadores instalados en runners, contenedores y máquinas de QA.

Documentar política de actualización de navegadores y drivers.

Integrar verificación de versión en el arranque de la suite.

Taller: resolver fallo de driver incompatible y dejar estrategia robusta de gestión.

Usar localizadores por ID, name, CSS selector, XPath, link text, class name y estrategias personalizadas.

Priorizar selectores estables, semánticos y mantenibles frente a rutas frágiles.

Evitar XPath absolutos, clases generadas y selectores dependientes de layout.

Coordinar con frontend atributos específicos para testing como `data-testid` o convenciones equivalentes.

Diseñar localizadores para componentes reutilizables.

Gestionar elementos repetidos, listas, tablas, cards y menús dinámicos.

Validar selectores desde DevTools antes de incorporarlos al test.

Documentar normas de selección para todo el equipo.

Refactorizar localizadores duplicados hacia Page Objects o componentes.

Taller: transformar una suite con selectores frágiles en selectores mantenibles.

Entender diferencia entre esperas implícitas, explícitas, fluent waits y sleeps.

Evitar `Thread.sleep`, `time.sleep` o pausas fijas como solución general.

Esperar condiciones reales: visibilidad, clicabilidad, presencia, URL, texto, estado y desaparición de loaders.

Crear esperas reutilizables para componentes y patrones de la aplicación.

Gestionar aplicaciones SPA con renderizado asíncrono y llamadas API.

Diagnosticar fallos intermitentes por timing.

Ajustar timeouts por tipo de acción y criticidad.

Evitar mezclar esperas implícitas y explícitas sin entender efectos.

Medir impacto de esperas en duración total de la suite.

Taller: eliminar flakiness causada por esperas fijas y condiciones incompletas.

Escribir texto, hacer click, limpiar campos, seleccionar opciones y validar contenido.

Gestionar checkboxes, radio buttons, selects, autocompletados, menús y date pickers.

Usar Actions API para hover, drag and drop, doble click, click derecho, teclas y combinaciones.

Evitar interacciones basadas en coordenadas salvo casos muy justificados.

Gestionar scroll, elementos fuera de viewport y sticky headers.

Tratar elementos deshabilitados, ocultos, superpuestos o animados.

Validar estados antes y después de cada interacción relevante.

Crear métodos de dominio para acciones complejas.

Documentar patrones de interacción propios de la aplicación.

Taller: automatizar formulario complejo con validaciones, calendario y componentes dinámicos.

Gestionar navegación entre URLs, back, forward, refresh y cambios de ruta.

Controlar pestañas y ventanas emergentes con window handles.

Cambiar correctamente a iframes y volver al contexto principal.

Evitar buscar elementos dentro de iframes sin cambiar de contexto.

Gestionar popups de autenticación, consentimientos, avisos y ventanas externas.

Validar apertura de nuevas pestañas y contenido cargado.

Diseñar helpers para navegación compleja.

Diagnosticar errores de contexto incorrecto.

Documentar flujos con terceros, pasarelas o widgets embebidos.

Taller: automatizar flujo con iframe de pago o widget externo simulado.

Entender qué es Shadow DOM y cómo afecta a los localizadores y al acceso a elementos.

Acceder a elementos dentro de shadow roots cuando la aplicación lo requiere.

Diferenciar componentes web nativos, librerías frontend y encapsulación visual.

Evitar forzar selectores que no atraviesan Shadow DOM.

Coordinar con frontend estrategias de testabilidad.

Diseñar helpers para componentes encapsulados.

Validar estados de componentes web reutilizables.

Revisar limitaciones según navegador y binding.

Documentar patrones de automatización para Web Components.

Taller: automatizar interacción con componente basado en Shadow DOM.

Usar JavaScript Executor para casos puntuales de diagnóstico, scroll o lectura de estado.

Evitar usar JavaScript para saltarse interacciones reales de usuario sin justificación.

Diferenciar click real de WebDriver y manipulación directa del DOM.

Leer propiedades, atributos, estado de framework y datos del navegador cuando aporta valor.

Ejecutar scripts pequeños, seguros y documentados.

Diagnosticar problemas de elementos cubiertos, scroll y listeners.

Evitar convertir tests Selenium en scripts DOM acoplados.

Crear criterios internos de uso permitido de JavaScript Executor.

Documentar cualquier excepción.

Taller: resolver caso difícil usando JavaScript Executor sin degradar la calidad del test.

Automatizar subida de archivos mediante inputs reales.

Configurar descargas en navegadores con directorio controlado.

Validar existencia, nombre, extensión, tamaño y contenido básico de archivos descargados.

Evitar depender de diálogos nativos del sistema operativo cuando puede usarse input file.

Gestionar archivos temporales por test para evitar contaminación.

Configurar permisos en runners y contenedores.

Trabajar con PDFs, CSVs, imágenes o documentos generados por la aplicación.

Limpiar artefactos después de cada ejecución.

Registrar evidencias cuando una descarga falla.

Taller: automatizar generación y descarga de informe con validación de contenido.

Leer, añadir, eliminar y validar cookies cuando el caso lo requiere.

Gestionar localStorage y sessionStorage de forma controlada.

Evitar saltarse flujos de login si el objetivo es probar autenticación real.

Reutilizar sesión solo en suites donde el aislamiento esté garantizado.

Limpiar estado del navegador entre tests.

Validar banners de consentimiento, idioma, preferencias y sesión.

Gestionar expiración, logout y cambios de usuario.

Documentar cuándo se permite preparar estado por cookies o storage.

Evitar dependencia de datos persistentes de ejecuciones anteriores.

Taller: crear estrategia de sesión para acelerar suite sin romper aislamiento.

Automatizar login tradicional, SSO, MFA simulado, OAuth, formularios internos y roles de usuario.

Evitar pruebas E2E bloqueadas por MFA real no automatizable.

Diseñar bypass seguro para entornos de prueba cuando está autorizado.

Gestionar usuarios por rol: admin, manager, usuario estándar, invitado y sin permisos.

Validar mensajes de acceso denegado y navegación restringida.

Preparar datos de usuarios sin compartir credenciales reales.

Integrar secretos de test con vault o variables seguras de CI.

Controlar sesiones caducadas y renovación de tokens.

Documentar estrategia de autenticación para automatización.

Taller: automatizar flujos con varios roles y validación de permisos.

Entender Page Object Model como patrón para separar interacción de test y detalles de UI.

Crear Page Objects con responsabilidades claras.

Evitar Page Objects gigantes que mezclan navegación, asserts, datos y lógica de negocio.

Definir métodos expresivos orientados a acciones del usuario.

Separar localizadores, acciones, validaciones y componentes reutilizables.

Gestionar herencia, composición y utilidades comunes con prudencia.

Crear base page sin convertirla en contenedor de todo.

Documentar convenciones de naming y estructura.

Refactorizar tests duplicados hacia Page Objects mantenibles.

Taller: convertir tests lineales en Page Objects limpios y reutilizables.

Crear objetos para componentes repetidos: header, sidebar, tabla, modal, toast, filtros y cards.

Evitar duplicar lógica de interacción de un mismo componente en múltiples páginas.

Diseñar componentes con scope de búsqueda para evitar colisiones de localizadores.

Gestionar componentes anidados y listas dinámicas.

Validar estados comunes desde componentes.

Alinear componentes de test con componentes frontend cuando es posible.

Reducir coste de mantenimiento ante cambios visuales.

Crear librería interna de componentes de automatización.

Documentar patrones de composición.

Taller: automatizar dashboard con tabla, filtros, modal y notificaciones usando componentes.

Entender Screenplay como patrón orientado a actores, tareas, preguntas e interacciones.

Comparar Screenplay con Page Object Model y enfoques híbridos.

Identificar cuándo Screenplay aporta claridad en suites grandes o dominios complejos.

Evitar introducir patrones sofisticados si el equipo no los mantendrá.

Diseñar actores, abilities, tasks, questions e interactions.

Separar intención de negocio y detalle técnico.

Crear criterios para elegir arquitectura de framework.

Documentar ventajas, costes y curva de aprendizaje.

Refactorizar una prueba crítica a estilo Screenplay.

Taller: implementar flujo de compra con enfoque Screenplay o patrón equivalente.

Diseñar estrategia de datos: estáticos, dinámicos, generados, por API, por base de datos o por fixtures.

Evitar tests que dependen de datos manuales inestables.

Crear datos antes del test y limpiarlos después cuando sea necesario.

Usar APIs para preparar estado en lugar de navegar por la UI en cada test.

Garantizar aislamiento entre tests paralelos.

Gestionar usuarios, pedidos, productos, permisos, documentos y entidades temporales.

Evitar usar datos productivos o sensibles.

Versionar fixtures y datasets.

Documentar ownership de datos de test.

Taller: reducir duración de suite preparando datos por API y validando por UI.

Diseñar aserciones que validan comportamiento de negocio, no solo presencia de elementos.

Evitar asserts débiles que pasan aunque el flujo esté roto.

Validar URL, estado, texto, datos, permisos, mensajes, cambios persistidos y efectos secundarios.

Separar aserciones de UI y validaciones por API cuando aporta fiabilidad.

Crear mensajes de error legibles para diagnóstico.

Usar soft assertions cuando conviene recopilar varios fallos.

Evitar aserciones excesivas que vuelven frágil el test.

Relacionar tests con criterios de aceptación.

Documentar intención de cada test.

Taller: mejorar una suite con aserciones pobres hasta convertirla en suite útil.

Clasificar tests por valor, duración, criticidad y frecuencia de ejecución.

Crear suites smoke para validación rápida tras despliegue.

Crear regresión selectiva para flujos críticos.

Evitar ejecutar toda la suite E2E en cada commit si no aporta valor.

Definir etiquetas, categorías, grupos y filtros.

Diseñar estrategia por entorno: local, pull request, nightly, release y producción sintética.

Medir duración y estabilidad de cada suite.

Retirar tests redundantes o de bajo valor.

Documentar criterio de entrada y salida por suite.

Taller: reorganizar 100 casos de prueba en suites ejecutables y gobernadas.

Configurar paralelización por clase, método, navegador, dataset o nodo.

Evitar paralelizar tests que comparten datos, usuario o estado global.

Diseñar tests thread-safe.

Gestionar drivers por hilo, fixtures aisladas y reporting concurrente.

Controlar consumo de CPU, RAM, red y navegadores.

Ajustar número de workers según Grid o runners disponibles.

Diagnosticar fallos que solo aparecen en paralelo.

Medir reducción real de tiempo frente a aumento de flakiness.

Documentar límites de paralelización.

Taller: paralelizar suite Selenium reduciendo tiempo sin romper estabilidad.

Entender Selenium Grid como infraestructura para ejecución remota y paralela de navegadores.

Diferenciar hub/node histórico, arquitectura actual, sesiones, router, distributor, session queue y event bus.

Ejecutar Grid en modo standalone, distribuido o mediante contenedores.

Registrar nodos con distintos navegadores, versiones y capacidades.

Evitar saturar Grid con más sesiones de las que puede soportar.

Configurar RemoteWebDriver, capabilities y URLs de ejecución.

Diagnosticar sesiones colgadas, nodos caídos, timeouts y falta de capacidad.

Monitorizar Grid, cola, sesiones activas y duración.

Documentar estrategia de escalado.

Taller: montar Selenium Grid y ejecutar suite paralela cross-browser.

Levantar Grid con imágenes oficiales o configuración corporativa.

Ejecutar navegadores en contenedores aislados.

Configurar memoria compartida, red, volúmenes, vídeos, logs y recursos.

Evitar errores de Chrome/Firefox por falta de `/dev/shm`, permisos o recursos.

Gestionar versiones de navegador e imagen.

Integrar Grid containerizado en pipelines o entornos efímeros.

Capturar evidencias desde contenedores.

Escalar nodos según demanda.

Documentar mantenimiento de imágenes y actualizaciones.

Taller: ejecutar Selenium Grid con Docker Compose o equivalente y reporting de evidencias.

Integrar Selenium en GitHub Actions, GitLab CI, Jenkins, Azure DevOps o herramienta equivalente.

Diseñar etapas: build, unit tests, API tests, despliegue, smoke E2E, regresión y reporting.

Evitar pipelines lentos, ruidosos y bloqueantes sin valor.

Ejecutar navegadores headless de forma estable.

Publicar reportes, capturas, vídeos, logs y artefactos.

Gestionar variables, secretos, entornos y credenciales.

Definir reintentos controlados sin ocultar fallos reales.

Ejecutar suites por ramas, pull requests, nightly o releases.

Medir duración, estabilidad y coste de pipeline.

Taller: crear pipeline CI/CD con Selenium, Grid, reportes y evidencias.

Generar reportes claros con estado, duración, suite, navegador, entorno y commit.

Capturar screenshots en fallo y en puntos críticos cuando aporta diagnóstico.

Grabar vídeo en ejecuciones remotas o Grid cuando el coste está justificado.

Recoger HTML, logs de navegador, consola, network logs y datos de sesión.

Evitar reportes llenos de ruido sin causa accionable.

Integrar Allure, ExtentReports, ReportPortal, HTML reports o herramienta corporativa.

Relacionar tests con historias, requisitos o casos de prueba.

Publicar artefactos en CI/CD.

Crear resumen ejecutivo de calidad para releases.

Taller: montar reporting completo con capturas, logs y agrupación de fallos.

Definir qué es un test flaky y por qué destruye confianza en la automatización.

Detectar flakiness por timing, datos, entorno, dependencias, red, paralelismo o localizadores.

Evitar ocultar flakiness con reintentos ilimitados.

Crear cuarentena de tests inestables y proceso de remediación.

Medir tasa de flakiness por suite, test, navegador y entorno.

Corregir esperas, datos, aislamiento, mocks o dependencias externas.

Diseñar tests deterministas y repetibles.

Añadir diagnóstico automático ante fallo intermitente.

Revisar tests flaky en retrospectivas de calidad.

Taller: estabilizar suite con cinco fallos intermitentes reales simulados.

Ejecutar pruebas en Chrome, Firefox, Edge y Safari cuando el proyecto lo requiere.

Gestionar diferencias de motor, renderizado, eventos, descargas y capacidades.

Evitar asumir que un test válido en Chrome cubre todos los navegadores.

Definir matriz de navegadores por usuarios reales, riesgo y coste.

Configurar capabilities específicas por navegador.

Gestionar Safari en macOS y sus requisitos.

Priorizar smoke cross-browser frente a regresión completa cuando el coste es alto.

Documentar incidencias específicas por navegador.

Integrar resultados por navegador en reporting.

Taller: ejecutar suite crítica en varios navegadores y analizar diferencias.

Entender diferencias entre ejecución visible y headless.

Configurar headless moderno en navegadores principales.

Evitar asumir que headless se comporta siempre igual que modo visible.

Ajustar tamaño de ventana, dispositivo, escala y preferencias.

Diagnosticar fallos solo reproducibles en CI.

Configurar fuentes, locales, timezone y dependencias del sistema en runners.

Gestionar capturas y vídeos en headless.

Comparar rendimiento y estabilidad.

Documentar configuración estándar de ejecución remota.

Taller: reproducir localmente fallo que solo aparece en headless CI.

Emular dispositivos móviles mediante DevTools capabilities cuando aplica.

Validar breakpoints, menús, scroll, formularios y layouts responsive.

Evitar confundir emulación de navegador con pruebas nativas reales.

Definir qué flujos web mobile deben automatizarse.

Configurar viewport, user agent, device scale y orientación.

Validar comportamiento táctil básico y contenido visible.

Integrar pruebas responsive en regresión selectiva.

Documentar límites de Selenium para mobile frente a Appium.

Comparar resultados con pruebas manuales en dispositivos reales.

Taller: automatizar smoke test mobile web de flujo crítico.

Entender WebDriver BiDi como evolución para comunicación bidireccional con el navegador.

Explorar capacidades relacionadas con logs, red, eventos, consola y observabilidad.

Diferenciar WebDriver clásico, Chrome DevTools Protocol y WebDriver BiDi.

Evitar depender de APIs experimentales sin validar soporte por navegador y binding.

Configurar opciones necesarias para usar BiDi cuando el binding lo permite.

Capturar eventos de consola o red para enriquecer diagnóstico.

Analizar casos donde BiDi aporta valor frente a Selenium clásico.

Documentar compatibilidad actual y limitaciones.

Integrar evidencias BiDi en reporting.

Taller: capturar logs de consola y eventos de red durante un test Selenium.

Recoger errores JavaScript de consola durante ejecución de tests.

Capturar logs de red, peticiones fallidas, códigos HTTP y tiempos cuando el stack lo permite.

Evitar ignorar errores de consola que afectan a usuarios aunque el test pase.

Correlacionar errores frontend con fallos funcionales.

Validar llamadas críticas a APIs desde el flujo UI.

Registrar evidencias de errores 4xx/5xx.

Integrar logs en reportes de ejecución.

Crear criterios para fallar o advertir por errores de consola.

Documentar limitaciones por navegador.

Taller: detectar fallo frontend invisible para aserciones tradicionales.

Entender qué resuelven las pruebas visuales y qué no resuelven.

Capturar screenshots de componentes, páginas o flujos completos.

Comparar imágenes con tolerancias controladas usando herramientas especializadas si procede.

Evitar falsos positivos por fuentes, antialiasing, tamaños, datos dinámicos o animaciones.

Definir baseline visual y proceso de aprobación.

Integrar pruebas visuales en suites selectivas, no en todo indiscriminadamente.

Documentar diferencias entre regresión visual y validación funcional.

Controlar coste de almacenamiento de imágenes.

Preparar reporting visual para revisión.

Taller: añadir prueba visual a pantalla crítica reduciendo falsos positivos.

Integrar checks automáticos de accesibilidad con herramientas compatibles.

Detectar problemas básicos de contraste, labels, roles, estructura, landmarks y navegación.

Evitar pensar que accesibilidad automatizada sustituye revisión experta.

Ejecutar análisis en pantallas críticas dentro de tests Selenium.

Reportar hallazgos con severidad y referencia a elemento.

Integrar resultados con backlog de calidad.

Validar formularios, modales, menús y estados de error.

Coordinar accesibilidad con diseño y frontend.

Definir umbral mínimo para bloquear releases.

Taller: ejecutar análisis de accesibilidad en flujo crítico y generar reporte.

Usar APIs para preparar datos antes de pruebas UI.

Validar efectos secundarios por API tras interacción UI.

Reducir tiempo de suite evitando preparar todo desde navegador.

Evitar mezclar demasiada lógica API dentro de tests UI sin estructura.

Crear clientes API reutilizables en el framework.

Gestionar autenticación, tokens y datos por entorno.

Crear teardown fiable de entidades temporales.

Comparar pruebas API y UI para decidir mejor nivel de cobertura.

Documentar estrategia de datos híbrida.

Taller: crear test Selenium que prepara pedido por API y valida edición por UI.

Usar Cucumber, SpecFlow, Behave o herramientas equivalentes cuando existe colaboración negocio-QA.

Escribir escenarios Gherkin claros, concretos y mantenibles.

Evitar Gherkin técnico lleno de clicks, selectores y pasos de bajo nivel.

Diseñar step definitions reutilizables sin ambigüedad.

Conectar escenarios con Page Objects o capa de dominio.

Gestionar tags, suites y reporting BDD.

Revisar coste de mantenimiento de BDD frente a valor de comunicación.

Definir ownership de escenarios.

Documentar normas de escritura.

Taller: transformar casos manuales en escenarios BDD automatizados con Selenium.

Entender Selenium IDE como herramienta de grabación, exploración o apoyo, no como arquitectura final para suites complejas.

Grabar flujos simples para comprender interacciones o prototipar casos.

Exportar o traducir aprendizajes hacia código mantenible.

Evitar depender de grabaciones frágiles para regresión crítica.

Usar IDE para formación, análisis inicial o soporte rápido.

Revisar limitaciones en datos, esperas, arquitectura y mantenimiento.

Crear criterios de uso permitido en equipos QA.

Documentar cómo pasar de grabación a framework.

Comparar coste de IDE frente a código en escenarios reales.

Taller: grabar flujo con Selenium IDE y refactorizarlo a test profesional.

Proteger credenciales, tokens, usuarios de test y secretos de pipeline.

Evitar hardcodear contraseñas en código o repositorios.

Usar vault, variables seguras o gestores de secretos.

Evitar automatizar sobre producción salvo pruebas sintéticas autorizadas y seguras.

Controlar datos personales y evidencias capturadas en screenshots, vídeos y logs.

Gestionar permisos de usuarios de prueba.

Limpiar datos tras ejecución.

Revisar dependencias del framework y CVEs.

Crear política de retención de evidencias.

Taller: securizar suite Selenium eliminando secretos y datos sensibles de artefactos.

Aplicar principios de código limpio al framework de automatización.

Evitar duplicación, métodos largos, asserts confusos y lógica de negocio dispersa.

Usar naming claro para tests, páginas, componentes y datos.

Crear revisiones de código para tests igual que para producción.

Añadir linters, formatters y análisis estático.

Mantener tests legibles para QA y desarrollo.

Separar helpers útiles de utilidades genéricas sin control.

Refactorizar tests sin cambiar intención.

Documentar patrones aceptados y anti-patrones.

Taller: refactorizar suite Selenium mal estructurada.

Medir deuda: tests lentos, flaky, duplicados, sin owner, sin valor o desactualizados.

Crear proceso de revisión periódica de suites.

Eliminar tests que ya no aportan valor.

Actualizar Page Objects cuando cambia la interfaz.

Gestionar tests en cuarentena con plazo de resolución.

Evitar acumular regresión infinita que nadie entiende.

Priorizar mantenimiento por impacto en pipeline y releases.

Crear ownership por módulo o flujo.

Medir coste de mantenimiento y retorno.

Taller: auditar suite Selenium y crear plan de saneamiento.

Definir métricas útiles: estabilidad, duración, cobertura crítica, fallos reales, flakiness y tiempo de feedback.

Evitar medir éxito por número bruto de tests automatizados.

Crear dashboard para QA Lead, desarrollo, DevOps y dirección.

Relacionar fallos con releases, módulos, equipos y criticidad.

Medir ahorro de tiempo manual con prudencia.

Identificar cuellos de botella de ejecución.

Reportar tendencia, no solo resultado de una ejecución.

Vincular automatización con riesgo de negocio.

Definir objetivos trimestrales de mejora.

Taller: diseñar cuadro de mando de automatización Selenium.

Integrar Selenium en definición de ready, definition of done y criterios de aceptación.

Definir cuándo automatizar durante el sprint y quién participa.

Evitar automatización tardía como fase separada al final del proyecto.

Coordinar QA, desarrollo, producto y DevOps.

Crear criterios para decidir qué historias requieren E2E.

Mantener suites pequeñas, rápidas y orientadas a riesgo.

Revisar fallos en daily, refinamiento o retro cuando afectan al equipo.

Crear backlog técnico de automatización.

Documentar flujo desde historia hasta test automatizado.

Taller: diseñar proceso ágil para incorporar Selenium sin bloquear delivery.

Comparar Selenium con Playwright, Cypress, WebdriverIO, Puppeteer y herramientas low-code.

Identificar fortalezas de Selenium: estándar WebDriver, ecosistema, Grid, lenguajes, cross-browser y madurez.

Reconocer límites: velocidad, control profundo del navegador, flakiness por mal diseño y menor ergonomía en algunos casos.

Evitar defender una herramienta por inercia sin analizar contexto.

Seleccionar herramienta según aplicación, equipo, lenguaje, CI/CD, navegadores y objetivos.

Diseñar convivencia entre Selenium y otras herramientas si aporta valor.

Preparar matriz de decisión técnica.

Evaluar coste de migración.

Documentar casos donde Selenium sigue siendo la mejor opción.

Taller: decidir stack de automatización para tres proyectos distintos.

Automatizar flujo de ecommerce con búsqueda, carrito, checkout, pago simulado y confirmación.

Automatizar dashboard B2B con login, filtros, tabla, exportación y permisos.

Automatizar aplicación pública con formularios, validaciones, navegación y responsive.

Automatizar backoffice con roles, modales, acciones masivas y estados.

Automatizar portal con SSO simulado, documentos, descargas y notificaciones.

Validar flujos críticos con datos preparados por API.

Ejecutar pruebas cross-browser de smoke.

Añadir reporting y evidencias.

Integrar suite en pipeline.

Taller: seleccionar caso propio de la empresa y diseñar cobertura E2E.

Automatizar por interfaz flujos que deberían probarse por API o unidad.

Usar sleeps fijos para resolver problemas de sincronización.

Crear localizadores dependientes de HTML frágil o clases generadas.

Mezclar lógica de test, UI, datos, asserts y configuración en el mismo archivo.

Ejecutar toda la regresión E2E en cada cambio sin estrategia.

Ignorar flakiness hasta que la suite deja de ser creíble.

Guardar credenciales en código o capturas con datos sensibles.

No limpiar datos de prueba ni aislar tests paralelos.

Mantener tests obsoletos que ya no validan valor de negocio.

Taller: auditar framework Selenium con anti-patrones y rediseñarlo.

Evaluar madurez actual: pruebas manuales, suites existentes, CI/CD, datos, entornos, reporting y flakiness.

Identificar quick wins: smoke tests críticos, Page Objects, reporting, Grid, datos por API y eliminación de sleeps.

Priorizar flujos por riesgo de negocio, frecuencia de uso, criticidad, estabilidad y coste de automatización.

Definir stack técnico: lenguaje, framework, reporting, Grid, CI/CD, datos y estándares.

Crear piloto con pocos flujos críticos y métricas claras.

Establecer normas de localizadores, esperas, datos, arquitectura y revisión de código.

Medir duración, estabilidad, fallos reales y valor de la suite.

Escalar por módulos tras validar el enfoque.

Crear plan a 30, 60, 90 y 180 días.

Taller: construir roadmap Selenium para una organización con varias aplicaciones web.

Definir una aplicación web con flujos críticos, roles, datos, navegadores, entornos y criterios de aceptación.

Crear framework Selenium en el lenguaje elegido con estructura profesional de tests, pages, components, data, config y reports.

Implementar localizadores robustos, esperas explícitas, Page Objects, componentes reutilizables y helpers de navegación.

Automatizar flujos de login, formulario, tabla, búsqueda, edición, descarga, permisos y validación de negocio.

Preparar datos de prueba mediante fixtures, API o estrategia controlada con limpieza posterior.

Ejecutar suite en local, headless, cross-browser y en Selenium Grid.

Integrar ejecución en CI/CD con reportes, capturas, logs, vídeos o artefactos según alcance.

Añadir diagnóstico de fallos con screenshots, console logs, network logs o BiDi cuando esté disponible.

Crear métricas de estabilidad, duración, flakiness, cobertura crítica y resultados por navegador.

Presentar solución final con arquitectura, decisiones técnicas, limitaciones, riesgos, mantenimiento y roadmap de escalado.