Sleeps fixos nos testes: pare de chutar um tempo e espere pela tela

Sleeps fixos nos testes deixam a suíte lenta e instável. Troque cada sleep por uma asserção que espera a tela e é aprovada assim que o elemento aparece.

Por Ait Nohaila, Representante de desenvolvimento de negócios 10 min de leitura

Um sleep fixo em um teste é um palpite: curto demais e o teste falha em um dia lento, longo demais e toda execução desperdiça tempo. Em vez disso, espere pela tela, com uma asserção que passa quando o elemento aparece.

Você conhece a história. Um teste falha na máquina de build, alguém acrescenta dois segundos de sleep, e ele passa. Um mês depois ele falha de novo, e o sleep vira cinco segundos. A suíte fica mais lenta, e nem um pouco mais estável.

O que é um sleep fixo em um teste?

Definição

Um sleep fixo, ou espera fixa, é uma etapa que pausa um teste por um tempo definido antes da próxima ação.

  • Ele está lá porque o aplicativo precisa de um momento: uma página carrega, um diálogo abre, uma busca retorna.

A pausa não olha para o aplicativo, então não tem como saber se esse momento já passou.

No código de teste, é uma linha como um sleep de 2 segundos. Em um teste gravado, é uma pausa que alguém acrescentou à mão depois de uma falha. Nos dois casos, uma pessoa chutou um número.

Por que um sleep fixo está sempre errado: curto demais ou longo demais

Um aplicativo nunca leva o mesmo tempo duas vezes. A máquina de build está ocupada, a rede está lenta, o banco de dados está maior do que no mês passado. Um único número fixo não serve para todos os dias.

Um sleep fixo de 3 segundos

Um dia rápido: a página fica pronta depois de 1 segundo

O teste espera 3 segundos: 2 deles à toa.

Um dia lento: a página fica pronta depois de 5 segundos

O teste clica depois de 3 segundos, cedo demais, e falha.

Uma asserção que aguarda até 10 segundos

Um dia rápido: a página fica pronta depois de 1 segundo

A asserção passa depois de 1 segundo, e o teste segue em frente.

Um dia lento: a página fica pronta depois de 5 segundos

A asserção passa depois de 5 segundos, e o teste segue em frente.

Cada barra é o tempo que o teste passou esperando. O sleep erra nos dois dias. A asserção acerta nos dois, porque acompanha a tela.
O palpite éO que aconteceO que a equipe vê
Curto demaisO teste clica antes de a tela estar pronta.Um teste que falha em dias lentos e passa quando é executado de novo: um teste instável (flaky).
Longo demaisO teste espera depois que a tela já está pronta.Uma suíte que demora mais a cada execução, até em dias rápidos.
Certo hojeO aplicativo muda, e o palpite fica errado de novo.Alguém aumenta o número, e a suíte fica um pouco mais lenta.

A temporização é um dos principais motivos pelos quais um teste falha sem que nada esteja quebrado.Os outros estão em testes instáveis e falsos positivos.

O que as esperas fixas custam a uma suíte de testes: uma conta simples

Um sleep de 2 segundos parece inofensivo. Uma suíte tem centenas deles, e toda execução paga por todos.

200 testes3 sleeps em cada um2 segundos por sleep20 minutos de cada execução
Uma conta de exemplo, não uma estatística: coloque os seus próprios números. O tempo é gasto quer o aplicativo tenha precisado dele ou não.
ExemploTestes lentos e instáveis ao mesmo tempo

Pegue 200 testes com três sleeps de 2 segundos cada. São 1200 segundos: 20 minutos de cada execução gastos esperando. Com dez execuções por dia, mais de três horas passam sem nada acontecer. E no dia em que uma página leva 3 segundos, os testes falham mesmo assim.

Um sleep fixo faz toda execução pagar pelo dia mais lento, e mesmo assim não o cobre.

Esperas explícitas em um framework com código: a correção que você mesmo escreve

