Why different doubles serve different purposes in JUnit - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Purpose of a Mock in Unit Testing

In JUnit testing, what is the main purpose of using a mock double?

A To simulate the behavior of real objects and verify interactions with them

B To replace the entire system under test with a fake implementation

C To store test data for later use in assertions

D To generate random input data automatically during tests

💡 Hint

Think about how mocks help check if certain methods were called.

Mocks simulate real objects and allow verification of method calls and interactions, which helps ensure the tested code behaves correctly.

🧠 Conceptual

intermediate

Difference Between Stub and Fake

Which statement best describes the difference between a stub and a fake test double?

A A stub records interactions, while a fake only returns null values

B A stub provides predefined responses, while a fake has a working implementation but is simpler than the real object

C A stub is used for integration tests, while a fake is used only in UI tests

D A stub is a real object, while a fake is a mock object

💡 Hint

Consider which double has actual logic and which just returns fixed data.

Stubs return fixed data for testing, while fakes have simple working implementations that behave like the real object but are easier to use.

❓ Predict Output

advanced

JUnit Mock Verification Output

What will be the output of the following JUnit test using Mockito when the verification fails?

JUnit

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

class ServiceTest {
    @Test
    void testServiceCall() {
        Service mockService = mock(Service.class);
        // No method call on mockService
        verify(mockService).performAction();
    }
}

interface Service {
    void performAction();
}

A Test passes with no output

B NullPointerException at verify line

C org.mockito.exceptions.verification.junit.ArgumentsAreDifferent: Wanted but not invoked: performAction()

D Compilation error due to missing method implementation

💡 Hint

Think about what happens if you verify a method call that never happened.

Mockito throws a verification error if a method expected to be called was never invoked on the mock.

❓ assertion

advanced

Correct Assertion for Stubbed Method Return

Given a stubbed method in JUnit using Mockito that returns a fixed value, which assertion correctly verifies the returned value?

JUnit

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

class CalculatorTest {
    @Test
    void testAdd() {
        Calculator calc = mock(Calculator.class);
        when(calc.add(2, 3)).thenReturn(5);
        int result = calc.add(2, 3);
        // Which assertion is correct here?
    }
}

interface Calculator {
    int add(int a, int b);
}

A assertFalse(result == 5);

B assertTrue(result == 6);

C assertNull(result);

D assertEquals(5, result);

💡 Hint

Check the expected value from the stubbed method.

The stubbed method returns 5 for inputs 2 and 3, so the assertion must check for 5.

❓ framework

expert

Choosing the Right Test Double for Integration Testing

In a complex integration test involving a database and external API, which test double is most appropriate to isolate the external API while keeping realistic behavior for the database?

A Use a fake for the external API and real database connection

B Use a stub for the database and a mock for the external API

C Use a mock for the database and a stub for the external API

D Use a mock for both the database and external API

💡 Hint

Consider which double provides simple working behavior and which verifies interactions.

Fakes provide simple working implementations suitable for external APIs in integration tests, while using the real database keeps realistic data behavior.

Practice

1. Which test double is primarily used to provide predefined data to the code under test without verifying interactions?

easy

A. Stub

B. Mock

C. Spy

D. Fake

Solution

1. Step 1: Understand the role of a stub

   A stub provides fixed data or responses to the code being tested but does not check if methods were called.

2. Step 2: Differentiate from mocks and spies

   Mocks verify interactions, spies do both spying and stubbing, and fakes are simplified implementations. Only stubs focus on providing data without verification.

3. Final Answer:

   Stub -> Option A

4. Quick Check:

   Stub = provides data only [OK]

Hint: Stubs give data, mocks check calls, spies do both [OK]

Common Mistakes:

• Confusing mocks with stubs
• Thinking spies only provide data
• Mixing fakes with stubs

2. Which of the following is the correct way to create a mock object using Mockito in JUnit?

easy

A. MyClass mock = spy(new MyClass());

B. MyClass mock = new MyClass();

C. MyClass mock = Mockito.mock(MyClass.class);

D. MyClass mock = new FakeMyClass();

Solution

1. Step 1: Recall Mockito syntax for mocks

   Mockito.mock(Class.class) creates a mock object for the given class.

2. Step 2: Identify incorrect options

   MyClass mock = new MyClass(); creates a real object, not a mock. MyClass mock = spy(new MyClass()); creates a spy, not a mock. MyClass mock = new FakeMyClass(); uses a fake class, not a mock.

3. Final Answer:

   MyClass mock = Mockito.mock(MyClass.class); -> Option C

4. Quick Check:

   Mockito.mock() creates mocks [OK]

Hint: Use Mockito.mock(Class.class) to create mocks [OK]

Common Mistakes:

• Using new keyword instead of Mockito.mock
• Confusing spy() with mock()
• Assuming fake classes are mocks

3. Given the following code snippet using Mockito:

List<String> list = Mockito.spy(new ArrayList<>());
list.add("one");
Mockito.verify(list).add("one");
System.out.println(list.size());

What will be printed?

medium

A. 0

B. null

C. Throws an exception

D. 1

Solution

1. Step 1: Understand spy behavior

   A spy wraps a real object and records interactions but calls real methods unless stubbed.

2. Step 2: Analyze the code execution

   Adding "one" to the spy list calls the real add method, so the list size becomes 1. The verify confirms the add call happened.

3. Final Answer:

   1 -> Option D

4. Quick Check:

   Spy calls real methods and records calls [OK]

Hint: Spy calls real methods and tracks calls [OK]

Common Mistakes:

• Thinking spy does not call real methods
• Assuming size remains 0 after add
• Expecting null or exception output

4. Identify the error in this Mockito test code:

MyService service = Mockito.mock(MyService.class);
service.process();
Mockito.verify(service.process());

medium

A. Missing MockitoAnnotations.initMocks(this) call

B. verify() should receive a method call without parentheses

C. verify() should be called before process()

D. process() method cannot be mocked

Solution

1. Step 1: Understand Mockito verify syntax

   Mockito.verify() expects the mock object as argument, then the method call without parentheses inside verify.

2. Step 2: Identify the mistake in code

   The code calls verify(service.process()), which calls process() immediately and passes its result. Correct is verify(service).process().

3. Final Answer:

   verify() should receive a method call without parentheses -> Option B

4. Quick Check:

   Use verify(mock).method() syntax [OK]

Hint: Use verify(mock).method() without parentheses inside verify [OK]

Common Mistakes:

• Calling method inside verify() parentheses
• Calling verify before method execution
• Confusing mock initialization with verification

5. You want to test a method that calls an external payment service. You need to check that the payment method was called with correct parameters, but also want to return a fixed success response. Which test double should you use?

hard

A. Mock

B. Spy

C. Stub

D. Fake

Solution

1. Step 1: Understand requirements for the test double

   You want to verify the method call (like a mock) and also provide a fixed response (like a stub).

2. Step 2: Identify the double that combines both features

   A mock verifies interactions and can return fixed responses when configured with when(mock.method(params)).thenReturn(success).

3. Final Answer:

   Mock -> Option A

4. Quick Check:

   Mock = verify calls + stub data [OK]

Hint: Mock verifies calls and stubs responses [OK]

Common Mistakes:

• Using stub which can't verify calls
• Using spy which executes real methods unless stubbed
• Confusing fake with mock