Serenity BDD con Screenplay: Guía Completa para QA en 2026

¿Qué es Serenity BDD con Screenplay Pattern?

Serenity BDD es un framework open-source que facilita la escritura de pruebas automatizadas de alta calidad y la generación de reportes detallados. Cuando se combina con el patrón Screenplay, obtenemos una arquitectura poderosa que modela las pruebas desde la perspectiva del usuario, creando código más legible, mantenible y escalable.

El patrón Screenplay se basa en tres conceptos fundamentales:

• Actores: Representan a los usuarios del sistema
• Tareas: Acciones de alto nivel que los actores pueden realizar
• Preguntas: Verificaciones que los actores pueden hacer sobre el estado del sistema

Esta combinación es especialmente valiosa en 2026, donde la complejidad de las aplicaciones web y móviles requiere frameworks que promuevan la colaboración entre equipos técnicos y de negocio.

Prerrequisitos

Antes de comenzar, asegurate de tener:

• Java 11 o superior instalado
• Maven o Gradle como gestor de dependencias
• IDE como IntelliJ IDEA o Eclipse
• Conocimientos básicos de Java y Selenium WebDriver
• Comprensión fundamental de BDD (Behavior-Driven Development)
• Git para control de versiones

Configuración del Proyecto

Paso 1: Crear el proyecto Maven

Comenzá creando un nuevo proyecto Maven con la siguiente estructura:

mvn archetype:generate -DgroupId=com.mundoqa.serenity
-DartifactId=serenity-screenplay-demo
-DarchetypeArtifactId=maven-archetype-quickstart
-DinteractiveMode=false

Paso 2: Configurar dependencias en pom.xml

Agregá las siguientes dependencias a tu archivo pom.xml:

<properties>
    <serenity.version>4.1.4</serenity.version>
    <maven.compiler.source>11</maven.compiler.source>
    <maven.compiler.target>11</maven.compiler.target>
</properties>

<dependencies>
    <dependency>
        <groupId>net.serenity-bdd</groupId>
        <artifactId>serenity-core</artifactId>
        <version>${serenity.version}</version>
    </dependency>
    <dependency>
        <groupId>net.serenity-bdd</groupId>
        <artifactId>serenity-screenplay</artifactId>
        <version>${serenity.version}</version>
    </dependency>
    <dependency>
        <groupId>net.serenity-bdd</groupId>
        <artifactId>serenity-screenplay-webdriver</artifactId>
        <version>${serenity.version}</version>
    </dependency>
    <dependency>
        <groupId>net.serenity-bdd</groupId>
        <artifactId>serenity-cucumber</artifactId>
        <version>${serenity.version}</version>
    </dependency>
</dependencies>

Paso 3: Configurar serenity.properties

Creá el archivo serenity.properties en src/test/resources:

webdriver.driver=chrome
webdriver.chrome.driver=auto
serenity.project.name=Mundo QA Serenity Demo
serenity.test.root=net.mundoqa.tests
serenity.take.screenshots=FOR_FAILURES

Implementación Práctica

Paso 4: Definir Page Objects

Comenzemos creando los elementos de página usando Serenity:

package net.mundoqa.pages;

import net.serenitybdd.screenplay.targets.Target;
import org.openqa.selenium.By;

public class LoginPage {
    public static final Target USERNAME_FIELD = 
        Target.the("campo de usuario")
              .located(By.id("username"));
    
    public static final Target PASSWORD_FIELD = 
        Target.the("campo de contraseña")
              .located(By.id("password"));
    
    public static final Target LOGIN_BUTTON = 
        Target.the("botón de login")
              .located(By.xpath("//button[@type='submit']"));
    
    public static final Target ERROR_MESSAGE = 
        Target.the("mensaje de error")
              .located(By.className("error-message"));
}

Paso 5: Crear Tareas (Tasks)

Las tareas representan acciones que el actor puede realizar:

package net.mundoqa.tasks;

import net.serenitybdd.screenplay.Actor;
import net.serenitybdd.screenplay.Task;
import net.serenitybdd.screenplay.actions.Click;
import net.serenitybdd.screenplay.actions.Enter;
import net.mundoqa.pages.LoginPage;

public class IniciarSesion implements Task {
    private final String usuario;
    private final String contraseña;
    
    public IniciarSesion(String usuario, String contraseña) {
        this.usuario = usuario;
        this.contraseña = contraseña;
    }
    
    public static IniciarSesion conCredenciales(String usuario, String contraseña) {
        return new IniciarSesion(usuario, contraseña);
    }
    
    @Override
    public <T extends Actor> void performAs(T actor) {
        actor.attemptsTo(
            Enter.theValue(usuario).into(LoginPage.USERNAME_FIELD),
            Enter.theValue(contraseña).into(LoginPage.PASSWORD_FIELD),
            Click.on(LoginPage.LOGIN_BUTTON)
        );
    }
}

Paso 6: Implementar Preguntas (Questions)

Las preguntas permiten verificar el estado del sistema:

package net.mundoqa.questions;

