Why mocking isolates units under test in JUnit

Introduction

Mocking helps test one part of code alone by pretending other parts work correctly. This way, you find problems faster and easier.

When testing a method that calls a database, but you don't want to use the real database.

When a function depends on a web service that might be slow or unavailable.

When you want to test a small piece of code without running the whole program.

When you want to check how your code behaves if another part returns specific values or errors.

Syntax

JUnit

import static org.mockito.Mockito.*;

// Create a mock object
MyClass mockObject = mock(MyClass.class);

// Define behavior
when(mockObject.someMethod()).thenReturn(someValue);

// Use mockObject in your test

Use mock() to create a fake version of a class.

Use when(...).thenReturn(...) to tell the mock what to return when a method is called.

Examples

This creates a mock of MyService and makes getData() return "mocked data".

JUnit

MyService mockService = mock(MyService.class);
when(mockService.getData()).thenReturn("mocked data");

This mock returns 10 when getNumber() is called.

JUnit

MyService mockService = mock(MyService.class);
when(mockService.getNumber()).thenReturn(10);

Sample Program

This test uses a mock DataService to provide fixed data. It checks that Calculator sums the numbers correctly without needing a real data source.

JUnit

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

class Calculator {
    private DataService dataService;

    public Calculator(DataService dataService) {
        this.dataService = dataService;
    }

    public int calculateSum() {
        int[] data = dataService.getData();
        int sum = 0;
        for (int num : data) {
            sum += num;
        }
        return sum;
    }
}

interface DataService {
    int[] getData();
}

public class CalculatorTest {
    @Test
    void testCalculateSum_withMock() {
        DataService mockDataService = mock(DataService.class);
        when(mockDataService.getData()).thenReturn(new int[] {1, 2, 3});

        Calculator calculator = new Calculator(mockDataService);
        int result = calculator.calculateSum();

        assertEquals(6, result);
    }
}

Important Notes

Mocking avoids using real dependencies that might be slow or unreliable.

It helps focus tests on the code you want to check.

Always mock only external parts, not the code you want to test.

Summary

Mocking creates fake parts to isolate the code under test.

This makes tests faster and more reliable.

Use mocking to control what dependencies return during tests.

Practice

1. Why do we use mocking in JUnit tests?
Mocking helps to:

easy

A. Replace the entire application with a mock

B. Isolate the unit under test by replacing its dependencies with fake objects

C. Automatically generate test data without writing code

D. Make the code run slower to catch timing issues

Solution

1. Step 1: Understand the purpose of mocking

   Mocking replaces real dependencies with fake ones to isolate the code being tested.

2. Step 2: Identify the effect on tests

   This isolation makes tests faster and more reliable by controlling external factors.

3. Final Answer:

   Isolate the unit under test by replacing its dependencies with fake objects -> Option B

4. Quick Check:

   Mocking isolates code = D [OK]

Hint: Mocking isolates by faking dependencies [OK]

Common Mistakes:

• Thinking mocking slows tests down
• Believing mocking generates test data automatically
• Confusing mocking with replacing the whole app

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

easy

A. MyClass mock = new Mock(MyClass);

B. MyClass mock = new MyClass();

C. MyClass mock = mockito.create(MyClass);

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

Solution

1. Step 1: Recall Mockito syntax for mocking

   Mockito uses the static method mock() with the class type as argument.

2. Step 2: Check each option

   Only MyClass mock = Mockito.mock(MyClass.class); uses the correct syntax: Mockito.mock(MyClass.class);

3. Final Answer:

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

4. Quick Check:

   Mockito.mock(Class) syntax = A [OK]

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

Common Mistakes:

• Using new keyword instead of Mockito.mock
• Wrong method names like create()
• Incorrect class references without .class

3. Given the following JUnit test code using Mockito:

class ServiceTest {
  @Mock
  Repository repo;

  @InjectMocks
  Service service;

  @Test
  void testGetData() {
    when(repo.getData()).thenReturn("mocked data");
    String result = service.getData();
    assertEquals("mocked data", result);
  }
}

What is the main reason this test passes even if the real Repository is not connected to a database?

medium

A. Because repo is a mock that returns controlled data

B. Because the real Repository is used and connected

C. Because service.getData() ignores the repository

D. Because the test does not check any output

Solution

1. Step 1: Understand the role of @Mock and when()

   The repo is mocked to return "mocked data" when getData() is called.

2. Step 2: Analyze test behavior

   The test passes because the mock returns the expected string, independent of any real database connection.

3. Final Answer:

   Because repo is a mock that returns controlled data -> Option A

4. Quick Check:

   Mock returns controlled data = C [OK]

Hint: Mocks return set values, ignoring real dependencies [OK]

Common Mistakes:

• Assuming real database is used
• Thinking service ignores repository
• Believing test lacks assertions

4. Identify the error in this JUnit test using Mockito:

@Test
void testCalculate() {
  Calculator calc = Mockito.mock(Calculator.class);
  when(calc.add(2, 3)).thenReturn(5);
  int result = calc.add(2, 3);
  assertEquals(6, result);
}

medium

A. The expected value in assertEquals is incorrect

B. The mock is not created properly

C. The when() method is used incorrectly

D. The test method lacks @Mock annotation

Solution

1. Step 1: Review mock setup and behavior

   The mock is set to return 5 when add(2, 3) is called.

2. Step 2: Check assertion correctness

   The assertion expects 6, but the mock returns 5, causing failure.

3. Final Answer:

   The expected value in assertEquals is incorrect -> Option A

4. Quick Check:

   Assert expected matches mock return = B [OK]

Hint: Assert expected value must match mock return [OK]

Common Mistakes:

• Expecting wrong values in assertions
• Confusing mock creation syntax
• Missing @Mock annotation on mock fields

5. In a complex system, why is mocking dependencies important to isolate the unit under test?
Consider a service that calls a database and a web API. Which benefit does mocking these dependencies provide?

hard

A. It automatically fixes bugs in the database and API

B. It makes the service code run slower to simulate real conditions

C. It allows testing the service logic without relying on database or API availability

D. It replaces the need for writing unit tests

Solution

1. Step 1: Understand dependency isolation

   Mocking replaces real dependencies like database and API with controlled fake versions.

2. Step 2: Identify benefits for testing

   This isolation allows testing service logic reliably without depending on external systems' availability or state.

3. Final Answer:

   It allows testing the service logic without relying on database or API availability -> Option C

4. Quick Check:

   Mocking isolates external dependencies = A [OK]

Hint: Mock dependencies to test logic independently [OK]

Common Mistakes:

• Thinking mocking slows code
• Believing mocking fixes bugs automatically
• Confusing mocking with skipping tests