Unit and Integration Testing: A Comprehensive Guide for Modern Software Development

NJUG plus spring boot

By Ejembe Onyekachi Maximilian — Presented at NaijaJUG Meetup

[embed]Naija JUG Lightening talks

Software testing is one of the cornerstones of modern software engineering. It ensures that applications are not only functional but also reliable, secure, and maintainable. In today’s competitive industry, where speed and quality are equally important, testing provides the confidence to deliver software at scale.

In this article, we’ll dive into unit testing and integration testing, explore why they matter, walk through common frameworks and annotations, and highlight best practices with real-world code examples.

🧪 Introduction to Software Testing

Software testing is the process of verifying that an application meets specified requirements and behaves as expected. A useful mental model here is the Testing Pyramid:

• Unit Tests (70%) — Fast, isolated, numerous
• Integration Tests (20%) — Validate interactions between components
• End-to-End Tests (10%) — Simulate complete user flows

This distribution balances speed, cost, and coverage.

🔹 Understanding Unit Testing

Unit testing focuses on the smallest testable parts of an application (usually methods or functions).

Key characteristics:

• Isolated
• Fast
• Repeatable
• Self-validating

✅ Example:

@Test
void calculateTotalPrice_ShouldReturnCorrectSum() {
    // Arrange
    OrderService service = new OrderService();
    List<Item> items = Arrays.asList(
        new Item("Book", 10.00),
        new Item("Pen", 2.50)
    );

    // Act
    double total = service.calculateTotal(items);

    // Assert
    assertEquals(12.50, total);
}

🔗 Understanding Integration Testing

Integration testing ensures that different components work correctly together. It validates the wiring — databases, APIs, services.

✅ Example (Spring Boot):

@SpringBootTest
@AutoConfigureMockMvc
class UserControllerIntegrationTest {

    @Autowired
    private MockMvc mockMvc;

    @Test
    void createUser_ShouldPersistInDatabase() throws Exception {
        mockMvc.perform(post("/api/users")
                .contentType(MediaType.APPLICATION_JSON)
                .content("{\"name\":\"Samuel\",\"email\":\"sam@example.com\"}"))
                .andExpect(status().isCreated())
                .andExpect(jsonPath("$.id").exists());
    }
}

💡 Why Testing Matters

• Cost Reduction — Early bug detection is 10–100x cheaper
• Customer Satisfaction — Happier users, fewer production issues
• Competitive Advantage — Reliable software builds trust
• Faster Releases — Automated tests power CI/CD pipelines

📊 Industry stats:

• Mature testing practices → 200x more frequent deployments
• Well-tested code → 50% fewer production defects
• Automated testing → 70% QA time savings

🔧 Common Testing Frameworks and Tools

Java/Spring Ecosystem

• JUnit 5 — The go-to unit testing framework
• Mockito — Mocking and stubbing dependencies
• AssertJ — Fluent assertions

Integration Testing

• Spring Boot Test — End-to-end support
• TestContainers — Real database testing with Docker
• REST Assured — API testing
• WireMock — Service stubbing

Extras

• Jacoco — Code coverage
• Cucumber — BDD
• Selenium — UI testing

📑 Essential Annotations

JUnit 5

• @Test – Marks a method as a test
• @BeforeEach / @AfterEach – Setup and teardown
• @BeforeAll / @AfterAll – Class-level setup
• @DisplayName – Descriptive test names
• @ParameterizedTest – Run with multiple inputs

Spring Testing

• @SpringBootTest – Full context load
• @WebMvcTest – Web layer only
• @DataJpaTest – JPA repositories with in-memory DB
• @MockBean – Mockito integration
• @AutoConfigureMockMvc – MockMvc setup

✅ Best Practices

Unit Testing

• Follow AAA (Arrange, Act, Assert)
• One assertion per test
• Focus on behavior, not implementation
• Keep tests independent

Integration Testing

• Use TestContainers for realism
• Reset DB state between runs
• Cover both happy path and edge cases
• Mock third-party APIs

🎯 Code coverage: Aim for ~80%, but focus on business logic.

🏗️ Real-World Example

Unit Test with Mockito

@ExtendWith(MockitoExtension.class)
class OrderServiceTest {

    @Mock
    private OrderRepository orderRepository;

    @Mock
    private EmailService emailService;

    @InjectMocks
    private OrderService orderService;

    @Test
    @DisplayName("Should process order successfully when valid")
    void processOrder_Success() {
        Order order = new Order("ORD-001", 100.00);
        when(orderRepository.save(any(Order.class))).thenReturn(order);
        doNothing().when(emailService).sendConfirmation(anyString());

        Order result = orderService.processOrder(order);

        assertNotNull(result);
        assertEquals("ORD-001", result.getId());
        verify(orderRepository).save(order);
        verify(emailService).sendConfirmation("ORD-001");
    }
}

Integration Test Example (Order flow creation & retrieval) was also covered in the document.

📌 Conclusion

• Unit and integration tests serve complementary purposes.
• Good tests = better design, safer refactoring, and faster releases.
• Testing is not an afterthought — it’s an investment in code quality.

“Quality is not an act, it is a habit.” — Aristotle

By building a strong testing culture, teams deliver reliable, maintainable software in today’s fast-paced industry.

Java #Testing #SpringBoot #JUnit5 #Mockito #IntegrationTesting #SoftwareEngineering #BestPractices