Smoke test vs sanity test vs teste de regressão: qual executar, e quando

Smoke test vs sanity test vs teste de regressão: o que cada um verifica, quando executar e como rodar os três a partir dos mesmos testes gravados.

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

O smoke test verifica se um novo build inicia e se os recursos principais respondem. O sanity test verifica uma correção ou uma mudança em profundidade. O teste de regressão verifica se nada do que funcionava antes quebrou. Eles diferem em amplitude, profundidade e momento.

A maioria das equipes conhece os três nomes e ainda assim faz os três à mão, quando sobra tempo. Quando um lançamento atrasa, a longa rodada de regressão é a primeira coisa cortada, e um bug antigo volta bem na frente de um cliente.

Smoke test vs sanity test vs teste de regressão: a resposta curta

Imagine o seu aplicativo como uma grade: os recursos da esquerda para a direita, e a profundidade com que cada um é testado de cima para baixo. Os três tipos de teste acendem partes diferentes dessa grade.

Smoke test

Amplo e raso

Vale a pena testar este build?

Sanity test

Estreito e profundo

Esta correção funciona?

Teste de regressão

Amplo e profundo

Alguma outra coisa quebrou?

Cada grade é o mesmo aplicativo: os recursos da esquerda para a direita, a profundidade do teste de cima para baixo. As células acesas são o que cada tipo de teste olha.

O que é smoke test (teste de fumaça)?

Definição

O smoke test, ou teste de fumaça, é um conjunto curto de testes que verifica se um novo build está estável o bastante para ser testado.

  • Ele inicia o aplicativo e toca cada recurso principal uma vez: o aplicativo abre, um usuário consegue entrar, as telas principais carregam, a ação principal responde.
  • Ele não olha os detalhes.

Um build que falha no smoke test volta na hora para os desenvolvedores, e ninguém perde um dia testando.

O smoke test também é chamado de build verification test (teste de verificação de build), porque é executado logo depois que um build é gerado. O valor dele é a velocidade: alguns minutos, a cada build, com um sim ou um não bem claro no final.

O que é sanity test (teste de sanidade)?

Definição

O sanity test, ou teste de sanidade, é um teste rápido e estreito que confirma que uma correção ou uma pequena mudança funciona, e que a parte do aplicativo em volta dela continua se comportando como deveria.

  • Ele é executado em um build que traz uma correção de bug ou uma pequena mudança.
  • Ele vai fundo nessa única área e deixa o resto de lado.

Quando ele passa, o build merece a rodada de regressão, que é mais longa.

Feito à mão, um sanity test costuma ser improvisado: o testador clica em volta da área corrigida, de memória. É rápido, mas não deixa nenhum registro do que foi olhado, e dois testadores raramente olham as mesmas coisas.

O que é teste de regressão?

Definição

O teste de regressão executa de novo os testes existentes depois de uma mudança, para verificar se nada do que já funcionava quebrou.

  • Ele é amplo e profundo: todos os fluxos importantes, com os resultados verificados.
  • É o mais longo dos três, e por isso é executado à noite ou antes de um lançamento.

Este artigo é breve nesse ponto de propósito.O guia completo, com os tipos de teste de regressão e o que deve entrar em uma suíte, é o que é teste de regressão.

Smoke test vs sanity test vs teste de regressão, lado a lado

O que compararSmoke testSanity testTeste de regressão
A pergunta que ele fazVale a pena testar este build?Esta correção funciona?Alguma outra coisa quebrou?
AmplitudeO aplicativo inteiroUm recurso ou uma correçãoO aplicativo inteiro
ProfundidadeRaso: um toque por recursoProfundo, em um só lugarProfundo, onde for importante
Quando é executadoA cada buildDepois de uma correção ou de uma pequena mudançaToda noite e antes de um lançamento
Quanto tempo levaAlguns minutosAlguns minutosUma hora ou mais, sem ninguém por perto
O que uma falha significaO build é rejeitadoA correção voltaUma regressão é detectada antes que os usuários a vejam

Smoke test e sanity test são a dupla que as pessoas mais confundem. O jeito de diferenciá-los é o que eles olham: um smoke test olha o build inteiro, um sanity test olha uma única mudança.

