Unit Test vs Integration Test — The 8-Min Suite Nobody Ran

package io.thecodeforge.payment;

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

// UNIT TEST — no database, no HTTP, no external dependencies
class PaymentAmountCalculatorTest {

    @Test
    void calculate_appliesDiscountForGoldTier() {
        // Arrange — mock only the external dependency (discount lookup)
        DiscountService discountService = mock(DiscountService.class);
        when(discountService.getDiscountRate("GOLD")).thenReturn(0.15);

        PaymentAmountCalculator calculator =
            new PaymentAmountCalculator(discountService);

        // Act
        long result = calculator.calculate(100_00, "GOLD"); // £100.00

        // Assert
        assertEquals(85_00, result); // 15% off = £85.00
        verify(discountService, times(1)).getDiscountRate("GOLD");
    }

    @Test
    void calculate_noDiscountForUnknownTier() {
        DiscountService discountService = mock(DiscountService.class);
        when(discountService.getDiscountRate("UNKNOWN")).thenReturn(0.0);

        PaymentAmountCalculator calculator =
            new PaymentAmountCalculator(discountService);

        assertEquals(100_00, calculator.calculate(100_00, "UNKNOWN"));
    }
}
// Runs in: ~50ms
// Tests: pure business logic, isolated from real DiscountService implementation

package io.thecodeforge.payment;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
import static org.junit.jupiter.api.Assertions.*;

// INTEGRATION TEST — uses real database (H2 in-memory for @DataJpaTest)
// Tests that the JPA mapping, queries, and constraints work correctly
@DataJpaTest
class PaymentRepositoryIntegrationTest {

    @Autowired
    private PaymentRepository paymentRepository;

    @Test
    void save_andFind_roundTrip() {
        // Arrange
        Payment payment = Payment.builder()
            .customerId("customer-42")
            .amountInPence(100_00)
            .currency("GBP")
            .status(PaymentStatus.PENDING)
            .build();

        // Act — actually hits the database
        Payment saved = paymentRepository.save(payment);
        Payment found = paymentRepository.findById(saved.getId()).orElseThrow();

        // Assert — verifies JPA mapping, column types, NOT NULL constraints
        assertEquals("customer-42", found.getCustomerId());
        assertEquals(100_00, found.getAmountInPence());
        assertEquals(PaymentStatus.PENDING, found.getStatus());
        assertNotNull(found.getCreatedAt()); // Verify @CreatedDate audit field
    }

    @Test
    void findByCustomerId_returnsAllPaymentsForCustomer() {
        paymentRepository.save(buildPayment("customer-42", 100_00));
        paymentRepository.save(buildPayment("customer-42", 200_00));
        paymentRepository.save(buildPayment("customer-99", 50_00));

        // Tests the actual JPQL query — unit test with a mock wouldn't catch typos
        var results = paymentRepository.findByCustomerId("customer-42");
        assertEquals(2, results.size());
    }
}
// Runs in: ~2-8 seconds (database startup)
// Tests: JPA mapping, query correctness, constraint enforcement

package io.thecodeforge.testing;

// BAD: mocking value objects and own classes
class BadMockingTest {
    @Test
    void bad_calculateDiscount() {
        Order order = mock(Order.class);          // Don't mock domain objects
        when(order.getTotal()).thenReturn(100.0);  // Just use a real Order
        DiscountCalculator calc = mock(DiscountCalculator.class);
        when(calc.apply(any())).thenReturn(90.0);  // You're testing the mock
        OrderProcessor processor = new OrderProcessor(calc);
        assertEquals(90.0, processor.process(order));
    }
}

// GOOD: mock external, use real for own code
class GoodMockingTest {
    @Test
    void good_calculateDiscount() {
        Order order = new Order(100.0, "GOLD");   // Real domain object
        DiscountCalculator calc = new DiscountCalculator(); // Real logic
        OrderProcessor processor = new OrderProcessor(calc);
        assertEquals(85.0, processor.process(order)); // 15% discount for Gold
    }
}

<project>
  <build>
    <plugins>
      <!-- Unit tests (default) -->
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-surefire-plugin</artifactId>
        <configuration>
          <excludes>
            <exclude>**/*IntegrationTest.java</exclude>
            <exclude>**/*E2ETest.java</exclude>
          </excludes>
        </configuration>
      </plugin>
      <!-- Integration tests (runs with -Pintegration) -->
      <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-failsafe-plugin</artifactId>
        <configuration>
          <includes>
            <include>**/*IntegrationTest.java</include>
          </includes>
        </configuration>
      </plugin>
    </plugins>
  </build>

  <profiles>
    <profile>
      <id>integration</id>
      <build>
        <plugins>
          <plugin>
            <groupId>org.apache.maven.plugins</groupId>
            <artifactId>maven-failsafe-plugin</artifactId>
            <executions>
              <execution>
                <goals><goal>integration-test</goal><goal>verify</goal></goals>
              </execution>
            </executions>
          </plugin>
        </plugins>
      </build>
    </profile>
  </profiles>
</project>