Jest usa “matchers” para permitir que você teste valores de maneiras diferentes. A maioria das informações nesta parte é retirada dos documentos do Jest.

Correspondentes comuns

A maneira mais simples de testar um valor é com igualdade exata (toBe).

// expect(expectativa).toBe(correspondente);
test('5 mais 5 é igual a 10', () => {
  expect(5 + 5).toBe(10);
});

Neste código, expect(5 + 5) retorna um objeto “expectativa”. Você normalmente não fará muito com esses objetos de expectativa, exceto chamar correspondentes neles.
Neste código, .toBe(10) é o correspondente. Quando o Jest é executado, ele rastreia todos os matchers com falha para que possa imprimir boas mensagens de erro para você.

Em outras palavras, a expressão acima pode ser lida mais ou menos assim: espero que essa expresssão (5+5) seja (10).

toBe usa “Object .is” para testar a igualdade exata. Se você quiser verificar o valor de um objeto, use toEqual:

toEqual recursivamente verifica cada campo de um objeto ou array.

test('object assignment', () => {
  const data = {one: 1};
  data['two'] = 2;
  expect(data).toEqual({one: 1, two: 2});
});

Você também pode testar o oposto (.not) de um matcher:

test('adiciona numeros positivos que não são zero', () => {
  for (let a = 1; a < 10; a++) {
    for (let b = 1; b < 10; b++) {
      expect(a + b).not.toBe(0);
    }
  }
});

1. Veracidade

Em testes, às vezes você precisa distinguir entre indefinido, nulo e falso. Jest contém ajudantes que permitem que você seja explícito sobre o que deseja.

• toBeNull corresponde apenas a nulo
• toBeUndefined corresponde a apenas undefined
• toBeDefined o oposto de toBeUndefined
• toBeTruthy corresponde a qualquer coisa que uma instrução if trata como verdadeira
• toBeFalsy corresponde a qualquer coisa que uma instrução if trata como falsa

Por exemplo:

test('nulo', () => {
  const n = null;
  expect(n).toBeNull();
  expect(n).toBeDefined();
  expect(n).not.toBeUndefined();
  expect(n).not.toBeTruthy();
  expect(n).toBeFalsy();
});

test('zero', () => {
  const z = 0;
  expect(z).not.toBeNull();
  expect(z).toBeDefined();
  expect(z).not.toBeUndefined();
  expect(z).not.toBeTruthy();
  expect(z).toBeFalsy();
});

 PASS  __test__/sum.test.js
  √ nulo (2 ms)
  √ zero

Test Suites: 1 passed, 1 total
Tests:       2 passed, 2 total
Snapshots:   0 total
Time:        0.356 s, estimated 1 s

Nota: use o matcher que corresponda mais precisamente ao que você deseja que seu código faça.

2. Números

O Jest fornece diferentes matchers para comparar números.

test('quatro mais quatro', () => {
  const value = 4 + 4;
  expect(value).toBeGreaterThan(7);
  expect(value).toBeGreaterThanOrEqual(7.5);
  expect(value).toBeLessThan(9);
  expect(value).toBeLessThanOrEqual(8.5);

  // são equivalentes para números
  expect(value).toBe(8);
  expect(value).toEqual(8);
});

• toBeGreaterThan corresponde a ser maior (>)
• toBeGreaterThanOrEqual corresponde a ser maior ou igual(>=)
• toBeLessThan corresponde a ser menor(<)
• toBeLessThanOrEqual corresponde a a ser menor ou igual(<=)

Para igualdade de ponto flutuante, use toBeCloseTo em vez de toEqual, porque você não quer que um teste dependa de um pequeno erro de arredondamento para entender esse erro clique aqui.

test('adicionando números de ponto flutuante', () => {
  const value = 0.1 + 0.2;
  
  // Isso não vai funcionar por causa de um erro de arredondamento
 // expect(value).toBe(0.3);     
 
  expect(value).toBeCloseTo(0.3); // Isso funciona.
});

3. Strings

Jest fornece a facilidade de verificar strings em expressões regulares com toMatch:

test('não há I na palavra', () => {
  expect('Augusto').not.toMatch(/I/);
});

test('mas tem "ton" em Dallington', () => {
  expect('Dallington').toMatch(/ton/);
});
names.spec.js

4. Matriz e iteráveis

Você pode verificar se uma matriz(array) ou iterável(set) contém um item específico usando toContain :

const pokemon = [
  'Charizard',
  'Pikachu',
  'Bulbasaur',
  'Pidgeot',
  'Squirtle',
];

test('minha pokedex registrou', () => {
  expect(pokemon).toContain('Charizard');
  expect(new Set(pokemon)).toContain('Pikachu');
});
pokemon.spec.js

5. Exceções

Se você quiser testar se uma função específica gera um erro quando é chamada, o Jest fornece o matcher toThrow{.bg-gray-500 .text-gray-100}.

function registerPokemon(pokemon) {
   ...
  throw new Error('esse pokémon já foi registrado');
}

test('registra o pokémon na pokédex', () => {
  expect(() => registerPokemon('Charizard')).toThrow();
  expect(() => registerPokemon('Charizard')).toThrow(Error);

  //  Você também pode usar a mensagem exata de erro ou um regexp
  expect(() => registerPokemon('Charizard')).toThrow('esse pokémon já foi registrado');
  expect(() => registerPokemon('Charizard')).toThrow(/já foi/);
});
pokedex.spec.js

Nota: a função que lança uma exceção precisa ser invocada dentro de uma função de encapsulamento, caso contrário a asserção toThrow{.bg-gray-500 .text-gray-100} falhará.