Qual executar, e em que momento de um lançamento

Os três não são rivais. Cada um tem o seu momento em um lançamento, e cada um decide se vale a pena executar o seguinte.

Cada build

Suíte de smoke

Alguns testes curtos, alguns minutos. Uma falha rejeita o build.

Depois de uma correção ou de uma pequena mudança

Sanity test

O teste que cobre a correção, executado de novo, com o resultado verificado.

Toda noite, e antes de um lançamento

Suíte de regressão

Todos os testes, sem ninguém por perto. O relatório é lido de manhã.

Quanto mais curto o teste, mais vezes ele é executado. O mais longo é executado enquanto ninguém está esperando por ele.

A ordem é sempre a mesma.

  • Primeiro o smoke: se o build não consegue iniciar ou fazer o login de um usuário, não vale a pena executar mais nada.
  • Depois o sanity: se a correção não funciona, o build volta antes da rodada longa.
  • Por último a regressão: com o build estável e a correção certa, todo o resto é verificado.

Uma semana, um aplicativo: os três na prática

ExemploUm aplicativo de faturamento, três dias

Os números abaixo são uma ilustração, com valores redondos.

QuandoO que foi executadoO que encontrou
Segunda-feira, chega um novo buildA suíte de smoke: entrar, abrir um cliente, criar uma fatura, exportá-la. Cinco testes, quatro minutos.Todos passam. Vale a pena testar o build.
Terça-feira, um bug de arredondamento no imposto é corrigidoUm sanity test: o teste da fatura executado de novo, com o total verificado.Ele passa. A correção funciona.
Terça-feira à noiteA suíte de regressão: todos os quarenta testes.Um falha: o total de uma nota de crédito está errado. A correção chegou até ela.

O bug da nota de crédito é encontrado na quarta-feira de manhã por um relatório, não três semanas depois por um cliente. Sem a execução noturna, a correção teria sido lançada junto com ele.

Por que o teste de regressão é o primeiro a ser pulado

Feitos à mão, os três disputam as mesmas horas.

  • Um smoke test a cada build tira um testador do teste de verdade várias vezes por dia.
  • Um sanity test feito de memória não deixa rastro do que foi olhado.
  • Uma rodada completa de regressão leva dias, então ela encolhe para as telas de que alguém se lembra quando o lançamento atrasa.
  • Os bugs que voltam estão nas telas para as quais ninguém teve tempo.
Ninguém decide pular o teste de regressão. Ele vai sendo espremido, um lançamento atrasado de cada vez.

Automatizar os três com um framework com código como Selenium ou Playwright transfere o trabalho para os programadores: alguém escreve os scripts, marca-os como smoke ou regressão no código e os conserta toda vez que uma tela muda.Os testadores que melhor conhecem o produto não conseguem mexer neles.Teste manual vs teste automatizado analisa essa troca em detalhes.

Com testes gravados, os três são os mesmos testes, agrupados de outra forma

O GUI Test Studio automatiza testes de ponta a ponta de qualquer aplicativo sem código. Você faz um fluxo uma vez no seu aplicativo enquanto o GUI Test Runner-Recorder o grava, e depois o teste é reproduzido sozinho: as mesmas etapas, na mesma ordem, a cada execução.

Quando os seus fluxos são testes gravados, smoke, sanity e regressão deixam de ser três trabalhos. São três maneiras de agrupar e executar os mesmos arquivos de teste.

Suíte de smoke

3 de 6 testes

EntrarBuscar um produtoCheckoutHistórico de pedidosReembolsoExportar faturas

A cada build

Sanity test

1 de 6 testes

EntrarBuscar um produtoCheckoutHistórico de pedidosReembolsoExportar faturas

Depois de uma correção no checkout

Suíte de regressão

6 de 6 testes

EntrarBuscar um produtoCheckoutHistórico de pedidosReembolsoExportar faturas

Toda noite

