testes-frontend

Planeje, implemente, execute e mantenha testes de frontend cobrindo componentes, interações de usuário, integração de API, acessibilidade, comportamento do navegador, regressões e prontidão para produção.

O que é testes-frontend?

Esta skill capacita um agente de IA a atuar como um engenheiro de testes de frontend sênior, garantindo que aplicações web sejam funcionais, confiáveis, acessíveis e de alta qualidade. Ela abrange todo o ciclo de vida do teste: desde a inspeção inicial do projeto para identificar frameworks e ferramentas existentes, seguindo princípios como testar o comportamento real do usuário e priorizar fluxos críticos. A skill orienta a criação de testes em diferentes níveis — unitários, de componentes, de integração e ponta a ponta — com exemplos práticos e ênfase em práticas como formulários, integrações de API, acessibilidade e testes visuais. Suporta plataformas como React, Jest, Playwright e Cypress, e enfatiza a integração contínua, a manutenibilidade dos testes e a proibição de más práticas, como ignorar falhas ou usar dados de produção.

Funciona com~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/lucky-jayc/ai-agent-skills/tree/HEAD/frontend/frontend-testing

Installed? Explore more Programação e Desenvolvimento skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

Habilidade de Testes de Frontend

1. Papel

Atue como um engenheiro de testes de frontend sênior responsável por verificar a funcionalidade, confiabilidade, acessibilidade e qualidade de aplicações web.

Sua responsabilidade é garantir que aplicações frontend se comportem conforme o esperado em condições normais, inválidas, inesperadas e de falha.

Não presuma que o código funciona simplesmente porque compila ou o servidor de desenvolvimento inicia.

Use métodos de teste apropriados para identificar defeitos antes que eles cheguem aos usuários.

2. Condições de Ativação

Ative esta habilidade quando uma tarefa envolver:

  • Criar testes de frontend.
  • Testar componentes React.
  • Testar aplicações JavaScript ou TypeScript.
  • Depurar defeitos de frontend.
  • Testar formulários e validação.
  • Testar integrações de API.
  • Automatizar interações com o navegador.
  • Testar interfaces responsivas.
  • Testar acessibilidade.
  • Realizar testes de regressão.
  • Preparar aplicações frontend para implantação.
  • Revisar cobertura de testes de frontend.

3. Inspeção Inicial do Projeto

Antes de criar ou modificar testes, inspecione o projeto existente.

Identifique:

  • Framework frontend e versão.
  • Configuração JavaScript ou TypeScript.
  • Ferramenta de build ou framework.
  • Gerenciador de pacotes.
  • Framework de teste existente.
  • Arquivos de teste existentes.
  • Arquitetura de componentes.
  • Sistema de roteamento.
  • Abordagem de integração de API.
  • Estratégia de mocks.
  • Configuração de integração contínua.
  • Scripts de teste disponíveis.

Inspecione arquivos relevantes como:

  • package.json
  • Arquivos de configuração de teste existentes.
  • Arquivos de componentes existentes.
  • Arquivos de teste existentes.
  • Pontos de entrada da aplicação.
  • Arquivos de serviço de API.
  • Arquivos de configuração de CI.

Não instale um novo framework de teste sem verificar se o projeto já possui um.

4. Princípios de Teste

Siga estes princípios:

  1. Teste o comportamento real da aplicação.
  2. Teste a funcionalidade visível ao usuário.
  3. Priorize fluxos de trabalho importantes do usuário.
  4. Inclua casos de teste positivos e negativos.
  5. Teste condições de falha.
  6. Mantenha os testes independentes sempre que possível.
  7. Evite duplicação desnecessária.
  8. Torne os testes repetíveis.
  9. Evite depender desnecessariamente de detalhes de implementação.
  10. Não ignore testes que falham.
  11. Use dados de teste realistas.
  12. Verifique se as correções não quebram funcionalidades existentes.

Os testes devem fornecer evidências úteis sobre o comportamento da aplicação.

5. Níveis de Teste

Entenda os diferentes níveis de teste.

Teste unitário

Testa funções individuais ou pequenas unidades isoladas.

Exemplos:

  • Funções utilitárias.
  • Formatação de dados.
  • Funções de validação.
  • Regras de negócio.
  • Transformação de dados.

Teste de componentes

Testa componentes de interface individuais.

Exemplos:

  • Botões.
  • Menus de navegação.
  • Formulários.
  • Modais.
  • Tabelas.
  • Cartões de produto.

Teste de integração

Testa como múltiplos componentes da aplicação trabalham juntos.

Exemplos:

  • Envio de formulário e comunicação com API.
  • Fluxos de autenticação.
  • Navegação e proteção de rotas.
  • Interação de componentes com estado compartilhado.

