doReturn and doThrow in JUnit - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does doReturn() do in JUnit mocking?

doReturn() tells a mock object to return a specific value when a method is called. It is useful when you want to avoid calling the real method.

beginner

How does doThrow() work in JUnit mocking?

doThrow() makes a mock method throw an exception when called. This helps test how your code handles errors.

intermediate

Why use doReturn() instead of when().thenReturn() in JUnit?

doReturn() is safer when mocking methods that are final, private, or have side effects. It avoids calling the real method during setup.

beginner

Show a simple example of doThrow() usage in JUnit.

doThrow(new RuntimeException()).when(mockedObject).someMethod();

This makes someMethod() throw a RuntimeException when called.

intermediate

What is the difference between doReturn() and thenReturn() in JUnit mocking?

thenReturn() is used with when() and calls the real method during setup, which can cause issues. doReturn() does not call the real method and is safer for certain cases.

What does doReturn(value).when(mock).method() do?

A Calls the real method <code>method()</code> on <code>mock</code>.

B Throws an exception when <code>method()</code> is called.

C Returns <code>value</code> when <code>method()</code> is called on <code>mock</code>.

D Does nothing.

doReturn() sets the return value for the mocked method call.

Which method is used to make a mock throw an exception when a method is called?

A doThrow()

B thenReturn()

C doReturn()

D when()

doThrow() makes the mock throw an exception on method call.

Why might you prefer doReturn() over when().thenReturn()?

A Because <code>doReturn()</code> avoids calling the real method during setup.

B Because <code>doReturn()</code> is slower.

C Because <code>when().thenReturn()</code> throws exceptions always.

D Because <code>doReturn()</code> calls the real method.

doReturn() avoids calling the real method, which is safer for some methods.

What happens if you use doThrow(new Exception()).when(mock).method()?

A The method returns normally.

B The method throws the specified exception when called.

C The method is never called.

D The mock is reset.

The mock method throws the exception when called.

Which of these is NOT a reason to use doReturn()?

A Mocking private methods.

B Avoiding side effects during setup.

C Mocking final methods.

D Calling the real method during setup.

doReturn() avoids calling the real method; calling it is a reason to avoid when().thenReturn().

Explain how doReturn() and doThrow() help in mocking with JUnit.

Think about how you control what a mock does when a method is called.

Describe a situation where doReturn() is better than when().thenReturn().

Consider methods that are hard or risky to call during test setup.

Practice

1. What is the main purpose of doReturn in JUnit mocking?

easy

A. To specify a value that a mocked method should return when called

B. To make a mocked method throw an exception

C. To verify how many times a method was called

D. To reset the state of a mock object

Solution

1. Step 1: Understand doReturn usage

   doReturn is used to tell a mock what value to return when a specific method is called.

2. Step 2: Differentiate from doThrow

   doThrow makes the method throw an exception, not return a value.

3. Final Answer:

   To specify a value that a mocked method should return when called -> Option A

4. Quick Check:

   doReturn sets return value [OK]

Hint: Remember: doReturn returns a value, doThrow throws exception [OK]

Common Mistakes:

• Confusing doReturn with doThrow
• Thinking doReturn verifies method calls
• Assuming doReturn resets mocks

2. Which of the following is the correct syntax to make a mock method throw an exception using doThrow?

easy

A. doThrow().when(mockObject).methodName(new IOException());

B. doThrow(IOException).when(mockObject).methodName();

C. doThrow(new IOException()).when(mockObject).methodName();

D. doThrow(new IOException).methodName().when(mockObject);

Solution

1. Step 1: Recall correct doThrow syntax

   The correct syntax is doThrow(new ExceptionType()).when(mock).method(); to specify the exception and method.

2. Step 2: Check each option

   doThrow(new IOException()).when(mockObject).methodName(); matches the correct syntax exactly. Others have misplaced parentheses or wrong order.

3. Final Answer:

   doThrow(new IOException()).when(mockObject).methodName(); -> Option C

