---
title: Testes e depuração
description: Fluxos de trabalho de testes e depuração com Verdent
---
Verdent for VS Code ajuda você a escrever testes abrangentes e depurar problemas por meio de ciclos multipass de gerar-testar-reparar, análise de erros e melhorias automatizadas na cobertura de testes. Gere testes unitários, de integração e de ponta a ponta que correspondam ao framework e ao estilo de testes do seu projeto.
### O que você vai aprender
- Gerar testes unitários cobrindo casos extremos e comportamento esperado
- Trabalhar com todos os principais frameworks de teste (Jest, Pytest, JUnit etc.)
- Criar testes de integração verificando fluxos de trabalho com múltiplos componentes
- Melhorar a cobertura de testes identificando e testando caminhos de código não cobertos
- Depurar problemas usando análise de mensagens de erro e rastreamento de execução
- Diagnosticar bugs a partir de stack traces, logs de erro e comportamento inesperado
### Pré-requisitos
Antes de testar e depurar com Verdent:
- Visual Studio Code com a extensão Verdent instalada
- Uma base de código ou espaço de trabalho de projeto aberto no VS Code
- Plano de assinatura Verdent ativo com créditos disponíveis
- Framework de testes configurado no seu projeto (opcional para geração de testes)
---
## Escrevendo testes unitários
Verdent gera testes unitários que correspondem ao framework e ao estilo de testes do seu projeto. Ele analisa os testes existentes para entender seus padrões e, em seguida, gera testes com a configuração, asserções e mocking adequados.
**Exemplo:**
```
Write unit tests for the calculateDiscount function
```
Verdent vai:
- Examinar a implementação da função `calculateDiscount`
- Identificar parâmetros de entrada e valores de retorno
- Analisar os testes existentes para corresponder às suas convenções (estrutura de testes, estilo de asserção, padrões de nomenclatura)
- Gerar testes cobrindo:
- **Caminho feliz**: entradas válidas com saídas esperadas
- **Casos extremos**: valores de limite, zero, números negativos, valores máximos
- **Entradas inválidas**: null, undefined, tipos errados
- **Comportamento esperado**: validação da lógica de negócio
**Estrutura do teste gerado:**
Verdent cria testes seguindo os padrões do seu projeto:
- **Organização do conjunto de testes**: blocos describe, classes de teste ou estrutura de módulo
- **Setup e teardown**: hooks before/after que correspondem aos seus testes existentes
- **Asserções**: usando a biblioteca de asserção do seu projeto (expect, assert, should etc.)
- **Mocking**: correspondendo aos seus padrões de mocking (jest.mock, sinon, unittest.mock)
- **Convenções de nomenclatura**: nomes de teste seguindo o estilo que você estabeleceu
**Ciclos multipass de gerar-testar-reparar:**
Para testes abrangentes, Verdent usa ciclos multipass:
1. **Gerar**: criar o conjunto de testes inicial
2. **Executar**: rodar os testes para verificar se funcionam
3. **Reparar**: corrigir testes que falham ou melhorar a cobertura
4. **Iterar**: repetir até que os testes passem e a cobertura seja suficiente
Isso garante que os testes não apenas sejam escritos, mas funcionem corretamente com sua base de código.
Verdent analisa os testes existentes para corresponder às suas convenções. Quanto mais consistentes forem seus padrões de teste existentes, melhor os testes gerados pelo Verdent se alinharão ao estilo do seu projeto.
---
## Frameworks de teste suportados
Verdent suporta todos os principais frameworks de teste em diferentes linguagens de programação e stacks de tecnologia, sem exigir configuração adicional.
**Frameworks de teste unitário:**
```javascript Jest
test('sum returns correct result', () => {
expect(sum(2, 3)).toBe(5);
});
```
```javascript Mocha
const assert = require('assert');
describe('sum', () => {
it('returns correct result', () => {
assert.strictEqual(sum(2, 3), 5);
});
});
```
```javascript Vitest
import { describe, it, expect } from 'vitest';
it('sum returns correct result', () => {
expect(sum(2, 3)).toBe(5);
});
```
```javascript Jasmine
describe('sum', () => {
it('returns correct result', () => {
expect(sum(2, 3)).toEqual(5);
});
});
```
**Testes específicos de framework:**
- **React Testing Library** - Teste de componentes React centrado no usuário
- **Vue Test Utils** - Biblioteca de testes oficial do Vue.js
**Testes de ponta a ponta:**
- **Cypress** - Testes de ponta a ponta e de componentes
- **Playwright** - Testes de ponta a ponta entre navegadores
- **Puppeteer** - Testes em Chrome headless
- **Pytest** - Framework de testes mais popular do Python
- **unittest** - Framework de testes embutido do Python
- **nose2** - Estende o unittest com plugins
- **doctest** - Testes embutidos em docstrings
Verdent gera testes com fixtures, parametrização e padrões de asserção adequados, correspondendo ao seu estilo de testes em Python.
- **JUnit** - Framework de testes padrão do Java (JUnit 4, JUnit 5)
- **TestNG** - Framework de testes com recursos avançados
- **Mockito** - Framework de mocking para Java
- **AssertJ** - Biblioteca de asserção fluente
Verdent cria testes com anotações, métodos de ciclo de vida e asserções seguindo as convenções de testes do Java.
- **RSpec** (Ruby) - Framework de desenvolvimento orientado a comportamento
- **PHPUnit** (PHP) - Framework de testes unitários para PHP
- **Go testing** (Go) - Pacote de testes embutido do Go
- **xUnit** (C#/.NET) - Framework de testes para .NET
- **Catch2** (C++) - Framework de testes moderno para C++
Verdent se adapta aos idiomas de teste da sua linguagem e gera testes que correspondem às convenções do seu projeto.
Verdent reconhece seu framework de testes a partir da configuração do projeto e dos testes existentes, gerando automaticamente testes que correspondem à sua configuração.
---
## Gerando testes de integração
Verdent gera testes de integração que verificam como múltiplos componentes, serviços ou módulos funcionam em conjunto. Ele cria testes simulando fluxos de trabalho reais, incluindo interações de API, operações de banco de dados, fluxos de autenticação e jornadas de usuário com várias etapas.
**Exemplo:**
```
Write integration tests for the user registration flow
```
Verdent gera testes que verificam o fluxo completo:
1. **Envio do formulário**: o usuário envia o formulário de cadastro com dados válidos
2. **Validação**: o backend valida o formato do e-mail, a força da senha e a completude dos dados
3. **Inserção no banco de dados**: o registro do usuário é criado no banco de dados
4. **Envio de e-mail**: o e-mail de confirmação é enviado (mockado ou real)
5. **Login bem-sucedido**: o novo usuário pode fazer login imediatamente com as credenciais
**Estrutura do teste de integração:**
Verdent cria testes de integração com:
- **Setup do teste**: população do banco de dados, inicialização de serviços, criação de dados de teste
- **Simulação do fluxo de trabalho**: operações de várias etapas em sequência
- **Verificação de estado**: checagem do estado do banco de dados, respostas de API, efeitos colaterais
- **Mocking de serviços externos**: serviços de e-mail, APIs de pagamento, integrações de terceiros
- **Teardown do teste**: limpeza dos dados de teste, rollback do banco de dados, encerramento de serviços
**Exemplos de cenários de teste:**
```
Write integration tests for the checkout and payment process
```
Verdent testa:
- Adição de itens ao carrinho
- Aplicação de códigos de desconto
- Cálculo de totais com impostos e frete
- Processamento de pagamento (com gateway de pagamento mockado)
- Criação do registro de pedido no banco de dados
- Envio do e-mail de confirmação
- Atualização do estoque
**Isolamento de testes:**
Verdent garante que os testes de integração sejam devidamente isolados:
- Cada teste começa com um estado de banco de dados limpo
- As chamadas a serviços externos são mockadas para evitar efeitos colaterais
- Os testes podem ser executados em qualquer ordem, sem dependências
- A limpeza ocorre mesmo que os testes falhem
Testes de integração se beneficiam de ambientes de teste isolados; Verdent pode ajudar a configurar fixtures de banco de dados e mockar serviços externos.
Testes de integração verificam se os componentes funcionam corretamente em conjunto. Eles são mais complexos do que os testes unitários, mas oferecem maior confiança de que os fluxos de trabalho do mundo real funcionam conforme o esperado.
---
## Melhorando a cobertura de testes
Verdent analisa sua base de código para identificar funções, ramificações e casos extremos não testados e, em seguida, gera testes para melhorar a cobertura. Ele examina seu conjunto de testes existente e identifica lacunas onde os caminhos de código não são exercitados.
**Exemplo:**
```
Analyze test coverage and write tests for uncovered code paths in the payment module
```
Verdent vai:
1. **Analisar os testes existentes**: examinar o que está atualmente testado
2. **Identificar lacunas de cobertura**: encontrar funções específicas, ramificações condicionais, caminhos de tratamento de erros e casos extremos sem testes
3. **Gerar os testes faltantes**: criar testes que tenham como alvo o código não coberto
4. **Verificar a melhoria da cobertura**: rodar os testes para confirmar o aumento da cobertura
**O que o Verdent identifica:**
- **Funções não testadas**: funções sem nenhuma cobertura de teste
- **Ramificações condicionais**: instruções if/else em que uma das ramificações não é testada
- **Caminhos de tratamento de erros**: blocos try/catch ou callbacks de erro sem testes de falha
- **Casos extremos**: valores de limite, tratamento de null/undefined, coerção de tipo
- **Pontos de integração**: chamadas de API, operações de banco de dados, interações com serviços externos
**Exemplo de melhoria de cobertura:**
```
Improve test coverage for the UserService class
```
Verdent identifica:
- `getUserById` tem testes para IDs válidos, mas não para IDs inválidos
- `updateUser` não tem testes para falhas de validação
- `deleteUser` não tem testes para verificações de autorização
- Os caminhos de tratamento de erros em `createUser` não são testados
Em seguida, gera testes que têm como alvo especificamente essas lacunas, aumentando a cobertura de 65% para 95%.
**Métricas de cobertura:**
Verdent ajuda você a alcançar percentuais de cobertura mais altos e a detectar potenciais bugs em código anteriormente não testado:
- **Cobertura de linha**: percentual de linhas de código executadas pelos testes
- **Cobertura de ramificação**: percentual de ramificações condicionais testadas
- **Cobertura de função**: percentual de funções com pelo menos um teste
- **Cobertura de instrução**: percentual de instruções executadas
---
## Depurando com Verdent
Verdent ajuda na depuração analisando mensagens de erro, rastreando o fluxo de execução, identificando causas-raiz e sugerindo correções. Cole logs de erro, descreva comportamentos inesperados ou peça ao Verdent que investigue problemas específicos.
Descreva o que está errado e o que você esperava:
```
This function returns undefined instead of the user object. Debug it.
```
Verdent vai:
- Ler a implementação da função
- Rastrear o fluxo de execução
- Identificar onde o caminho de código falha (instrução de retorno ausente, condicional incorreta, problema de async/await)
- Propor uma correção com explicação
- Sugerir casos de teste para evitar regressão
**Exemplo:**
```
The login form redirects to the home page even when credentials are invalid
```
Verdent vai:
- Examinar a lógica de envio do formulário de login
- Rastrear o fluxo de autenticação
- Identificar o bug (o redirecionamento acontece antes de a validação assíncrona ser concluída)
- Propor uma correção (aguardar a validação antes de redirecionar)
Solicite uma análise de desempenho:
```
The product search is slow when the database has 10,000+ products
```
Verdent vai:
- Analisar a implementação da consulta de busca
- Identificar a ineficiência (consultas N+1, índice de banco de dados ausente, algoritmo ineficiente)
- Sugerir otimização (adicionar índice de banco de dados, agrupar consultas, fazer cache de resultados)
A depuração de desempenho ajuda a identificar gargalos em algoritmos, consultas de banco de dados ou respostas de API que deixam seu aplicativo lento.
Entenda como o código é executado:
```
Why does this API endpoint return a 500 error when the email parameter is missing?
```
Verdent vai:
- Rastrear o tratamento da requisição do endpoint até a validação e o banco de dados
- Identificar onde ocorre o erro (acesso a propriedade de undefined)
- Explicar por que o erro acontece (verificação de null ausente antes do acesso à propriedade)
- Sugerir uma correção defensiva (validar os parâmetros antes de usá-los)
O rastreamento do fluxo de execução ajuda você a entender o caminho que seu código percorre e onde ele se desvia do comportamento esperado.
Cole mensagens de erro ou stack traces diretamente no chat. Verdent analisa o erro, localiza o código problemático e explica o que deu errado com caminhos de arquivo e números de linha específicos.
---
## Diagnosticando a partir de mensagens de erro e logs
Cole mensagens de erro, stack traces ou arquivos de log diretamente no chat. Verdent analisa o erro, identifica o arquivo de origem e o número da linha, explica a causa e sugere uma correção.
Cole mensagens de erro e stack traces:
```
TypeError: Cannot read property 'name' of undefined
at UserProfile.render (UserProfile.jsx:45)
at processComponent (react-dom.js:2103)
```
Cole isto no Verdent:
```
I'm getting this error: [paste stack trace]
```
Verdent vai:
- Identificar o tipo de erro (TypeError por acesso a null/undefined)
- Localizar a linha exata (`UserProfile.jsx:45`)
- Ler o código naquela localização
- Explicar por que está acontecendo (o objeto user é undefined antes de os dados carregarem)
- Propor correções:
- Adicionar verificação de null: `if (!user) return `
- Usar optional chaining: `user?.name`
- Garantir que os dados carreguem antes de renderizar o componente
Cole arquivos de log ou saída do console para análise:
```
Analyze these logs and tell me why the API requests are failing:
[paste 50 lines of log output]
```
Verdent vai:
- Examinar os logs em busca de padrões de erro
- Identificar falhas de autenticação, timeouts de rede ou erros de banco de dados
- Rastrear a sequência de eventos que levou à falha
- Sugerir correções com base no padrão de erro
A análise de logs ajuda a identificar padrões em várias falhas e a entender a sequência de eventos que leva aos erros.
Para problemas complexos, Verdent usa depuração em várias etapas:
1. **Analisar logs de erro** para identificar o ponto de falha
2. **Ler o código relevante** para entender a implementação
3. **Rastrear o fluxo de execução** para encontrar onde as coisas dão errado
4. **Sugerir correções** com exemplos de código
5. **Gerar testes** para evitar regressão
**Exemplo:**
```
The shopping cart total is sometimes incorrect. Here are the error logs: [paste logs]
```
Verdent vai:
1. Analisar os logs e identificar quando o bug ocorre (quando códigos de desconto são aplicados)
2. Ler a lógica de cálculo de desconto
3. Identificar o bug (o desconto é calculado antes do imposto, e não depois)
4. Propor uma correção (reordenar as etapas de cálculo)
5. Sugerir casos de teste (carrinho com desconto, carrinho com imposto, carrinho com ambos)
---
## Boas práticas
Escreva testes à medida que desenvolve recursos, não após a conclusão. Verdent pode gerar testes imediatamente após criar novas funções ou componentes.
Verdent corresponde aos padrões de teste do seu projeto. Mantenha uma estrutura de testes consistente para que o Verdent gere testes alinhados às suas convenções.
Peça ao Verdent que teste condições de limite, cenários de erro e entradas incomuns: "Escreva testes incluindo casos extremos para entradas inválidas e valores de limite."
Não parafraseie os erros. Cole o stack trace completo para um diagnóstico preciso e uma resolução mais rápida.
Ao depurar, declare claramente o que você esperava que acontecesse e o que de fato aconteceu. Esse contexto ajuda o Verdent a identificar a causa-raiz.
Para recursos críticos, solicite a geração de testes abrangentes com ciclos multipass: "Gere testes abrangentes para o módulo de pagamento e verifique se todos passam."
Após refatorar o código, solicite testes para verificar se a funcionalidade foi preservada: "Gere testes para verificar se o módulo de autenticação refatorado funciona corretamente."
Após corrigir um bug, solicite um teste para evitar regressão: "Escreva um teste que garanta que esse bug não aconteça novamente."
---
## Veja também
Aprenda a escrever novos recursos com a assistência de IA do Verdent
Melhore a qualidade do código por meio de fluxos de trabalho de refatoração seguros