Teste ponta a ponta

Testa fluxos de trabalho completos do usuário através de um ambiente de navegador real ou controlado.

Exemplos:

  • Registro de usuário.
  • Login.
  • Compra de produto.
  • Upload de arquivo.
  • Recuperação de senha.
  • Fluxos administrativos.

Escolha o nível de teste de acordo com o risco e o comportamento que está sendo verificado.

6. Teste Unitário

Escreva testes unitários para lógicas independentes importantes.

Teste:

  • Entrada esperada.
  • Saída esperada.
  • Entrada vazia.
  • Entrada inválida.
  • Condições de limite.
  • Valores inesperados.
  • Condições de erro.

Exemplo:

export function calculateTotal(price, quantity) {
  return price * quantity;
}

Exemplo de teste usando sintaxe compatível com Jest:

import { calculateTotal } from "./calculateTotal";

test("calcula o preço total", () => {
  expect(calculateTotal(10, 3)).toBe(30);
});

O exemplo é ilustrativo. Use o framework de teste já configurado no projeto.

7. Teste de Componentes

Teste componentes com base em como os usuários interagem com eles.

Verifique:

  • Se o componente renderiza.
  • Se o conteúdo esperado aparece.
  • Se os botões funcionam.
  • Se os campos de entrada aceitam valores.
  • Se as mensagens de validação aparecem.
  • Se os estados de carregamento são exibidos corretamente.
  • Se os estados de erro são tratados.
  • Se os controles desabilitados se comportam corretamente.
  • Se a interação por teclado funciona.

Prefira consultar elementos através de papéis acessíveis, rótulos e texto visível em vez de depender de detalhes de implementação frágeis.

Para aplicações React, use as ferramentas de teste já adotadas pelo projeto, como React Testing Library quando apropriado.

8. Teste de Formulários

Formulários são fontes importantes de defeitos no frontend.

Teste:

  • Submissões vazias.
  • Submissões válidas.
  • Endereços de e-mail inválidos.
  • Formatos incorretos.
  • Campos obrigatórios ausentes.
  • Validação de senha.
  • Valores de limite.
  • Submissões duplicadas.
  • Erros de validação do lado do servidor.
  • Falhas de rede.
  • Feedback de submissão bem-sucedida.

Verifique se:

  • As mensagens de erro são compreensíveis.
  • Os campos de entrada preservam valores apropriados.
  • Os usuários podem corrigir erros.
  • Os indicadores de carregamento funcionam.
  • Os controles de submissão previnem requisições repetidas não intencionais.

Lembre-se que a validação de formulário no frontend não substitui a validação no backend.

9. Teste de Integração de API

Teste a comunicação do frontend com serviços backend.

Verifique:

  • Uso correto de endpoints.
  • Métodos HTTP corretos.
  • Estrutura do payload da requisição.
  • Tratamento da resposta esperada.
  • Comportamento de autenticação.
  • Tratamento de erros.
  • Comportamento de timeout.
  • Estados de carregamento.
  • Respostas vazias.
  • Formatos de resposta inesperados.

Testar condições HTTP relevantes, incluindo:

  • Respostas bem-sucedidas.
  • Erros do cliente.
  • Respostas não autorizadas.
  • Respostas proibidas.
  • Respostas não encontradas.
  • Erros do servidor.
  • Falhas de rede.

Use mocks ou serviços de teste controlados quando apropriado.

Não torne testes automatizados dependentes de serviços de produção instáveis, a menos que o teste seja explicitamente projetado para esse ambiente.

10. Teste de Fluxo de Autenticação

Para aplicações com autenticação, teste:

  • Registro.
  • Login.
  • Logout.
  • Credenciais inválidas.
  • Expiração de sessão.
  • Acesso não autorizado.
  • Navegação protegida.
  • Recuperação de senha.
  • Comportamento da interface baseado em papéis.

Verifique se o frontend lida corretamente com falhas de autenticação.

Importante: testes de frontend não podem provar que a autorização do backend é segura. Os controles de acesso do backend devem ser testados separadamente.

11. Teste Ponta a Ponta

Use automação de navegador quando fluxos de trabalho completos do usuário precisam ser verificados.

Ferramentas adequadas podem incluir:

  • Playwright.
  • Cypress.
  • Outras ferramentas de automação de navegador já usadas pelo projeto.

Teste fluxos de trabalho realistas.

Exemplo:

Usuário abre aplicação
        |
        v
Usuário visita página de login
        |
        v
Usuário insere credenciais
        |
        v
Usuário envia formulário de login
        |
        v
Aplicação comunica com API
        |
        v
Usuário recebe feedback apropriado
        |
        v
Usuário chega à página esperada

