Was sind Assertions beim Testen?

Question

Accepted Answer

**Assertions** sind Anweisungen in einem Test, die **überprüfen, ob eine Bedingung wahr ist** — verifying that the actual result matches the expected result. Sie sind der Kern dessen, wie Tests bestimmen, ob sie bestanden oder fehlgeschlagen sind: Wenn eine Assertion fehlschlägt, schlägt der Test fehl.

## Was Assertions tun

```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).
```

## Gängige Assertion-Typen

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

## Gute 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)
```

## Warum es wichtig ist

Das Verständnis von Assertions ist grundlegend, weil sie **der Kernmechanismus sind, durch den Tests das Verhalten überprüfen** — bestimmend für bestanden oder fehlgeschlagen — daher ist es essentiell, notwendiges Wissen für das Schreiben eines Tests.

Eine Assertion **überprüft, dass eine Bedingung wahr ist** (typischerweise dass ein tatsächliches Ergebnis einem erwarteten entspricht), und sie ist der „Verifikations"-Teil eines Tests: Wenn eine Assertion den Check besteht, hält die Bedingung, und wenn sie fehlschlägt, schlägt der Test fehl.

Ohne Assertions überprüft ein Test eigentlich nichts — daher ist das Verständnis dafür grundlegend für das Schreiben aussagekräftiger Tests.

Das Verständnis der **gängigen Assertion-Typen** — Gleichheit (striktes `toBe` vs tiefes/Wert-`toEqual` für Objekte, eine wichtige Unterscheidung), Wahrheitswert- und Null-Checks, Vergleiche, Sammlungs- und String-Checks, Error-Assertions (Überprüfung, dass eine Funktion wirft), und Negation — ist notwendiges praktisches Wissen zum Ausdrücken, was ein Test überprüfen sollte.

Das Verständnis von **guten Assertion-Praktiken** — Asserting des spezifischen erwarteten Ergebnisses (klar darüber, was überprüft wird), Verwendung des richtigen Matchers (z.B. `toEqual` für Objektvergleich, nicht `toBe`), Sicherstellung klarer Fehlermeldungen (damit ein fehlgeschlagener Test erklärt, was schiefgelaufen ist), und Ausgleich von Assertions (Testen eines Verhaltens, aber Verifikation des tatsächlichen Ergebnisses) — spiegelt das Schreiben klarer, effektiver Tests wider.

Da Assertions die Art sind, wie jeder Test das Verhalten überprüft (die grundlegende Überprüfung, die einen Test aussagekräftig macht) und das Verständnis dafür — die Typen, die richtigen Matcher, und gute Praktiken — notwendig ist, um einen Test zu schreiben, der tatsächlich etwas überprüft, ist das Verständnis von Assertions essentiell, grundlegendes Testwissen — der Kernbaustein von Tests, notwendig zum Ausdrücken und Überprüfen erwarteten Verhaltens, und grundlegend für das Schreiben von Tests, die sinnvoll Korrektheit überprüfen, eine grundlegende Kompetenz für jeden, der Tests schreibt.