Vad är assertions vid testning?

Question

Accepted Answer

**Assertions** är påståenden i ett test som **kontrollerar om ett villkor är sant** — verifierar att det faktiska resultatet matchar det förväntade resultatet. De är kärnan i hur test avgör pass eller misslyckande: om en assertion misslyckas, misslyckas testet.

## Vad assertions gör

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

## Vanliga assertion-typer

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

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

## Varför det är viktigt

Att förstå assertions är fundamentalt eftersom de är **den grundläggande mekanismen genom vilken test verifierar beteende** — avgör pass eller misslyckande — så det är väsentlig, måste-kunna-kunskap för att skriva något test.

En assertion **kontrollerar att ett villkor är sant** (typiskt att ett faktiskt resultat matchar ett förväntat), och det är "verifikations"-delen av ett test: om en assertion passerar gäller kontrollen, och om den misslyckas misslyckas testet.

Utan assertions verifierar ett test faktiskt ingenting — så att förstå dem är fundamentalt för att skriva meningsfulla test.

Att förstå de **vanliga assertion-typerna** — likhet (strikt `toBe` mot djup/värde `toEqual` för objekt, en viktig skillnad), sanningsvärdekontroller och null-kontroller, jämförelser, samlings- och strängkontroller, error-assertions (verifiering att en funktion kastar), och negation — är nödvändig praktisk kunskap för att uttrycka vad ett test bör verifiera.

Att förstå **bra assertion-praxis** — att assertera det specifika förväntade resultatet (klart om vad som kontrolleras), använda rätt matcher (t.ex. `toEqual` för objektjämförelse, inte `toBe`), säkerställa tydliga felmeddelanden (så ett misslyckat test förklarar vad som gick fel), och balansera assertions (testa ett beteende, men verifiera det faktiska resultatet) — reflekterar att skriva tydliga, effektiva test.

Eftersom assertions är hur varje test verifierar beteende (den grundläggande kontrollen som gör ett test meningsfullt) och att förstå dem — typerna, rätt matchers, och bra praxis — är nödvändigt för att skriva något test som faktiskt verifierar något, är förståelse för assertions väsentlig, grundläggande test-kunskap — den grundläggande byggstenen för test, nödvändig för att uttrycka och verifiera förväntat beteende, och fundamental för att skriva test som meningsfullt kontrollerar korrekthet, en grundläggande kompetens för alla som skriver test.