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.
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?
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 comparar | Smoke test | Sanity test | Teste de regressão |
|---|---|---|---|
| A pergunta que ele faz | Vale a pena testar este build? | Esta correção funciona? | Alguma outra coisa quebrou? |
| Amplitude | O aplicativo inteiro | Um recurso ou uma correção | O aplicativo inteiro |
| Profundidade | Raso: um toque por recurso | Profundo, em um só lugar | Profundo, onde for importante |
| Quando é executado | A cada build | Depois de uma correção ou de uma pequena mudança | Toda noite e antes de um lançamento |
| Quanto tempo leva | Alguns minutos | Alguns minutos | Uma hora ou mais, sem ninguém por perto |
| O que uma falha significa | O build é rejeitado | A correção volta | Uma 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ã.
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
Os números abaixo são uma ilustração, com valores redondos.
| Quando | O que foi executado | O que encontrou |
|---|---|---|
| Segunda-feira, chega um novo build | A 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 é corrigido | Um sanity test: o teste da fatura executado de novo, com o total verificado. | Ele passa. A correção funciona. |
| Terça-feira à noite | A 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
A cada build
Sanity test
1 de 6 testes
Depois de uma correção no checkout
Suíte de regressão
6 de 6 testes
Toda noite
| Tipo de execução | O que é, com testes gravados | Como é executado |
|---|---|---|
| Suíte de smoke | Alguns testes curtos, um por recurso principal. | Pelo gtr-cli, a cada build. |
| Sanity test | O único teste que cobre a correção, executado de novo. | Com Executar teste, ou a partir do meio do teste. |
| Suíte de regressão | Todos 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
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
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
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
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
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
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.
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.
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
| Limite | O que significa |
|---|---|
| Uma execução usa a tela real | Os 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 partida | Um 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 verificar | Uma 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.
Continue lendo
Todos os artigos
Automação de testes
O que é teste de ponta a ponta? Um guia simples com um exemplo real
10 min de leitura

Automação de testes
O que é teste funcional? Exemplos, tipos e como ele difere do teste de ponta a ponta
9 min de leitura

Automação de testes
Teste manual vs. teste automatizado: por que o teste manual fica aquém nos testes de ponta a ponta
15 min de leitura