Arrange-Act-Assert pattern in JUnit - Framework Patterns

Framework Mode - Arrange-Act-Assert pattern

Folder Structure

project-root/
├── src/
│   ├── main/
│   │   └── java/
│   │       └── com/example/app/
│   │           └── Calculator.java
│   └── test/
│       └── java/
│           └── com/example/app/
│               └── CalculatorTest.java
└── pom.xml
  

This is a simple Maven project structure for JUnit tests using the Arrange-Act-Assert pattern.

Test Framework Layers

• Arrange: Prepare test data and environment. For example, create objects or set variables.
• Act: Execute the method or action under test.
• Assert: Verify the outcome matches expectations using assertions.
• Tests: Located in src/test/java, contain test methods following AAA.
• Application Code: Located in src/main/java, contains the logic to be tested.

Configuration Patterns

JUnit tests typically use Maven or Gradle for build and dependency management.

• pom.xml: Defines JUnit dependency and test plugins.
• Test Properties: Use src/test/resources for test-specific config if needed.
• Environment: Tests run in isolated JVM; environment variables or system properties can be set in test setup if needed.

Test Reporting and CI/CD Integration

• Maven Surefire plugin generates test reports in target/surefire-reports.
• Reports show passed/failed tests with stack traces for failures.
• CI tools (Jenkins, GitHub Actions) run tests automatically and publish reports.
• Failing tests block merges to keep code quality high.

Best Practices for Arrange-Act-Assert Pattern

• Keep each test focused on one behavior or scenario.
• Clearly separate Arrange, Act, and Assert sections with comments or blank lines.
• Use descriptive test method names to explain what is tested.
• Avoid logic in tests; tests should be simple and easy to read.
• Use assertions that give clear failure messages.

Self Check

Where in this framework structure would you add a new test method that uses the Arrange-Act-Assert pattern to verify the addition operation of a Calculator class?

Key Result

Arrange-Act-Assert organizes tests into clear steps: prepare data, perform action, then verify results.

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