4. Quick Check:

   Correct doThrow syntax = doThrow(new IOException()).when(mockObject).methodName(); [OK]

Hint: Use new Exception() inside doThrow, then when(mock).method() [OK]

Common Mistakes:

• Omitting 'new' before exception
• Placing parentheses incorrectly
• Calling method before when()

3. Given the following code snippet, what will be the output when mockService.getData() is called?

MyService mockService = mock(MyService.class);
doReturn("Hello").when(mockService).getData();
doThrow(new RuntimeException()).when(mockService).getData();
System.out.println(mockService.getData());

medium

A. Hello

B. RuntimeException is thrown

C. null

D. Compilation error

Solution

1. Step 1: Analyze the order of stubbing

   First doReturn("Hello") is set, then doThrow(RuntimeException) overrides it for the same method.

2. Step 2: Determine which stub applies on method call

   The last stub doThrow takes effect, so calling getData() throws RuntimeException.

3. Final Answer:

   RuntimeException is thrown -> Option B

4. Quick Check:

   Last stub wins, so exception thrown [OK]

Hint: Last doReturn or doThrow for method overrides previous [OK]

Common Mistakes:

• Assuming first stub applies
• Expecting returned string instead of exception
• Thinking code won't compile

4. Identify the error in the following code snippet using doReturn and doThrow:

doReturn("Success").when(mockService).process();
doThrow(new IllegalArgumentException()).when(mockService).process();
doReturn("Done").when(mockService).process();
String result = mockService.process();

medium

A. The code will throw IllegalArgumentException at runtime

B. Cannot use doReturn and doThrow on the same method

C. doThrow must be called after doReturn to work

D. The last doReturn overrides previous stubs, so no error

Solution

1. Step 1: Understand stub overriding order

   Stubs are applied in order; the last stub for a method is effective.

2. Step 2: Check the last stub

   The last stub is doReturn("Done"), so calling process() returns "Done" without exception.

3. Final Answer:

   The last doReturn overrides previous stubs, so no error -> Option D

4. Quick Check:

   Last stub wins, no exception thrown [OK]

Hint: Last stub for method call is effective, no conflict error [OK]

Common Mistakes:

• Thinking doThrow always throws exception regardless of order
• Believing mixing doReturn and doThrow causes compile error
• Expecting exception thrown despite last stub

5. You want to test a method that calls externalService.fetch(). You want to simulate two calls: the first returns "Data1", the second throws an IOException. Which is the correct way to stub fetch() using doReturn and doThrow?

hard

A. doReturn("Data1").doThrow(new IOException()).when(externalService).fetch();

B. doReturn("Data1").when(externalService).fetch(); doThrow(new IOException()).when(externalService).fetch();

C. doReturn("Data1").when(externalService).fetch(); doReturn("Data2").when(externalService).fetch();

D. doThrow(new IOException()).doReturn("Data1").when(externalService).fetch();

Solution

1. Step 1: Understand chaining stubs for multiple calls

   Mockito allows chaining stubs with doReturn(...).doThrow(...).when(mock).method(); to simulate sequential calls.

2. Step 2: Analyze options

   doReturn("Data1").doThrow(new IOException()).when(externalService).fetch(); correctly chains doReturn then doThrow for first return and second throw. Separate doReturn("Data1").when(externalService).fetch(); doThrow(new IOException()).when(externalService).fetch(); overrides stubs, causing all calls to throw the exception. The other options use repeated returns or incorrect order.

3. Final Answer:

   doReturn("Data1").doThrow(new IOException()).when(externalService).fetch(); -> Option A

4. Quick Check:

   Chain doReturn then doThrow for sequential calls [OK]

Hint: Chain doReturn().doThrow() for sequential call behaviors [OK]

Common Mistakes:

• Overwriting stubs instead of chaining
• Wrong order of doThrow and doReturn
• Expecting multiple when() calls for sequence