Improving Code Reliability with Mockito and Clean Architecture

Introduction

Maintaining a robust codebase in the Imalimac/TP-Integrador-POO2-Grupo-15 project requires more than just functional code; it demands a solid testing strategy. Recently, our team focused on improving the reliability of our system by integrating Mockito into our test suite and performing a comprehensive refactor of our file structure.

The Problem

As the project grew, we encountered two primary challenges:

1. High Coupling: Dependencies between classes made unit testing individual components difficult without invoking the entire object graph.
2. Manual Regression: Without automated testing for core business logic, minor refactors occasionally introduced regressions in existing features.

The Solution: Dependency Mocking and Refactoring

We turned to Mockito to isolate our services during testing. By mocking dependencies, we were able to focus purely on the logic within the class under test, ensuring that external system behaviors did not interfere with unit results.

Here is an example of how we isolate a service using a mock dependency:

@ExtendWith(MockitoExtension.class)
class OrderServiceTest {

    @Mock
    private InventoryRepository inventoryRepository;

    @InjectMocks
    private OrderService orderService;

    @Test
    void processOrder_ShouldVerifyInventory() {
        when(inventoryRepository.isAvailable(any())).thenReturn(true);
        
        boolean result = orderService.process(new Order());
        
        assertTrue(result);
        verify(inventoryRepository).isAvailable(any());
    }
}

This approach allows us to define the expected behavior of collaborators (the repository) without needing a database connection, speeding up our test suite and increasing reliability.

Results After Refactoring

By combining these testing improvements with a clean-up of our file architecture, we achieved:

• Isolation: Tests now run independently of the database or external services.
• Clarity: A refactored file structure makes it easier to locate domain logic versus infrastructure code.
• Confidence: The team can now refactor shared components with the safety net of automated unit tests.

Getting Started

1. Identify the most complex service class in your project.
2. Use Mockito to inject mock dependencies instead of concrete implementations.
3. Create unit tests that assert behavior rather than state.
4. Run your tests in CI to ensure that every pull request remains stable.

Key Insight

Testing isn't just about catching bugs—it's about enabling change. By mocking your dependencies, you lower the cost of refactoring and make your codebase significantly more modular.

Generated with Gitvlg.com