Em um framework com código como Selenium, Playwright ou Cypress, a resposta para um sleep fixo é esperar por uma condição no código, o que costuma ser chamado de espera explícita (explicit wait): nomeie o elemento, nomeie a condição, defina um limite. É a ideia certa. Também é código para escrever, ler e manter.

Do que você precisaEm um framework com códigoNo GUI Test Studio
Esperar um elemento aparecerUma linha de código que nomeia o elemento e a condição.Nada para escrever: a asserção que procura o elemento é a espera.
Esperar um indicador de carregamento sumirOutra linha, com a condição oposta.Uma asserção visual de ausência no indicador de carregamento.
Definir quanto tempo esperarUm número no código ou em um arquivo de configuração.Um campo da asserção, alterado em várias asserções de uma vez.
Acompanhar um aplicativo que ficou mais lentoEncontrar as esperas no código e ajustá-las.Aumente um tempo limite. Não custa nada em um dia rápido.

No GUI Test Studio, toda asserção é uma espera

O GUI Test Studio automatiza testes de ponta a ponta de qualquer aplicativo sem código. Você grava um fluxo, e o teste recebe as asserções a partir da gravação. Uma asserção não olha uma vez e desiste. Ela continua procurando até que o que ela espera esteja na tela, e o teste segue em frente na hora.

Três coisas valem para toda asserção.

  • Ela tem um tempo limite, o máximo que vai aguardar, definido em 5 segundos por padrão.
  • Ela passa no momento em que o elemento está lá, não no fim do tempo limite.
  • Ela só falha quando o tempo limite acaba sem o elemento.
O tempo limite é um campo da asserção. O cartão no topo diz isso em palavras: aguarda até 5 s.

Uma gravação faz isso por você.Cada elemento em que você clica recebe uma asserção colocada antes do clique, então o teste confirma que o botão está lá e depois clica nele.A pergunta feita depois de uma gravação chama o tempo limite de Aguardar até, e o GUI Test Studio o chama de Tempo limite.Tempos limite, áreas de busca e falhas traz os detalhes.

Não há código em nenhum momento, seja em um aplicativo web ou em um de desktop: veja Testar aplicativos de desktop do Windows sem escrever código.

O que você está esperando? A asserção a usar

Por trás de todo sleep há algo que o autor estava esperando. Dê nome a isso, e você terá dado nome à asserção.

Esperar que apareça

Exportar

Asserção visual ou asserção textual

Passa no momento em que o elemento está na tela.

Esperar que suma

Carregando

Asserção visual de ausência ou asserção textual de ausência

Passa no momento em que o indicador de carregamento some.

Esperar o tipo certo de valor

ORD-20418

Asserção textual dinâmica

Passa no momento em que um valor desse formato está lá, seja qual for o valor.

Seja o que for que você espera, a asserção encerra a espera no momento em que a tela diz que é hora. Nenhum tempo é adivinhado.
O que você está esperandoA asserção a usarEla passa
Um botão, um ícone ou uma imagem aparecerAsserção visualNo momento em que o elemento está na tela e tem a aparência certa.
Uma mensagem ou um título aparecerAsserção textualNo momento em que as palavras estão na tela.
Um indicador de carregamento ou uma barra de progresso sumirAsserção visual de ausênciaNo momento em que ele sai da tela.
Uma palavra como Carregando sumirAsserção textual de ausênciaNo momento em que a palavra não está mais lá.
Um total, uma data ou um número de pedido aparecerAsserção textual dinâmicaNo momento em que um valor do formato certo está lá, seja qual for o valor.
Uma lista ter o número certo de linhasAsserção visual de contagem ou asserção textual de contagemNo momento em que a contagem obedece à regra dela.
Algo que a tela nunca mostraUma etapa EsperaDepois do tempo fixo que você definiu.

Escolher a asserção certa parte da mesma pergunta para as nove asserções.

Como esperar um indicador de carregamento (spinner) desaparecer?

