Single assertion per test debate in JUnit - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is the main idea behind the 'single assertion per test' approach?

It means each test method should check only one condition or behavior to keep tests simple and focused.

intermediate

Why might some developers prefer multiple assertions in one test?

Because it can reduce the number of test methods and group related checks, making tests shorter.

beginner

What is a downside of having multiple assertions in a single test?

If one assertion fails, the rest are skipped, so you might miss other problems in the same test run.

beginner

How does the single assertion rule help with debugging test failures?

It makes it clear exactly what failed, so you can fix problems faster without guessing which check caused the failure.

intermediate

Can you combine multiple related checks in one test without violating the single assertion idea?

Yes, by using one assertion that checks a combined condition or by splitting tests logically to keep clarity.

What is a key benefit of using a single assertion per test?

A Easier to identify which check failed

B Fewer test methods to write

C Runs tests faster

D Allows ignoring failures

Using one assertion per test helps quickly find the exact failure cause.

What happens if a test with multiple assertions fails on the first assertion?

A Remaining assertions are skipped

B All assertions run anyway

C Test automatically retries

D Test passes

JUnit stops running the test after the first failed assertion.

Which is a reason to use multiple assertions in one test?

A To avoid writing any assertions

B To group related checks together

C To make debugging harder

D To slow down test execution

Grouping related checks can make tests shorter and organized.

How can you keep tests clear while testing multiple conditions?

A Write tests without names

B Put all assertions in one big test

C Avoid assertions completely

D Use one assertion per test method

One assertion per test keeps tests focused and easy to understand.

What is a practical compromise in the single assertion debate?

A Write one test for the whole app

B Never write assertions

C Use one assertion per test only for unrelated checks

D Ignore test failures

You can group related checks but keep unrelated ones separate for clarity.

Explain the pros and cons of using a single assertion per test in JUnit.

Think about test clarity and failure detection.

Describe how you would decide when to use single or multiple assertions in a test.

Focus on clarity and maintenance.

Practice

1. Why is it recommended to have only one assertion per test in JUnit testing?

easy

A. It makes tests simpler and easier to understand.

B. It reduces the total number of tests needed.

C. It allows multiple failures to be reported at once.

D. It speeds up the execution time of tests significantly.

Solution

1. Step 1: Understand test simplicity

   Having one assertion per test keeps the test focused and easy to read.

2. Step 2: Understand failure clarity

   When a test fails, it is clear exactly what went wrong because only one condition is checked.

3. Final Answer:

   It makes tests simpler and easier to understand. -> Option A

4. Quick Check:

   One assertion = simple test [OK]

Hint: One assertion means clear, simple tests [OK]

Common Mistakes:

• Thinking multiple assertions speed up tests
• Believing one test must cover many cases
• Confusing test simplicity with fewer tests

2. Which of the following JUnit test method structures follows the single assertion per test best practice?

easy

A. @Test
void testSum() {
assertTrue(sum(2, 3) > 0);
assertTrue(sum(3, 4) > 0);
}

B. @Test
void testSum() {
assertEquals(5, sum(2, 3));
assertEquals(7, sum(3, 4));
}

C. @Test
void testSum() {
int result = sum(2, 3);
assertTrue(result > 0);
assertEquals(5, result);
}

D. @Test
void testSum() {
assertEquals(5, sum(2, 3));
}

@Test
void testSumNegative() {
assertEquals(-1, sum(-2, 1));
}

Solution

1. Step 1: Review each test method

   @Test void testSum() { assertEquals(5, sum(2, 3)); } @Test void testSumNegative() { assertEquals(-1, sum(-2, 1)); } splits checks into two separate test methods, each with one assertion.

2. Step 2: Compare with other options

   Options B, C, and D have multiple assertions in one test method, which breaks the single assertion rule.

3. Final Answer:

   Separate tests with one assertion each. -> Option D

4. Quick Check:

   One assertion per test method = @Test void testSum() { assertEquals(5, sum(2, 3)); } @Test void testSumNegative() { assertEquals(-1, sum(-2, 1)); } [OK]

Hint: One test, one assertion, split tests if needed [OK]

Common Mistakes:

• Putting multiple assertions in one test method
• Not splitting tests logically
• Confusing assertTrue with assertEquals usage

3. Given the following JUnit test, what will be the test result if sum(2, 3) returns 6?

@Test
void testSum() {
  assertEquals(5, sum(2, 3));
}

medium

A. Test passes successfully.

B. Test fails with an assertion error.

C. Test throws a compilation error.

D. Test is ignored during execution.

Solution

1. Step 1: Understand assertEquals behavior

   assertEquals expects the first and second values to be equal for the test to pass.

2. Step 2: Compare expected and actual values

   Expected is 5, actual is 6, so they do not match, causing failure.

3. Final Answer:

   Test fails with an assertion error. -> Option B

4. Quick Check:

   Expected != actual -> fail [OK]

Hint: Mismatch in assertEquals causes failure [OK]

Common Mistakes:

• Assuming test passes if values differ
• Confusing compilation errors with assertion failures
• Thinking test is skipped without @Ignore

4. Identify the problem in this JUnit test method regarding the single assertion per test principle:

@Test
void testUser() {
  assertEquals("John", user.getName());
  assertEquals(30, user.getAge());
}

medium

A. The test method is missing the @Before annotation.

B. The assertEquals methods are used incorrectly with wrong parameter order.

C. The test method has multiple assertions, making it harder to find failures.

D. The test method should use assertTrue instead of assertEquals.

Solution

1. Step 1: Check number of assertions

   The test has two assertEquals calls, violating the single assertion rule.

2. Step 2: Understand impact of multiple assertions

   Multiple assertions make it unclear which check failed if the test fails.

3. Final Answer:

   The test method has multiple assertions, making it harder to find failures. -> Option C

4. Quick Check:

   Multiple assertions = unclear failure [OK]

Hint: One assertion per test avoids confusion [OK]

Common Mistakes:

• Thinking multiple assertions are always better
• Confusing @Before with test assertions
• Misusing assertEquals parameter order

5. You have a method calculateDiscount that returns a discount percentage based on user type and purchase amount. How should you write JUnit tests following the single assertion per test debate best practice?

hard

A. Write separate test methods for each user type and purchase amount combination, each with one assertion.

B. Write tests only for the most common user type and skip others.

C. Write one test method that asserts the discount is never negative, ignoring user types.

D. Write one test method with multiple assertions checking all user types and amounts.

Solution

1. Step 1: Understand test coverage needs

   Each user type and purchase amount combination can behave differently and needs separate testing.

2. Step 2: Apply single assertion per test

   Writing separate test methods with one assertion each keeps tests clear and failures easy to locate.

3. Final Answer:

   Write separate test methods for each user type and purchase amount combination, each with one assertion. -> Option A

4. Quick Check:

   Separate focused tests = Write separate test methods for each user type and purchase amount combination, each with one assertion. [OK]

Hint: Split tests by case, one assertion each [OK]

Common Mistakes:

• Combining many assertions in one test
• Ignoring edge cases for coverage
• Skipping tests for less common inputs