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.
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.
| O palpite é | O que acontece | O que a equipe vê |
|---|---|---|
| Curto demais | O 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 demais | O 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 hoje | O 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.
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ê precisa | Em um framework com código | No GUI Test Studio |
|---|---|---|
| Esperar um elemento aparecer | Uma 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 sumir | Outra linha, com a condição oposta. | Uma asserção visual de ausência no indicador de carregamento. |
| Definir quanto tempo esperar | Um 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 lento | Encontrar 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.
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
Asserção visual ou asserção textual
Passa no momento em que o elemento está na tela.
Esperar que suma
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
Asserção textual dinâmica
Passa no momento em que um valor desse formato está lá, seja qual for o valor.
| O que você está esperando | A asserção a usar | Ela passa |
|---|---|---|
| Um botão, um ícone ou uma imagem aparecer | Asserção visual | No momento em que o elemento está na tela e tem a aparência certa. |
| Uma mensagem ou um título aparecer | Asserção textual | No momento em que as palavras estão na tela. |
| Um indicador de carregamento ou uma barra de progresso sumir | Asserção visual de ausência | No momento em que ele sai da tela. |
| Uma palavra como Carregando sumir | Asserção textual de ausência | No momento em que a palavra não está mais lá. |
| Um total, uma data ou um número de pedido aparecer | Asserção textual dinâmica | No momento em que um valor do formato certo está lá, seja qual for o valor. |
| Uma lista ter o número certo de linhas | Asserção visual de contagem ou asserção textual de contagem | No momento em que a contagem obedece à regra dela. |
| Algo que a tela nunca mostra | Uma etapa Espera | Depois 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.
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 falhar | Indicada para |
|---|---|
| Parar o teste | Uma 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 teste | Uma 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
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
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
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
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
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
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.
O que saber antes de começar
| É bom saber | O que significa |
|---|---|
| Uma asserção que falha usa todo o tempo limite | Uma 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 ver | Quando nada na tela diz que o aplicativo está pronto, use uma etapa Espera. |
| Uma tela que ainda está aparecendo | Um 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 verificar | Uma 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.
Continue lendo
Todos os artigos
Confiabilidade dos testes
Testes self-healing: quando um teste que se conserta sozinho esconde um bug real
11 min de leitura

Confiabilidade dos testes
Evidências de teste para auditorias: o que um auditor quer de um teste automatizado
11 min de leitura

Confiabilidade dos testes
"Element not found" de novo? Como testar quando seletores e localizadores falham
14 min de leitura