Cómo Verificar si Tu Test Realmente Pasó: Assertions en Selenium

Introducción

Imagina esto: escribes un test automatizado para una página de login, el script se ejecuta sin errores y aparece como “PASSED” en verde. Te sientes orgulloso del trabajo… hasta que descubres que el test nunca verificó si el login realmente funcionó. Es como enviar un mensaje de WhatsApp y asumir que llegó sin ver los checks azules.

Esta situación, más común de lo que pensamos, nos lleva a una pregunta fundamental: ¿cómo sabemos realmente si nuestro test pasó por las razones correctas? La respuesta está en las assertions, y en 2026, dominar este concepto sigue siendo esencial para cualquier QA Engineer que trabaje con Selenium.

El Problema de los “Tests Silenciosos”

Durante mis años como QA Engineer, he visto demasiados tests que son como ese amigo que dice “todo bien” cuando claramente algo está mal. Ejecutan cada paso del script, no lanzan excepciones, pero nunca verifican si lo que esperamos realmente ocurrió.

Considera este escenario típico:

driver.get("https://ejemplo.com/login");
driver.findElement(By.id("username")).sendKeys("usuario");
driver.findElement(By.id("password")).sendKeys("contraseña");
driver.findElement(By.id("submit")).click();

Este código se ejecutará “exitosamente” incluso si:

• La página de login no carga correctamente
• Los campos de usuario y contraseña no existen
• El botón de submit no funciona
• El login falla pero no hay redirección

Sin assertions, nuestros tests se convierten en teatro: mucho movimiento, pero sin verificar que el resultado sea el esperado.

¿Qué Son las Assertions y Por Qué Son Críticas?

Las assertions son declaraciones que verifican si una condición específica es verdadera en un momento dado. Son la diferencia entre un script que hace cosas y un test que realmente valida comportamientos.

En el contexto de Selenium, las assertions nos permiten:

• Verificar estados de elementos: ¿está visible? ¿está habilitado?
• Validar contenido: ¿el texto es el correcto? ¿la URL cambió?
• Confirmar comportamientos: ¿se mostró el mensaje de éxito? ¿aparecieron los datos esperados?

Tipos de Assertions en Selenium con Ejemplos Prácticos

1. Assertions Básicas con JUnit/TestNG

Para nuestro ejemplo del login, podríamos usar:

// Verificar que estamos en la página correcta después del login
String currentUrl = driver.getCurrentUrl();
Assert.assertTrue("No se redirigió correctamente", currentUrl.contains("/dashboard"));

// Verificar que aparece el mensaje de bienvenida
WebElement welcomeMessage = driver.findElement(By.className("welcome"));
Assert.assertTrue("Mensaje de bienvenida no visible", welcomeMessage.isDisplayed());

2. Soft Assertions: El Enfoque Inteligente

Una técnica que uso frecuentemente son las “soft assertions”, especialmente útiles cuando quieres verificar múltiples condiciones sin que una falla detenga todo el test:

SoftAssert softAssert = new SoftAssert();
softAssert.assertTrue(welcomeMessage.isDisplayed(), "Mensaje no visible");
softAssert.assertEquals(driver.getTitle(), "Dashboard", "Título incorrecto");
softAssert.assertAll(); // Aquí se evalúan todas las assertions

3. Assertions con Selenium WebDriver Wait

Combinar assertions con waits explícitos es una práctica que recomiendo ampliamente:

WebDriverWait wait = new WebDriverWait(driver, Duration.ofSeconds(10));
WebElement successMessage = wait.until(
ExpectedConditions.visibilityOfElementLocated(By.id("success-msg"))
);
Assert.assertEquals("Login exitoso!", successMessage.getText());

Errores Comunes que Veo en Teams de QA

En mi experiencia trabajando con equipos hispanohablantes, he identificado patrones recurrentes:

1. El “Happy Path” Exclusivo

Muchos testers solo verifican que el flujo principal funcione, pero olvidan validar estados de error. Un test completo de login debería verificar tanto el éxito como el fracaso:

// Test de login fallido
driver.findElement(By.id("username")).sendKeys("usuario_incorrecto");
driver.findElement(By.id("password")).sendKeys("password_incorrecta");
driver.findElement(By.id("submit")).click();

WebElement errorMessage = driver.findElement(By.className("error"));
Assert.assertTrue("No se mostró mensaje de error", errorMessage.isDisplayed());
Assert.assertTrue("Usuario sigue logueado", driver.getCurrentUrl().contains("/login"));

2. Assertions Demasiado Genéricas

En lugar de verificar “algo cambió”, sé específico sobre qué debe cambiar:

// ❌ Genérico
Assert.assertNotEquals(currentUrl, previousUrl);

// ✅ Específico
Assert.assertEquals("https://ejemplo.com/dashboard", driver.getCurrentUrl());

Herramientas y Librerías Útiles en 2026

El ecosistema de testing ha evolucionado. Algunas herramientas que recomiendo para mejorar tus assertions:

• AssertJ: Para assertions más legibles y expresivas
• Hamcrest: Matchers potentes para validaciones complejas
• Selenide: Framework que incluye assertions inteligentes por defecto

Mejores Prácticas para Assertions Efectivas

1. Mensajes de Error Descriptivos

Siempre incluye mensajes que ayuden a entender qué salió mal:

Assert.assertEquals("El título de la página no coincide con lo esperado después del login",
"Mi Dashboard", driver.getTitle());

2. Verifica el Estado, No Solo la Presencia

No basta con que un elemento esté presente; debe estar en el estado correcto:

WebElement submitButton = driver.findElement(By.id("submit"));
Assert.assertTrue("Botón submit no está habilitado", submitButton.isEnabled());
Assert.assertTrue("Botón submit no es visible", submitButton.isDisplayed());

3. Timing y Sincronización

Las aplicaciones modernas son asíncronas. Tus assertions deben considerar esto:

// Esperar a que la condición sea verdadera antes de hacer assertion
wait.until(ExpectedConditions.textToBePresentInElement(
driver.findElement(By.id("status")), "Completado"
));

Por Qué Esto Importa para Testers Hispanohablantes en 2026

El mercado de QA en Latinoamérica está creciendo exponencialmente, pero la competencia también. Las empresas buscan profesionales que no solo sepan escribir scripts, sino que entiendan la diferencia entre automatización y testing real.

Dominar las assertions te diferencia porque:

• Reduces falsos positivos en tus reportes
• Generas confianza en tus tests automatizados
• Facilitas el mantenimiento de la suite de tests
• Demuestras comprensión profunda del testing, no solo de la herramienta

Reflexión Final

Las assertions son el corazón de cualquier test automatizado confiable. Sin ellas, nuestros scripts son solo robots haciendo clic sin propósito. En 2026, con la creciente adopción de CI/CD y la presión por releases más rápidos, la calidad de nuestros tests es más crucial que nunca.

La próxima vez que escribas un test en Selenium, pregúntate: “¿Cómo sé realmente que esto funcionó?” La respuesta debe estar en tus assertions. Porque un test que no verifica es como un guardia de seguridad que nunca mira las cámaras.

Como QA Engineers, nuestra responsabilidad va más allá de hacer que los tests se ejecuten; debemos asegurar que realmente validen lo que prometemos validar.

---

Fuente de referencia: https://medium.com/@maheshikamaduwanthi995/how-to-check-if-your-test-really-passed-assertions-in-selenium-97cdcdd107ce?source=rss——test_automation-5