Vad är enhetstestning?

Question

Accepted Answer

**Enhetstestning** verifierar individuella **enheter** av kod (funktioner, metoder, klasser) i **isolering** — kontrollerar att varje liten del fungerar korrekt på egen hand. Enhetstester är snabba, fokuserade och bildar grunden för en bra teststrategi.

## Vad ett enhetstest är

```text
A UNIT test verifies the smallest testable piece (a function/method) in ISOLATION:
  → test ONE thing; give inputs, check the output/behavior
  → ISOLATED from dependencies (database, network, other units) — mock/stub those
  → FAST (no real I/O), focused, deterministic
```

## Exempel

```js
// the function under test
function add(a, b) { return a + b; }

// a unit test (Jest)
test('add returns the sum of two numbers', () => {
  expect(add(2, 3)).toBe(5);          // input → expected output
  expect(add(-1, 1)).toBe(0);         // test cases, including edge cases
});

// test logic/behavior of a single unit
test('Cart.total sums item prices', () => {
  const cart = new Cart();
  cart.add({ price: 10 });
  cart.add({ price: 5 });
  expect(cart.total).toBe(15);
});
```

## Egenskaper hos bra enhetstester

```text
✓ FAST — run in milliseconds (so you run many, often)
✓ ISOLATED — test one unit; mock external dependencies; independent of other tests
✓ DETERMINISTIC — same result every time (no flakiness)
✓ Test BEHAVIOR/outcomes (not implementation details); clear and readable
✓ Cover normal cases, EDGE CASES, and error conditions
```

## Varför det spelar roll

Att förstå enhetstestning är grundläggande eftersom **enhetstester är grunden för en bra teststrategi** — basen av testpyramiden — så det är väsentlig, måste-veta kunskap.

Ett enhetstest verifierar **den minsta testbara delen av kod (en funktion eller metod) i isolering**, och kontrollerar att den fungerar korrekt på egen hand med givna indata som producerar förväntade resultat.

Att förstå detta — testning av en sak i taget, isolerat från beroenden (mockande av externa system som databaser och nätverk), snabbt och deterministiskt — är kärnan i enhetstestning.

Enhetstester är värdefulla eftersom de är **snabba** (körs på millisekunder, så du kan köra många ofta för snabb återkoppling), **fokuserade** (pekar exakt ut vad som bröts när de misslyckas), och bildar **grunden** som det mesta av en testsvit bör bestå av.

Att förstå **egenskaperna hos bra enhetstester** — snabba, isolerade (mockande beroenden, oberoende av andra tester), deterministiska (ingen flakiness), testande av beteende och resultat (inte implementeringsdetaljer, så tester inte bröts vid omstrukturering), och täckande av normala fall, edge cases och felvillkor — är viktigt för att skriva effektiva tester som ger verkligt värde istället för skört eller lågt värde.

Enhetstestning är den mest vanliga och grundläggande formen av testning, central för TDD, CI/CD och självsäker utveckling.

Since enhetstester är grunden för testning (basen av pyramiden, de mest talrika och ofta körda testerna) och att förstå vad de är och hur man skriver bra (isolerade, snabba, fokuserade, testande av beteende) är väsentligt för någon teststrategi, är förståelse för enhetstestning väsentlig, grundläggande kunskap — hörnstenen i mjukvarutestning som varje utvecklare bör förstå och praktisera, grundläggande för att verifiera kodkorrekthet och möjliggöra den självsäkra, säkra utveckling som bra testning ger.