Automação de QA
Teste os fluxos essenciais do seu produto.
Integramos testes automatizados ao seu processo de entrega, começando pelos fluxos e pelas falhas relevantes para o produto. Combinamos a cobertura, as verificações do pipeline e como seu time manterá os testes.
O que construímos
- Testes automatizados para fluxos de usuário, integrações e casos de falha acordados
- Verificações de CI e critérios de release definidos com seu time
- Ambientes, dados e documentação para executar e manter as suítes
- Rascunhos de testes assistidos por IA, revisados por engenheiros com base nos requisitos
Provas
Auth0
Entre 2012 e 2019, nosso trabalho no produto da Auth0 incluiu testes unitários e de integração automatizados, além de componentes, extensões e bibliotecas de Python e Node.js.
Leia o caso- Testes unitários e de integração
- Produto da Auth0
- 2012–2019
- Trabalho com a Auth0
Quando os times nos procuram
- As verificações de release dependem de poucas pessoas que conhecem o sistema
- Regressão manual que leva dias por ciclo
- Bugs que os clientes encontram antes do QA
Obter resultados úteis antes do deploy
Quando um release exige repetir as mesmas verificações manuais, seu time precisa de tempo para executá-las e investigar as falhas. Testes pouco confiáveis trazem outro problema: fica difícil distinguir um defeito do produto de um problema do ambiente ou dos dados de teste.
Começamos com um mapa de riscos e as verificações que podem ser automatizadas de forma confiável. Conectamos essas verificações ao pipeline combinado e revisamos a velocidade, as falhas e as necessidades de manutenção. Os testes exploratórios e algumas verificações manuais continuam no plano; a automação não elimina todo o risco de regressão.
Como construímos
Mapear os riscos do produto
identificar fluxos importantes, casos de falha e lacunas nos testes existentes
Escolher os primeiros testes
avaliar o risco, a repetibilidade e o esforço de manutenção
Configurar as verificações do pipeline
combinar quando os testes rodam e quais resultados bloqueiam um release
Planejar a manutenção
atribuir responsáveis e documentar como executar, diagnosticar e atualizar os testes
O que torna uma suíte de testes útil
Primeiro os caminhos críticos
Combinamos os fluxos de uso importantes, seus casos de falha e os resultados esperados. Relacionamos os testes a esses requisitos para o time saber o que está coberto e o que ainda precisa ser testado.
Testes com base nos requisitos
Os engenheiros verificam os resultados esperados e os casos de falha. Os testes gerados precisam verificar o comportamento previsto, incluindo as condições que a implementação pode tratar incorretamente.
Verificações de release acordadas
Configuramos quais suítes rodam no pipeline, quando rodam e como as falhas são investigadas. Seu time combina os critérios para publicar uma mudança.
Responsáveis e manutenção
Usamos ferramentas e convenções adequadas ao seu stack, documentamos como as suítes funcionam e combinamos quem as atualiza quando o produto muda.
Os resultados dos testes ajudam na decisão de deploy. Também documentamos as lacunas de cobertura e os riscos que precisam de outras verificações.
Funciona bem com
Perguntas frequentes
A automação vai substituir o nosso pessoal de QA?
A automação pode cobrir algumas verificações repetitivas. Seu time de QA continua avaliando riscos, testando comportamentos novos e investigando resultados inesperados. Combinamos quais verificações manuais continuam necessárias para o produto e o release.
De quanta cobertura precisamos?
Relacionamos a cobertura aos fluxos de uso, integrações e casos de falha importantes. Os relatórios de cobertura ajudam a identificar lacunas, mas testes aprovados não demonstram que um produto está livre de defeitos. Combinamos as prioridades e os riscos que precisam de mais verificações.
Vocês usam IA para gerar testes?
Sim. Usamos ferramentas de IA para preparar casos de teste. Os engenheiros revisam o comportamento esperado, os dados e as condições de falha com base nos requisitos antes de adicioná-los à suíte.
Como isso muda quando o código é escrito com IA?
Revisamos a implementação e seus testes com base no comportamento esperado. Um teste gerado pode repetir uma premissa incorreta do código gerado, por isso verificamos os requisitos, as condições-limite e os casos de falha durante a revisão.
Quanto tempo até vermos menos regressões?
Começamos pelos caminhos críticos e conectamos as primeiras suítes ao pipeline. Os prazos dependem dos testes existentes, do sistema e do escopo que combinarmos com seu time. Acompanhamos quais regressões os testes detectam e quais chegam aos clientes para decidir o que cobrir depois.
Quais testes primeiro?
Ordenamos os fluxos com seu time pelo impacto de uma falha, pelos problemas conhecidos e pelo esforço necessário para testá-los. Alguns exemplos são login, checkout, relatórios ou uma integração da qual um cliente depende. O primeiro escopo inclui os casos escolhidos e os motivos dessa prioridade.