Why mocking isolates units under test in JUnit - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

Why use mocking in unit tests?

In unit testing with JUnit, why do we use mocking frameworks like Mockito?

A To replace real dependencies with controlled fake objects, isolating the unit under test.

B To speed up the test execution by running tests in parallel automatically.

C To generate test data automatically without writing any code.

D To convert integration tests into system tests for better coverage.

💡 Hint

Think about how dependencies affect the behavior of the unit you want to test.

Mocking replaces real dependencies with fake ones that behave in a controlled way. This helps test only the unit's logic without interference from other parts.

❓ Predict Output

intermediate

Output of a JUnit test using a mock

What is the output of this JUnit test when the mocked dependency returns 5?

JUnit

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

class Calculator {
    Dependency dep;
    Calculator(Dependency dep) { this.dep = dep; }
    int compute() { return dep.getValue() * 2; }
}

interface Dependency {
    int getValue();
}

public class CalculatorTest {
    @Test
    void testCompute() {
        Dependency mockDep = mock(Dependency.class);
        when(mockDep.getValue()).thenReturn(5);
        Calculator calc = new Calculator(mockDep);
        assertEquals(10, calc.compute());
    }
}

A Test passes because compute() returns 10 as expected.

B Test fails because compute() returns 5 instead of 10.

C Test fails with NullPointerException because mock is not initialized.

D Test fails due to a compilation error in the mock setup.

💡 Hint

Check what value the mock returns and how compute() uses it.

The mock returns 5 for getValue(), so compute() returns 5 * 2 = 10, matching the assertion.

❓ assertion

advanced

Correct assertion to verify mock interaction

Which assertion correctly verifies that the mocked dependency's method was called exactly once?

JUnit

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

interface Service {
    void perform();
}

public class ServiceTest {
    @Test
    void testPerformCalled() {
        Service mockService = mock(Service.class);
        mockService.perform();
        // Which assertion below is correct?
    }
}

A assertEquals(1, mockService.perform());

B verify(mockService, times(1)).perform();

C verify(mockService).perform(1);

D assertTrue(mockService.perform() == 1);

💡 Hint

Mockito uses verify() to check method calls, not assertEquals.

Option B uses Mockito's verify() with times(1) to check perform() was called once. Other options misuse assertions or method calls.

🔧 Debug

advanced

Why does this mock cause NullPointerException?

Given this test code, why does it throw NullPointerException?

JUnit

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

class Processor {
    Helper helper;
    Processor(Helper helper) { this.helper = helper; }
    int process() { return helper.getData() + 1; }
}

interface Helper {
    Integer getData();
}

public class ProcessorTest {
    @Test
    void testProcess() {
        Helper mockHelper = mock(Helper.class);
        Processor proc = new Processor(mockHelper);
        assertEquals(2, proc.process());
    }
}

A The test assertion is incorrect, causing the exception.

B The Processor constructor is missing, causing the exception.

C The mockHelper.getData() returns null by default, causing NullPointerException when adding 1.

D The mockHelper is not initialized properly, so it is null causing the exception.

💡 Hint

What does a mock return if no behavior is defined?

Mocks return default values like null for objects. Adding 1 to null causes NullPointerException.

❓ framework

expert

How mocking isolates units in complex integration scenarios

In a complex system with multiple dependencies, how does mocking help isolate the unit under test in JUnit?

A By automatically generating integration test cases from unit tests.

B By running all dependent modules in parallel to speed up integration testing.

C By disabling all logging and monitoring during tests to reduce noise.

D By replacing all external dependencies with mocks, tests focus only on the unit's logic without side effects or delays.

💡 Hint

Think about controlling dependencies to avoid unpredictable behavior.

Mocking replaces dependencies with controlled fakes, so the unit test runs fast and reliably without external side effects.

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