Com uma asserção que passa quando algo some. Um indicador de carregamento é o aplicativo dizendo que não está pronto. Então a melhor espera é o fim do próprio indicador.

ExemploUm relatório que leva de 2 a 20 segundos

Depois de um clique em Gerar relatório, um indicador de carregamento gira por 2 a 20 segundos. Um sleep fixo teria de ser de 20 segundos, todas as vezes. Uma asserção visual de ausência no indicador, com um tempo limite de 30 segundos, deixa o teste seguir em frente no momento em que o relatório fica pronto.

Um valor que muda a cada execução é esperado da mesma forma.Uma asserção textual dinâmica não espera um total ou uma data específicos: ela aguarda um valor do formato certo, como um valor em dinheiro ou um número de pedido.Asserções visuais e Asserções textuais descrevem cada uma delas.

O que acontece quando o tempo acaba: parar ou continuar

Uma espera que termina sem o elemento é uma falha, e cada asserção diz o que essa falha faz.

Se falharIndicada para
Parar o testeUma asserção da qual os próximos cliques dependem, como a asserção de um botão antes do clique nele. Seguir em frente clicaria no lugar errado.
Continuar o testeUma asserção que só confirma o que está na tela. Assim, uma única execução relata todos os problemas que encontra.

Nos dois casos, nada fica para adivinhar depois.O relatório diz qual asserção ficou sem tempo e mostra como a tela estava naquele momento: veja como ler um relatório de teste.

Como substituir um sleep fixo por uma asserção que aguarda

Um teste gravado tem poucas pausas fixas, se tiver alguma. Isto vale para a Espera que alguém acrescentou depois de um dia ruim, ou para uma etapa que ainda falha quando o aplicativo está lento.

  1. 1

    Encontre a pausa fixa

    Abra o teste no GUI Test Studio e encontre a Espera na régua de tempo, ou a etapa que falha em dias lentos.

  2. 2

    Pergunte o que a pausa estava esperando

    Olhe a gravação naquele momento e dê nome ao que mostra que o aplicativo está pronto: um botão, uma mensagem ou um indicador de carregamento que sumiu.

  3. 3

    Adicione a asserção que aguarda isso

    Arraste a asserção correspondente da paleta Asserções para a faixa Asserções naquele momento, e mostre a ela o que procurar na gravação.

  4. 4

    Defina quanto tempo ela pode aguardar

    Defina o Tempo limite da asserção para o dia mais lento que você aceita.Em um dia rápido, a asserção continua passando na hora.

  5. 5

    Decida o que uma falha faz

    Escolha Parar o teste quando as próximas etapas dependem da asserção, ou Continuar o teste quando ela só confirma o que está na tela.

  6. 6

    Remova a Espera e execute o teste

    Marque Ignorado na Espera, ou exclua-a, e depois execute o teste.Agora a execução segue em frente no momento em que a tela fica pronta.

Você também pode pedir a mudança em um prompt, ao seu assistente de IA ou a um modelo de IA local, um dos nossos ou o seu: dar a uma asserção um tempo limite maior, adicionar uma espera, decidir o que acontece se ela falhar.Veja Criar um teste a partir de um prompt.

Quando uma etapa Espera de verdade é a escolha certa

Às vezes o aplicativo precisa de tempo e não mostra nada enquanto isso. Nenhuma asserção consegue aguardar o que não está na tela. É para isso que serve a etapa Espera.

Uma Espera fixa é a escolha certa em poucos casos.

  • Um arquivo é escrito em segundo plano antes que a próxima etapa o leia.
  • Um job de servidor é executado sem nenhum progresso na tela.
  • Uma ferramenta fora do aplicativo precisa de um momento para iniciar.

A Espera fica na paleta Eventos, em Fluxo do teste.Solte-a na linha do tempo e ela vai para a régua de tempo, naquele momento.Fluxo do teste: esperas, aplicativos, celulares e scripts a descreve.

Uma Espera tem uma única configuração que importa: quanto tempo.

