O que é teste de integração?

Question

Accepted Answer

**Teste de integração** verifica que múltiplos **componentes ou unidades funcionam corretamente em conjunto** — testando as interações e pontos de integração (como código com um banco de dados, serviços se chamando, ou módulos combinados). Detecta problemas que testes unitários (que isolam unidades) não conseguem.

## O que o teste de integração verifica

```text
Integration tests verify COMPONENTS WORKING TOGETHER (not in isolation):
  → code + DATABASE (does the data layer actually work with a real DB?)
  → service A calling service B / an external API
  → multiple modules/units combined; the integration POINTS between them
→ catches issues in how parts INTERACT — which unit tests (isolated) can't catch.
```

## Por que testes de integração são importantes (vs testes unitários)

```text
UNIT tests isolate units (mocking dependencies) → fast, but DON'T verify real integration:
  → a unit can pass its tests but FAIL when combined (wrong assumptions about a dependency,
    a real DB query that's wrong, an API contract mismatch, config issues)
INTEGRATION tests use REAL (or realistic) dependencies → catch these interaction bugs:
  → wiring/configuration errors, data layer issues, contract mismatches between components
→ Integration tests verify the parts actually work TOGETHER.
```

## Exemplo e considerações

```js
// integration test: the repository actually works with a (test) database
test('UserRepository saves and retrieves a user', async () => {
  const repo = new UserRepository(testDb);     // REAL test database
  await repo.save({ name: 'Ann' });
  const user = await repo.findByName('Ann');    // real query
  expect(user.name).toBe('Ann');
});
```

```text
→ SLOWER than unit tests (real I/O, setup); use a TEST database/environment
→ Test important integration points (data access, key service interactions, APIs)
→ Fewer than unit tests (the pyramid middle); manage test data/state carefully
```

## Por que isso importa

Entender teste de integração é importante porque **detecta uma classe de bugs que testes unitários não conseguem** — problemas em como componentes funcionam em conjunto — portanto é conhecimento valioso para testes abrangentes.

Enquanto testes unitários verificam unidades individuais isoladamente (mockando dependências), esse isolamento significa que **não conseguem verificar integração real**: uma unidade pode passar em todos seus testes mas falhar quando realmente combinada com outras (devido a suposições incorretas sobre uma dependência, uma consulta a banco de dados real estar incorreta, incompatibilidade de contrato de API, ou problemas de configuração). **Testes de integração** preenchem essa lacuna testando **componentes funcionando em conjunto com dependências reais (ou realistas)** — verificando que código realmente funciona com um banco de dados real, que serviços interagem corretamente, e que pontos de integração funcionam — detectando os bugs de conexão, camada de dados e contrato que testes unitários isolados não conseguem.

Entender essa relação complementar (testes unitários para lógica isolada, testes de integração para interações reais) é fundamental para testes abrangentes, já que nenhum deles sozinho é suficiente.

Entender as **considerações** — que testes de integração são mais lentos (I/O real e setup, então ficam no meio da pirâmide com menos testes que unitários), usam bancos de dados/ambientes de teste, focam em pontos de integração importantes (acesso a dados, interações-chave entre serviços, APIs), e requerem gerenciamento cuidadoso de dados de teste/estado — reflete a prática de testes de integração.

Testes de integração proporcionam confiança de que as partes montadas funcionam, o que testes unitários sozinhos não conseguem fornecer.

Como aplicações reais são compostas de componentes interagindo e bugs de integração (problemas de banco de dados, incompatibilidades de contrato, erros de configuração) são comuns e não detectados por testes unitários, e como testes de integração os detectam verificando que componentes funcionam em conjunto, entender teste de integração é conhecimento valioso, relevante na prática — um complemento essencial aos testes unitários que detecta bugs de interação, importante para testes abrangentes que verificam não apenas unidades isoladas mas que as partes do sistema realmente funcionam em conjunto corretamente.