Browser docs

Arrange/Act/Assert

April 14, 2023 3 min read Idiom Testing
On this page

Also known as

Given/When/Then

Intent

Arrange/Act/Assert (AAA) is a pattern for organizing unit tests. It breaks tests down into three clear and distinct steps:

  1. Arrange: Perform the setup and initialization required for the test.
  2. Act: Take action(s) required for the test.
  3. Assert: Verify the outcome(s) of the test.

Explanation

This pattern has several significant benefits. It creates a clear separation between a test’s setup, operations, and results. This structure makes the code easier to read and understand. If you place the steps in order and format your code to separate them, you can scan a test and quickly comprehend what it does.

It also enforces a certain degree of discipline when you write your tests. You have to think clearly about the three steps your test will perform. It makes tests more natural to write at the same time since you already have an outline.

Real world example

We need to write comprehensive and clear unit test suite for a class.

In plain words

Arrange/Act/Assert is a testing pattern that organizes tests into three clear steps for easy maintenance.

WikiWikiWeb says

Arrange/Act/Assert is a pattern for arranging and formatting code in UnitTest methods.

Programmatic Example

Let’s first introduce our Cash class to be unit tested.

 1public class Cash {
 2
 3  private int amount;
 4
 5  Cash(int amount) {
 6    this.amount = amount;
 7  }
 8
 9  void plus(int addend) {
10    amount += addend;
11  }
12
13  boolean minus(int subtrahend) {
14    if (amount >= subtrahend) {
15      amount -= subtrahend;
16      return true;
17    } else {
18      return false;
19    }
20  }
21
22  int count() {
23    return amount;
24  }
25}

Then we write our unit tests according to Arrange/Act/Assert pattern. Notice the clearly separated steps for each unit test.

 1class CashAAATest {
 2
 3  @Test
 4  void testPlus() {
 5    //Arrange
 6    var cash = new Cash(3);
 7    //Act
 8    cash.plus(4);
 9    //Assert
10    assertEquals(7, cash.count());
11  }
12
13  @Test
14  void testMinus() {
15    //Arrange
16    var cash = new Cash(8);
17    //Act
18    var result = cash.minus(5);
19    //Assert
20    assertTrue(result);
21    assertEquals(3, cash.count());
22  }
23
24  @Test
25  void testInsufficientMinus() {
26    //Arrange
27    var cash = new Cash(1);
28    //Act
29    var result = cash.minus(6);
30    //Assert
31    assertFalse(result);
32    assertEquals(1, cash.count());
33  }
34
35  @Test
36  void testUpdate() {
37    //Arrange
38    var cash = new Cash(5);
39    //Act
40    cash.plus(6);
41    var result = cash.minus(3);
42    //Assert
43    assertTrue(result);
44    assertEquals(8, cash.count());
45  }
46}

Applicability

Use Arrange/Act/Assert pattern when

  • You need to structure your unit tests so that they’re easier to read, maintain, and enhance.

Credits