O que saber antes de começar

É bom saberO que significa
Uma asserção que falha usa todo o tempo limiteUma asserção que falha aguarda até o fim antes de dizer isso. Defina cada tempo limite para o dia mais lento que você aceita, não muito além.
Uma asserção precisa de algo para verQuando nada na tela diz que o aplicativo está pronto, use uma etapa Espera.
Uma tela que ainda está aparecendoUm elemento pode ser encontrado enquanto um menu ainda surge aos poucos ou uma página ainda carrega.Uma asserção visual é comparada no melhor momento dela, no curto período depois de ser encontrada: veja a Passagem de acurácia aprimorada.
Um teste verifica o que mandaram verificarUma espera prova que um elemento chegou. O que mais está nessa tela só é verificado se uma asserção olhar para isso.

Pontos principais

  • 1Um sleep fixo é um palpite, e um palpite é curto demais em um dia lento e longo demais em todos os outros dias.
  • 2Os sleeps deixam uma suíte lenta e instável ao mesmo tempo: toda execução paga por eles, e o dia mais lento falha mesmo assim.
  • 3Em vez disso, espere pela tela: que um elemento apareça, que suma ou que mostre o tipo certo de valor.
  • 4No GUI Test Studio, toda asserção é essa espera, de até 5 segundos por padrão, e ela passa no momento em que o elemento está lá.
  • 5Guarde a etapa Espera para o que nenhuma asserção consegue ver, como um arquivo escrito em segundo plano.

Perguntas

Por que sleeps fixos são ruins nos testes?

Porque um sleep fixo é um palpite. Quando o aplicativo é mais lento que o palpite, o teste age cedo demais e falha. Quando o aplicativo é mais rápido, o teste espera à toa, a cada execução.

O que usar no lugar de um sleep em um teste?

Espere pelo que a tela mostra quando o aplicativo está pronto: um botão, uma mensagem ou um indicador de carregamento que sumiu. No GUI Test Studio, uma asserção faz isso sozinha: ela continua procurando até o tempo limite e passa no momento em que o elemento está lá.

Qual é a diferença entre uma espera fixa e uma espera explícita?

Uma espera fixa pausa por um tempo definido, não importa o que o aplicativo faça. Uma espera explícita pausa até que uma condição seja verdadeira, até um limite, então termina assim que o aplicativo está pronto. Em um framework com código, você a escreve para cada elemento, e no GUI Test Studio cada asserção é uma.

Quanto tempo um teste deve esperar por um elemento?

O tempo do dia mais lento que você aceita. No GUI Test Studio, uma asserção aguarda até 5 segundos por padrão, e você aumenta isso para uma tela lenta. O limite só é atingido quando o elemento nunca aparece.

Um tempo limite maior deixa os meus testes mais lentos?

Não, não quando os testes passam. Uma asserção segue em frente no momento em que o elemento está lá, então um tempo limite de 30 segundos custa 1 segundo em um dia em que a tela leva 1 segundo. Só uma asserção que falha usa todo o tempo limite.

Como esperar um indicador de carregamento (spinner) desaparecer?

Use uma asserção que passa quando algo some. No GUI Test Studio, uma asserção visual de ausência no indicador passa no momento em que ele sai da tela, e uma asserção textual de ausência faz o mesmo para uma palavra como Carregando.

Quando uma espera fixa ainda é a escolha certa?

Quando o aplicativo precisa de tempo e não mostra nada enquanto isso: um arquivo escrito em segundo plano, um job em um servidor sem nenhum progresso na tela. O GUI Test Studio tem uma etapa Espera para esse caso.

Preciso adicionar as esperas por conta própria em um teste gravado?

Não. Uma gravação dá a cada elemento em que você clica uma asserção colocada antes do clique, e essa asserção aguarda o elemento. Você só ajusta um tempo limite quando uma tela é mais lenta que o normal.

Selenium, Playwright e Cypress são marcas de seus respectivos proprietários.

Todos os artigos