Co jsou asertace při testování?

Question

Accepted Answer

**Asertace** jsou příkazy v testu, které **kontrolují, zda je podmínka pravdivá** — ověřují, že skutečný výsledek odpovídá očekávanému výsledku. Jsou jádrem toho, jak testy určují úspěch nebo selhání: pokud asertace selže, test selže.

## Co asertace dělají

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

## Běžné typy asertací

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

## Dobré asertace

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

## Proč je to důležité

Porozumění asertacím je základní, protože jsou **základním mechanismem, kterým testy ověřují chování** — určují úspěch nebo selhání — takže je to nezbytné, nezbytné znalosti pro psaní libovolného testu.

Asertace **kontroluje, zda je podmínka pravdivá** (obvykle zda skutečný výsledek odpovídá očekávanému), a je to "ověřovací" část testu: pokud asertace projde, kontrola platí, a pokud selže, test selže.

Bez asertací test vlastně nic neověřuje — takže jejich pochopení je základní pro psaní smysluplných testů.

Porozumění **běžným typům asertací** — rovnosti (přísné `toBe` vs hluboké/hodnotové `toEqual` pro objekty, důležitý rozdíl), kontroly pravdivosti a null, porovnání, kontroly kolekcí a řetězců, asertace chyb (ověření, že funkce vyvolá chybu) a negace — je nezbytné praktické znalosti pro vyjádření toho, co by měl test ověřit.

Porozumění **dobrým praktikám asertací** — asertování konkrétního očekávaného výsledku (jasné o tom, co se kontroluje), použití správného matcheru (např. `toEqual` pro porovnání objektů, ne `toBe`), zajištění jasných chybových zpráv (aby selhávající test vysvětlil, co se nepovedlo) a vyvážení asertací (testování jednoho chování, ale ověření skutečného výsledku) — odráží psaní jasných, efektivních testů.

Keďže asertace jsou způsobem, jak každý test ověřuje chování (základní kontrola, která činí test smysluplným) a jejich pochopení — typů, správných matcherů a dobrých praktik — je nezbytné pro psaní libovolného testu, který skutečně něco ověřuje, pochopení asertací je základní, nadstavbová znalost testování — základní stavební blok testů, nezbytný pro vyjádření a ověření očekávaného chování a základní pro psaní testů, které smysluplně kontrolují správnost, základní kompetence pro kohokoli, kdo píše testy.