Why Unit Tests Are Faster

Direct Answer

Unit tests are usually faster because they create only the object graph needed for one behavior and avoid broad framework startup and external I/O. Integration tests may build an ApplicationContext, migrate a database, start a server, or contact containers. There is no universal timing: measure the suite, reuse cached contexts, and keep each test at the smallest boundary that proves the requirement.

Code Example

// Focused unit test: no Spring context or external I/O
@ExtendWith(MockitoExtension.class)
class OrderServiceTest {
    @Mock private OrderRepository orderRepository;
    @InjectMocks private OrderService orderService;

    @Test
    void shouldCalculateTotalWithDiscount() {
        var order = new Order(1L, "Laptop", 1000.0);
        when(orderRepository.findById(1L)).thenReturn(Optional.of(order));

        var total = orderService.calculateTotal(1L, 0.1);

        assertEquals(900.0, total);
    }
}

// Integration test: context and configured persistence boundary
@DataJpaTest
class OrderRepositoryIntegrationTest {
    @Autowired private OrderRepository orderRepository;

    @Test
    void shouldPersistOrder() {
        var saved = orderRepository.save(new Order(null, "Laptop", 1000.0));
        assertThat(orderRepository.findById(saved.id())).isPresent();
    }
}

Measure both tests in the real build; no annotation guarantees a fixed duration.

Common Mistakes & Pitfalls

• Counting assertions instead of setup: Context creation, migrations, containers, and I/O often dominate the cost.
• Using a universal threshold: Compare with the suite's baseline and inspect setup separately from test execution.
• Using @DirtiesContext as database cleanup: It evicts a Spring context. Use a test transaction when its boundary fits, or clean database state explicitly; Testcontainers does not by itself reset data between every test.