DEV Community

Tarcisio C. Uchoa
Tarcisio C. Uchoa

Posted on Edited on

🤖 Robot Framework: boas práticas e antipadrões na automação de testes (Dos and Don'ts)

Como escrever testes automatizados mais legíveis, confiáveis, rápidos e fáceis de manter.

👋 Introdução

O Robot Framework é um framework open source de automação de testes, baseado em palavras-chave (keyword-driven testing), amplamente utilizado para testes de aceitação, automação de aplicações web, APIs, sistemas desktop e outros cenários.

Entretanto, utilizar um framework de automação não significa, por si só, construir uma boa suíte de testes.

A qualidade da automação depende diretamente de como os testes são projetados, organizados, implementados e mantidos.

Neste artigo, quero explorar algumas diretrizes para escrever bons casos de teste com Robot Framework, apresentando boas práticas (Dos) e antipadrões (Don'ts) que podem comprometer a legibilidade, a manutenção e a confiabilidade da automação.

O objetivo é compartilhar práticas que ajudem a construir uma automação sustentável, evitando que a suíte de testes se transforme em um novo problema para a equipe.

📚 Referência complementar: How to Write Good Test Cases – Robot Framework

🎯 Os três principais objetivos

Ao desenvolver casos de teste automatizados, devemos buscar três objetivos fundamentais:

  • Fácil de entender: qualquer pessoa da equipe deve conseguir compreender o propósito do teste e o comportamento que está sendo validado.
  • Fácil de manter: alterações na aplicação não devem exigir modificações excessivas em diversos casos de teste.
  • Rápido de executar: a suíte deve executar de maneira eficiente, permitindo feedback frequente e contribuindo para o processo de desenvolvimento.

Esses três objetivos estão diretamente relacionados. Uma automação bem estruturada reduz o esforço de manutenção, facilita a identificação de problemas e torna a execução mais eficiente.

🏷️ Convenções de nomenclatura (Naming)

Escolher bons nomes é uma das práticas mais simples e, ao mesmo tempo, mais importantes na automação.

Isso vale para:

  • Casos de teste;
  • Suítes de teste;
  • Keywords;
  • Variáveis;
  • Bibliotecas;
  • Arquivos Resource;
  • Argumentos e parâmetros.

Um bom nome deve ser explícito, fácil de compreender e consistente com os padrões adotados pelo projeto.

Prefira nomes que expressem o que está sendo realizado, e não como a implementação funciona.

Por exemplo:

  • ✅ Valid login
  • ❌ Click login button and verify title

O primeiro nome comunica o comportamento que está sendo testado. O segundo descreve detalhes da implementação.

A nomenclatura deve permitir que alguém compreenda a intenção do teste sem precisar analisar todas as instruções executadas.

📝 Documentação

A documentação também tem um papel importante na construção de uma suíte de testes sustentável.

Algumas recomendações:

  • Suítes de teste podem se beneficiar de documentações que expliquem seu contexto, objetivo e escopo.
  • Casos de teste bem nomeados, utilizando keywords igualmente bem nomeadas, geralmente dispensam documentação adicional.
  • Keywords reutilizáveis devem ser documentadas, especialmente quando possuem comportamentos ou regras que não são evidentes pelo nome.
  • Argumentos com nomes claros ajudam a tornar a utilização das keywords mais intuitiva.
  • Keywords implementadas em bibliotecas externas devem possuir documentação detalhada sobre parâmetros, retornos, exceções e comportamento esperado.

A documentação deve complementar o código, e não explicar aquilo que poderia estar mais claro no próprio código.

📌 Como interpretar os exemplos

Para facilitar a leitura, utilizaremos quatro classificações:

  • 🟢 BOM (DO): uma boa prática, geralmente recomendada.
  • 🔴 RUIM (DON'T): um antipadrão que deve ser evitado.
  • 🔵 TENTE (TRY): uma abordagem que pode funcionar bem em diferentes contextos.
  • 🟡 EVITE (AVOID): uma prática que normalmente deve ser evitada, embora possa ser necessária em determinadas situações.

🧱 1. Abstração e organização dos testes

🟢 BOM: Utilize um nível de abstração apropriado

Um bom caso de teste deve descrever o comportamento que está sendo validado, sem expor desnecessariamente os detalhes técnicos de implementação.

*** Test Cases ***
Valid login
    Open browser to login page
    Input username    demo
    Input password    mode
    Submit credentials
    Welcome page should be open
Enter fullscreen mode Exit fullscreen mode

Observe que cada keyword representa uma ação ou validação com significado para o cenário.

O caso de teste fica mais simples, legível e fácil de compreender, mesmo para pessoas que não conhecem todos os detalhes técnicos da automação.

🔴 RUIM: Utilize um nível de abstração muito baixo

Evite colocar todos os detalhes técnicos diretamente no caso de teste.

*** Test Cases ***
Valid login
    Open Browser    ${LOGIN_URL}    ${BROWSER}
    Maximize Browser Window
    Title Should Be    Login Page
    Input Text    username_field    demo
    Input Text    password_field    mode
    Click Button    login_button
    Title Should Be    Welcome Page
    Location Should Be    ${WELCOME_URL}
Enter fullscreen mode Exit fullscreen mode

Nesse exemplo, o teste mistura o comportamento esperado com detalhes de interação, configuração do navegador e identificação dos elementos da página.

Isso dificulta a leitura e aumenta o esforço de manutenção quando a interface da aplicação sofre alterações.

🔴 RUIM: Utilize comentários no lugar de abstrações

Comentários não devem substituir uma boa organização das keywords.

*** Test Cases ***
Valid login
    # Open browser to login page
    Open Browser    ${LOGIN_URL}    ${BROWSER}
    Maximize Browser Window

    # Input username
    Input Text    username_field    demo

    # Input password
    Input Text    password_field    mode

    # Submit credentials
    Click Button    login_button

    # Welcome page should be open
    Title Should Be    Welcome Page
Enter fullscreen mode Exit fullscreen mode

Os comentários apenas repetem aquilo que o código já está fazendo.

Uma alternativa melhor é encapsular essas operações em keywords que representem suas respectivas responsabilidades.

🔴 RUIM: Utilize documentação para compensar a falta de abstração

A documentação também não deve ser utilizada para explicar uma sequência de instruções que poderia estar representada por keywords mais expressivas.

*** Test Cases ***
Valid login
    [Documentation]    Test for valid login:
    ...    - Open browser to login page
    ...    - Input username
    ...    - Input password
    ...    - Submit credentials
    ...    - Verify welcome page

    Open Browser    ${LOGIN_URL}    ${BROWSER}
    Input Text    username_field    demo
    Input Text    password_field    mode
    Click Button    login_button
    Title Should Be    Welcome Page
Enter fullscreen mode Exit fullscreen mode

Se a documentação precisa descrever cada passo do teste, provavelmente existe uma oportunidade de melhorar o nível de abstração.


📊 2. Reutilização e organização dos cenários

🟢 BOM: Utilize testes orientados a dados (Data-Driven)

O estilo Data-Driven Testing permite executar o mesmo fluxo de teste com diferentes conjuntos de dados.

É especialmente útil quando queremos validar uma mesma regra de negócio com diferentes combinações de entradas.

*** Settings ***
Test Template    Login with invalid credentials should fail

*** Test Cases ***       USERNAME       PASSWORD
Invalid username         invalid        ${VALID_PASSWORD}
Invalid password         ${VALID_USER}  invalid
Both invalid             invalid        whatever
Empty username           ${EMPTY}       ${VALID_PASSWORD}
Empty password           ${VALID_USER}  ${EMPTY}
Both empty               ${EMPTY}       ${EMPTY}
Enter fullscreen mode Exit fullscreen mode

Nesse exemplo, todos os cenários utilizam a mesma keyword como template, variando apenas os dados de entrada.

Benefícios:

  • Redução da duplicação de código;
  • Maior facilidade para adicionar novos cenários;
  • Padronização das validações;
  • Melhor representação das regras de negócio.

O Data-Driven deve ser utilizado quando os cenários realmente compartilham o mesmo fluxo e comportamento de validação. Não é necessário transformar todos os testes em templates.

🔵 TENTE: Utilize o estilo Gherkin (BDD)

O Robot Framework permite escrever casos de teste utilizando palavras como Given, When, Then, And e But.

Essa abordagem pode ajudar a aproximar os testes automatizados da linguagem utilizada pelo negócio.

*** Test Cases ***
Valid login
    Given the login page is open
    When user "demo" logs in with password "mode"
    Then the welcome page should be open
Enter fullscreen mode Exit fullscreen mode

O exemplo apresenta um cenário de maneira mais próxima à linguagem natural.

Entretanto, é importante lembrar que utilizar palavras do Gherkin não significa, automaticamente, implementar BDD.

O Behavior-Driven Development envolve colaboração entre negócio, desenvolvimento e testes, com foco na compreensão compartilhada dos comportamentos esperados.

Utilize essa abordagem quando ela realmente contribuir para a comunicação e o entendimento dos requisitos.


✅ 3. Validações e independência dos testes

🔴 RUIM: Não escreva testes sem validações

Um teste automatizado precisa verificar se o comportamento observado corresponde ao resultado esperado.

*** Test Cases ***
Valid login
    Open browser to login page
    Input username    demo
    Input password    mode
    Submit credentials
Enter fullscreen mode Exit fullscreen mode

O exemplo executa as ações de login, mas não verifica se o acesso foi realizado com sucesso.

Se a aplicação apresentar um erro após o envio das credenciais, o teste poderá não identificar corretamente o problema.

Uma versão melhor seria:

*** Test Cases ***
Valid login
    Open browser to login page
    Input username    demo
    Input password    mode
    Submit credentials
    Welcome page should be open
Enter fullscreen mode Exit fullscreen mode

Lembre-se: executar ações não é o mesmo que testar um comportamento.

Um teste precisa conter verificações (assertions) que comprovem os resultados esperados.

🟡 EVITE: Inclua validações que não pertencem ao objetivo do teste

Um caso de teste deve possuir um objetivo claro e validações relacionadas a esse objetivo.

Considere o exemplo:

*** Test Cases ***
Change password
    Open browser to login page
    Input username    demo
    Input password    mode
    Submit credentials
    Welcome page should be open

    Open user management
    Select user    demo
    Change password    mode    newpwd
    Password changed successfully message should be shown

    Log out
    Input username    demo
    Input password    newpwd
    Submit credentials
    Welcome page should be open
Enter fullscreen mode Exit fullscreen mode

Esse teste realiza três verificações ou comportamentos diferentes:

  1. Validar o login com a senha atual;
  2. Alterar a senha do usuário;
  3. Validar o login com a nova senha.

Embora estejam relacionados, esses comportamentos podem ser separados em casos de teste independentes.

Isso facilita a identificação de falhas e evita que um problema em uma etapa comprometa a execução das demais.

🟡 EVITE: Crie dependências entre casos de teste

Considere a seguinte estrutura:

*** Test Cases ***
Valid login
    Open browser to login page
    Input username    demo
    Input password    mode
    Submit credentials
    Welcome page should be open

Change password
    Open user management
    Select user    demo
    Change password    mode    newpwd
    Password changed successfully message should be shown

Login with new password
    Log out
    Input username    demo
    Input password    newpwd
    Submit credentials
    Welcome page should be open
Enter fullscreen mode Exit fullscreen mode

Nesse exemplo, o terceiro teste depende de uma alteração realizada pelo segundo.

Se o teste de alteração de senha não for executado, ou falhar, o teste seguinte poderá falhar por um motivo que não está relacionado ao seu próprio objetivo.

Sempre que possível, cada caso de teste deve preparar os próprios dados e seu estado inicial.

Testes independentes são mais previsíveis, facilitam a execução paralela e tornam a análise dos resultados mais confiável.


🧹 4. Preparação e limpeza do ambiente

🟢 BOM: Utilize Teardowns para realizar a limpeza

É importante garantir que os recursos utilizados durante os testes sejam liberados, mesmo quando ocorre uma falha.

O Test Teardown permite executar uma rotina de limpeza ao final de cada caso de teste.

*** Test Cases ***
Valid login
    [Teardown]    Close Browser

    Open browser to login page
    Input username    demo
    Input password    mode
    Submit credentials
    Welcome page should be open
Enter fullscreen mode Exit fullscreen mode

Nesse exemplo, o navegador será fechado ao final do teste, independentemente de seu resultado.

Essa prática evita o acúmulo de sessões, navegadores abertos e outros recursos que podem comprometer execuções posteriores.

🟢 BOM: Utilize Suite Setup e Suite Teardown quando apropriado

Quando vários testes compartilham uma preparação ou um recurso, pode ser interessante utilizar configurações no nível da suíte.

*** Settings ***
Suite Setup       Open browser to login page
Test Template     Login with invalid credentials should fail
Test Teardown     Go to login page
Suite Teardown    Close Browser

*** Test Cases ***       USERNAME       PASSWORD
Invalid username         invalid        ${VALID_PASSWORD}
Invalid password         ${VALID_USER}  invalid
Both invalid             invalid        whatever
Empty username           ${EMPTY}       ${VALID_PASSWORD}
Empty password           ${VALID_USER}  ${EMPTY}
Both empty               ${EMPTY}       ${EMPTY}
Enter fullscreen mode Exit fullscreen mode

Nesse exemplo:

  • Suite Setup: prepara o navegador uma única vez antes da execução da suíte;
  • Test Teardown: retorna à página de login após cada teste;
  • Suite Teardown: fecha o navegador ao final da suíte.

Isso pode reduzir o tempo de execução quando a preparação compartilhada é custosa.

Atenção: compartilhar uma sessão não significa compartilhar o estado dos testes. Cada caso precisa continuar isolado e previsível. Se um teste alterar dados ou configurações utilizados pelos demais, o compartilhamento poderá introduzir dependências.

🔵 TENTE: Utilize arquivos de inicialização no nível do diretório

Quando diferentes suítes compartilham as mesmas configurações, pode ser interessante centralizar a preparação e a limpeza em um arquivo __init__.robot.

Por exemplo:

*** Settings ***
Documentation     Testes de login com credenciais válidas e inválidas
Suite Setup       Open browser to login page
Suite Teardown    Close Browser
Enter fullscreen mode Exit fullscreen mode

Esse arquivo permite aplicar configurações comuns às suítes de um diretório, reduzindo a duplicação de configurações.

É uma alternativa interessante para projetos com uma estrutura de diretórios bem definida.


🔧 5. Gerenciamento de variáveis e dados

🟢 BOM: Utilize variáveis para evitar valores fixos (Hard Coding)

Valores que podem mudar ou que são utilizados em diferentes partes da automação devem ser centralizados em variáveis.

*** Variables ***
${LOGIN_URL}       http://localhost:7272/
${BROWSER}         Firefox
${VALID_USER}      demo
${VALID_PASSWORD}  mode
${DELAY}           0.1

*** Keywords ***
Open browser to login page
    Open Browser    ${LOGIN_URL}    ${BROWSER}
    Set Selenium Speed    ${DELAY}
Enter fullscreen mode Exit fullscreen mode

Dessa forma, caso a URL ou o navegador precisem ser alterados, basta atualizar a configuração correspondente.

Além disso, a centralização facilita a reutilização e a manutenção dos testes.

🔴 RUIM: Não utilize variáveis em excesso

Embora as variáveis sejam importantes, sua utilização indiscriminada pode tornar o código desnecessariamente complexo.

Exemplo:

*** Variables ***
${USERNAME_FIELD}    username_field

*** Keywords ***
Input username
    [Arguments]    ${username}
    Input Text    ${USERNAME_FIELD}    ${username}
Enter fullscreen mode Exit fullscreen mode

Se o valor username_field é utilizado apenas uma vez e não possui uma razão específica para ser centralizado, a variável pode não agregar benefícios.

Uma alternativa mais simples:

*** Keywords ***
Input username
    [Arguments]    ${username}
    Input Text    username_field    ${username}
Enter fullscreen mode Exit fullscreen mode

Utilize variáveis quando elas melhorarem a legibilidade, a reutilização ou a manutenção do projeto. Não crie variáveis apenas para substituir todos os valores literais.

🟡 EVITE: Atribua variáveis desnecessariamente nos casos de teste

Quando uma keyword já executa a ação e realiza a validação necessária, não é preciso atribuir seu retorno a uma variável apenas para repassá-lo a outra keyword.

Exemplo:

*** Test Cases ***
Withdraw from account
    Withdraw from account    $50
    Withdraw should have succeeded
Enter fullscreen mode Exit fullscreen mode

Uma abordagem menos direta seria:

*** Test Cases ***
Withdraw from account
    ${status}=    Withdraw from account    $50
    Withdraw should have succeeded    ${status}
Enter fullscreen mode Exit fullscreen mode

A segunda abordagem não está necessariamente errada. Ela pode ser necessária quando o resultado precisa ser utilizado em outras verificações.

Entretanto, evite atribuições que não agreguem valor ao fluxo do teste.

🟡 EVITE: Coloque lógica complexa nos dados de teste

Os casos de teste devem priorizar a descrição dos cenários e das regras de negócio, e não concentrar implementações complexas.

Imagine uma keyword responsável por calcular o tamanho da maior linha de um texto.

Uma implementação diretamente em Robot Framework poderia envolver loops, comparações e atribuições sucessivas:

*** Keywords ***
Get max line length
    [Arguments]    ${string}
    ${max}=    Set Variable    ${0}
    @{lines}=    Split To Lines    ${string}

    FOR    ${line}    IN    @{lines}
        ${length}=    Get Length    ${line}
        IF    ${length} > ${max}
            ${max}=    Set Variable    ${length}
        END
    END

    RETURN    ${max}
Enter fullscreen mode Exit fullscreen mode

Embora seja possível implementar essa lógica no próprio Robot Framework, a complexidade pode prejudicar a legibilidade.


🐍 6. Utilize bibliotecas para lógicas complexas

🟢 BOM: Mova lógicas complexas para bibliotecas quando apropriado

O Robot Framework permite a criação de bibliotecas externas, por exemplo, utilizando Python.

Isso é especialmente útil quando precisamos implementar cálculos, manipulação de dados, integrações ou operações que não são naturais na linguagem de keywords.

O exemplo anterior poderia ser implementado em Python:

def get_max_line_length(string):
    lines = string.splitlines()
    if not lines:
        return 0
    return max(len(line) for line in lines)
Enter fullscreen mode Exit fullscreen mode

Com essa abordagem, o Robot Framework fica responsável por descrever o cenário e organizar a execução dos testes, enquanto a biblioteca concentra a lógica de implementação.

Uma boa separação de responsabilidades torna a automação mais organizada, reutilizável e fácil de manter.

Isso não significa que toda lógica deva ser transferida para Python. Keywords simples e expressivas continuam sendo perfeitamente adequadas no próprio Robot Framework.


⏱️ 7. Sincronização e estabilidade da automação

🟢 BOM: Utilize Polling para sincronizar operações assíncronas

Muitas operações em aplicações modernas não são concluídas imediatamente.

Downloads, processamento de informações, chamadas de API e atualizações de interface podem levar tempos diferentes dependendo do ambiente.

Nesses casos, uma boa prática é aguardar até que a condição esperada seja atendida, respeitando um tempo limite.

*** Settings ***
Library    BuiltIn

*** Keywords ***
Download result
    [Arguments]    ${path}
    Initiate results downloading    ${path}
    Wait Until Created    ${path}    timeout=30s
Enter fullscreen mode Exit fullscreen mode

Nesse exemplo, a keyword Wait Until Created representa uma verificação que consulta periodicamente se o arquivo foi criado, encerrando a espera quando a condição é satisfeita ou quando o tempo limite é atingido.

O Robot Framework também oferece a keyword Wait Until Keyword Succeeds, que permite repetir uma operação até que ela seja concluída com sucesso.

🔴 RUIM: Utilize Sleep para sincronizar operações

Evite utilizar pausas fixas como mecanismo principal de sincronização.

*** Keywords ***
Download result
    [Arguments]    ${path}
    Initiate results downloading    ${path}
    Sleep    10 seconds
Enter fullscreen mode Exit fullscreen mode

O problema é que o tempo necessário para concluir uma operação pode variar.

Se o download terminar em dois segundos, o teste ficará aguardando desnecessariamente por mais oito segundos.

Se demorar quinze segundos, a execução continuará mesmo sem o arquivo estar disponível.

O resultado é uma automação mais lenta e potencialmente instável.

Prefira aguardar uma condição específica em vez de simplesmente aguardar a passagem do tempo.


"🤖 Robot Framework: boas práticas e antipadrões na automação de testes (Dos and Don'ts)" © 2026 por Tarcisio Uchoa está licenciado sob Creative Commons Atribuição 4.0 Internacional (CC BY 4.0).

Este material é uma adaptação de "Robot Framework Dos And Don'ts" (disponível em: https://pt.slideshare.net/slideshow/robot-framework-dos-and-donts/38564910), criado por Nokia Networks e licenciado sob Creative Commons Atribuição 3.0 (CC BY 3.0).

Top comments (0)