Seis testes gravados, feitos uma única vez. Uma suíte de smoke, um sanity test e uma suíte de regressão são três maneiras de escolher entre eles.
Tipo de execuçãoO que é, com testes gravadosComo é executado
Suíte de smokeAlguns testes curtos, um por recurso principal.Pelo gtr-cli, a cada build.
Sanity testO único teste que cobre a correção, executado de novo.Com Executar teste, ou a partir do meio do teste.
Suíte de regressãoTodos os testes que você tem.Pelo gtr-cli, toda noite e antes de um lançamento.

Três coisas mantêm os mesmos testes utilizáveis nos três papéis.

  • Cada asserção aguarda o que espera e segue em frente no momento em que isso aparece, então um teste curto continua curto.
  • Um grupo de etapas como Entrar é um cenário que outros testes reutilizam, então ele é gravado uma única vez.
  • O GTS Engine encontra cada elemento primeiro pelas informações de acessibilidade do aplicativo e pela visão quando o aplicativo não diz nada, então um teste sobrevive a pequenas mudanças na tela.

Por que uma asserção que aguarda é melhor do que uma pausa de duração fixa está em sleeps fixos nos testes, e Cenários mostra como as etapas de um teste são reutilizadas em outro.

Um sanity test não precisa reproduzir um teste longo desde o início.No GUI Test Studio, coloque o indicador de reprodução onde começa a parte corrigida e escolha Salvar e executar a partir do indicador de reprodução: com o aplicativo colocado no estado em que estava naquele momento, só as etapas dali em diante são executadas.Executar um teste explica isso.

Como montar uma suíte de smoke e uma suíte de regressão com os mesmos testes

A configuração toda são seis pequenas etapas, e a primeira é a única que leva tempo de verdade.

  1. 1

    Grave cada fluxo uma vez

    Clique em Gravar no GUI Test Runner-Recorder e faça o fluxo no seu aplicativo, como um usuário faria. Cada fluxo importante vira um arquivo de teste, com asserções sobre o que a tela mostrou.

  2. 2

    Compartilhe as etapas em comum como um cenário

    Agrupe as etapas com que todo teste começa, como o login, em um cenário chamado Entrar. Adicione esse teste aos outros como cenário, para que o login seja gravado uma vez e reutilizado.

  3. 3

    Escolha os smoke tests

    Escolha um teste curto por recurso principal: o aplicativo abre, um usuário entra, a tela principal carrega, a ação principal responde. Mantenha os arquivos desses testes juntos em uma pasta, como tests\smoke.

  4. 4

    Mantenha os testes mais profundos em uma segunda pasta

    Coloque todos os outros testes em uma pasta como tests\regression. A suíte de regressão são as duas pastas juntas: todos os testes que você tem.

  5. 5

    Execute o smoke a cada build e tudo à noite

    Na máquina de build, o gtr-cli executa a pasta de smoke depois de cada build e as duas pastas toda noite. Um teste que falha faz o build falhar, e cada execução guarda o relatório, o vídeo e as imagens dela.

  6. 6

    Depois de uma correção, execute um teste de novo

    Abra o teste que cobre a correção e clique em Executar teste: esse é o seu sanity test. Em um teste longo, inicie a execução a partir do indicador de reprodução no GUI Test Studio, com o aplicativo colocado no estado em que estava naquele momento.

Um sanity test é um clique em Executar teste, e o cartão Execuções guarda o resultado ao lado dos anteriores.

Executar os smoke tests a cada build e os testes de regressão toda noite

Em uma máquina de build, o gtr-cli executa testes pela linha de comando em qualquer ferramenta de CI/CD. Ele aceita arquivos de teste, pastas e padrões de nome de arquivo, quantos você listar. Uma pasta executa os arquivos de teste que estão nela.

Os mesmos testes, dois momentos
gtr-cli run tests\smoke --countdown 0 --junit results\smoke.xml
gtr-cli run tests\smoke tests\regression --countdown 0 --junit results\regression.xml
  • A primeira linha pertence ao job de build, e um teste que falha faz o build falhar pelo código de saída.
  • A segunda linha pertence a um job noturno.
  • Cada execução escreve um arquivo de resultados que a sua ferramenta de CI lê, e guarda o Relatório de confiança, o vídeo e as imagens dela.

