Testes self-healing: quando um teste que se conserta sozinho esconde um bug real
Testes self-healing mantêm a suíte verde quando o aplicativo muda. Veja como uma falsa correção esconde um bug real, e como manter cada mudança visível.
Os testes self-healing se consertam sozinhos quando o aplicativo muda: um teste que não encontra um elemento escolhe um parecido e segue em frente. Isso poupa manutenção, mas uma escolha errada aprova um fluxo quebrado, e ninguém é avisado.
Você conhece aquela manhã. Chegou um build novo, quarenta testes estão vermelhos e nenhum deles encontrou um bug: cada um perdeu um botão que costumava encontrar. O self-healing promete acabar com essas manhãs. A pergunta é o que ele faz no dia em que o botão sumiu de verdade.
O que são testes self-healing?
Definição
Um teste self-healing é um teste automatizado que muda sozinho quando não consegue mais encontrar um elemento.
- A ferramenta procura a correspondência mais próxima na tela e a usa no lugar dele.
- A execução continua como se nada tivesse acontecido.
A automação de testes self-healing existe por causa de um tipo de manutenção. Em um teste com código, cada botão, campo e link é encontrado por meio de um localizador: uma linha que descreve onde o elemento fica na página ou na janela. Quando um desenvolvedor renomeia ou move o elemento, o localizador deixa de corresponder, e o teste falha embora o aplicativo funcione.
Por que os localizadores quebram com tanta frequência é o assunto de “element not found”: quando seletores e localizadores falham.
Por que as equipes querem automação de testes self-healing
Três dores tornam o self-healing atraente.
Builds vermelhos que não encontraram nada
Uma pequena mudança no aplicativo deixa dezenas de testes vermelhos, e nenhum deles aponta para um bug.
Horas de conserto
Os testadores passam a semana consertando localizadores em vez de testar o produto.
Uma suíte em que ninguém confia
Depois de alarmes falsos demais, a equipe para de olhar os testes vermelhos.
O desejo por trás disso é justo. Um teste deveria sobreviver a uma mudança que nenhum usuário perceberia: um id renomeado, um botão movido um pouco, um novo contêiner em volta de um formulário. Nada disso é bug, e nada disso deveria custar uma manhã.
Testes que falham sem motivo têm um custo próprio, calculado em testes instáveis e falsos positivos.
O que é uma falsa correção?
Definição
Uma falsa correção é um conserto que escolhe o elemento errado.
- O teste segue em frente e clica ou verifica algo que só se parece com aquilo para o qual foi feito.
- Depois, é aprovado.
A execução fica verde sobre um fluxo que está quebrado.
Semana passada
Seu pedido
O teste clica em Pagar agora.
Esta semana
Seu pedido
Pagar agora sumiu. O teste se corrige sozinho e clica em Pagar depois.
O que o build diz
Teste aprovado
O que o cliente recebe
Um pedido que nunca foi pago
Por engano, uma versão troca o botão Pagar agora por Pagar depois. O teste não encontra Pagar agora. A correção dele acha um botão do mesmo tamanho, no mesmo lugar, com um nome parecido, e clica nele. O pedido é salvo como não pago, a última etapa ainda vê uma página de pedido, e a execução é aprovada. A primeira pessoa a perceber é um cliente.
Um teste que falha custa alguns minutos. Uma falsa correção apaga o único sinal que o teste existia para dar.
Um alarme falso falha por nada. Uma falsa correção é aprovada por nada, o que é pior: ninguém abre um teste verde para conferir.
Como um teste encontra um elemento, e o que ele espera: duas mudanças diferentes
Nem todo conserto tem o mesmo risco. Um teste guarda duas coisas sobre cada elemento, e elas não deveriam ser tratadas da mesma forma.
Como o elemento é encontrado
O usuário vê a mesma tela.
O teste pode acompanhar sozinho, e dizer onde encontrou o elemento.
O que a asserção espera
O usuário vê outra tela.
O teste falha, e uma pessoa decide.
| O que mudou | Exemplo | Se o teste acompanha em silêncio |
|---|---|---|
| Como o elemento é encontrado | O botão manteve o visual e a função, mas mudou de lugar ou ganhou outro id. | Risco baixo: o usuário vê a mesma tela. |
| O que o teste espera | As palavras, a cor ou o estado do botão mudaram, ou outro elemento tomou o lugar dele. | Risco alto: esta é uma decisão sobre o seu produto. |
A regra importa ainda mais quando a IA escreve o código testado, como explica como testar código gerado por IA.
Duas perguntas para fazer a qualquer teste self-healing
Antes de confiar em um teste que se conserta sozinho, faça duas perguntas.
Quem é avisado?
Quando um teste mudou sozinho, quem é avisado, e essa pessoa consegue ver do que e para o que ele mudou?
Quem decidiu?
Quem decidiu que a nova versão estava certa: uma pessoa que olhou a tela, ou só a ferramenta?
Se as respostas honestas forem “ninguém” e “a ferramenta”, cada execução verde precisa de um segundo olhar, e o tempo economizado é gasto de novo.O mesmo hábito de perguntar antes de confiar está por trás de ferramentas de teste com IA: 7 perguntas para fazer antes de escolher uma.
Menos quebras para corrigir: nenhum localizador para manter
O GUI Test Studio, que automatiza testes de ponta a ponta de qualquer aplicativo sem código, parte do outro lado. Ninguém escreve um localizador, então não existe nenhum para você manter. Você grava o fluxo uma vez, ou o descreve em um prompt, e cada asserção trata do que o usuário vê.
O GTS Engine + AI encontra cada elemento de duas formas.
- Primeiro ele pergunta ao aplicativo, pelas informações de acessibilidade do aplicativo.
- Quando o aplicativo não diz nada, ele encontra o elemento pela visão, na tela.
- Um botão que mudou de lugar, uma janela mais larga ou uma lista que rolou é encontrado onde está agora, e o Relatório de confiança diz onde.
Em uma página web, um teste gravado guarda várias formas de chegar a cada elemento.Quando a primeira deixa de funcionar, a seguinte encontra o mesmo elemento, e a execução registra isso.Como o GUI Test Studio encontra os elementos explica as duas formas.
Essa segunda metade é o motivo de um elemento parecido não passar despercebido. Se Pagar depois está onde Pagar agora estava, a asserção o compara com o Pagar agora que espera, e falha.
Quando a tela mudou de verdade: uma falha que todos podem ver
Algumas mudanças são reais: palavras novas em um botão, uma cor nova, um campo que sumiu. O GUI Test Studio não decide por você o que elas significam. A asserção falha, a execução fica vermelha e o Relatório de confiança abre no que aconteceu.
O relatório dá o que uma decisão precisa.
- A imagem esperada fica ao lado da obtida, e a diferença é marcada.
- Com a Análise inteligente com IA ativada, uma frase diz o que mudou em palavras simples, como um botão que passou de ativo para desativado.
- O vídeo da execução mostra as etapas que levaram até ali.
- O relatório é salvo com a execução, então a falha fica registrada.
O guia O Relatório de confiança explica tudo o que uma execução mostra, e como ler um relatório de teste percorre uma falha da primeira linha até a decisão.
Aceitar o novo visual ou registrar o bug: uma pessoa decide
Asserção reprovada: botão Pagar
Esperado
Pagar agoraObtido
Pagar depoisAs palavras do botão mudaram de “Pagar agora” para “Pagar depois”.
Não foi intencional: registre o bug
Um relatório de bug com as etapas e as duas imagens, como arquivo ou como issue do Jira.
Foi intencional: aceite o novo visual
Um clique, que pode ser desfeito, e depois salvo no teste.
Olhar
Esperado ao lado do obtido
Um bug?
Registre pelo relatório
De propósito?
Aceite o novo visual
Salvar
No teste
- 1
Abrir a asserção reprovada
No Relatório de confiança, selecione a asserção reprovada. A imagem esperada fica ao lado da obtida, e a diferença é marcada.
- 2
Decidir: um bug, ou uma mudança feita de propósito
Pergunte se a equipe queria que a tela ficasse assim. Se ninguém queria, é um bug.
- 3
Um bug: registrar pelo relatório
Crie um relatório de bug em PDF ou em arquivo Excel, ou como issue do Jira. As etapas, as imagens e o motivo são preenchidos a partir da execução.
- 4
Uma mudança de propósito: aceitar o novo visual
Clique em Aceitar o obtido como esperado.O novo visual fica pendente até você salvar, e Ctrl+Z o desfaz.
- 5
Salvar
Clique em Salvar.O arquivo de teste é atualizado, e a próxima execução espera o novo visual.
Depois de um redesign, muitas asserções falham pelo mesmo motivo.Uma lista mostra cada asserção reprovada com as duas imagens: desmarque os bugs reais e aceite o resto de uma vez.Atualizar um teste depois de uma mudança mostra cada janela.
Uma correção silenciosa vs uma decisão visível
| Pergunta | Uma correção silenciosa | Uma decisão visível |
|---|---|---|
| O que acontece quando um elemento mudou? | A ferramenta escolhe um elemento parecido, e a execução segue. | A asserção falha, e a execução diz isso. |
| Quem é avisado? | Quem lê o log de correções, se alguém ler. | Todos que veem o build. O relatório abre na falha. |
| Quem decide que a nova versão está certa? | A ferramenta. | Uma pessoa que viu o esperado ao lado do obtido. |
| Como aparece um bug real? | Um teste verde. | Um teste vermelho, com as duas imagens. |
| O que fica depois? | Uma execução verde, e um teste que já não verifica aquilo para o qual foi feito. | O relatório salvo da execução que falhou, e o visual aceito no teste. |
| Quanto custa? | Nada hoje, e um bug que escapa depois. | Um clique por mudança, ou uma revisão para várias. |
Um teste que muda sozinho entre duas execuções já não é o mesmo teste.Por que o mesmo teste deveria dar a mesma resposta duas vezes é o assunto de testes repetíveis com IA.
O que saber antes de começar
| Limite | O que significa |
|---|---|
| Aceitar é um clique por mudança | Uma pessoa revisa cada novo visual. Depois de um redesign, a lista de asserções reprovadas permite aceitar várias de uma vez. |
| Um teste verifica o que mandaram verificar | Uma mudança em uma parte da tela que nenhuma asserção observa não é vista. Adicione uma asserção onde importa. |
| A IA pode aprovar uma diferença pequena | Com a Análise inteligente com IA ativada, uma asserção reprovada que só difere de formas que um usuário não perceberia pode ser aprovada. O relatório diz isso, e o arquivo de teste não é alterado. |
Principais conclusões
- 1Os testes self-healing se consertam sozinhos escolhendo um elemento parecido quando o deles não é encontrado.
- 2Uma falsa correção escolhe o elemento errado: um teste verde sobre um fluxo quebrado, e ninguém é avisado.
- 3Duas mudanças, duas regras: a forma de encontrar um elemento pode se adaptar, e o que uma asserção espera só muda quando uma pessoa concorda.
- 4O GUI Test Studio não tem localizador para você manter: cada elemento é encontrado primeiro pelas informações de acessibilidade do aplicativo, e pela visão quando o aplicativo não diz nada.
- 5Uma mudança real falha à vista de todos, e uma pessoa aceita o novo visual com um clique ou registra o bug.
Perguntas
O que são testes self-healing?
Testes self-healing são testes automatizados que mudam sozinhos quando não conseguem mais encontrar um elemento. A ferramenta procura a correspondência mais próxima na tela, usa essa no lugar e segue com a execução. O objetivo é poupar a equipe de consertar os testes depois de pequenas mudanças no aplicativo.
O que é uma falsa correção na automação de testes?
Uma falsa correção é um conserto que escolhe o elemento errado. O teste clica ou verifica algo que só se parece com o elemento para o qual foi feito, e é aprovado. O resultado é um teste verde sobre um fluxo que está quebrado.
A automação de testes self-healing é segura?
Ela é segura quando só muda a forma como um teste encontra um elemento e avisa você a cada vez. Ela é um risco quando muda o que o teste espera, ou escolhe outro elemento, sem que uma pessoa olhe. Pergunte quem é avisado quando um teste mudou sozinho, e quem decidiu que a mudança estava certa.
Por que os testes automatizados quebram quando o aplicativo muda?
A maioria dos testes com código encontra cada botão e campo por meio de um localizador, uma linha que descreve onde o elemento fica na página ou na janela. Quando um desenvolvedor renomeia ou move o elemento, o localizador deixa de corresponder e o teste falha, embora o aplicativo funcione.
O GUI Test Studio tem testes self-healing?
Ele precisa de muito menos correção, e deixa a decisão com uma pessoa. Não há localizador para você escrever ou consertar: cada elemento é encontrado primeiro pelas informações de acessibilidade do aplicativo, e pela visão quando o aplicativo não diz nada. Quando a tela mudou de verdade, a asserção falha no Relatório de confiança, e você aceita o novo visual com um clique ou registra o bug.
Como atualizar um teste depois de uma mudança intencional?
Abra a asserção reprovada no Relatório de confiança, olhe a imagem esperada e a obtida, e clique em Aceitar o obtido como esperado. Ctrl+Z desfaz isso até você clicar em Salvar. Depois de salvar, o teste espera o novo visual.
Posso aceitar várias mudanças de uma vez depois de um redesign?
Sim. O Relatório de confiança lista cada asserção reprovada com as duas imagens em uma única lista. Você desmarca as que são bugs reais e aceita o resto de uma vez.
Quem deve decidir quando um teste muda?
Uma pessoa que viu o que mudou. Um teste declara o que a sua equipe espera do produto, então uma mudança no que ele espera é uma decisão de produto. Uma ferramenta pode preparar essa decisão mostrando o esperado ao lado do obtido, mas não deveria tomá-la sozinha.
Windows e Jira são marcas de seus respectivos proprietários.
Continue lendo
Todos os artigos
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
Sleeps fixos nos testes: pare de chutar um tempo e espere pela tela
10 min de leitura

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