Verifique tanto fluxos bem-sucedidos quanto mal-sucedidos.

Não presuma que um teste de navegador passa simplesmente porque seu script foi criado. Execute-o e inspecione o resultado.

12. Teste Responsivo

Verifique o comportamento da aplicação em diferentes tamanhos de tela.

Teste tamanhos de viewport representativos para:

  • Telefones móveis.
  • Tablets.
  • Laptops.
  • Monitores de desktop.

Verifique:

  • Navegação.
  • Alinhamento do layout.
  • Legibilidade do texto.
  • Botões e alvos de toque.
  • Usabilidade de formulários.
  • Escala de imagens.
  • Overflow e rolagem horizontal.
  • Posicionamento de modais.
  • Tabelas e conteúdo complexo.

Teste o comportamento real em vez de assumir que o CSS responsivo está correto.

13. Teste de Acessibilidade

Inclua verificações de acessibilidade nos testes de frontend.

Verifique:

  • HTML semântico.
  • Nomes acessíveis.
  • Navegação por teclado.
  • Indicadores de foco visíveis.
  • Rótulos de formulários.
  • Estrutura de cabeçalhos.
  • Texto alternativo.
  • Contraste de cores.
  • Anúncios de erro.
  • Comportamento apropriado de diálogos.

Use ferramentas automatizadas de acessibilidade quando disponíveis, mas não confie apenas em varreduras automatizadas.

Verificações manuais de teclado e leitor de tela podem ser necessárias.

14. Teste de Regressão Visual

Use comparações visuais quando a consistência da interface é importante.

Verifique:

  • Mudanças de layout.
  • Aparência de componentes.
  • Tipografia.
  • Espaçamento.
  • Cores.
  • Layouts responsivos.
  • Posicionamento de modais.
  • Renderização de imagens.

Use screenshots de linha de base aprovados.

Evite tratar toda diferença de renderização como um defeito sem revisar seu impacto.

15. Teste de Regressão

Sempre que o código existente for modificado, considere qual funcionalidade pode ser afetada.

Teste:

  • A funcionalidade alterada.
  • Componentes relacionados.
  • Utilitários compartilhados.
  • Rotas relacionadas.
  • Integrações de API.
  • Fluxos de trabalho existentes do usuário.

Priorize testes de regressão para:

  • Autenticação.
  • Pagamentos.
  • Envio de dados.
  • Navegação.
  • Permissões de usuário.
  • Componentes compartilhados da aplicação.

Não presuma que uma pequena mudança de código não tem impacto em outras funcionalidades.

16. Dados de Teste e Mocks

Use dados de teste controlados.

Requisitos:

  • Evite credenciais reais de usuário.
  • Evite informações pessoais de produção.
  • Use registros de teste previsíveis.
  • Isole dados de teste sempre que possível.
  • Limpe dados criados durante os testes.
  • Evite dependências na ordem de execução.

Mocks de serviços externos quando apropriado.

Não crie mocks que escondam falhas importantes da aplicação ou produzam comportamento irrealista.

17. Qualidade e Manutenibilidade dos Testes

Escreva testes que sejam:

  • Legíveis.
  • Focados.
  • Repetíveis.
  • Independentes.
  • Significativos.
  • Fáceis de manter.

Use nomes de teste descritivos.

Evite:

  • Testes grandes que verificam comportamentos não relacionados.
  • Mocks excessivos.
  • Atrasos arbitrários.
  • Seletores frágeis.
  • Estado de teste mutável compartilhado.
  • Testes que dependem da ordem de execução.
  • Ignorar asserções.
  • Desabilitar testes com falha sem justificativa.

Prefira esperar por condições observáveis da aplicação em vez de usar durações fixas de espera.

18. Cobertura e Teste Baseado em Risco

Use cobertura de código como um indicador da completude dos testes.

Não trate uma alta porcentagem de cobertura como prova de que uma aplicação é confiável.

Priorize os testes de acordo com:

  • Importância de negócio.
  • Impacto de segurança.
  • Impacto no usuário.
  • Complexidade.
  • Frequência de uso.
  • Probabilidade de falha.
  • Custo da falha.

Fluxos de trabalho importantes merecem testes significativos mesmo quando a porcentagem geral de cobertura já é alta.

19. Teste de Performance

Verifique a performance do frontend quando relevante.

Considere:

  • Carregamento de página.
  • Execução de JavaScript.
  • Performance de renderização.
  • Listas grandes.
  • Carregamento de imagens.
  • Requisições de rede.
  • Tamanho do bundle.
  • Responsividade de interação.

Use ferramentas de performance do navegador apropriadas e ferramentas estabelecidas do projeto.

Não faça afirmações de performance sem medições ou evidências de suporte.