De manhã, um teste de regressão que falhou é lido, não adivinhado: o Relatório de confiança mostra a etapa que falhou, o esperado ao lado do obtido, e o histórico das execuções anteriores.Como ler um relatório de teste mostra o que olhar primeiro, e Executar testes no seu pipeline lista todas as opções do gtr-cli.

O que saber antes de começar

LimiteO que significa
Uma execução usa a tela realOs testes são executados um depois do outro em uma máquina, a menos que um teste web seja executado sem janela de navegador. Dê à execução noturna de regressão uma máquina de build que ninguém esteja usando.
O mesmo ponto de partidaUm teste é reproduzido a partir do estado em que foi gravado. Cada suíte precisa colocar o aplicativo de volta nesse estado, e um teste web abre a própria janela limpa do navegador.
Um teste verifica o que mandaram verificarUma suíte de smoke verde diz que os recursos principais respondem. Ela não diz que cada detalhe está certo: esse é o trabalho da suíte de regressão.

Pontos principais

  • 1O smoke test é amplo e raso. Ele decide em minutos se vale a pena testar um build.
  • 2O sanity test é estreito e profundo. Ele confirma uma correção antes de a rodada longa começar.
  • 3O teste de regressão é amplo e profundo. Ele prova que a mudança não quebrou nada que funcionava.
  • 4Cada um tem o seu momento: smoke a cada build, sanity depois de uma correção, regressão toda noite e antes de um lançamento.
  • 5Com testes gravados, eles são um único conjunto de arquivos de teste. O GUI Test Studio os agrupa e executa de três maneiras, sem código.

Perguntas

Qual é a diferença entre smoke test e sanity test?

O smoke test verifica o build inteiro de forma rasa, para decidir se ele está estável o bastante para ser testado. O sanity test verifica uma correção ou uma pequena mudança em profundidade. O smoke vem primeiro, a cada build, e o sanity vem depois de um build que traz uma correção.

Qual é a diferença entre smoke test e teste de regressão?

O smoke test toca cada recurso principal uma vez e leva minutos. O teste de regressão executa todos os fluxos importantes com os resultados verificados, e pode levar horas. Um smoke test diz que o build está vivo, e um teste de regressão diz que nada do que funcionava quebrou.

O sanity test faz parte do teste de regressão?

Na prática, sim. Um sanity test é uma pequena fatia da suíte de regressão: os testes que cobrem a área que mudou. Ele é executado logo depois da correção, e a suíte de regressão completa é executada mais tarde, à noite ou antes de um lançamento.

O que vem primeiro: smoke test, sanity test ou teste de regressão?

O smoke test vem primeiro, a cada novo build. O sanity test vem em seguida, quando o build traz uma correção ou uma pequena mudança. O teste de regressão vem por último, à noite ou antes de um lançamento, porque é o mais longo dos três.

O que é um build verification test (teste de verificação de build)?

Build verification test, ou teste de verificação de build, é outro nome para o smoke test. Ele é executado logo depois que um build é gerado e responde a uma pergunta: este build está estável o bastante para continuar sendo testado?

Quantos testes entram em uma suíte de smoke?

Poucos: um teste curto por recurso principal, normalmente de cinco a dez no total, para que a suíte inteira seja executada em alguns minutos. Uma suíte de smoke que fica lenta deixa de ser executada a cada build, e aí não protege mais nada.

Um smoke test que falha deve fazer o build falhar?

Sim. Não vale a pena continuar testando um build que falha no smoke test, então o pipeline deve parar e a equipe deve ser avisada. Com o GUI Test Studio, o gtr-cli termina com um código de saída que o pipeline lê, então um teste que falha faz o build falhar.

É possível automatizar smoke tests e testes de regressão sem código?

Sim. Com o GUI Test Studio, você grava cada fluxo uma vez, fazendo-o no seu aplicativo, e o teste é reproduzido sozinho. A suíte de smoke e a suíte de regressão passam a ser dois grupos dos mesmos arquivos de teste, executados pelo gtr-cli a cada build e toda noite.

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

Todos os artigos