Screenplay Pattern com Playwright
O Screenplay Pattern é uma abordagem moderna e centrada no ator para escrever testes automatizados. Quando combinado com o Playwright, fornece uma forma poderosa e expressiva de escrever testes de automação de navegador que leem como documentação viva.
O módulo serenity-screenplay-playwright une:
- Expressividade do Screenplay - Design de teste centrado no ator e baseado em tarefas
- Confiabilidade do Playwright - Automação de navegador moderna com espera automática
- Relatórios ricos do Serenity - Documentação passo a passo com capturas de tela
Por que Screenplay com Playwright?
O Screenplay Pattern oferece várias vantagens sobre abordagens tradicionais de Page Object:
| Page Object | Screenplay |
|---|---|
| Testes chamam métodos da página diretamente | Actor executam Task e fazem Question |
| Estilo de código procedural | Estilo declarativo, focado em comportamento |
| Testes acoplados à estrutura da UI | Testes expressam intenção de negócio |
| Difícil compor ações | Task facilmente compostas em workflows |
Com Playwright, você também obtém:
- Espera automática incorporada em todas as interações
- Asserções integradas com retry automático
- Interceptação de rede para mock de APIs
- Suporte a múltiplos navegadores (Chromium, Firefox, WebKit)
Configuração do Projeto
Dependências Maven
Adicione estas dependências ao seu pom.xml:
<properties>
<serenity.version>5.3.3</serenity.version>
<playwright.version>1.58.0</playwright.version>
</properties>
<dependencies>
<!-- Serenity Screenplay com Playwright -->
<dependency>
<groupId>net.serenity-bdd</groupId>
<artifactId>serenity-screenplay-playwright</artifactId>
<version>${serenity.version}</version>
<scope>test</scope>
</dependency>
<!-- Serenity Screenplay Core -->
<dependency>
<groupId>net.serenity-bdd</groupId>
<artifactId>serenity-screenplay</artifactId>
<version>${serenity.version}</version>
<scope>test</scope>
</dependency>
<!-- Serenity Ensure (para asserções fluentes) -->
<dependency>
<groupId>net.serenity-bdd</groupId>
<artifactId>serenity-ensure</artifactId>
<version>${serenity.version}</version>
<scope>test</scope>
</dependency>
<!-- Serenity JUnit 5 -->
<dependency>
<groupId>net.serenity-bdd</groupId>
<artifactId>serenity-junit5</artifactId>
<version>${serenity.version}</version>
<scope>test</scope>
</dependency>
<!-- Playwright -->
<dependency>
<groupId>com.microsoft.playwright</groupId>
<artifactId>playwright</artifactId>
<version>${playwright.version}</version>
<scope>test</scope>
</dependency>
<!-- JUnit 5 -->
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter</artifactId>
<version>6.0.1</version>
<scope>test</scope>
</dependency>
</dependencies>
Conceitos Principais
Actor e Ability
No Screenplay, os testes são escritos da perspectiva de Actor que possuem Ability. Para testes Playwright, os actor precisam da Ability BrowseTheWebWithPlaywright:
import net.serenitybdd.screenplay.Actor;
import net.serenitybdd.screenplay.playwright.abilities.BrowseTheWebWithPlaywright;
Actor toby = Actor.named("Toby");
toby.can(BrowseTheWebWithPlaywright.usingTheDefaultConfiguration());
A Ability gerencia o ciclo de vida do navegador Playwright automaticamente:
- Cria o navegador, contexto e página sob demanda
- Limpa automaticamente quando o teste termina (não é necessário teardown explícito)
- Se inscreve nos eventos de ciclo de vida de teste do Serenity para gerenciamento de recursos sem fricção
Task
Task representam ações de alto nível que um ator executa. Elas expressam o que o ator faz em termos de negócio:
import net.serenitybdd.screenplay.Task;
import net.serenitybdd.screenplay.Actor;
import net.serenitybdd.screenplay.playwright.interactions.Open;
import net.serenitybdd.annotations.Step;
public class OpenTodoMvcApp implements Task {
@Override
@Step("{0} opens the TodoMVC application")
public <T extends Actor> void performAs(T actor) {
actor.attemptsTo(
Open.url("https://todomvc.com/examples/react/dist/")
);
}
public static OpenTodoMvcApp onTheHomePage() {
return new OpenTodoMvcApp();
}
}
Task podem ser compostas de outras Task e Interaction:
public class AddATodoItem implements Task {
private final String todoItem;
public AddATodoItem(String todoItem) {
this.todoItem = todoItem;
}
@Override
@Step("{0} adds a todo item called '#todoItem'")
public <T extends Actor> void performAs(T actor) {
actor.attemptsTo(
Enter.theValue(todoItem).into(TodoList.NEW_TODO_INPUT),
Press.keys("Enter")
);
}
public static AddATodoItem called(String todoItem) {
return new AddATodoItem(todoItem);
}
}
Question
Question permitem que os actor consultem o estado da aplicação:
import net.serenitybdd.screenplay.Question;
import net.serenitybdd.screenplay.playwright.abilities.BrowseTheWebWithPlaywright;
public class TheVisibleTodos {
public static Question<Collection<String>> displayed() {
return Question.about("the visible todos").answeredBy(
actor -> BrowseTheWebWithPlaywright.as(actor)
.getCurrentPage()
.locator(".todo-list li label")
.allTextContents()
);
}
public static Question<Integer> count() {
return Question.about("visible todo count").answeredBy(
actor -> BrowseTheWebWithPlaywright.as(actor)
.getCurrentPage()
.locator(".todo-list li")
.count()
);
}
}
Target
Target definem elementos de UI usando seletores do Playwright:
import net.serenitybdd.screenplay.playwright.Target;
public class TodoList {
public static final Target NEW_TODO_INPUT =
Target.the("new todo input")
.locatedBy("[placeholder='What needs to be done?']");
public static final Target TODO_ITEMS =
Target.the("todo items")
.locatedBy(".todo-list li");
public static Target todoItemCalled(String todoText) {
return Target.the("todo item '" + todoText + "'")
.locatedBy(".todo-list li:has-text('" + todoText + "')");
}
public static Target checkboxFor(String todoText) {
return Target.the("checkbox for '" + todoText + "'")
.locatedBy(".todo-list li:has-text('" + todoText + "') .toggle");
}
}
Target suportam:
- Seletores parametrizados:
Target.the("item {0}").locatedBy("[data-id='{0}']").of("123") - Target aninhados:
button.inside(form) - Suporte a frame:
Target.the("editor").inFrame("#iframe").locatedBy("#content")
Escrevendo Testes
Estrutura Básica de Teste
Aqui está um exemplo completo de um teste Screenplay com Playwright:
import net.serenitybdd.junit5.SerenityJUnit5Extension;
import net.serenitybdd.screenplay.Actor;
import net.serenitybdd.screenplay.ensure.Ensure;
import net.serenitybdd.screenplay.playwright.abilities.BrowseTheWebWithPlaywright;
import org.junit.jupiter.api.*;
import org.junit.jupiter.api.extension.ExtendWith;
@ExtendWith(SerenityJUnit5Extension.class)
@DisplayName("When adding todos")
class WhenAddingTodosTest {
Actor toby;
@BeforeEach
void setUp() {
toby = Actor.named("Toby");
toby.can(BrowseTheWebWithPlaywright.usingTheDefaultConfiguration());
}
// Não é necessário @AfterEach - a limpeza acontece automaticamente!
@Test
@DisplayName("should add a single todo item")
void shouldAddSingleTodoItem() {
toby.attemptsTo(
OpenTodoMvcApp.onTheHomePage(),
AddATodoItem.called("Buy milk"),
Ensure.that(TheVisibleTodos.count()).isEqualTo(1),
Ensure.that(TheTodoItem.called("Buy milk").exists()).isTrue()
);
}
@Test
@DisplayName("should add multiple todo items")
void shouldAddMultipleTodoItems() {
toby.attemptsTo(
OpenTodoMvcApp.onTheHomePage(),
AddATodoItem.called("Buy milk"),
AddATodoItem.called("Walk the dog"),
AddATodoItem.called("Do laundry"),
Ensure.that(TheVisibleTodos.displayed())
.containsExactly("Buy milk", "Walk the dog", "Do laundry")
);
}
}
Usando Ensure para Asserções
A classe Ensure fornece asserções fluentes que se integram com o modelo baseado em tarefas do Screenplay:
toby.attemptsTo(
// Comparações numéricas
Ensure.that(TheRemainingCount.value()).isEqualTo(3),
Ensure.that(TheVisibleTodos.count()).isGreaterThan(0),
// Verificações booleanas
Ensure.that(TheTodoItem.called("Buy milk").isCompleted()).isTrue(),
Ensure.that(TheClearCompletedButton.isVisible()).isFalse(),
// Comparações de string
Ensure.that(TheCurrentFilter.selected()).isEqualTo("All"),
// Asserções de coleção
Ensure.that(TheVisibleTodos.displayed())
.containsExactly("Buy milk", "Walk the dog"),
Ensure.that(TheVisibleTodos.displayed())
.contains("Buy milk")
);
Interaction Integradas
O módulo serenity-screenplay-playwright fornece muitas Interaction integradas:
Navegação
// Abrir uma URL
actor.attemptsTo(Open.url("https://example.com"));
// Navegar para trás/frente
actor.attemptsTo(Navigate.back());
actor.attemptsTo(Navigate.forward());
// Recarregar a página
actor.attemptsTo(Navigate.refresh());
Clique
// Clique simples
actor.attemptsTo(Click.on(TodoList.SUBMIT_BUTTON));
// Duplo clique
actor.attemptsTo(DoubleClick.on(TodoList.TODO_LABEL));
// Clique direito
actor.attemptsTo(RightClick.on(TodoList.CONTEXT_MENU_TRIGGER));
Interações de Formulário
// Digitar texto
actor.attemptsTo(Enter.theValue("Hello").into(TodoList.INPUT_FIELD));
// Limpar um campo
actor.attemptsTo(Clear.field(TodoList.INPUT_FIELD));
// Pressionar teclas
actor.attemptsTo(Press.keys("Enter"));
actor.attemptsTo(Press.keys("Control+a"));
// Marcar/desmarcar checkboxes
actor.attemptsTo(Check.checkbox(TodoList.AGREE_CHECKBOX));
actor.attemptsTo(Uncheck.checkbox(TodoList.AGREE_CHECKBOX));
// Selecionar de dropdown
actor.attemptsTo(SelectFromOptions.byVisibleText("Option 1").from(TodoList.DROPDOWN));
actor.attemptsTo(SelectFromOptions.byValue("opt1").from(TodoList.DROPDOWN));
Ações de Mouse
// Passar o mouse sobre um elemento
actor.attemptsTo(Hover.over(TodoList.DELETE_BUTTON));
// Arrastar e soltar
actor.attemptsTo(Drag.from(SOURCE).to(TARGET));
// Rolar para visualização
actor.attemptsTo(ScrollIntoView.element(TodoList.FOOTER));
Espera
// Esperar por um elemento
actor.attemptsTo(WaitFor.the(TodoList.LOADING_SPINNER).toDisappear());
Execução de JavaScript
// Executar JavaScript
actor.attemptsTo(
ExecuteJavaScript.withScript("window.scrollTo(0, document.body.scrollHeight)")
);
Tratamento de Diálogos
// Aceitar alerta
actor.attemptsTo(HandleDialog.byAccepting());
// Dispensar alerta
actor.attemptsTo(HandleDialog.byDismissing());
// Digitar texto em prompt
actor.attemptsTo(HandleDialog.byEntering("my response"));
Asserções Específicas do Playwright
A classe Ensure também fornece asserções específicas do Playwright com auto-retry:
import net.serenitybdd.screenplay.playwright.assertions.Ensure;
actor.attemptsTo(
// Visibilidade de elemento
Ensure.that(TodoList.MAIN_SECTION).isVisible(),
Ensure.that(TodoList.LOADING_SPINNER).isHidden(),
// Conteúdo de texto
Ensure.that(TodoList.HEADER).hasText("todos"),
Ensure.that(TodoList.HEADER).containsText("todo"),
// Contagem de elementos
Ensure.that(TodoList.TODO_ITEMS).hasCount(3),
// Atributos e classes
Ensure.that(TodoList.TODO_ITEM).hasClass("completed"),
Ensure.that(TodoList.INPUT).hasAttribute("placeholder", "What needs to be done?"),
// Estado do elemento
Ensure.that(TodoList.SUBMIT_BUTTON).isEnabled(),
Ensure.that(TodoList.CHECKBOX).isChecked(),
// URL e título da página
Ensure.thatTheCurrentUrl().contains("/dashboard"),
Ensure.thatThePageTitle().isEqualTo("My App")
);