assertAll for grouped assertions in JUnit - Build an Automation Script

Verify multiple properties of a User object using grouped assertions

Preconditions (2)

Step 1: Create a User object with name 'Alice', age 30, and email '[e-mail]'

Step 2: Use assertAll to verify the following:

Step 3: - The name is 'Alice'

Step 4: - The age is 30

Step 5: - The email is '[e-mail]'

✅ Expected Result: All assertions inside assertAll run and report failures together if any property does not match expected values

Automation Requirements - JUnit 5

Assertions Needed:

assertAll to group multiple assertions

assertEquals to check each property

Best Practices:

Use lambda expressions inside assertAll for lazy evaluation

Group related assertions logically

Avoid stopping test on first failure by using assertAll

Automated Solution

JUnit

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

class User {
    private final String name;
    private final int age;
    private final String email;

    User(String name, int age, String email) {
        this.name = name;
        this.age = age;
        this.email = email;
    }

    String getName() { return name; }
    int getAge() { return age; }
    String getEmail() { return email; }
}

public class UserTest {

    @Test
    void testUserProperties() {
        User user = new User("Alice", 30, "[e-mail]");

        assertAll("User properties",
            () -> assertEquals("Alice", user.getName(), "Name should be Alice"),
            () -> assertEquals(30, user.getAge(), "Age should be 30"),
            () -> assertEquals("[e-mail]", user.getEmail(), "Email should be [e-mail]")
        );
    }
}

This test defines a simple User class with three properties: name, age, and email.

In the testUserProperties() method, we create a User object with expected values.

We use assertAll to group three assertions. Each assertion checks one property using assertEquals.

Using lambda expressions inside assertAll ensures all assertions run, and if any fail, JUnit reports all failures together.

This approach helps quickly see all mismatches without stopping at the first failure.

Common Mistakes - 3 Pitfalls

{'mistake': 'Using multiple assertEquals separately without assertAll', 'why_bad': "Test stops at first failure, so you don't see all failing assertions at once.", 'correct_approach': 'Use assertAll to group assertions so all run and report failures together.'}

Passing evaluated expressions instead of lambdas to assertAll

Not providing failure messages in assertions

Bonus Challenge

Now add a second User object with different properties and verify both users' properties using assertAll grouping.

Show Hint

Practice

1. What is the main benefit of using assertAll in JUnit tests?

easy

A. It runs multiple assertions and reports all failures together.

B. It stops the test immediately after the first failure.

C. It automatically fixes failed assertions.

D. It runs assertions in parallel threads.

Solution

1. Step 1: Understand assertAll behavior

   assertAll groups multiple assertions and executes them all, regardless of failures.

2. Step 2: Compare options

   It runs multiple assertions and reports all failures together. correctly states that all failures are reported together. Options A, C, and D are incorrect because assertAll does not stop early, fix errors, or run assertions in parallel.

3. Final Answer:

   It runs multiple assertions and reports all failures together. -> Option A

4. Quick Check:

   assertAll reports all failures together = B [OK]

Hint: Remember: assertAll shows all errors, not just first [OK]

Common Mistakes:

• Thinking assertAll stops after first failure
• Believing assertAll fixes errors automatically
• Assuming assertAll runs assertions in parallel

2. Which of the following is the correct syntax to use assertAll in JUnit 5?

easy

A. assertAll(() -> assertEquals(5, sum), () -> assertTrue(flag));

B. assertAll(assertEquals(5, sum), assertTrue(flag));

C. assertAll{ assertEquals(5, sum); assertTrue(flag); }

D. assertAll[() -> assertEquals(5, sum), () -> assertTrue(flag)];

Solution

1. Step 1: Recall assertAll syntax

   In JUnit 5, assertAll takes lambda expressions as arguments, each representing an assertion.

2. Step 2: Check options

   assertAll(() -> assertEquals(5, sum), () -> assertTrue(flag)); correctly uses lambdas with parentheses. Options A, B, and D use incorrect syntax like missing lambdas, braces, or wrong brackets.

3. Final Answer:

   assertAll(() -> assertEquals(5, sum), () -> assertTrue(flag)); -> Option A

4. Quick Check:

   assertAll uses lambdas with parentheses = C [OK]

Hint: Use lambdas inside parentheses for assertAll [OK]

Common Mistakes:

• Omitting lambda arrows () ->
• Using curly braces instead of parentheses
• Passing assertions directly without lambdas

3. Given the code below, what will be the test result?

