when().thenThrow() for exceptions in JUnit - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of when().thenThrow() with checked exception

What will be the output when the following JUnit test runs?

JUnit

import static org.mockito.Mockito.*;
import org.junit.jupiter.api.Test;
import java.io.IOException;

class Service {
    void perform() throws IOException {
        // does something
    }
}

public class ServiceTest {
    @Test
    void testPerformThrows() throws IOException {
        Service mockService = mock(Service.class);
        when(mockService.perform()).thenThrow(new IOException("IO error"));
        mockService.perform();
    }
}

A Test fails with IOException: IO error

B Test passes without exception

C Test fails with NullPointerException

D Test fails with RuntimeException

💡 Hint

when().thenThrow() makes the mock throw the specified exception when the method is called.

The mock is set to throw an IOException when perform() is called. Since the test calls perform(), it throws IOException causing the test to fail unless the exception is caught or expected.

❓ assertion

intermediate

Correct assertion to verify exception thrown by mock

Which assertion correctly verifies that the mocked method throws the expected exception?

JUnit

import static org.mockito.Mockito.*;
import static org.mockito.ArgumentMatchers.*;
import static org.junit.jupiter.api.Assertions.*;
import org.junit.jupiter.api.Test;

class Calculator {
    int divide(int a, int b) {
        return a / b;
    }
}

public class CalculatorTest {
    @Test
    void testDivideThrows() {
        Calculator mockCalc = mock(Calculator.class);
        when(mockCalc.divide(anyInt(), eq(0))).thenThrow(new ArithmeticException("Divide by zero"));
        // Which assertion below is correct?
    }
}

A assertDoesNotThrow(() -> mockCalc.divide(10, 0));

B assertTrue(mockCalc.divide(10, 0) == 0);

C assertThrows(ArithmeticException.class, () -> mockCalc.divide(10, 0));

D assertEquals(0, mockCalc.divide(10, 0));

💡 Hint

Use assertThrows to check if a method call throws an exception.

assertThrows expects the specified exception to be thrown by the lambda expression. This matches the mock setup that throws ArithmeticException when dividing by zero.

🔧 Debug

advanced

Identify the error in when().thenThrow() usage

What is the error in the following test code that uses when().thenThrow()?

JUnit

import static org.mockito.Mockito.*;
import org.junit.jupiter.api.Test;

class Network {
    void connect() {
        // connects to network
    }
}

public class NetworkTest {
    @Test
    void testConnectThrows() {
        Network mockNetwork = mock(Network.class);
        when(mockNetwork.connect()).thenThrow(new Exception("Connection failed"));
        mockNetwork.connect();
    }
}

A Mocking void method with when() is correct

B thenThrow() cannot throw Exception objects

C No error, test will pass

D Cannot throw checked Exception without declaring it or handling it

💡 Hint

Check if the exception thrown is checked and if the method signature allows it.

connect() does not declare throwing checked Exception, so thenThrow(new Exception()) causes a compile error. For void methods, doThrow() should be used instead.

🧠 Conceptual

advanced

Difference between thenThrow() and doThrow() in Mockito

Which statement correctly describes the difference between thenThrow() and doThrow() when mocking exceptions?

A thenThrow() throws checked exceptions; doThrow() throws unchecked exceptions only

B thenThrow() is used for methods with return values; doThrow() is used for void methods

C thenThrow() can only throw RuntimeException; doThrow() can throw any Throwable

D thenThrow() is deprecated; doThrow() is the recommended replacement

💡 Hint

Consider method return types when choosing between thenThrow() and doThrow().

thenThrow() is used to stub methods that return a value to throw exceptions. doThrow() is used to stub void methods to throw exceptions.

❓ framework

expert

JUnit test behavior with chained thenThrow() calls

Given the following mock setup, what exception is thrown on the second call to process()?

JUnit

import static org.mockito.Mockito.*;
import org.junit.jupiter.api.Test;

class Processor {
    String process() {
        return "done";
    }
}

public class ProcessorTest {
    @Test
    void testProcessMultipleExceptions() {
        Processor mockProcessor = mock(Processor.class);
        when(mockProcessor.process())
            .thenThrow(new IllegalStateException("First call failed"))
            .thenThrow(new IllegalArgumentException("Second call failed"));
        try {
            mockProcessor.process();
        } catch (Exception e) {
            System.out.println(e.getClass().getSimpleName() + ": " + e.getMessage());
        }
        try {
            mockProcessor.process();
        } catch (Exception e) {
            System.out.println(e.getClass().getSimpleName() + ": " + e.getMessage());
        }
    }
}

A IllegalArgumentException with message 'Second call failed'

B IllegalStateException with message 'First call failed'

C No exception thrown on second call

D RuntimeException with no message

💡 Hint

Mockito chains thenThrow calls to throw exceptions in order on consecutive calls.

The first call throws IllegalStateException, the second call throws IllegalArgumentException as configured by chained thenThrow calls.

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