Arrange/Act/Assert

About 2 min

Intent

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

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

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.

public class Cash {

  private int amount;

  Cash(int amount) {
    this.amount = amount;
  }

  void plus(int addend) {
    amount += addend;
  }

  boolean minus(int subtrahend) {
    if (amount >= subtrahend) {
      amount -= subtrahend;
      return true;
    } else {
      return false;
    }
  }

  int count() {
    return amount;
  }
}

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

class CashAAATest {

  @Test
  void testPlus() {
    //Arrange
    var cash = new Cash(3);
    //Act
    cash.plus(4);
    //Assert
    assertEquals(7, cash.count());
  }

  @Test
  void testMinus() {
    //Arrange
    var cash = new Cash(8);
    //Act
    var result = cash.minus(5);
    //Assert
    assertTrue(result);
    assertEquals(3, cash.count());
  }

  @Test
  void testInsufficientMinus() {
    //Arrange
    var cash = new Cash(1);
    //Act
    var result = cash.minus(6);
    //Assert
    assertFalse(result);
    assertEquals(1, cash.count());
  }

  @Test
  void testUpdate() {
    //Arrange
    var cash = new Cash(5);
    //Act
    cash.plus(6);
    var result = cash.minus(3);
    //Assert
    assertTrue(result);
    assertEquals(8, cash.count());
  }
}

Applicability

Use Arrange/Act/Assert pattern when

Unit testing, especially within the context of TDD and BDD
Anywhere clarity and structure are needed in test cases

Known uses

Widely adopted in software projects using TDD and BDD methodologies.
Utilized in various programming languages and testing frameworks, such as JUnit (Java), NUnit (.NET), and xUnit frameworks.

Consequences

Benefits:

Improved readability of tests by clearly separating the setup, action, and verification steps.
Easier maintenance and understanding of tests, as each test is structured in a predictable way.
Facilitates debugging by isolating test failures to specific phases within the test.

Trade-offs:

May introduce redundancy in tests, as similar arrangements may be repeated across tests.
Some complex tests might not fit neatly into this structure, requiring additional context or setup outside these three phases.

Page Objectopen in new window: A pattern for organizing UI tests that can be used in conjunction with Arrange/Act/Assert.

Arrange/Act/Assert

Also known as

Intent

Explanation

Applicability

Known uses

Consequences

Credits