import net.serenitybdd.screenplay.Actor;
import net.serenitybdd.screenplay.Question;
import net.serenitybdd.screenplay.questions.Text;
import net.mundoqa.pages.LoginPage;

public class MensajeDeError implements Question<String> {
    
    public static MensajeDeError mostrado() {
        return new MensajeDeError();
    }
    
    @Override
    public String answeredBy(Actor actor) {
        return Text.of(LoginPage.ERROR_MESSAGE).answeredBy(actor);
    }
}

Paso 7: Escribir los Tests

Ahora creamos nuestras pruebas usando el patrón Screenplay:

package net.mundoqa.tests;

import net.serenitybdd.junit5.SerenityJUnit5Extension;
import net.serenitybdd.screenplay.Actor;
import net.serenitybdd.screenplay.abilities.BrowseTheWeb;
import net.serenitybdd.screenplay.actions.Open;
import net.thucydides.core.annotations.Managed;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.openqa.selenium.WebDriver;

import static net.serenitybdd.screenplay.GivenWhenThen.*;
import static org.hamcrest.Matchers.containsString;

@ExtendWith(SerenityJUnit5Extension.class)
public class LoginTest {
    
    @Managed(driver = "chrome")
    WebDriver navegador;
    
    Actor usuario;
    
    @BeforeEach
    public void configurarActor() {
        usuario = Actor.named("Usuario de prueba")
                      .whoCan(BrowseTheWeb.with(navegador));
    }
    
    @Test
    public void deberiaPermitirLoginConCredencialesValidas() {
        givenThat(usuario).wasAbleTo(
            Open.browserOn().url("https://ejemplo.com/login")
        );
        
        when(usuario).attemptsTo(
            IniciarSesion.conCredenciales("usuario_valido", "password_valido")
        );
        
        then(usuario).should(
            seeThat("está en el dashboard", 
                   CurrentUrl.information(), 
                   containsString("/dashboard"))
        );
    }
    
    @Test
    public void deberiaMostrarErrorConCredencialesInvalidas() {
        givenThat(usuario).wasAbleTo(
            Open.browserOn().url("https://ejemplo.com/login")
        );
        
        when(usuario).attemptsTo(
            IniciarSesion.conCredenciales("usuario_invalido", "password_invalido")
        );
        
        then(usuario).should(
            seeThat(MensajeDeError.mostrado(), 
                   containsString("Credenciales inválidas"))
        );
    }
}

Casos de Uso Reales en Proyectos QA

E-commerce Testing

En un proyecto de e-commerce real que lideré en 2026, implementamos Serenity con Screenplay para automatizar el flujo completo de compra. Creamos actores como “Comprador”, “Administrador” y “Vendedor”, cada uno con habilidades específicas. Las tareas incluían “AgregarProductoAlCarrito”, “ProcederAlPago” y “VerificarOrden”.

Aplicaciones Bancarias

Para una aplicación bancaria, utilizamos este patrón para modelar diferentes tipos de usuarios (cliente retail, cliente corporativo, cajero). Las preguntas como “SaldoDeCuenta” y “HistorialDeTransacciones” nos permitieron crear verificaciones robustas y legibles.

Testing de APIs

Serenity Screenplay también funciona excelentemente para testing de APIs. Creamos tareas como “ConsultarServicioRest” y preguntas como “RespuestaDelServicio” para validar contratos de API de manera elegante.

Ventajas del Patrón Screenplay

• Legibilidad mejorada: Los tests se leen como narrativas naturales
• Reutilización: Las tareas y preguntas se pueden combinar flexiblemente
• Mantenibilidad: Cambios en la UI requieren modificaciones mínimas
• Colaboración: El código es comprensible para stakeholders no técnicos
• Reportes detallados: Serenity genera documentación viviente automáticamente

Mejores Prácticas

• Nombrá las tareas y preguntas con verbos que reflejen intenciones de usuario
• Mantené las tareas focalizadas en una responsabilidad específica
• Usá el patrón Builder para tareas complejas con múltiples parámetros
• Implementá Abilities personalizadas para interacciones específicas del dominio
• Utilizá el sistema de etiquetas de Serenity para organizar y filtrar tests

Conclusión y Próximos Pasos

Serenity BDD con Screenplay pattern representa una evolución significativa en la automatización de pruebas. En mi experiencia trabajando con equipos QA en 2026, he visto cómo esta combinación transforma la calidad del código de pruebas y mejora la colaboración entre equipos.

Para continuar tu aprendizaje, te recomiendo:

1. Experimentar con diferentes tipos de Abilities (REST API, base de datos)
2. Implementar reporting personalizado con Serenity
3. Integrar con pipelines de CI/CD
4. Explorar Serenity con otros frameworks como Appium para testing móvil
5. Practicar con proyectos reales aplicando los patrones aprendidos

El dominio de estas herramientas te posicionará como un QA Engineer moderno, capaz de crear suites de pruebas que realmente agreguen valor al desarrollo de software. ¡Empezá tu proyecto y experimentá con estos conceptos hoy mismo!

---