Refactoring for Reliability: Improving Testability in Imalimac

Testing is often the difference between a project that scales and one that collapses under its own weight. In the Imalimac TP-Integrador-POO2-Grupo-15 project, we recently focused on strengthening our testing foundation to ensure our repository patterns remain robust as the codebase grows.

The Challenge of Growing Code

As our project evolved, the complexity of our data layers began to increase. We were relying on direct implementations that made unit testing difficult. Without a clear separation, testing a repository meant triggering real database side effects, which is the antithesis of a fast, reliable test suite.

Our Approach: Mocking the Data Layer

To address this, we integrated Mockito to decouple our domain logic from the persistence layer. By mocking our repository interfaces, we transformed our tests from fragile, external-dependent scenarios into lightning-fast unit tests.

@ExtendWith(MockitoExtension.class)
class UserDataServiceTest {

    @Mock
    private UserRepository userRepository;

    @InjectMocks
    private UserDataService userDataService;

    @Test
    void shouldReturnUserWhenExists() {
        when(userRepository.findById(1L)).thenReturn(Optional.of(new User("Developer")));
        
        User user = userDataService.getUserById(1L);
        
        assertEquals("Developer", user.getName());
    }
}

Refactoring for Structure

Beyond just adding tests, we performed a significant reorganization of our directory structure. Like tidying up a messy workbench, this refactor made it easier to navigate dependencies and ensured that our test artifacts are as organized as our production code.

This shift allows us to verify business logic independently of the underlying storage engine, a core principle of the Repository Pattern.

Key Lessons Learned

1. Isolation is Key: Using tools like JUnit and Mockito allows us to test logic in total isolation from infrastructure.
2. Structure Matters: A clean directory structure isn't just aesthetic; it reduces cognitive load when onboarding new team members or hunting for bugs.
3. Test Early, Test Often: By incorporating these patterns early, we catch regressions before they move from the development environment to our repository layers.

Building a resilient application requires looking at the system as a whole. By investing in our testing infrastructure today, we are ensuring that future feature development remains predictable and maintainable.

Generated with Gitvlg.com