Why different doubles serve different purposes in JUnit - Test Execution Impact

Test Overview

This test demonstrates how different test doubles (dummy, stub, mock, spy) serve different purposes in unit testing. It verifies that each double behaves as expected in a simple calculator service scenario.

Test Code - JUnit 5 with Mockito

JUnit

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

interface CalculatorService {
    int add(int a, int b);
    int subtract(int a, int b);
}

class Calculator {
    private final CalculatorService service;
    public Calculator(CalculatorService service) {
        this.service = service;
    }
    public int performAddition(int a, int b) {
        return service.add(a, b);
    }
    public int performSubtraction(int a, int b) {
        return service.subtract(a, b);
    }
}

public class CalculatorTest {

    @Test
    void testWithDummy() {
        // Dummy: passed but not used
        CalculatorService dummyService = new CalculatorService() {
            public int add(int a, int b) { return 0; }
            public int subtract(int a, int b) { return 0; }
        };
        Calculator calc = new Calculator(dummyService);
        int result = calc.performAddition(5, 3);
        assertEquals(0, result, "Dummy returns default 0");
    }

    @Test
    void testWithStub() {
        // Stub: returns fixed value
        CalculatorService stubService = new CalculatorService() {
            public int add(int a, int b) { return 8; }
            public int subtract(int a, int b) { return 0; }
        };
        Calculator calc = new Calculator(stubService);
        int result = calc.performAddition(5, 3);
        assertEquals(8, result, "Stub returns fixed sum");
    }

    @Test
    void testWithMock() {
        // Mock: verifies interaction
        CalculatorService mockService = Mockito.mock(CalculatorService.class);
        Mockito.when(mockService.add(5, 3)).thenReturn(8);
        Calculator calc = new Calculator(mockService);
        int result = calc.performAddition(5, 3);
        assertEquals(8, result, "Mock returns stubbed sum");
        Mockito.verify(mockService).add(5, 3);
    }

    @Test
    void testWithSpy() {
        // Spy: partial real behavior + verification
        CalculatorService realService = new CalculatorService() {
            public int add(int a, int b) { return a + b; }
            public int subtract(int a, int b) { return a - b; }
        };
        CalculatorService spyService = Mockito.spy(realService);
        Calculator calc = new Calculator(spyService);
        int result = calc.performAddition(5, 3);
        assertEquals(8, result, "Spy calls real method");
        Mockito.verify(spyService).add(5, 3);
    }
}

Execution Trace - 4 Steps

Step	Action	System State	Assertion	Result
1	Test starts with dummy double	Calculator created with dummy service that returns 0	Assert result equals 0	PASS
2	Test runs with stub double	Calculator created with stub service returning fixed 8 for add	Assert result equals 8	PASS
3	Test runs with mock double	Calculator created with mock service; add(5,3) stubbed to 8	Assert result equals 8 and verify add(5,3) called	PASS
4	Test runs with spy double	Calculator created with spy wrapping real service; add method real	Assert result equals 8 and verify add(5,3) called	PASS

Failure Scenario

Failing Condition: Mock verification fails because add method was not called

Execution Trace Quiz - 3 Questions

Which test double returns a fixed value without real logic?

A Spy

B Mock

C Stub

D Dummy

Key Result

Use the right test double for your goal: dummy for placeholders, stub for fixed returns, mock for interaction checks, and spy for partial real behavior with verification.

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