Given/When/Then
Arrange/Act/Assert (AAA) is a pattern for organizing unit tests. It breaks tests down into three clear and distinct steps:
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}
Use Arrange/Act/Assert pattern when