when().thenThrow() for exceptions in JUnit - Build an Automation Script

Verify method throws exception using when().thenThrow() in JUnit with Mockito

Preconditions (3)

Step 1: Mock the dependency that the service class uses

Step 2: Use when().thenThrow() to simulate an exception when the method is called

Step 3: Call the service method that uses the mocked dependency

Step 4: Catch the exception or use assertion to verify the exception is thrown

✅ Expected Result: The test should pass if the expected exception is thrown when the method is called

Automation Requirements - JUnit 5 with Mockito

Assertions Needed:

Assert that the expected exception is thrown using assertThrows

Best Practices:

Use @ExtendWith(MockitoExtension.class) to enable Mockito in JUnit 5

Use explicit exception assertion with assertThrows instead of try-catch

Mock only the dependencies, not the class under test

Use descriptive method names for test clarity

Automated Solution

JUnit

import static org.mockito.Mockito.when;
import static org.junit.jupiter.api.Assertions.assertThrows;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

class Dependency {
    String getData() {
        return "real data";
    }
}

class Service {
    private final Dependency dependency;

    Service(Dependency dependency) {
        this.dependency = dependency;
    }

    String fetchData() {
        return dependency.getData();
    }
}

@ExtendWith(MockitoExtension.class)
public class ServiceTest {

    @Mock
    Dependency dependency;

    @InjectMocks
    Service service;

    @Test
    void fetchData_shouldThrowException_whenDependencyThrows() {
        when(dependency.getData()).thenThrow(new RuntimeException("Dependency failure"));

        RuntimeException thrown = assertThrows(RuntimeException.class, () -> {
            service.fetchData();
        });

        // Optional: verify exception message
        org.junit.jupiter.api.Assertions.assertEquals("Dependency failure", thrown.getMessage());
    }
}

This test uses Mockito to mock the Dependency class. The when().thenThrow() method tells Mockito to throw a RuntimeException when getData() is called.

The assertThrows method from JUnit 5 checks that the exception is actually thrown when service.fetchData() is called. This is cleaner and clearer than using try-catch blocks.

Annotations @Mock and @InjectMocks set up the test objects automatically. The @ExtendWith(MockitoExtension.class) enables Mockito support in JUnit 5.

This approach ensures the test fails if the exception is not thrown, making the test reliable and easy to understand.

Common Mistakes - 4 Pitfalls

{'mistake': 'Not using assertThrows and instead using try-catch to check exceptions', 'why_bad': 'Try-catch makes tests longer and less clear. It can also hide failures if assertions are missed.', 'correct_approach': "Use JUnit 5's assertThrows to clearly and concisely assert exceptions."}

Mocking the class under test instead of its dependencies

Not initializing Mockito annotations with @ExtendWith(MockitoExtension.class)

Using generic Exception instead of specific exception types

Bonus Challenge

Now add data-driven testing with 3 different exceptions thrown by the dependency

Show Hint

Practice

1. What is the main purpose of using when().thenThrow() in JUnit tests?

easy

A. To verify that a method returns a specific value

B. To skip the execution of a test method

C. To create a new instance of a class

D. To simulate an exception being thrown by a mocked method

Solution

1. Step 1: Understand the role of when().thenThrow()

   This syntax is used in mocking frameworks like Mockito to simulate exceptions when a mocked method is called.

2. Step 2: Identify the purpose in testing

   It helps test how your code handles exceptions by forcing the mocked method to throw an exception.

3. Final Answer:

   To simulate an exception being thrown by a mocked method -> Option D

4. Quick Check:

   Exception simulation [OK]

Hint: Use when().thenThrow() to simulate errors in mocks [OK]

Common Mistakes:

• Confusing exception simulation with return value mocking
• Thinking it creates real exceptions instead of simulated ones
• Using it to skip tests instead of throwing exceptions

2. Which of the following is the correct syntax to make a mocked method throw an IllegalArgumentException using Mockito?

easy

A. when(mock.method()).throwException(IllegalArgumentException)

B. when(mock.method()).thenThrow(new IllegalArgumentException())

C. mock.method().thenThrow(IllegalArgumentException)

D. when(mock.method()).throws(IllegalArgumentException)

Solution

1. Step 1: Recall Mockito syntax for throwing exceptions

   The correct syntax uses when(mock.method()).thenThrow(new ExceptionType()).

