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.

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

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

Pagar agora

O teste clica em Pagar agora.

Esta semana

Seu pedido

Pagar depois

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

Uma falsa correção: o teste se consertou em outro botão, e a execução continuou verde sobre um checkout quebrado.
ExemploUm checkout que perdeu o botão Pagar

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

Um novo idUm botão que mudou de lugarUma janela mais largaUma lista que rolou

O usuário vê a mesma tela.

O teste pode acompanhar sozinho, e dizer onde encontrou o elemento.

O que a asserção espera

Outras palavrasOutra corUm ícone que faltaOutro elemento

O usuário vê outra tela.

O teste falha, e uma pessoa decide.

Um teste guarda duas coisas sobre cada elemento. Só a primeira pode mudar sem que uma pessoa olhe.
O que mudouExemploSe o teste acompanha em silêncio
Como o elemento é encontradoO 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 esperaAs 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.

Uma asserção reprovada no Relatório de confiança: o esperado ao lado do obtido, o que mudou e o botão Aceitar à direita.

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 agora

Obtido

Pagar depois

As 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.

A mesma mudança, tornada visível: a execução fica vermelha, os dois visuais aparecem na tela, e uma pessoa escolhe.
  1. Olhar

    Esperado ao lado do obtido

  2. Um bug?

    Registre pelo relatório

  3. De propósito?

    Aceite o novo visual

  4. Salvar

    No teste

  1. 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. 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. 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. 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. 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

PerguntaUma correção silenciosaUma 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

LimiteO que significa
Aceitar é um clique por mudançaUma 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 verificarUma 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 pequenaCom 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.

Todos os artigos