Häufige Matcher

In diesem Kapitel werden wir uns einige gängige Matcher ansehen, die zum Testen verschiedener Arten von Werten verwendet werden können.

Arrays und Objekte abgleichen

Der toEqual Matcher vergleicht zwei Elemente auf einer tiefen Ebene. Daher ist er nützlich zum Abgleichen von Strukturen wie Array oder vielleicht einem Object:

9
1
2
expect([1, 2, 3, 4]).toEqual([1, 2, 3, 4]);
expect({name: 'John', age: 27}).toEqual({name: 'John', age: 27});

Tiefenprüfung

Die Methode toContain überprüft, ob das übergebene Array einen bestimmten Wert enthält:

9
1
2
expect([1, 2, 3]).toContain(2); // Pass
expect([1, 2, 3]).toContain(4); // Fail

Die Methode toContainEqual wird für komplizierte Arrays verwendet, um tiefe Vergleiche durchzuführen:

9
1
2
3
4
5
6
7
const people = [
	{ name: 'Alice', age: 25 },
	{ name: 'Bob', age: 30 },
	{ name: 'Charlie', age: 35 }
];
  
expect(people).toContainEqual({ name: 'Bob', age: 30 });

Übereinstimmung von Zeichenfolgenmustern

Die Methode toMatch wird auch zum Abgleichen von Zeichenfolgen verwendet:

expect("Hello World").toMatch("Hello World");

Dieser Matcher vergleicht die beiden Zeichenfolgen nicht genau, sondern sucht nach einem Substring innerhalb der ursprünglichen Eingabe. Daher besteht auch die folgende Assertion:

expect("Hello World").toMatch("World");

Tatsächlich akzeptiert die Methode toMatch einfach einen Regulären Ausdruck (RegEx), der nach dem angegebenen Muster im ursprünglichen Eingabestring sucht.

Ein Substring oder einfacher Text ist ein gültiger RegEx-Ausdruck, daher sucht das einfache Schreiben von World nach dem Begriff World im Eingabestring, und es passt, weil "World" ein Substring von "Hello World" ist.

Ein Regulärer Ausdruck ist einfach eine Zeichenfolge, die verwendet wird, um ein bestimmtes Muster darzustellen. Reguläre Ausdrücke werden verwendet, um effizient nach Textstücken zu suchen, die einem gewünschten Muster entsprechen. Die meisten Programmiersprachen wie Python und JavaScript verfügen über integrierte Unterstützung für Reguläre Ausdrücke, und Sprachen, die keine integrierte Unterstützung haben, verfügen über externe Bibliotheken, die installiert werden können, um Unterstützung für Reguläre Ausdrücke hinzuzufügen.

Regex folgt einer spezifischen Syntax, genau wie Programmiersprachen. Es ist nicht notwendig, Reguläre Ausdrücke zu lernen, um in diesem Kurs voranzukommen, jedoch können wir uns ein Beispiel ansehen, um zu sehen, wie Reguläre Ausdrücke im Allgemeinen nützlich sein können.

Das Muster /^[a-m]{5}$/ überprüft, ob der Eingabestring 5 Zeichen lang ist und nur Kleinbuchstaben von 'a' bis 'm' enthält.

9
1
2
3
4
5
expect('abcde').toMatch(/^[a-m]{5}$/); // Pass
expect('xyz').not.toMatch(/^[a-m]{5}$/); // Fail
expect('abcdefg').not.toMatch(/^[a-m]{5}$/); // Fail
expect('abCde').not.toMatch(/^[a-m]{5}$/); // Fail
expect('edcba').toMatch(/^[a-m]{5}$/); // Pass

Reguläre Ausdrücke sind ziemlich robust und können verwendet werden, um nach jeder Art von Muster zu suchen. Zum Beispiel überprüft das Muster /^[^\\s@]+@[^\\s@]+\\.[^\\s@]+$/, ob der Eingabestring eine gültige E-Mail ist.

Überprüfung auf `null` und `undefined`

Um zu überprüfen, ob ein Wert null ist, können wir keine der vorherigen Matcher verwenden, da null weder eine Ganzzahl, eine Struktur noch ein String ist. In diesem Fall verwenden wir den Matcher toBeNull, der kein Argument akzeptiert:

9
1
2
expect(1).toBeNull(); // Fail
expect(null).toBeNull(); // Pass

JavaScript hat auch das Schlüsselwort undefined. Wir können überprüfen, ob ein Wert undefined ist, indem wir den Matcher toBeUndefined verwenden:

Es gibt auch einen Matcher, um das Gegenteil zu überprüfen. Der toBeDefined Matcher überprüft, dass der Zielwert definiert ist.

9
1
2
expect('Hello World').toBeDefined(); // Pass
expect(undefined).toBeDefined(); // Fail

Überprüfung von Booleschen Werten & Wahrheitswerten

Um zu überprüfen, ob ein Wert True oder False ist, verwenden wir die Methoden toBeTruthy und toBeFasly :

9
1
2
3
4
expect(true).toBeTruthy(); // Pass
expect(false).toBeTruthy(); // Fail
expect(true).toBeFalsy(); // Fail
expect(false).toBeFalsy(); // Pass

Diese Methoden überprüfen die „Wahrheit“ oder „Falschheit“ eines Wertes. Jeder Wert, der innerhalb einer if-Bedingung als True betrachtet würde, ist ein Thuthy-Wert, andernfalls ist es ein Falsy-Wert.

9
1
2
3
4
5
if(10) {
    console.log('truthy');
} else {
    console.log('falsy');
}

In diesem Fall wird "turthy" ausgegeben, was darauf hinweist, dass 10 ein wahrer Wert ist. Im Gegensatz dazu wird beim Ersetzen von 10 durch eine 0 oder einen leeren String ('') "falsy" ausgegeben.

Überprüfen auf Ausnahmen

Wir können auch überprüfen, ob eine bestimmte Ausnahme von einer Funktion ausgelöst wurde, indem wir den toThrow-Matcher verwenden.

Angenommen, wir haben die klassische factorial-Funktion, die eine Ausnahme auslöst, wenn eine ungültige Eingabe an die Funktion übergeben wird:

9
1
2
3
4
5
function factorial(n) {
    if(n < 0) throw Error("Factorial of a negative number cannot be calculated.");
    if(n == 1) return 1;
    return n * factorial(n - 1);
}

Wir können den toThrow Matcher verwenden, um zu testen, ob die Funktion tatsächlich einen Fehler / eine Ausnahme bei ungültiger Eingabe auslöst:

9
1
2
3
expect(() => factorial(-1)).toThrow(
  "Factorial of a negative number cannot be calculated."
);

Die toThrow Methode akzeptiert ein Argument, das der Textinhalt der erwarteten Ausnahme sein soll. Da sie den Text der ausgelösten Ausnahme vergleicht, sollte daher der genaue Text der erwarteten Ausnahme in der toThrow Methode übergeben werden.

Negation

Wir können Matcher auch negieren, indem wir den Matcher nach einem not verketten:

9
1
2
3
4
expect(1 + 2).not.toBe(4); // Pass
expect(1 + 2).not.toBe(3); // Fail
expect('An example string').not.toMatch('example'); // Pass
expect([1, 2, 3]).not.toContain('a'); // Pass