What is the Arrange-Act-Assert pattern?

Question

Accepted Answer

**Arrange-Act-Assert (AAA)** is a pattern for structuring tests clearly into three phases: **Arrange** (set up), **Act** (perform the action), **Assert** (verify the result). It makes tests readable, organized, and easy to understand.

## The three phases

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

## Example

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

The three phases are visually clear (often separated by blank lines or comments), making the test's intent obvious: what's set up, what's done, what's checked.

## Why AAA helps

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

## Why it matters

Understanding the Arrange-Act-Assert pattern is valuable because it provides a **simple, effective structure for writing clear, maintainable tests**, so it's useful practical knowledge.

The pattern — structuring every test into **Arrange** (set up the test context, inputs, and state), **Act** (perform the single action being tested), and **Assert** (verify the outcome matches expectations) — makes tests readable and well-organized, with the intent immediately clear (what's set up, what's done, what's checked).

Understanding **why AAA helps** is the key value: it improves **readability** (the clear three-part structure makes tests easy to follow), encourages **focus** (one action per test, since there's one clear Act phase — promoting focused tests that verify one behavior), improves **maintainability** (consistent structure across the test suite), and helps **spot problems** (excessive setup in Arrange signals complex dependencies, multiple Acts signal a test doing too much).

Following AAA produces tests that are easy to write, understand, and maintain — valuable since tests are read and modified over time, and unclear tests are a real maintenance burden.

Knowing that **Given-When-Then** (the BDD phrasing: Given setup, When action, Then outcome) is the same idea connects AAA to behavior-driven approaches.

Since writing clear, well-structured, maintainable tests is important (tests are code that must be understood and maintained) and AAA provides a simple, effective structure for this, and since understanding the pattern and its benefits helps write better tests, understanding the Arrange-Act-Assert pattern is valuable, practically-relevant knowledge — a simple but effective practice for writing clear, focused, maintainable tests, widely used and worth applying for better test quality, a useful habit for anyone writing tests.