Vad är Arrange-Act-Assert-mönstret?

Question

Accepted Answer

**Arrange-Act-Assert (AAA)** är ett mönster för att strukturera tester tydligt i tre faser: **Arrange** (förbered), **Act** (utför åtgärden), **Assert** (verifiera resultatet). Det gör tester läsbara, organiserade och lätta att förstå.

## De tre faserna

```text
ARRANGE → set up the test: create objects, prepare inputs, configure mocks, set state
ACT     → perform the ACTION being tested (call the function/method under test)
ASSERT  → verify the OUTCOME: check the result/behavior matches what's expected
→ A clear three-part structure for every test.
```

## Exempel

```js
test('Cart calculates total with discount', () => {
  // ARRANGE — set up
  const cart = new Cart();
  cart.add({ price: 100 });
  cart.applyDiscount(0.1);          // 10% off

// ACT — perform the action under test
  const total = cart.getTotal();

// ASSERT — verify the result
  expect(total).toBe(90);
});
```

De tre faserna är visuellt tydliga (ofta åtskilda av tomma rader eller kommentarer), vilket gör testets syfte uppenbart: vad som förbereds, vad som görs, vad som kontrolleras.

## Varför AAA hjälper

```text
✓ READABILITY — clear structure; easy to see setup vs action vs verification
✓ FOCUS — encourages testing ONE action per test (one clear Act)
✓ MAINTAINABILITY — consistent structure across tests; easy to understand/modify
✓ Spot problems — too much in Arrange (complex setup) or multiple Acts (testing too much)
→ (Given-When-Then is the same idea, in BDD terms: Given setup, When action, Then outcome.)
```

## Varför det är viktigt

Att förstå Arrange-Act-Assert-mönstret är värdefullt eftersom det ger en **enkel, effektiv struktur för att skriva tydliga, underhållbara tester**, så det är användbar praktisk kunskap.

Mönstret — att strukturera varje test i **Arrange** (förbered testkontexten, inmatningar och tillstånd), **Act** (utför den enskilda åtgärden som testas), och **Assert** (verifiera att resultatet motsvarar förväntningarna) — gör tester läsbara och välorganiserade, med syftet omedelbar klart (vad som förbereds, vad som görs, vad som kontrolleras).

Att förstå **varför AAA hjälper** är nyckelvärdet: det förbättrar **läsbarhet** (den tydliga tredeltade strukturen gör tester lätta att följa), uppmuntrar **fokus** (en åtgärd per test, eftersom det finns en tydlig Act-fas — vilket främjar fokuserade tester som verifierar ett beteende), förbättrar **underhållbarhet** (konsekvent struktur över testsviten), och hjälper till att **upptäcka problem** (överdriven förberedelse i Arrange signalerar komplexa beroenden, flera Acts signalerar ett test som gör för mycket).

Att följa AAA producerar tester som är lätta att skriva, förstå och underhålla — värdefullt eftersom tester läses och modifieras över tid, och otydliga tester är en verklig underhållsbörda.

Att veta att **Given-When-Then** (BDD-uttrycket: Given förberedelse, When åtgärd, Then resultat) är samma idé kopplar AAA till beteendedrivna tillvagagångar.

Eftersom det är viktigt att skriva tydliga, välstrukturerade, underhållbara tester (tester är kod som måste förstås och underhållas) och AAA ger en enkel, effektiv struktur för detta, och eftersom att förstå mönstret och dess fördelar hjälper till att skriva bättre tester, är att förstå Arrange-Act-Assert-mönstret värdefullt, praktiskt relevant kunskap — en enkel men effektiv praxis för att skriva tydliga, fokuserade, underhållbara tester, allmänt använd och värd att tillämpa för bättre testkvalitet, en användbar vana för alla som skriver tester.