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.