Why advanced mocking handles complex dependencies in JUnit - Test Execution Impact

Test Overview

This test verifies that advanced mocking can handle complex dependencies by simulating interactions between multiple dependent objects in a service method.

Test Code - JUnit 5 with Mockito

JUnit

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

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

class OrderServiceTest {

    @Mock
    InventoryService inventoryService;

    @Mock
    PaymentService paymentService;

    @InjectMocks
    OrderService orderService;

    @BeforeEach
    void setup() {
        MockitoAnnotations.openMocks(this);
    }

    @Test
    void testPlaceOrder_Success() {
        // Arrange
        String productId = "prod123";
        int quantity = 2;
        when(inventoryService.isAvailable(productId, quantity)).thenReturn(true);
        when(paymentService.charge(anyDouble())).thenReturn(true);

        // Act
        boolean result = orderService.placeOrder(productId, quantity, 50.0);

        // Assert
        assertTrue(result);
        verify(inventoryService).isAvailable(productId, quantity);
        verify(paymentService).charge(50.0);
    }
}

// Supporting classes
class OrderService {
    private final InventoryService inventoryService;
    private final PaymentService paymentService;

    public OrderService(InventoryService inventoryService, PaymentService paymentService) {
        this.inventoryService = inventoryService;
        this.paymentService = paymentService;
    }

    public boolean placeOrder(String productId, int quantity, double amount) {
        if (!inventoryService.isAvailable(productId, quantity)) {
            return false;
        }
        return paymentService.charge(amount);
    }
}

interface InventoryService {
    boolean isAvailable(String productId, int quantity);
}

interface PaymentService {
    boolean charge(double amount);
}

Execution Trace - 6 Steps

Step	Action	System State	Assertion	Result
1	Test starts and Mockito annotations are initialized	Mocks for InventoryService and PaymentService are created and injected into OrderService	—	PASS
2	Test calls orderService.placeOrder with productId 'prod123', quantity 2, amount 50.0	OrderService calls inventoryService.isAvailable with 'prod123' and 2	—	PASS
3	Mocked inventoryService returns true for availability	OrderService proceeds to call paymentService.charge with 50.0	—	PASS
4	Mocked paymentService returns true for charge	OrderService returns true indicating order placed successfully	assertTrue(result) verifies order placement success	PASS
5	Verify inventoryService.isAvailable was called with correct parameters	Verification passes confirming interaction	verify(inventoryService).isAvailable(productId, quantity)	PASS
6	Verify paymentService.charge was called with correct amount	Verification passes confirming interaction	verify(paymentService).charge(50.0)	PASS

Failure Scenario

Failing Condition: inventoryService mock returns false indicating product not available

Execution Trace Quiz - 3 Questions

What does the test verify about the orderService.placeOrder method?

A It verifies that placeOrder throws an exception on payment failure

B It verifies that placeOrder returns true when inventory is available and payment succeeds

C It verifies that placeOrder updates the database directly

D It verifies that placeOrder calls external APIs without mocks

Key Result

Using advanced mocking allows testing service methods with complex dependencies by simulating their behavior, ensuring tests are isolated and reliable.

Practice

1. Why do we use advanced mocking in JUnit tests when dealing with complex dependencies?

easy

A. To automatically generate user interfaces

B. To isolate the code under test and control the behavior of its dependencies

C. To avoid writing any test cases

D. To make the code run faster in production

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: Recognize the benefit of advanced mocking

   Advanced mocking allows control over complex dependencies, making tests reliable and focused.

3. Final Answer:

   To isolate the code under test and control the behavior of its dependencies -> Option B

4. Quick Check:

   Mocking isolates dependencies [OK]

Hint: Mocking isolates dependencies to test code alone [OK]

Common Mistakes:

• Thinking mocking speeds up production code
• Believing mocking removes the need for tests
• Confusing mocking with UI generation

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

easy

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

B. MyClass mock = new MyClass();

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

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

Solution

1. Step 1: Recall Mockito mock creation syntax

   Mockito uses the static method mock(Class) to create mock objects.

2. Step 2: Verify the correct syntax

   The correct syntax is: MyClass mock = Mockito.mock(MyClass.class);

3. Final Answer:

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

4. Quick Check:

   Mockito.mock(Class) creates mocks [OK]

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

Common Mistakes:

• Using new keyword instead of Mockito.mock
• Calling non-existent Mockito methods
• Incorrect class reference syntax

3. Given the following JUnit test code using Mockito:

@ExtendWith(MockitoExtension.class)
class ServiceTest {
  @Mock
  Repository repo;

  @InjectMocks
  Service service;

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

What will be the test result if repo.fetch() is called inside service.getData()?

medium

A. Test fails because repo.fetch() returns null

B. Test fails due to syntax error in mocking

C. Test throws NullPointerException due to uninitialized repo

D. Test passes because repo.fetch() returns mocked "data"

Solution

1. Step 1: Understand Mockito annotations usage

   @Mock creates a mock for Repository, and @InjectMocks injects it into Service.

2. Step 2: Analyze the when-thenReturn setup

   Calling repo.fetch() returns "data" as stubbed, so service.getData() returns "data".

3. Final Answer:

   Test passes because repo.fetch() returns mocked "data" -> Option D

4. Quick Check:

   Mock returns stubbed value [OK]

Hint: Stub methods with when().thenReturn() to control outputs [OK]

Common Mistakes:

• Assuming mocks return null by default
• Forgetting to initialize mocks with @ExtendWith or MockitoAnnotations
• Confusing mock injection with real object creation

4. Consider this JUnit test snippet using Mockito:

@ExtendWith(MockitoExtension.class)
class TestClass {
  @Mock
  Database db;

  @Test
  void testQuery() {
    when(db.query("SELECT * FROM users")).thenReturn(null);
    String result = db.query("SELECT * FROM users");
    assertNotNull(result);
  }
}

What is the problem with this test?

medium

A. The assertion will fail because the mock returns null

B. The syntax of when() is incorrect

C. The mock object db is not created properly

D. The test will pass because null is acceptable

Solution

1. Step 1: Analyze the stubbed return value

   The mock is set to return null for the query method call.

2. Step 2: Check the assertion logic

   The test asserts that the result is not null, but the stub returns null, so assertion fails.

3. Final Answer:

   The assertion will fail because the mock returns null -> Option A

4. Quick Check:

   Assertion contradicts stubbed null [OK]

Hint: Match stubbed return values with assertions [OK]

Common Mistakes:

• Ignoring that stub returns null
• Assuming syntax error without checking code
• Believing test passes with failing assertions

5. You have a service class that depends on two complex external APIs. You want to write a JUnit test that verifies your service logic without calling these APIs. Which advanced mocking approach best handles this scenario?

hard

A. Manually create fake API responses inside the service code

B. Write integration tests that call the real APIs directly

C. Use Mockito to create mocks for both API clients and inject them into the service

D. Skip testing the service since APIs are complex

Solution

1. Step 1: Identify the need to isolate service from external APIs

   Testing should avoid calling real APIs to keep tests fast and reliable.

2. Step 2: Choose advanced mocking to simulate API behavior

   Mockito mocks for API clients allow controlling responses and injecting them into the service.

3. Final Answer:

   Use Mockito to create mocks for both API clients and inject them into the service -> Option C

4. Quick Check:

   Mock external APIs to isolate service [OK]

Hint: Mock external dependencies to isolate service logic [OK]

Common Mistakes:

• Testing with real APIs causing slow or flaky tests
• Hardcoding fake responses inside service code
• Avoiding tests due to complexity