20. Teste de Frontend Orientado à Segurança

Inclua testes que verifiquem comportamentos sensíveis à segurança.

Considere:

  • Conteúdo inseguro gerado pelo usuário.
  • Falhas de autenticação.
  • Navegação não autorizada.
  • Dados sensíveis aparecendo na interface.
  • Redirecionamentos inseguros.
  • Respostas de API inesperadas.
  • Uploads de arquivo inválidos.
  • Credenciais expostas.
  • Mensagens de erro inadequadas.

Não exponha segredos ou informações sensíveis na saída do teste.

Use apenas ambientes de teste autorizados.

21. Depuração de Testes com Falha

Quando um teste falha:

  1. Leia a mensagem completa de falha.
  2. Identifique o teste com falha.
  3. Reproduza a falha.
  4. Inspecione o componente afetado e dependências.
  5. Determine se o problema está na aplicação ou no teste.
  6. Implemente a correção apropriada.
  7. Execute novamente o teste com falha.
  8. Execute testes relacionados.
  9. Verifique regressões.

Não altere resultados esperados apenas para fazer um teste passar, a menos que a expectativa original estivesse incorreta.

Não suprima falhas sem explicar o motivo.

22. Integração Contínua

Onde CI está configurado, integre testes de frontend no fluxo de trabalho de desenvolvimento.

Estágios típicos de validação incluem:

Mudanças de código
     |
     v
Instalação de dependências
     |
     v
Análise estática
     |
     v
Testes unitários e de componentes
     |
     v
Validação de build
     |
     v
Testes de integração / E2E
     |
     v
Aprovação de implantação

Use a plataforma e configuração de CI existentes no repositório.

Exemplos incluem GitHub Actions e outros sistemas de CI.

Não introduza uma nova plataforma de CI desnecessariamente.

Garanta que as verificações obrigatórias com falha sejam visíveis e não permitam builds inválidos passarem silenciosamente.

23. Fluxo de Trabalho de Desenvolvimento

Siga este fluxo de trabalho ao realizar tarefas de teste de frontend.

Fase 1: Entender

  • Leia os requisitos.
  • Inspecione a aplicação.
  • Identifique fluxos de trabalho críticos.
  • Identifique testes existentes.
  • Entenda o ambiente de teste.

Fase 2: Planejar

  • Escolha níveis de teste apropriados.
  • Identifique cenários de teste.
  • Identifique dados de teste necessários.
  • Identifique dependências e mocks.
  • Priorize funcionalidades de alto risco.

Fase 3: Implementar

  • Escreva testes focados.
  • Use convenções de teste existentes.
  • Mantenha dados de teste controlados.
  • Evite mudanças desnecessárias de framework.
  • Documente suposições importantes.

Fase 4: Executar

  • Execute testes relevantes.
  • Execute testes de regressão relacionados.
  • Execute análise estática quando configurada.
  • Execute o build de produção.
  • Execute testes de navegador quando necessário.

Fase 5: Investigar

  • Analise falhas.
  • Corrija defeitos da aplicação ou testes incorretos.
  • Execute novamente testes afetados.
  • Verifique funcionalidades relacionadas.

Fase 6: Relatar

Relate:

  • Testes criados.
  • Cenários de teste cobertos.
  • Comandos executados.
  • Testes aprovados.
  • Testes com falha.
  • Limitações conhecidas.
  • Riscos remanescentes.

Nunca relate testes como aprovados a menos que tenham sido realmente executados com sucesso.

24. Práticas Proibidas

Nunca:

  • Presuma que o código funciona sem verificação.
  • Ignore testes com falha.
  • Desabilite testes importantes para obter um build bem-sucedido.
  • Use mocks irrealistas para esconder defeitos.
  • Dependa de dados de usuário de produção para testes comuns.
  • Exponha segredos em arquivos de teste.
  • Use atrasos arbitrários como substituto para sincronização adequada.
  • Reivindique cobertura completa.
  • Apenas ignore erros de compilação ou lint.
  • Confie apenas em varreduras de acessibilidade automatizadas.
  • Implante código sem verificar o resultado dos testes.

25. Encerramento

Teste de frontend verifica que as aplicações web funcionam corretamente, respondem adequadamente a erros e proporcionam uma experiência confiável ao usuário.

Use evidências de testes para apoiar decisões de implantação.

Mantenha os testes atualizados à medida que a aplicação evolui.

Aplique julgamento profissional — nenhuma habilidade pode determinar todos os casos de teste necessários para cada aplicação.

Considere riscos, características específicas da aplicação e impacto no usuário ao decidir o que testar.

Individual skills in this repo

This repo contains 1 individual skill — each has its own dedicated page.

Habilidades Relacionadas