Utilisation des matchers

Traduction Bêta Non Officielle

Cette page a été traduite par PageTurner AI (bêta). Non approuvée officiellement par le projet. Vous avez trouvé une erreur ? Signaler un problème →

Jest utilise des "matchers" pour tester des valeurs de différentes manières. Ce document présente quelques matchers couramment utilisés. Pour la liste complète, consultez la documentation de l'API expect.

Matchers courants

La manière la plus simple de tester une valeur est l'égalité exacte.

test('two plus two is four', () => {
  expect(2 + 2).toBe(4);
});

Dans ce code, expect(2 + 2) renvoie un objet "d'attente". Vous n'interagirez généralement pas beaucoup avec ces objets sauf pour y appeler des matchers. Ici, .toBe(4) est le matcher. Lorsque Jest s'exécute, il suit tous les matchers en échec pour afficher des messages d'erreur clairs.

toBe utilise Object.is pour tester l'égalité exacte. Pour vérifier la valeur d'un objet, utilisez toEqual :

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

toEqual vérifie récursivement chaque champ d'un objet ou tableau.

astuce

toEqual ignore les clés d'objet avec propriétés undefined, les éléments de tableau undefined, la parcimonie des tableaux et les incohérences de type d'objet. Pour en tenir compte, utilisez plutôt toStrictEqual.

Vous pouvez aussi tester l'inverse d'un matcher avec not :

test('adding positive numbers is not zero', () => {
  for (let a = 1; a < 10; a++) {
    for (let b = 1; b < 10; b++) {
      expect(a + b).not.toBe(0);
    }
  }
});

Véracité

Dans les tests, vous devez parfois distinguer undefined, null et false, mais parfois non. Jest propose des aides pour préciser vos intentions.

• toBeNull ne correspond qu'à null

• toBeUndefined ne correspond qu'à undefined

• toBeDefined est l'opposé de toBeUndefined

• toBeTruthy correspond à tout ce qu'une instruction if considère comme vrai

• toBeFalsy correspond à tout ce qu'une instruction if considère comme faux

Par exemple :

test('null', () => {
  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();
});

Utilisez le matcher correspondant le plus précisément à l'intention de votre code.

Nombres

La plupart des méthodes de comparaison numérique ont des équivalents en matchers.

test('two plus two', () => {
  const value = 2 + 2;
  expect(value).toBeGreaterThan(3);
  expect(value).toBeGreaterThanOrEqual(3.5);
  expect(value).toBeLessThan(5);
  expect(value).toBeLessThanOrEqual(4.5);

  // toBe and toEqual are equivalent for numbers
  expect(value).toBe(4);
  expect(value).toEqual(4);
});

Pour l'égalité en virgule flottante, utilisez toBeCloseTo plutôt que toEqual pour éviter qu'un test dépende d'une infime erreur d'arrondi.

test('adding floating point numbers', () => {
  const value = 0.1 + 0.2;
  //expect(value).toBe(0.3);           This won't work because of rounding error
  expect(value).toBeCloseTo(0.3); // This works.
});

Chaînes de caractères

Vérifiez des chaînes avec des expressions régulières via toMatch :

test('there is no I in team', () => {
  expect('team').not.toMatch(/I/);
});

test('but there is a "stop" in Christoph', () => {
  expect('Christoph').toMatch(/stop/);
});

Tableaux et itérables

Vérifiez si un tableau ou itérable contient un élément particulier avec toContain :

const shoppingList = [
  'diapers',
  'kleenex',
  'trash bags',
  'paper towels',
  'milk',
];

test('the shopping list has milk on it', () => {
  expect(shoppingList).toContain('milk');
  expect(new Set(shoppingList)).toContain('milk');
});

Exceptions

Pour tester si une fonction lance une erreur lors de son appel, utilisez toThrow.

function compileAndroidCode() {
  throw new Error('you are using the wrong JDK!');
}

test('compiling android goes as expected', () => {
  expect(() => compileAndroidCode()).toThrow();
  expect(() => compileAndroidCode()).toThrow(Error);

  // You can also use a string that must be contained in the error message or a regexp
  expect(() => compileAndroidCode()).toThrow('you are using the wrong JDK');
  expect(() => compileAndroidCode()).toThrow(/JDK/);

  // Or you can match an exact error message using a regexp like below
  expect(() => compileAndroidCode()).toThrow(/^you are using the wrong JDK$/); // Test fails
  expect(() => compileAndroidCode()).toThrow(/^you are using the wrong JDK!$/); // Test pass
});

astuce

La fonction lançant une exception doit être appelée dans une fonction englobante, sinon l'assertion toThrow échouera.

Et plus encore

Ceci n'est qu'un aperçu. Pour la liste complète des matchers, consultez la documentation de référence.

Après avoir découvert les matchers disponibles, l'étape suivante est d'explorer comment Jest permet de tester du code asynchrone.