🧪 Testes Automatizados com IA

📊 O Impacto Real dos Testes em Projetos de Vibe Coding

📋 Exemplo Completo: Função → Prompt → Testes Gerados

// src/utils/calculateDiscount.ts
export function calculateDiscount(
  price: number,
  discountPercent: number
): number {
  if (price <= 0) throw new Error('Price must be positive');
  if (discountPercent < 0 || discountPercent > 100)
    throw new Error('Discount must be between 0 and 100');
  const discounted = price * (1 - discountPercent / 100);
  return Math.round(discounted * 100) / 100;
}

"Gere testes unitários completos para @src/utils/calculateDiscount.ts

Requisitos:
1. Casos felizes: 10%, 50%, 100% de desconto
2. Edge cases: desconto 0, preço negativo, desconto >100, tipo errado
3. Precisão: R$100 com 33.333% de desconto deve arredondar corretamente
4. Use Vitest. Descrições em português. Organize em describe blocks."

// src/utils/calculateDiscount.test.ts
import { describe, it, expect } from 'vitest';
import { calculateDiscount } from './calculateDiscount';

describe('calculateDiscount', () => {
  describe('casos felizes', () => {
    it('aplica 10% de desconto corretamente', () => {
      expect(calculateDiscount(100, 10)).toBe(90);
    });
    it('aplica 50% de desconto corretamente', () => {
      expect(calculateDiscount(200, 50)).toBe(100);
    });
    it('aplica 100% de desconto (produto gratuito)', () => {
      expect(calculateDiscount(150, 100)).toBe(0);
    });
    it('arredonda para 2 casas decimais', () => {
      expect(calculateDiscount(100, 33.333)).toBe(66.67);
    });
  });

  describe('edge cases — erros esperados', () => {
    it('lança erro para preço negativo', () => {
      expect(() => calculateDiscount(-10, 10))
        .toThrow('Price must be positive');
    });
    it('lança erro para preço zero', () => {
      expect(() => calculateDiscount(0, 10))
        .toThrow('Price must be positive');
    });
    it('lança erro para desconto acima de 100%', () => {
      expect(() => calculateDiscount(100, 101))
        .toThrow('Discount must be between 0 and 100');
    });
    it('lança erro para desconto negativo', () => {
      expect(() => calculateDiscount(100, -5))
        .toThrow('Discount must be between 0 and 100');
    });
  });
});

🔗 Exemplo: Teste de Integração para Endpoint de Pedidos

// src/routes/orders.integration.test.ts
import request from 'supertest';
import { app } from '../app';
import { db } from '../lib/database';
import { createTestUser, generateToken } from '../test/helpers';

describe('POST /api/orders', () => {
  let testToken: string;
  let testUserId: string;

  beforeAll(async () => {
    const user = await createTestUser({ email: 'test@example.com' });
    testUserId = user.id;
    testToken = generateToken(user);
  });

  beforeEach(async () => {
    await db.orders.deleteMany({ where: { userId: testUserId } });
  });

  afterAll(async () => {
    await db.users.delete({ where: { id: testUserId } });
    await db.$disconnect();
  });

  it('cria pedido com produtos válidos e retorna 201', async () => {
    const res = await request(app)
      .post('/api/orders')
      .set('Authorization', `Bearer ${testToken}`)
      .send({ items: [{ productId: 'prod_001', quantity: 2 }] });

    expect(res.status).toBe(201);
    expect(res.body).toMatchObject({
      id: expect.any(String),
      status: 'pending',
      total: expect.any(Number),
      userId: testUserId,
    });

    // Verifica persistência no banco
    const saved = await db.orders.findUnique({ where: { id: res.body.id } });
    expect(saved).not.toBeNull();
    expect(saved?.userId).toBe(testUserId);
  });

  it('retorna 401 sem token de autenticação', async () => {
    const res = await request(app)
      .post('/api/orders')
      .send({ items: [{ productId: 'prod_001', quantity: 1 }] });
    expect(res.status).toBe(401);
  });

  it('retorna 422 com carrinho vazio', async () => {
    const res = await request(app)
      .post('/api/orders')
      .set('Authorization', `Bearer ${testToken}`)
      .send({ items: [] });
    expect(res.status).toBe(422);
    expect(res.body.error).toContain('items');
  });
});

🎭 Playwright Gerado pela IA — Fluxo de Login

Output gerado a partir do prompt abaixo

// e2e/auth/login.spec.ts
import { test, expect } from '@playwright/test';

test.describe('Fluxo de Login', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('/login');
  });

  test('login com credenciais válidas redireciona para dashboard', async ({ page }) => {
    await page.getByTestId('input-email').fill('user@example.com');
    await page.getByTestId('input-password').fill('SenhaSegura123');
    await page.getByTestId('btn-submit').click();

    await expect(page).toHaveURL('/dashboard', { timeout: 5000 });
    await expect(page.getByTestId('user-greeting')).toBeVisible();
  });

  test('exibe erro para credenciais inválidas', async ({ page }) => {
    await page.getByTestId('input-email').fill('wrong@example.com');
    await page.getByTestId('input-password').fill('senhaerrada');
    await page.getByTestId('btn-submit').click();

    await expect(page.getByTestId('error-message')).toBeVisible();
    await expect(page.getByTestId('error-message'))
      .toContainText('Credenciais inválidas');
    await expect(page).toHaveURL('/login');
  });

  test('botão de submit fica desabilitado com campos vazios', async ({ page }) => {
    await expect(page.getByTestId('btn-submit')).toBeDisabled();
  });

  test('redireciona para /dashboard se já autenticado', async ({ browser }) => {
    const context = await browser.newContext({
      storageState: 'e2e/auth/logged-in.json' // estado salvo
    });
    const page = await context.newPage();
    await page.goto('/login');
    await expect(page).toHaveURL('/dashboard');
  });
});

🔄 Processo em 3 Passos

"Escreva testes para uma função validatePassword que:
- Aceita senhas com 8+ caracteres
- Exige ao menos uma maiúscula e uma minúscula
- Exige ao menos um número
- Rejeita espaços em branco
- Retorna { valid: boolean, errors: string[] }

NÃO implemente a função ainda. Apenas os testes."

// password.test.ts — gerado, todos falhando inicialmente
it('aceita senha válida "MinhaSenh4"', () => {
  expect(validatePassword('MinhaSenh4')).toEqual({ valid: true, errors: [] });
});
it('rejeita senha sem número', () => {
  const result = validatePassword('SenhaSemNum');
  expect(result.valid).toBe(false);
  expect(result.errors).toContain('Deve conter ao menos um número');
});
// ... mais 8 testes cobrindo todos os requisitos

"Agora implemente validatePassword em TypeScript
de forma que @src/utils/password.test.ts passe
completamente. Execute npm run test para verificar
antes de finalizar. Não modifique os testes."

📊 Targets de Cobertura por Camada

⚙️ GitHub Action para Relatório de Cobertura

# .github/workflows/coverage.yml
name: Coverage Report

on:
  pull_request:
    branches: [main]

jobs:
  coverage:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: '22'
          cache: 'npm'

      - run: npm ci

      - name: Run tests with coverage
        run: npm run test:coverage
        env:
          DATABASE_URL: ${{ secrets.TEST_DATABASE_URL }}

      - name: Upload to Codecov
        uses: codecov/codecov-action@v4
        with:
          token: ${{ secrets.CODECOV_TOKEN }}
          fail_ci_if_error: true

      - name: Comment coverage on PR
        uses: davelosert/vitest-coverage-report-action@v2
        # Adiciona comentário no PR com diff de cobertura

🔬 Protocolo de Debugging em 4 Passos