testes automatizados agentes IA · 2026-07-11

Testes automatizados com agentes de IA: Claude Code, Codex e Playwright no Windows

Guia tutorial de testes automatizados com agentes de IA. Aprenda a gerar testes unitários com Claude Code, testes de integração com Codex e testes E2E com Playwright no Windows.

Escrever testes é a parte do desenvolvimento que todo mundo sabe que deveria fazer, mas que frequentemente fica para depois. Prazos apertados, features acumuladas e a pressão por entrega contínua empurram a cobertura de testes para o fim da fila. Usar testes automatizados com agentes de IA muda esse jogo: em vez de escrever cada caso manualmente, você delega a geração para Claude Code, Codex e Playwright, e dedica seu tempo ao que realmente exige julgamento humano — revisar, ajustar e validar.

Neste tutorial prático, você vai aprender a gerar testes unitários com Claude Code e Jest, criar testes de integração com Codex, configurar testes E2E com Playwright guiado por agente, organizar tudo em uma suíte coesa e integrar o pipeline no seu CI. Tudo rodando no Windows 11, sem abstrações.

Sumário

O problema: testes manuais consomem tempo que você nao tem

Manter uma suíte de testes abrangente é um dos maiores desafios do desenvolvimento de software. Segundo levantamentos do setor, desenvolvedores gastam entre 15% e 25% do seu tempo escrevendo e mantendo testes — e ainda assim a cobertura média de projetos reais raramente ultrapassa 60%. O resultado é conhecido: código não testado acumula dívida técnica, bugs chegam à produção e refatorações viram loteria.

O problema se agrava com a adoção de agentes de IA no fluxo de desenvolvimento. Claude Code e Codex geram código em alta velocidade, mas o teste desse código raramente acompanha o mesmo ritmo. Você acelera a produção de features enquanto o gargalo da qualidade permanece no mesmo lugar.

Agentes de IA oferecem uma saída prática: eles próprios podem gerar os testes. Um teste unitário com Jest gerado por Claude Code leva segundos, não minutos. Um teste de integração com Codex cobre cenários que você nem listou. A chave é saber pedir — e saber revisar.

Imagem sugerida: Gráfico comparativo mostrando tempo gasto em testes manuais vs. tempo com agentes de IA (ex.: 25 min manual vs. 3 min com agente por função). imgs/testes-automatizados/comparativo-tempo.png

Testes unitarios com Claude Code e Jest

Claude Code é particularmente bom em entender contexto de código e gerar casos de borda que um desenvolvedor apressado ignoraria. Com o prompt certo, ele produz testes Jest completos — mocks, asserts e cenários de erro inclusos.

Setup inicial

Certifique-se de que o Jest está instalado no seu projeto:

npm install --save-dev jest @types/jest ts-jest

Configure o Jest no package.json ou em um arquivo jest.config.ts. Com o ambiente pronto, abra o Claude Code no diretório do seu projeto:

claude

Prompt para testes unitarios

O prompt ideal para gerar testes automatizados com Claude Code descreve a função alvo, o comportamento esperado e os cenários de borda:

"Gere testes unitários Jest para a função calcularFrete em src/shipping/calcularFrete.ts. A função recebe peso (kg), distancia (km) e regiao ('sul', 'nordeste', 'norte', 'sudeste', 'centro-oeste'). Regras: frete minimo R$ 10, acrescimo de 20% para regiao norte, desconto de 5% para peso acima de 50kg. Inclua casos: valores normais, frete minimo, regiao norte com peso alto, peso negativo (deve lancar erro), regiao invalida, valores zerados."

Claude Code analisa o código real da função, identifica os caminhos de execução e gera os testes:

