Agente de Revisão Principal

Test Analyst

Garante que seus testes realmente te protejam

Testes que passam não significam que seu código funciona. Test Analyst encontra as lacunas — casos limite ausentes, testes instáveis e problemas de isolamento que deixam bugs passarem.

O Que Test Analyst Detecta

As lacunas na sua suite de testes que deixam bugs escaparem

Cobertura de Casos Limite Ausentes

O caminho feliz está testado, mas e os valores nulos, arrays vazios e condições de fronteira?

Entradas nulasColeções vaziasValores limiteCaminhos de erro

Testes Instáveis

Testes que passam às vezes e falham outras — os assassinos silenciosos da confiança em CI/CD

Dependências de tempoDependências de ordemEstado compartilhadoChamadas de rede

Isolamento de Testes Deficiente

Testes que dependem uns dos outros ou compartilham estado mutável — pesadelos de depuração

Fixtures compartilhadosPoluição de banco de dadosEstado globalBugs de ordem de testes

Todos os Tipos de Testes Cobertos

De testes unitários a E2E, Test Analyst revisa todos

Testes Unitários

Testes em nível de função e classe

Testes de Integração

Testes de interação de componentes

Testes E2E

Testes de fluxo de usuário de ponta a ponta

Testes de API

Testes de endpoints e contratos

Testes de Snapshot

Detecção de regressão de UI

Testes de Desempenho

Testes de carga e benchmark

Melhorando a Qualidade dos Testes

Exemplos reais de melhorias em testes

Caso Limite Ausente

Teste Fraco
describe('calculateDiscount', () => {
  it('applies 10% for orders over $100', () => {
    expect(calculateDiscount(150)).toBe(15)
  })

  it('applies 5% for orders over $50', () => {
    expect(calculateDiscount(75)).toBe(3.75)
  })

  // What about $0? Negative? Exactly $50? $100?
})

Testes de fronteira ausentes: $0, $50, $100, negativo

Teste Robusto
describe('calculateDiscount', () => {
  it('applies 10% for orders over $100', () => {
    expect(calculateDiscount(150)).toBe(15)
  })

  it('applies 5% for orders over $50', () => {
    expect(calculateDiscount(75)).toBe(3.75)
  })

  it('returns 0 for orders at boundary', () => {
    expect(calculateDiscount(50)).toBe(0)
    expect(calculateDiscount(100)).toBe(5) // 5% tier
  })

  it('handles zero and negative gracefully', () => {
    expect(calculateDiscount(0)).toBe(0)
    expect(calculateDiscount(-10)).toBe(0)
  })
})

Adicionar casos limite para fronteiras e entradas inválidas

Detecção de Testes Instáveis

Teste Fraco
it('shows notification after save', async () => {
  await user.click(saveButton)

  // Flaky! Depends on timing
  await waitFor(() => {
    expect(screen.getByText('Saved!')).toBeVisible()
  })

  // Even worse: arbitrary timeout
  await new Promise(r => setTimeout(r, 100))
  expect(notificationCount).toBe(1)
})

Timeouts arbitrários e suposições de tempo

Teste Robusto
it('shows notification after save', async () => {
  await user.click(saveButton)

  // Wait for specific state change
  await waitFor(() => {
    expect(screen.getByRole('alert')).toHaveTextContent('Saved!')
  })

  // Assert on observable behavior, not timing
  expect(
    await screen.findByRole('alert', { name: /saved/i })
  ).toBeVisible()
})

Esperar mudanças de estado observáveis, não tempo

Problema de Isolamento de Testes

Teste Fraco
let testUser: User

beforeAll(async () => {
  // Shared across ALL tests — mutations leak!
  testUser = await createUser({ name: 'Test' })
})

it('updates user name', async () => {
  await updateUser(testUser.id, { name: 'Updated' })
  // Now testUser.name is 'Updated' for all following tests
})

it('checks original name', () => {
  // FAILS! Previous test mutated shared state
  expect(testUser.name).toBe('Test')
})

Estado compartilhado em beforeAll vaza entre testes

Teste Robusto
describe('user updates', () => {
  let testUser: User

  beforeEach(async () => {
    // Fresh user for EACH test
    testUser = await createUser({ name: 'Test' })
  })

  afterEach(async () => {
    await deleteUser(testUser.id)
  })

  it('updates user name', async () => {
    await updateUser(testUser.id, { name: 'Updated' })
    expect(testUser.name).toBe('Updated')
  })

  it('checks original name', () => {
    // Works! Fresh testUser with original name
    expect(testUser.name).toBe('Test')
  })
})

Usar beforeEach para isolamento de testes

Análise de Testes

Como Test Analyst Funciona

Test Analyst não apenas conta testes — analisa o que eles realmente testam. Encontra as lacunas entre o que seus testes cobrem e o que seu código precisa.

Análise de Caminhos

Mapeia caminhos de código para encontrar ramificações não testadas

Detecção de Instabilidade

Identifica dependências de tempo e ordem

Sugestões de Casos Limite

Recomenda casos de teste específicos para adicionar

Pipeline de Análise

1

Analisar Cobertura de Testes

Mapeia quais caminhos de código estão testados e quais não estão

2

Identificar Pontos Fracos

Encontra casos limite e condições de erro sem testes

3

Detectar Anti-padrões

Detecta padrões instáveis e problemas de isolamento

4

Sugerir Melhorias

Recomenda casos de teste específicos para adicionar

Por Que a Qualidade dos Testes Importa

Testes ruins são piores que não ter testes — eles dão falsa confiança

Detectar Bugs Reais

Testes que cobrem casos limite detectam bugs antes dos usuários

CI/CD Confiável

Chega de "tentar até passar" — testes passam ou falham por razões reais

Refatorar com Segurança

Bons testes permitem que você mude código com confiança

100% de cobertura não significa nada se os testes não detectam bugs.
Test Analyst garante que seus testes realmente funcionem.

Testes Que Realmente
Te Protegem

Deixe Test Analyst encontrar as lacunas na sua suite de testes. Grátis por 14 dias, sem cartão de crédito necessário.

Começar Teste GratuitoVer Todos os Agentes
Detecção de casos limite
Prevenção de testes instáveis
Análise de isolamento