Arrange-Act-Assert pattern in JUnit - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the purpose of the Arrange step in the Arrange-Act-Assert pattern?

The Arrange step sets up all the necessary objects, data, and conditions needed before the action is performed. It prepares the test environment.

beginner

In the Arrange-Act-Assert pattern, what happens during the Act step?

The Act step performs the actual action or behavior that you want to test, such as calling a method or function.

beginner

Why is the Assert step important in the Arrange-Act-Assert pattern?

The Assert step checks if the outcome of the Act step matches the expected result. It verifies that the code works as intended.

beginner

Show a simple JUnit test method using the Arrange-Act-Assert pattern.

Example: @Test void testAddition() { // Arrange Calculator calc = new Calculator(); int a = 5; int b = 3; // Act int result = calc.add(a, b); // Assert assertEquals(8, result); }

beginner

How does the Arrange-Act-Assert pattern help in writing clear tests?

It separates the test into clear steps: setup, action, and verification. This makes tests easier to read, understand, and maintain.

Which step in Arrange-Act-Assert is responsible for setting up test data?

A Arrange

B Act

C Assert

D Cleanup

The Arrange step prepares all necessary data and objects before the test action.

In JUnit, which method call typically belongs to the Assert step?

A System.out.println()

B new Object()

C assertEquals(expected, actual)

D methodUnderTest()

assertEquals checks if the actual result matches the expected value, which is the Assert step.

What is the main goal of the Act step?

A Perform the action to test

B Set up test data

C Verify the output

D Clean resources

The Act step executes the behavior or method you want to test.

Why should tests follow the Arrange-Act-Assert pattern?

A To make tests run faster

B To organize tests clearly and logically

C To avoid writing assertions

D To skip setup steps

This pattern helps keep tests clear and easy to understand by separating setup, action, and verification.

Which of these is NOT part of the Arrange-Act-Assert pattern?

A Arrange

B Act

C Assert

D Deploy

Deploy is unrelated to the Arrange-Act-Assert testing pattern.

Explain the three steps of the Arrange-Act-Assert pattern and why each is important.

Think about preparing, doing, and checking in a test.

Write a simple JUnit test method using the Arrange-Act-Assert pattern for a method that multiplies two numbers.

Follow the pattern steps clearly in your code.

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