import { calcularFrete } from './calcularFrete'; describe('calcularFrete', () => { it('deve calcular frete normal para regiao sudeste', () => { const resultado = calcularFrete(10, 100, 'sudeste'); expect(resultado).toBeCloseTo(10 * 100 * 0.05, 2); // taxa ficticia de 5% expect(resultado).toBeGreaterThanOrEqual(10); }); it('deve aplicar acrescimo de 20% para regiao norte', () => { const resultado = calcularFrete(10, 100, 'norte'); const base = 10 * 100 * 0.05; expect(resultado).toBeCloseTo(base * 1.2, 2); }); it('deve garantir frete minimo de R$ 10', () => { const resultado = calcularFrete(1, 1, 'sul'); expect(resultado).toBe(10); }); it('deve lancar erro para peso negativo', () => { expect(() => calcularFrete(-1, 100, 'sul')).toThrow(); }); it('deve lancar erro para regiao invalida', () => { expect(() => calcularFrete(10, 100, 'leste')).toThrow(); }); });

Revisão e refinamento

O valor real está na revisão. Claude Code gera a estrutura, mas cabe a você ajustar tolerâncias, nomes de testes e valores esperados. Peça refinamento com prompts como:

"Adicione casos de teste para valores decimais de peso (ex.: 0.5kg, 2.7kg) e para frete com desconto de 5% acima de 50kg."

O ciclo prompt-revisao-commit é onde o Jest com Claude Code entrega produtividade real: você revisa em 2 minutos o que levaria 15 para escrever do zero.

Imagem sugerida: Screenshot do terminal Windows mostrando Claude Code gerando testes Jest para uma funcao de frete. imgs/testes-automatizados/claude-code-jest.png

Testes de integracao com Codex

Enquanto os testes unitários validam funções isoladas, os testes de integração verificam se os componentes conversam corretamente — banco, API, filas, cache. Codex, com sua capacidade de entender APIs REST e fluxos assíncronos, é a ferramenta certa para essa camada.

Cenário: API de pedidos

Suponha uma rota POST /api/pedidos que recebe dados do pedido, valida, persiste no banco e publica um evento na fila. O teste de integração com Codex deve cobrir o fluxo completo.

Prompt para Codex:

"Gere testes de integração para a rota POST /api/pedidos em tests/integration/pedidos.test.ts. Use supertest para chamar a API, um banco de testes PostgreSQL (via testcontainers) e verifique: 1) status 201 com pedido valido, 2) status 400 com dados invalidos, 3) status 401 sem token de autenticacao, 4) status 404 para produto inexistente no pedido, 5) confirmacao de que o evento foi publicado na fila apos sucesso."

Codex produz algo como:

import request from 'supertest'; import { app } from '../../src/app'; import { setupTestDb, teardownTestDb } from './setup'; describe('POST /api/pedidos', () => { beforeAll(async () => { await setupTestDb(); }); afterAll(async () => { await teardownTestDb(); }); const token = 'Bearer test-token-valido'; it('deve criar pedido com dados validos', async () => { const response = await request(app) .post('/api/pedidos') .set('Authorization', token) .send({ clienteId: 'cli-123', itens: [{ produtoId: 'prod-456', quantidade: 2 }], formaPagamento: 'credito', }); expect(response.status).toBe(201); expect(response.body).toHaveProperty('pedidoId'); expect(response.body.status).toBe('criado'); }); it('deve rejeitar pedido sem itens', async () => { const response = await request(app) .post('/api/pedidos') .set('Authorization', token) .send({ clienteId: 'cli-123', itens: [] }); expect(response.status).toBe(400); expect(response.body.erro).toContain('itens'); }); it('deve rejeitar requisicao sem token', async () => { const response = await request(app) .post('/api/pedidos') .send({ clienteId: 'cli-123', itens: [{ produtoId: 'prod-456', quantidade: 1 }] }); expect(response.status).toBe(401); }); });

Dados de teste gerados por IA

Peça para o próprio Codex gerar os fixtures:

"Gere um arquivo tests/integration/fixtures.ts com dados de teste para cliente, produtos e pedidos. Inclua um cliente valido, um cliente sem crédito, um produto ativo, um produto inativo e um pedido parcial."

Codex gera dados realistas que cobrem os cenários que você precisa testar — sem você precisar inventar valores na mão.

Execução no Windows

No Windows, use PowerShell para rodar os testes de integração:

$env:NODE_ENV = "test" $env:DATABASE_URL = "postgresql://localhost:5432/test_db" npx jest --config jest.integration.config.ts --verbose

Codex também ajuda a configurar o testcontainers-node para subir bancos temporários, algo essencial para testes de integração confiáveis no Windows.

Imagem sugerida: Terminal mostrando a execucao de testes de integracao gerados por Codex com saida colorida (verde/vermelho). imgs/testes-automatizados/codex-integration-tests.png

Testes E2E com Playwright e agente de IA

Testes end-to-end simulam o usuário real: cliques, navegação, formulários, fluxos completos. Playwright é a ferramenta mais robusta para isso no Windows, e combinado com um agente de IA, você automatiza também a escrita dos cenários.

Configurando Playwright no Windows

npm install --save-dev @playwright/test npx playwright install

Playwright baixa os navegadores Chromium, Firefox e WebKit automaticamente. Para Windows 11, certifique-se de que o PowerShell tem permissão de execução de scripts.

Prompt para gerar testes E2E

O agente de IA (Claude Code ou Codex) precisa entender o fluxo do usuário. Forneça contexto da página:

"Gere testes E2E com Playwright para o fluxo de checkout de uma loja virtual. Cenario: 1) usuario faz login, 2) busca por 'tenis', 3) adiciona o primeiro resultado ao carrinho, 4) vai para o carrinho, 5) aplica cupom 'FRETE10', 6) preenche endereco, 7) confirma pagamento, 8) ve tela de sucesso. Use page objects. Valide cada etapa com assertions."

O resultado usando Playwright com agente de IA:

import { test, expect } from '@playwright/test'; import { LoginPage } from './pages/LoginPage'; import { BuscaPage } from './pages/BuscaPage'; import { CarrinhoPage } from './pages/CarrinhoPage'; import { CheckoutPage } from './pages/CheckoutPage'; test('fluxo completo de checkout com cupom', async ({ page }) => { const login = new LoginPage(page); const busca = new BuscaPage(page); const carrinho = new CarrinhoPage(page); const checkout = new CheckoutPage(page); await login.acessar(); await login.fazerLogin('teste@email.com', 'senha123'); await busca.pesquisar('tenis'); await busca.selecionarPrimeiroResultado(); await carrinho.verificarItemAdicionado('Tenis'); await carrinho.aplicarCupom('FRETE10'); await carrinho.verificarDescontoAplicado(); await carrinho.irParaCheckout(); await checkout.preencherEndereco({ cep: '01310-100', numero: '200', complemento: 'apto 42', }); await checkout.confirmarPagamento(); await expect(page.locator('.sucesso')).toBeVisible(); await expect(page.locator('.pedido-id')).not.toBeEmpty(); });

Page Objects com IA

Para manter a suíte sustentável, peça para o agente gerar os page objects separadamente:

"Crie uma classe LoginPage seguindo o padrao Page Object para a pagina de login em tests/e2e/pages/LoginPage.ts. Deve ter metodos para acessar a pagina, preencher email/senha e submeter o formulario. Inclua wait para a transicao de pagina."

Vantagens no Windows

Playwright roda nativamente no Windows sem dependências adicionais. Os testes E2E com agentes de IA se beneficiam disso: você pode executar a suíte completa no PowerShell, com relatórios HTML e captura de tela em cada falha.

npx playwright test --reporter=html npx playwright show-report

Imagem sugerida: Print do relatório HTML do Playwright mostrando os testes E2E gerados por IA, com status verde e capturas de tela. imgs/testes-automatizados/playwright-report.png

Organizacao e validacao da suíte de testes

Com testes gerados por três agentes diferentes, a organização da suíte é crítica. Uma estrutura recomendada para testes automatizados com agentes de IA no Windows:

tests/ unit/ shipping/ calcularFrete.test.ts users/ criarUsuario.test.ts integration/ api/ pedidos.test.ts usuarios.test.ts fixtures.ts setup.ts e2e/ pages/ LoginPage.ts CarrinhoPage.ts CheckoutPage.ts fluxos/ checkout.test.ts cadastro.test.ts

Scripts no package.json

{ "scripts": { "test": "jest", "test:unit": "jest tests/unit", "test:integration": "jest --config jest.integration.config.ts", "test:e2e": "playwright test", "test:all": "npm run test:unit && npm run test:integration && npm run test:e2e" } }

Validacao com Claude Code

Depois de gerar os testes, peça para o próprio Claude Code revisar a suíte:

"Revise todos os testes em tests/ e identifique: 1) testes que podem ser falsos positivos, 2) cenários faltando (ex.: erro de rede, timeout, concorrencia), 3) assertions muito genéricas, 4) dependencias entre testes que deveriam ser independentes."

Claude Code identifica padrões que um code review tradicional perderia — como testes que passam sem realmente validar nada porque usam toBeDefined() em vez de toEqual(valorEsperado).

Cobertura via Codex

Codex pode gerar um relatório de cobertura apontando lacunas:

"Analise a cobertura de testes do diretorio src/ e liste as funções com menos de 50% de cobertura. Para cada uma, sugira 3 cenários de teste que cobririam os caminhos nao testados."

Isso transforma a validação de cobertura de um exercício pós-facto em um processo orientado por dados.

Imagem sugerida: Diagrama da estrutura de diretorios de testes mostrando unit, integration e e2e com setas indicando o fluxo de geracao por agente. imgs/testes-automatizados/estrutura-testes.png

Pipeline CI com testes gerados por IA

De nada adianta gerar testes se eles não rodam automaticamente a cada push. Integrar a suíte no pipeline CI garante que os testes automatizados com agentes de IA sejam executados e validados continuamente.

Exemplo com GitHub Actions no Windows

name: Test Suite on: [push, pull_request] jobs: test: runs-on: windows-latest steps: - uses: actions/checkout@v4 - uses: actions/setup-node@v4 with: node-version: '20' - run: npm ci - run: npm run test:unit - run: npm run test:integration env: DATABASE_URL: ${{ secrets.TEST_DATABASE_URL }} - run: npx playwright install --with-deps - run: npm run test:e2e - uses: actions/upload-artifact@v4 if: failure() with: name: playwright-report path: playwright-report/

Regeneracao automatica de testes

Quando uma função é alterada, os testes existentes podem ficar desatualizados. Use um script no CI que detecta alterações e aciona o agente para regenerar:

"O arquivo src/shipping/calcularFrete.ts foi modificado. Compare com a versao anterior em git diff HEAD~1 -- src/shipping/calcularFrete.ts e atualize os testes em tests/unit/shipping/calcularFrete.test.ts para refletir as mudancas."

Esse ciclo mantém a suíte sincronizada com o código sem intervenção manual — o agente lê o diff, entende o que mudou e ajusta os asserts.

Gatilhos no CI com Claude Code CLI

O Claude Code CLI pode ser integrado diretamente no pipeline:

- name: Regenerar testes para funções alteradas run: | git diff --name-only HEAD~1 -- 'src/**/*.ts' | xargs -I {} claude --promret "Gere testes atualizados para {} considerando as mudancas no diff" --output tests/

Isso é particularmente útil em squads onde múltiplos desenvolvedores mexem nas mesmas funções — o agente garante que os testes sempre refletem o código atual.

Imagem sugerida: Screenshot do GitHub Actions mostrando o pipeline CI com as etapas de teste unitario, integracao e E2E passando em verde. imgs/testes-automatizados/ci-pipeline.png

FAQ — Perguntas frequentes sobre testes automatizados com agentes de IA

<div itemscope itemtype="https://schema.org/FAQPage">

<div itemscope itemprop="mainEntity" itemtype="https://schema.org/Question">

<span itemprop="name">Claude Code consegue gerar testes Jest para projetos TypeScript no Windows?</span>

<div itemscope itemprop="acceptedAnswer" itemtype="https://schema.org/Answer">

<span itemprop="text">Sim. Claude Code analisa o codigo TypeScript e gera testes Jest com tipagem completa. No Windows, certifique-se de que o ts-jest esta configurado e que o tsconfig.json aponta para o diretorio correto. Claude Code respeita as configuracões do projeto e gera imports com tipos.</span>

</div>

</div>

<div itemscope itemprop="mainEntity" itemtype="https://schema.org/Question">

<span itemprop="name">Como garantir que os testes gerados por IA nao sao falsos positivos?</span>

<div itemscope itemprop="acceptedAnswer" itemtype="https://schema.org/Answer">

<span itemprop="text">Sempre revise assertions genericas como toBeDefined() ou toBeTruthy() — elas passam mesmo com valores inesperados. Prefira toEqual(valorEsperado) com valores concretos. Use o proprio agente para revisar: peça a Claude Code para identificar assertions que podem ser falsos positivos na suite gerada.</span>

</div>

</div>

<div itemscope itemprop="mainEntity" itemtype="https://schema.org/Question">

<span itemprop="name">Preciso de uma chave de API separada para cada agente ao gerar testes?</span>

<div itemscope itemprop="acceptedAnswer" itemtype="https://schema.org/Answer">

<span itemprop="text">Sim. Claude Code usa a API da Anthropic (chave ANTHROPIC_API_KEY) e Codex usa a OpenAI (chave OPENAI_API_KEY). Playwright nao precisa de chave — ele roda localmente. Configure as variaveis de ambiente no Windows via setx ou no perfil do PowerShell para evitar expor chaves nos prompts.</span>

</div>

</div>

<div itemscope itemprop="mainEntity" itemtype="https://schema.org/Question">

<span itemprop="name">Playwright com agente de IA funciona no PowerShell do Windows 11?</span>

<div itemscope itemprop="acceptedAnswer" itemtype="https://schema.org/Answer">

<span itemprop="text">Sim. Playwright tem suporte nativo ao Windows e funciona sem WSL. Instale os navegadores com npx playwright install e execute os testes com npx playwright test. O agente de IA gera os scripts de teste, e o Playwright cuida da execucao com relatorios HTML e captura de tela.</span>

</div>

</div>

<div itemscope itemprop="mainEntity" itemtype="https://schema.org/Question">

<span itemprop="name">Como integrar testes gerados por IA no CI do GitHub Actions no Windows?</span>

<div itemscope itemprop="acceptedAnswer" itemtype="https://schema.org/Answer">

<span itemprop="text">Use o runner windows-latest no GitHub Actions. Instale as dependencias com npm ci, execute os testes unitarios com Jest e os E2E com Playwright. Para regeneracao automatica, adicione um passo que executa Claude Code CLI no diff para atualizar testes de funcoes modificadas.</span>

</div>

</div>

<div itemscope itemprop="mainEntity" itemtype="https://schema.org/Question">

<span itemprop="name">Qual a diferenca entre gerar testes com Claude Code vs. Codex?</span>

<div itemscope itemprop="acceptedAnswer" itemtype="https://schema.org/Answer">

<span itemprop="text">Claude Code entende melhor o contexto local do projeto (arquivos, dependencias, estrutura) e gera testes unitarios mais aderentes ao codigo existente. Codex e mais forte em cenarios de API e integracao, especialmente com fluxos assincronos e dados mockados. Na pratica, use Claude Code para testes unitarios e Codex para testes de integracao e geracao de fixtures.</span>

</div>

</div>

</div>

Proximos passos

Gerar testes automatizados com agentes de IA no Windows não é mais especulação — é um fluxo de trabalho testado e replicável. Claude Code cuida dos testes unitários com Jest, Codex cobre os cenários de integração com dados realistas, Playwright executa os fluxos E2E completos, e o CI fecha o ciclo com validação contínua.

O resultado: uma suíte de testes que cresce na mesma velocidade que seu código, sem que você precise escrever cada linha manualmente. Você revisa, ajusta e commit — o trabalho pesado de geracao fica com os agentes.

Quer ver seus agentes de IA trabalhando lado a lado no Windows, cada um em seu terminal, com saida em tempo real? O Orquestra foi construído para isso: um canvas infinito onde Claude Code, Codex e Playwright rodam simultaneamente, com logs centralizados e controle de sessão. Sem alternar entre janelas.

Baixe o Orquestra para Windows 11 e comece a gerar testes com IA hoje.

Posts relacionados

Referencias externas

Pronto para orquestrar seus agentes?

Baixe o Orquestra para Windows 11 e comece a coordenar seus agentes de IA em um canvas infinito. Grátis por 7 dias.

Começar teste grátis