Matcher verwenden

Inoffizielle Beta-Übersetzung

Diese Seite wurde von PageTurner AI übersetzt (Beta). Nicht offiziell vom Projekt unterstützt. Fehler gefunden? Problem melden →

Jest verwendet "Matcher", um das Testen von Werten auf verschiedene Arten zu ermöglichen. Dieses Dokument stellt einige häufig verwendete Matcher vor. Die vollständige Liste findest du in der expect-API-Dokumentation.

Häufig verwendete Matcher

Die einfachste Methode zum Testen eines Werts ist die exakte Gleichheitsprüfung.

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

In diesem Code gibt expect(2 + 2) ein "Erwartungsobjekt" zurück. Normalerweise interagierst du mit diesen Erwartungsobjekten nur durch den Aufruf von Matchern. Hier ist .toBe(4) der Matcher. Während der Ausführung protokolliert Jest alle fehlgeschlagenen Matcher, um dir aussagekräftige Fehlermeldungen anzuzeigen.

toBe nutzt Object.is für exakte Gleichheitsprüfungen. Um Objektwerte zu vergleichen, verwende toEqual:

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

toEqual überprüft rekursiv jedes Feld eines Objekts oder Arrays.

Tipp

toEqual ignoriert Objektschlüssel mit undefined-Eigenschaften, undefined-Array-Elemente, Array-Lücken oder Objekttyp-Unterschiede. Um diese zu berücksichtigen, verwende stattdessen toStrictEqual.

Du kannst auch die Umkehrung eines Matchers mit not testen:

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);
    }
  }
});

Wahrheitsgehalt

In Tests musst du manchmal zwischen undefined, null und false unterscheiden, während du sie in anderen Fällen gleich behandeln möchtest. Jest bietet Hilfsmittel, um explizit anzugeben, was du benötigst.

• toBeNull trifft nur auf null zu

• toBeUndefined trifft nur auf undefined zu

• toBeDefined ist das Gegenteil von toBeUndefined

• toBeTruthy trifft auf alles zu, was eine if-Anweisung als wahr behandelt

• toBeFalsy trifft auf alles zu, was eine if-Anweisung als falsch behandelt

Beispiel:

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();
});

Verwende den Matcher, der am genauesten deinen Testanforderungen entspricht.

Zahlen

Für die meisten Zahlenvergleiche gibt es entsprechende Matcher.

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);
});

Für Gleitkommagleichheit verwende toBeCloseTo statt toEqual, da Tests nicht von minimalen Rundungsfehlern abhängen sollten.

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.
});

Zeichenketten

Du kannst Zeichenketten mit regulären Ausdrücken via toMatch prüfen:

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

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

Arrays und Iterables

Mit toContain kannst du prüfen, ob ein Array oder Iterable ein bestimmtes Element enthält:

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

Um zu testen, ob eine Funktion beim Aufruf einen Fehler auslöst, verwende 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
});

Tipp

Die Funktion, die eine Exception auslöst, muss innerhalb einer Wrapper-Funktion aufgerufen werden, da die toThrow-Assertion sonst fehlschlägt.

Und mehr

Dies ist nur ein kleiner Einblick. Die vollständige Matcher-Liste findest du in der Referenzdokumentation.

Nachdem du die verfügbaren Matcher kennengelernt hast, ist der nächste Schritt zu erkunden, wie Jest dir das Testen asynchronen Codes ermöglicht.