Arrange-Act-Assert pattern in JUnit - Build an Automation Script

Verify addition of two numbers using Arrange-Act-Assert pattern

Preconditions (2)

Step 1: Arrange: Create an instance of Calculator

Step 2: Act: Call add method with inputs 5 and 3

Step 3: Assert: Verify the result is 8

✅ Expected Result: The test passes confirming that 5 + 3 equals 8

Automation Requirements - JUnit 5

Assertions Needed:

Assert that the addition result equals expected value

Best Practices:

Use Arrange-Act-Assert pattern clearly separated in test method

Use descriptive test method names

Use JUnit 5 annotations and assertions

Automated Solution

JUnit

import static org.junit.jupiter.api.Assertions.assertEquals;
import org.junit.jupiter.api.Test;

class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
}

public class CalculatorTest {

    @Test
    void testAdd_TwoNumbers_ReturnsSum() {
        // Arrange
        Calculator calculator = new Calculator();

        // Act
        int result = calculator.add(5, 3);

        // Assert
        assertEquals(8, result, "5 + 3 should equal 8");
    }
}

This test uses the Arrange-Act-Assert pattern:

• Arrange: We create a Calculator object to prepare for the test.
• Act: We call the add method with inputs 5 and 3.
• Assert: We check that the result is 8 using assertEquals.

This clear separation helps understand what is setup, what is tested, and what is verified.

Common Mistakes - 3 Pitfalls

Mixing Arrange, Act, and Assert steps without clear separation

Not using assertions to verify the result

Hardcoding values inside assertions without explanation

Bonus Challenge

Now add data-driven testing with 3 different pairs of numbers to verify addition

Show Hint

Practice

1. What is the main purpose of the Arrange-Act-Assert pattern in JUnit testing?

easy

A. To write tests without any setup

B. To organize tests into setup, action, and verification steps

C. To skip assertions in tests

D. To run tests in parallel automatically

Solution

1. Step 1: Understand the pattern components

   Arrange-Act-Assert divides a test into three clear parts: setup (Arrange), execution (Act), and checking results (Assert).

2. Step 2: Identify the purpose

   This separation helps make tests easier to read and maintain by clearly showing what is prepared, what is done, and what is checked.

3. Final Answer:

   To organize tests into setup, action, and verification steps -> Option B

4. Quick Check:

   Arrange-Act-Assert = organize test steps [OK]

Hint: Remember: Arrange = setup, Act = do, Assert = check [OK]

Common Mistakes:

• Thinking Arrange means skipping setup
• Believing Act is for assertions
• Confusing Assert with running tests
• Assuming it runs tests in parallel

2. Which of the following is the correct order of steps in the Arrange-Act-Assert pattern in a JUnit test?

easy

A. Arrange, Act, Assert

B. Assert, Arrange, Act

C. Act, Arrange, Assert

D. Act, Assert, Arrange

Solution

1. Step 1: Recall the pattern sequence

   The pattern always starts with Arrange (setup), then Act (execute), and finally Assert (verify).

2. Step 2: Match the correct order

   Only Arrange, Act, Assert lists the steps in the correct order: Arrange, Act, Assert.

3. Final Answer:

   Arrange, Act, Assert -> Option A

4. Quick Check:

   Order = Arrange, Act, Assert [OK]

Hint: Think: Prepare, Perform, Prove in order [OK]

Common Mistakes:

• Mixing up the order of Act and Assert
• Starting with Assert before setup
• Skipping the Arrange step
• Confusing Act with Assert

3. Consider the following JUnit test code snippet:

void testSum() {
  int a = 5;
  int b = 3;
  int result = Calculator.add(a, b);
  assertEquals(8, result);
}

Which part of the Arrange-Act-Assert pattern does int result = Calculator.add(a, b); represent?

medium

A. Arrange

B. Cleanup

C. Assert

D. Act

Solution

1. Step 1: Identify the code purpose

   The line calls the method under test to perform the action, storing the output.

2. Step 2: Match to pattern step

   This is the 'Act' step where the test executes the behavior to be tested.

3. Final Answer:

   Act -> Option D

4. Quick Check:

   Calling method = Act step [OK]

Hint: Act is the step where you call the method under test [OK]

Common Mistakes:

• Confusing Act with Arrange (setup)
• Thinking assertEquals line is Act
• Assuming variable declarations are Act
• Selecting Cleanup which is not part of AAA

4. Identify the error in this JUnit test following the Arrange-Act-Assert pattern:

@Test
void testMultiply() {
  int x = 4;
  int y = 2;
  int product = x * y;
  assertEquals(8, x * y);
}

medium

A. The Act step is missing

B. The Arrange step is incorrect

C. The Assert step uses a direct expression instead of the product variable

D. The test method lacks the @Before annotation

Solution

1. Step 1: Review the Act step

   The Act step is the calculation: int product = x * y; which is correct.

2. Step 2: Check the Assert step

   The assertion compares 8 with x * y directly instead of using the product variable, which breaks the pattern clarity.

3. Final Answer:

   The Assert step uses a direct expression instead of the product variable -> Option C

4. Quick Check:

   Assert should check the Act result variable [OK]

Hint: Assert should verify the Act result variable, not repeat calculation [OK]

Common Mistakes:

• Thinking Act step is missing
• Believing @Before is required for every test
• Confusing Arrange with Act
• Ignoring the importance of using variables in Assert

5. You want to test a method divide(int a, int b) that throws IllegalArgumentException when b is zero. Using Arrange-Act-Assert, which is the best way to write this test in JUnit 5?

hard

A. Arrange inputs, call divide inside assertThrows, Assert exception is thrown

B. Arrange inputs, call divide normally, Assert result equals zero

C. Call divide without Arrange, Assert no exception thrown

D. Arrange inputs, call divide, Assert result equals a divided by b

Solution

1. Step 1: Arrange inputs for exception case

   Set a to any number and b to zero to trigger the exception.

2. Step 2: Act by calling divide inside assertThrows

   Use assertThrows(IllegalArgumentException.class, () -> divide(a, b)) to check the exception is thrown.

3. Step 3: Assert the exception is correctly thrown

   This confirms the method behaves as expected when dividing by zero.

4. Final Answer:

   Arrange inputs, call divide inside assertThrows, Assert exception is thrown -> Option A

5. Quick Check:

   Use assertThrows for exception tests [OK]

Hint: Use assertThrows to test exceptions in Act-Assert step [OK]

Common Mistakes:

• Ignoring exception testing and checking wrong result
• Calling method outside assertThrows
• Not arranging inputs properly
• Asserting wrong expected value