2. Step 2: Match the options with correct syntax

   when(mock.method()).thenThrow(new IllegalArgumentException()) matches the correct syntax exactly, creating a new exception instance inside thenThrow().

3. Final Answer:

   when(mock.method()).thenThrow(new IllegalArgumentException()) -> Option B

4. Quick Check:

   Correct Mockito exception syntax [OK]

Hint: Use thenThrow(new Exception()) with when() for exceptions [OK]

Common Mistakes:

• Using throwException or throws which are not Mockito methods
• Not creating a new exception instance
• Calling thenThrow directly on mock.method()

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

MyService mockService = mock(MyService.class);
when(mockService.getData()).thenThrow(new RuntimeException("Error"));

assertThrows(RuntimeException.class, () -> mockService.getData());

medium

A. Test passes because RuntimeException is thrown as expected

B. Test fails because no exception is thrown

C. Test fails due to syntax error in when().thenThrow()

D. Test passes but exception type is incorrect

Solution

1. Step 1: Analyze the mocking behavior

   The mocked method getData() is set to throw a RuntimeException when called.

2. Step 2: Understand the assertion

   assertThrows expects a RuntimeException from calling mockService.getData().

3. Final Answer:

   Test passes because RuntimeException is thrown as expected -> Option A

4. Quick Check:

   Exception thrown matches assertThrows [OK]

Hint: assertThrows expects the exception thrown by thenThrow() [OK]

Common Mistakes:

• Assuming no exception is thrown from mocked method
• Confusing exception types in assertThrows
• Thinking thenThrow causes syntax errors

4. Identify the error in the following test code using Mockito:

when(mockService.getData()).thenThrow(RuntimeException.class);
assertThrows(RuntimeException.class, () -> mockService.getData());

medium

A. Missing try-catch block around mockService.getData()

B. assertThrows should not be used with exceptions

C. Incorrect use of thenThrow with exception class instead of instance

D. No error; code is correct

Solution

1. Step 1: Check thenThrow argument type

   thenThrow requires an exception instance, not a class type.

2. Step 2: Identify correct usage

   The code should use thenThrow(new RuntimeException()) instead of passing the class.

3. Final Answer:

   Incorrect use of thenThrow with exception class instead of instance -> Option C

4. Quick Check:

   thenThrow needs exception instance [OK]

Hint: Use new Exception() inside thenThrow(), not exception class [OK]

Common Mistakes:

• Passing exception class instead of instance to thenThrow
• Expecting assertThrows to catch exceptions without mocking
• Adding unnecessary try-catch in test

5. You want to test that your service handles a NullPointerException thrown by a dependency's void call() method. Which of the following code snippets correctly mocks the dependency and verifies the exception handling using JUnit and Mockito?

hard

A. doThrow(new NullPointerException()).when(dependency).call();
assertThrows(NullPointerException.class, () -> service.callDependency());

B. when(dependency.call()).thenThrow(NullPointerException.class);
assertThrows(Exception.class, () -> service.callDependency());

C. when(dependency.call()).thenReturn(null);
assertThrows(NullPointerException.class, () -> service.callDependency());

D. when(dependency.call()).thenThrow(new NullPointerException());
assertThrows(NullPointerException.class, () -> service.callDependency());

Solution

1. Step 1: Understand mocking exceptions with void methods

   If dependency.call() is a void method, doThrow().when() is the correct way to mock exceptions.

2. Step 2: Verify correct assertion

   assertThrows(NullPointerException.class, () -> service.callDependency()) correctly checks that the service handles the exception.

3. Step 3: Analyze options

   when(dependency.call()).thenThrow(new NullPointerException()); assertThrows(NullPointerException.class, () -> service.callDependency()); uses when().thenThrow() which works only for non-void methods. when(dependency.call()).thenThrow(NullPointerException.class); assertThrows(Exception.class, () -> service.callDependency()); passes class instead of instance and wrong exception type in assertion. when(dependency.call()).thenReturn(null); assertThrows(NullPointerException.class, () -> service.callDependency()); returns null instead of throwing exception.

4. Final Answer:

   doThrow(new NullPointerException()).when(dependency).call(); assertThrows(NullPointerException.class, () -> service.callDependency()); -> Option A

5. Quick Check:

   Use doThrow for void methods + assertThrows [OK]

Hint: Use doThrow() for void methods, then assertThrows() to check [OK]

Common Mistakes:

• Using thenThrow() on void methods
• Passing exception class instead of instance
• Asserting wrong exception type
• Returning null instead of throwing exception