O que são assertions em testes?

Question

Accepted Answer

**Assertions** são instruções em um teste que **verificam se uma condição é verdadeira** — confirmando que o resultado real corresponde ao resultado esperado. Elas são o núcleo de como os testes determinam se passam ou falham: se uma assertion falha, o teste falha.

## O que as assertions fazem

```text
An ASSERTION checks that something is as expected:
  → "assert that the actual value EQUALS the expected value"
  → if TRUE → the assertion passes; if FALSE → the assertion FAILS → the TEST FAILS
→ Assertions are how a test VERIFIES behavior (the "check" part of a test).
```

## Tipos comuns de assertion

```js
// equality
expect(result).toBe(5);                  // strict equality
expect(obj).toEqual({ name: 'Ann' });    // deep/value equality (objects)

// truthiness / null
expect(value).toBeTruthy();
expect(value).toBeNull();
expect(value).toBeDefined();

// comparisons
expect(count).toBeGreaterThan(0);
expect(price).toBeLessThanOrEqual(100);

// collections / strings
expect(array).toContain('item');
expect(array).toHaveLength(3);
expect(text).toMatch(/pattern/);          // regex

// errors
expect(() => risky()).toThrow();          // expect a function to throw

// negation
expect(value).not.toBe(null);
```

## Boas assertions

```text
✓ Assert the SPECIFIC expected outcome (clear what's being checked)
✓ Use the RIGHT matcher (toBe vs toEqual; specific > generic)
✓ Clear FAILURE messages (good assertions/matchers explain what failed)
✓ Don't over-assert (test one behavior) or under-assert (verify the actual result)
```

## Por que isso importa

Compreender assertions é fundamental porque são **o mecanismo central pelo qual os testes verificam o comportamento** — determinando aprovação ou falha — portanto, é conhecimento essencial e obrigatório para escrever qualquer teste.

Uma assertion **verifica se uma condição é verdadeira** (tipicamente que um resultado real corresponde ao esperado), e é a parte de "verificação" de um teste: se uma assertion passa a verificação é bem-sucedida, e se falha o teste falha.

Sem assertions, um teste não verifica nada — então compreendê-las é fundamental para escrever testes significativos.

Compreender os **tipos comuns de assertion** — igualdade (strict `toBe` vs deep/valor `toEqual` para objetos, uma distinção importante), verificações de veracidade e nulidade, comparações, verificações de coleções e strings, assertions de erro (verificar se uma função lança exceção), e negação — é conhecimento prático necessário para expressar o que um teste deve verificar.

Compreender as **boas práticas de assertion** — verificar o resultado esperado específico (claro sobre o que é verificado), usar o matcher correto (ex: `toEqual` para comparação de objetos, não `toBe`), garantir mensagens de falha claras (para que um teste falhando explique o que deu errado), e balancear assertions (testando um comportamento, mas verificando o resultado atual) — reflete a escrita de testes claros e eficazes.

Como assertions são como cada teste verifica o comportamento (a verificação fundamental que torna um teste significativo) e compreendê-las — os tipos, os matchers corretos e boas práticas — é necessário para escrever qualquer teste que realmente verifique algo, compreender assertions é conhecimento essencial e fundamental de testes — o bloco construtivo central dos testes, necessário para expressar e verificar comportamento esperado, e fundamental para escrever testes que verificam significativamente a correção, uma competência básica para qualquer pessoa que escreva testes.