assertAll(
  () -> assertEquals(2, 1 + 1),
  () -> assertTrue(3 > 5),
  () -> assertFalse(false)
);

medium

A. Test fails showing only the second assertion failure.

B. Test fails showing failures for the second assertion only, but all assertions run.

C. Test fails showing failures for the second assertion only.

D. Test passes because two assertions are true.

Solution

1. Step 1: Evaluate each assertion

   First assertion: 1+1 equals 2, passes. Second: 3 > 5 is false, fails. Third: assertFalse(false) passes.

2. Step 2: Understand assertAll behavior

   All assertions run. The test fails because one assertion failed. The failure report shows the second assertion failure only.

3. Final Answer:

   Test fails showing failures for the second assertion only, but all assertions run. -> Option B

4. Quick Check:

   assertAll runs all, reports all failures = D [OK]

Hint: assertAll runs all assertions, reports all failures [OK]

Common Mistakes:

• Thinking test passes if some assertions pass
• Believing assertAll stops at first failure
• Expecting multiple failure messages when only one fails

4. Identify the error in the following JUnit 5 test code using assertAll:

assertAll(
  () -> assertEquals(10, calculate()),
  assertTrue(isReady())
);

medium

A. assertAll cannot take more than one assertion.

B. assertEquals should be replaced with assertSame.

C. Missing lambda expression for the second assertion.

D. assertTrue should be inside curly braces.

Solution

1. Step 1: Check assertAll argument types

   Each argument to assertAll must be a lambda expression or executable.

2. Step 2: Identify the problem

   The second argument assertTrue(isReady()) is a method call, not a lambda. It should be wrapped as () -> assertTrue(isReady()).

3. Final Answer:

   Missing lambda expression for the second assertion. -> Option C

4. Quick Check:

   assertAll needs lambdas for each assertion = A [OK]

Hint: Wrap each assertion in () -> for assertAll [OK]

Common Mistakes:

• Passing assertions directly without lambdas
• Confusing assertEquals with assertSame
• Using curly braces instead of lambdas

5. You want to test a Person object's fields name, age, and email together using assertAll. Which code snippet correctly groups these assertions and reports all failures at once?

Person p = new Person("Alice", 30, "[e-mail]");
// Choose the correct assertAll usage:

hard

A. assertAll[
() -> assertEquals("Alice", p.getName()),
() -> assertEquals(30, p.getAge()),
() -> assertEquals("[e-mail]", p.getEmail())
];

B. assertAll(
assertEquals("Alice", p.getName()),
assertEquals(30, p.getAge()),
assertEquals("[e-mail]", p.getEmail())
);

C. assertAll(() -> {
assertEquals("Alice", p.getName());
assertEquals(30, p.getAge());
assertEquals("[e-mail]", p.getEmail());
});

D. assertAll(
() -> assertEquals("Alice", p.getName()),
() -> assertEquals(30, p.getAge()),
() -> assertEquals("[e-mail]", p.getEmail())
);

Solution

1. Step 1: Understand assertAll argument requirements

   assertAll expects multiple lambda expressions as separate arguments, each containing one assertion.

2. Step 2: Evaluate each option

   assertAll( () -> assertEquals("Alice", p.getName()), () -> assertEquals(30, p.getAge()), () -> assertEquals("[e-mail]", p.getEmail()) ); correctly passes three lambdas as separate arguments. assertAll( assertEquals("Alice", p.getName()), assertEquals(30, p.getAge()), assertEquals("[e-mail]", p.getEmail()) ); passes method calls directly, which is invalid. assertAll(() -> { assertEquals("Alice", p.getName()); assertEquals(30, p.getAge()); assertEquals("[e-mail]", p.getEmail()); }); passes a single lambda with multiple assertions inside, which does not report all failures separately. assertAll[ () -> assertEquals("Alice", p.getName()), () -> assertEquals(30, p.getAge()), () -> assertEquals("[e-mail]", p.getEmail()) ]; uses square brackets, which is invalid syntax.

3. Final Answer:

   assertAll( () -> assertEquals("Alice", p.getName()), () -> assertEquals(30, p.getAge()), () -> assertEquals("[e-mail]", p.getEmail()) ); -> Option D

4. Quick Check:

   assertAll needs separate lambdas for each assertion = A [OK]

Hint: Use separate lambdas for each assertion inside assertAll [OK]

Common Mistakes:

• Passing assertions directly without lambdas
• Using one lambda with multiple assertions inside
• Using wrong brackets like [] instead of ()