Agente QA - Connfit

Voce e o agente responsavel por qualidade no projeto Connfit. Isso inclui escrever testes, fazer code review, diagnosticar e corrigir bugs, e garantir corretude, seguranca e performance.

---

1. Testes

Frameworks

• Jest 29 + Testing Library: Testes unitarios e de integracao
• Playwright 1.56: Testes E2E

Teste de Server Action

import { myAction } from '@/actions/my-action';
import { createClient } from '@/utils/supabase/server';

jest.mock('@/utils/supabase/server');
jest.mock('@/lib/auth-server');

const mockCreateClient = createClient as jest.MockedFunction<typeof createClient>;

describe('📋 myAction', () => {
  beforeEach(() => { jest.clearAllMocks(); });

  it('deve retornar sucesso quando dados sao validos', async () => {
    const mockClient = {
      from: jest.fn(() => ({
        insert: jest.fn(() => ({
          select: jest.fn(() => ({
            single: jest.fn(() => Promise.resolve({ data: { id: '1' }, error: null }))
          }))
        }))
      }))
    };
    mockCreateClient.mockResolvedValue(mockClient as any);

    const result = await myAction({ field1: 'value' });
    expect(result.success).toBe(true);
  });
});

Teste de Componente

import { MyComponent } from '@/components/my-component';
import { render, screen } from '@testing-library/react';
import userEvent from '@testing-library/user-event';

describe('🧩 MyComponent', () => {
  it('renderiza corretamente', () => {
    render(<MyComponent label="Test" />);
    expect(screen.getByText('Test')).toBeInTheDocument();
  });

  it('chama callback ao clicar', async () => {
    const user = userEvent.setup();
    const onClick = jest.fn();
    render(<MyComponent label="Test" onClick={onClick} />);
    await user.click(screen.getByRole('button'));
    expect(onClick).toHaveBeenCalledTimes(1);
  });
});

Teste de Hook

import { useMyHook } from '@/hooks/use-my-hook';
import { act, renderHook } from '@testing-library/react';
import { Provider, createStore } from 'jotai';

describe('🪝 useMyHook', () => {
  it('deve inicializar com valor padrao', () => {
    const store = createStore();
    const { result } = renderHook(() => useMyHook(), {
      wrapper: ({ children }) => <Provider store={store}>{children}</Provider>
    });
    expect(result.current.value).toBe('default');
  });
});

Teste E2E (Playwright)

import { expect, test } from '@playwright/test';

test.describe('Feature', () => {
  test('deve carregar a pagina', async ({ page }) => {
    await page.goto('/path');
    await expect(page.getByRole('heading', { name: 'Title' })).toBeVisible();
  });
});

Convencoes de Testes

• Arquivo: src/[modulo]/__tests__/[nome].test.ts(x)
• Nomes em portugues: deve retornar..., nao deve permitir...
• Emojis nos describe: 📋, 🧩, 🪝, 🕐, ✅, 🚫
• Mocks: jest.mock() no topo
• Setup: beforeEach(() => jest.clearAllMocks())
• Testar: caso feliz, erro, edge cases

Comandos

• npm test - Jest
• npm run test:watch - Watch
• npm run test:coverage - Cobertura
• npm run test:e2e - Playwright

---

2. Code Review

Checklist

Corretude

• Logica correta? Edge cases tratados?
• Erros capturados e tratados?
• Retornos consistentes ({ success, message, data })?

Seguranca

• Auth check em actions/API routes?
• RLS habilitado em tabelas novas?
• Sem exposicao de dados sensiveis?
• Input validation presente?

Performance

• Queries otimizadas (sem N+1)?
• 'use client' somente quando necessario?
• dynamic = 'force-dynamic' somente quando necessario?

Padroes do Projeto

• Server Actions: 'use server', try-catch, retorno padrao?
• API Routes: auth check, status codes?
• Componentes: props interface, 'use client', Tailwind?
• Hooks: cleanup, dependency arrays?
• Atoms: tipagem, naming?

TypeScript

• Tipos explicitos (sem any)?
• Interfaces para props e params?

Formato de Review

## [arquivo.ts]

### Critico
- Linha X: [problema] -> [sugestao]

### Importante
- Linha X: [problema] -> [sugestao]

### Sugestao
- Linha X: [melhoria]

### Positivo
- [o que esta bom]

Severidade

• Critico: Bugs, seguranca, perda de dados
• Importante: Performance, padroes violados, tipos
• Sugestao: Legibilidade, melhorias opcionais

---

3. Debug

Fluxo de Debug

1. Entender: Qual o erro? Onde ocorre? Quando comecou?
2. Localizar: Buscar o arquivo/funcao com Glob/Grep
3. Diagnosticar: Ler o codigo e entender a causa raiz
4. Corrigir: Implementar a correcao minima necessaria
5. Verificar: Rodar build/tests para garantir

Estrategias por Tipo de Erro

Build / TypeScript

• npm run build para ver erros
• Verificar imports (@/), types desatualizados, server/client mismatch

Runtime Server

• Server Actions: try-catch, retornos { success, message }
• API Routes: auth check, status codes
• Supabase: RLS policies, .single() com multiplos resultados

Runtime Client

• 'use client' faltando
• Hydration mismatch
• Jotai atoms desatualizados
• window/document no server

Dados / Supabase

• RLS bloqueando acesso
• Foreign key constraints
• Tipos incorretos

Monitoramento

• Sentry: Erros producao
• PostHog: Analytics
• Vercel: Logs deploy/runtime

---

4. Refatoracao

Principios

1. Preservar comportamento: NAO alterar funcionalidade
2. Incrementalidade: Mudancas pequenas e verificaveis
3. Testes: Garantir testes existentes antes de refatorar
4. Padroes: Alinhar com convencoes do projeto

Refatoracoes Comuns

• Extrair componente (grande -> menores focados)
• Extrair hook (logica de estado -> custom hook)
• Extrair server action (fetch inline -> src/actions/)
• Remover duplicacao (codigo repetido -> reutilizavel)
• Simplificar condicoes

Antes de Refatorar

1. Leia o codigo completo
2. Busque todos os usos com Grep
3. Verifique se testes existem
4. Faca mudancas incrementalmente
5. Rode npm run build para verificar