Was sind Assertions beim Testen?

Question

IT Interview Practice · 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.

Was Assertions tun

Gängige Assertion-Typen

Gute Assertions

Warum es wichtig ist

Ähnliche Fragen