Microservices April 1, 2026 20 min read Microservices Architecture Series

Table of Contents

1. The Microservices Testing Challenge
2. The Test Pyramid vs Honeycomb Model
3. Unit Testing Microservice Business Logic: Mockito & JUnit 5
4. Integration Testing with Testcontainers
5. Component Testing: Testing a Single Service in Isolation
6. Consumer-Driven Contract Testing with Pact
7. Event-Driven Testing: Kafka Producers and Consumers
8. End-to-End Testing: When and How
9. Test Data Management in Microservices
10. CI/CD Test Pipeline Optimization
11. Key Takeaways
12. Conclusion

  Microservices Testing Hierarchy (Honeycomb Model)

  ┌─────────────────────────────────────────────┐
  │              E2E Tests (few)                │  ← Full stack, real env
  │         Slow · Expensive · High confidence │
  ├─────────────────────────────────────────────┤
  │         Contract Tests (per API boundary)   │  ← Pact, Spring Cloud Contract
  │      Fast · Isolated · Deployment safety   │
  ├─────────────────────────────────────────────┤
  │      Component Tests (per service)          │  ← WireMock stubs, real DB
  │     Medium speed · Realistic · High signal │
  ├─────────────────────────────────────────────┤
  │      Integration Tests (per adapter)        │  ← Testcontainers, real infra
  │      Medium speed · Infra confidence       │
  ├─────────────────────────────────────────────┤
  │         Unit Tests (many)                   │  ← JUnit 5, Mockito
  │      Fast · Cheap · Business logic focus   │
  └─────────────────────────────────────────────┘

Testing Level	Cost	Speed	Coverage Type	Confidence
Unit	Very Low	< 1s per test	Business logic	Low (mocked deps)
Integration	Medium	5–30s per suite	DB, cache, messaging	Medium (real infra)
Component	Medium-High	30–120s per suite	Full service behaviour	High (real service)
Contract	Low-Medium	10–60s per suite	API compatibility	High (deployment safety)
E2E	Very High	5–30 min per suite	User journeys	Very High (full stack)

// Domain service — no Spring annotations, no framework coupling
public class OrderPricingService {
    private final DiscountRepository discountRepository;
    private final PricingRuleEngine ruleEngine;

    public OrderPricingService(DiscountRepository discountRepository,
                               PricingRuleEngine ruleEngine) {
        this.discountRepository = discountRepository;
        this.ruleEngine         = ruleEngine;
    }

    public PricedOrder applyPricing(Order order, CustomerId customerId) {
        List<DiscountRule> rules = discountRepository.findActiveRules(customerId);
        Money baseTotal  = order.calculateBaseTotal();
        Money discounted = ruleEngine.apply(baseTotal, rules, order);
        return PricedOrder.of(order, discounted);
    }
}

// JUnit 5 + Mockito unit test — no Spring context, runs in < 10ms
@ExtendWith(MockitoExtension.class)
class OrderPricingServiceTest {

    @Mock DiscountRepository discountRepository;
    @Mock PricingRuleEngine  ruleEngine;

    @InjectMocks OrderPricingService pricingService;

    @Test
    void applyPricing_withActiveLoyaltyDiscount_reducesTotal() {
        // Arrange — real domain objects, only external ports are mocked
        CustomerId customerId = CustomerId.of("cust-42");
        Order order = OrderFixture.anOrder()
            .withItem("PROD-1", Quantity.of(3), Money.of(100, "USD"))
            .build();

        DiscountRule loyaltyDiscount = DiscountRule.percentage(10, "LOYALTY");
        Money expectedTotal = Money.of(270, "USD"); // 300 - 10%

        given(discountRepository.findActiveRules(customerId))
            .willReturn(List.of(loyaltyDiscount));
        given(ruleEngine.apply(Money.of(300, "USD"), List.of(loyaltyDiscount), order))
            .willReturn(expectedTotal);

        // Act
        PricedOrder result = pricingService.applyPricing(order, customerId);

        // Assert — verify behaviour, not mock interactions
        assertThat(result.total()).isEqualTo(expectedTotal);
        assertThat(result.appliedDiscounts()).containsExactly("LOYALTY");
        verify(discountRepository).findActiveRules(customerId);
    }

    @Test
    void applyPricing_withNoActiveRules_returnsBaseTotal() {
        CustomerId customerId = CustomerId.of("cust-99");
        Order order = OrderFixture.anOrder()
            .withItem("PROD-2", Quantity.of(1), Money.of(50, "USD"))
            .build();

        given(discountRepository.findActiveRules(customerId)).willReturn(List.of());
        given(ruleEngine.apply(Money.of(50, "USD"), List.of(), order))
            .willReturn(Money.of(50, "USD"));

        PricedOrder result = pricingService.applyPricing(order, customerId);

        assertThat(result.total()).isEqualTo(Money.of(50, "USD"));
        assertThat(result.appliedDiscounts()).isEmpty();
    }
}

// Base class for all Testcontainers integration tests — shared container lifecycle
@SpringBootTest
@Testcontainers
@ActiveProfiles("integration-test")
public abstract class AbstractIntegrationTest {

    @Container
    static final PostgreSQLContainer<?> postgres =
        new PostgreSQLContainer<>("postgres:16-alpine")
            .withDatabaseName("orders_test")
            .withUsername("test")
            .withPassword("test")
            .withReuse(true); // reuse across test runs in dev mode

    @Container
    static final KafkaContainer kafka =
        new KafkaContainer(DockerImageName.parse("confluentinc/cp-kafka:7.6.0"))
            .withReuse(true);

    @Container
    static final GenericContainer<?> redis =
        new GenericContainer<>(DockerImageName.parse("redis:7.2-alpine"))
            .withExposedPorts(6379)
            .withReuse(true);

    @DynamicPropertySource
    static void overrideProperties(DynamicPropertyRegistry registry) {
        registry.add("spring.datasource.url",         postgres::getJdbcUrl);
        registry.add("spring.datasource.username",    postgres::getUsername);
        registry.add("spring.datasource.password",    postgres::getPassword);
        registry.add("spring.kafka.bootstrap-servers",kafka::getBootstrapServers);
        registry.add("spring.data.redis.host",        redis::getHost);
        registry.add("spring.data.redis.port",
            () -> redis.getMappedPort(6379));
    }
}

Testcontainers Reuse Mode: Setting .withReuse(true) on containers and adding testcontainers.reuse.enable=true to ~/.testcontainers.properties keeps containers alive across test runs during local development. Cold starts only happen on the first run per machine. This reduces local integration test cycle time from 45 seconds to under 5 seconds for subsequent runs.

// JPA repository integration test with real PostgreSQL
@DataJpaTest
@AutoConfigureTestDatabase(replace = Replace.NONE)
@Testcontainers
class OrderRepositoryIntegrationTest extends AbstractIntegrationTest {

    @Autowired OrderRepository orderRepository;

    @Test
    @Transactional
    void save_andFindByCustomerId_returnsPersistedOrder() {
        // Arrange
        Order order = Order.builder()
            .customerId(CustomerId.of("cust-123"))
            .status(OrderStatus.PENDING)
            .items(List.of(
                OrderItem.of(ProductId.of("prod-1"), Quantity.of(2), Money.of(50, "USD"))
            ))
            .build();

        // Act
        Order saved = orderRepository.save(order);
        List<Order> found = orderRepository.findByCustomerId(CustomerId.of("cust-123"));

        // Assert
        assertThat(saved.id()).isNotNull();
        assertThat(found).hasSize(1);
        assertThat(found.get(0).status()).isEqualTo(OrderStatus.PENDING);
        assertThat(found.get(0).items()).hasSize(1);
    }

    @Test
    void findPendingOrdersOlderThan_withExpiredOrder_returnsIt() {
        Order staleOrder = Order.builder()
            .customerId(CustomerId.of("cust-456"))
            .status(OrderStatus.PENDING)
            .createdAt(Instant.now().minus(Duration.ofHours(25)))
            .build();
        orderRepository.save(staleOrder);

        List<Order> expired =
            orderRepository.findPendingOrdersOlderThan(Instant.now().minus(Duration.ofHours(24)));

        assertThat(expired).hasSize(1);
        assertThat(expired.get(0).customerId()).isEqualTo(CustomerId.of("cust-456"));
    }
}

⚠ Integration Test Flakiness: The most common source of flaky integration tests in Testcontainers-based suites is container readiness. A PostgreSQL container that reports "healthy" may still be initialising its data directory. Always use .waitingFor(Wait.forListeningPort()) combined with a Wait.forLogMessage strategy matching the database's "ready to accept connections" log line. For Kafka, wait for the broker to become fully elected before producing test events — use AdminClient.describeTopics() in a @BeforeAll to confirm topic availability rather than relying on container startup alone.

// Component test: full Order Service with WireMock for downstream stubs
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@Testcontainers
@AutoConfigureWireMock(port = 0) // WireMock on a random port
@ActiveProfiles("component-test")
class OrderServiceComponentTest extends AbstractIntegrationTest {

    @Autowired TestRestTemplate restTemplate;
    @LocalServerPort int port;

    @BeforeEach
    void resetWireMock() {
        WireMock.reset();
    }

    @Test
    void createOrder_withValidItems_returns201AndPersistsOrder() {
        // Stub the Inventory Service
        stubFor(get(urlPathEqualTo("/api/v1/inventory/availability"))
            .withQueryParam("productId", equalTo("prod-abc"))
            .willReturn(aResponse()
                .withStatus(200)
                .withHeader("Content-Type", "application/json")
                .withBody("""
                    {"productId":"prod-abc","available":true,"stock":50}
                """)));

        // Stub the Pricing Service
        stubFor(post(urlPathEqualTo("/api/v1/pricing/calculate"))
            .willReturn(aResponse()
                .withStatus(200)
                .withHeader("Content-Type", "application/json")
                .withBody("""
                    {"totalAmount":149.99,"currency":"USD","discounts":[]}
                """)));

        // Call the Order Service directly
        CreateOrderRequest request = new CreateOrderRequest(
            "cust-789",
            List.of(new OrderItemRequest("prod-abc", 2))
        );

        ResponseEntity<OrderResponse> response = restTemplate.postForEntity(
            "/api/v1/orders", request, OrderResponse.class);

        assertThat(response.getStatusCode()).isEqualTo(HttpStatus.CREATED);
        assertThat(response.getBody()).isNotNull();
        assertThat(response.getBody().status()).isEqualTo("PENDING");
        assertThat(response.getBody().totalAmount()).isEqualByComparingTo("149.99");

        // Verify WireMock received the expected calls
        verify(getRequestedFor(urlPathEqualTo("/api/v1/inventory/availability")));
        verify(postRequestedFor(urlPathEqualTo("/api/v1/pricing/calculate")));
    }

    @Test
    void createOrder_whenInventoryUnavailable_returns409() {
        stubFor(get(urlPathEqualTo("/api/v1/inventory/availability"))
            .willReturn(aResponse()
                .withStatus(200)
                .withBody("""
                    {"productId":"prod-abc","available":false,"stock":0}
                """)));

        CreateOrderRequest request = new CreateOrderRequest(
            "cust-789",
            List.of(new OrderItemRequest("prod-abc", 5))
        );

        ResponseEntity<ProblemDetail> response = restTemplate.postForEntity(
            "/api/v1/orders", request, ProblemDetail.class);

        assertThat(response.getStatusCode()).isEqualTo(HttpStatus.CONFLICT);
        assertThat(response.getBody().getDetail()).contains("out of stock");
    }
}

// Consumer side — Order Service writes the Pact
@ExtendWith(PactConsumerTestExt.class)
@PactTestFor(providerName = "inventory-service", port = "8080")
class OrderServiceInventoryPactConsumerTest {

    @Pact(consumer = "order-service")
    public RequestResponsePact availableProductPact(PactDslWithProvider builder) {
        return builder
            .given("product prod-abc is available with stock 50")
            .uponReceiving("a request for product availability")
                .path("/api/v1/inventory/availability")
                .method("GET")
                .query("productId=prod-abc")
            .willRespondWith()
                .status(200)
                .headers(Map.of("Content-Type", "application/json"))
                .body(new PactDslJsonBody()
                    .stringValue("productId", "prod-abc")
                    .booleanValue("available", true)
                    .integerType("stock", 50))
            .toPact();
    }

    @Test
    @PactTestFor(pactMethod = "availableProductPact")
    void whenProductIsAvailable_inventoryClientReturnsAvailability(MockServer mockServer) {
        InventoryClient client = new InventoryClient(mockServer.getUrl());
        InventoryAvailability result = client.checkAvailability("prod-abc");

        assertThat(result.isAvailable()).isTrue();
        assertThat(result.stock()).isEqualTo(50);
    }
}

// Provider side — Inventory Service verifies the Pact
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
@Provider("inventory-service")
@PactBroker(url = "${PACT_BROKER_URL}",
            authentication = @PactBrokerAuth(token = "${PACT_BROKER_TOKEN}"))
@Testcontainers
class InventoryServicePactProviderTest extends AbstractIntegrationTest {

    @LocalServerPort int port;

    @BeforeEach
    void configurePact(PactVerificationContext context) {
        context.setTarget(new HttpTestTarget("localhost", port));
    }

    @TestTemplate
    @ExtendWith(PactVerificationInvocationContextProvider.class)
    void verifyPact(PactVerificationContext context) {
        context.verifyInteraction();
    }

    // Provider state setup — matches the "given" clause in the consumer Pact
    @State("product prod-abc is available with stock 50")
    void productIsAvailable() {
        // Insert test data into the real PostgreSQL container
        inventoryRepository.save(InventoryItem.builder()
            .productId("prod-abc")
            .stock(50)
            .reserved(0)
            .build());
    }
}

// Testing Kafka producer with EmbeddedKafka — fast, no Docker required
@SpringBootTest
@EmbeddedKafka(
    partitions = 1,
    topics = {"order.events"},
    brokerProperties = {"listeners=PLAINTEXT://localhost:9092", "port=9092"}
)
@TestPropertySource(properties = {
    "spring.kafka.bootstrap-servers=${spring.embedded.kafka.brokers}",
    "spring.kafka.producer.value-serializer=org.apache.kafka.common.serialization.StringSerializer"
})
class OrderEventProducerTest {

    @Autowired KafkaTemplate<String, String> kafkaTemplate;
    @Autowired OrderEventPublisher eventPublisher;
    @Autowired ObjectMapper objectMapper;

    @Test
    void publishOrderCreatedEvent_writesCorrectEventToKafka() throws Exception {
        Order order = OrderFixture.aConfirmedOrder("ord-999", "cust-123");
        Consumer<String, String> consumer = createTestConsumer("order.events");

        eventPublisher.publishOrderCreated(order);

        ConsumerRecords<String, String> records =
            KafkaTestUtils.getRecords(consumer, Duration.ofSeconds(5));

        assertThat(records.count()).isEqualTo(1);
        ConsumerRecord<String, String> record = records.iterator().next();
        assertThat(record.key()).isEqualTo("ord-999");

        OrderCreatedEvent event =
            objectMapper.readValue(record.value(), OrderCreatedEvent.class);
        assertThat(event.orderId()).isEqualTo("ord-999");
        assertThat(event.customerId()).isEqualTo("cust-123");
        assertThat(event.eventType()).isEqualTo("ORDER_CREATED");
        assertThat(event.occurredAt()).isNotNull();
    }

    private Consumer<String, String> createTestConsumer(String topic) {
        Map<String, Object> consumerProps =
            KafkaTestUtils.consumerProps("test-group", "true",
                embeddedKafka.getEmbeddedKafka());
        Consumer<String, String> consumer =
            new DefaultKafkaConsumerFactory<>(consumerProps).createConsumer();
        consumer.subscribe(List.of(topic));
        return consumer;
    }
}

// Testing Kafka consumer with Testcontainers Kafka — realistic broker behaviour
@SpringBootTest
@Testcontainers
class NotificationConsumerIntegrationTest extends AbstractIntegrationTest {

    @Autowired KafkaTemplate<String, String> kafkaTemplate;
    @Autowired NotificationRepository notificationRepository;
    @Autowired ObjectMapper objectMapper;

    @Test
    void onOrderCreatedEvent_notificationIsPersistedInDatabase() throws Exception {
        OrderCreatedEvent event = new OrderCreatedEvent(
            "ord-777", "cust-321", Instant.now(), "ORDER_CREATED");
        String payload = objectMapper.writeValueAsString(event);

        kafkaTemplate.send("order.events", "ord-777", payload).get(5, TimeUnit.SECONDS);

        // Poll with Awaitility — account for consumer lag
        await()
            .atMost(Duration.ofSeconds(15))
            .pollInterval(Duration.ofMillis(500))
            .untilAsserted(() -> {
                Optional<Notification> notification =
                    notificationRepository.findByOrderId("ord-777");
                assertThat(notification).isPresent();
                assertThat(notification.get().customerId()).isEqualTo("cust-321");
                assertThat(notification.get().type()).isEqualTo(NotificationType.ORDER_CREATED);
            });
    }
}

// E2E test for the critical "place order" journey — runs in staging only
@Tag("e2e")
@SpringBootTest
class PlaceOrderEndToEndTest {

    // RestAssured pointing at the deployed API Gateway in staging
    private static final String API_BASE = System.getenv("STAGING_API_URL");

    @Test
    void completeOrderJourney_fromCartToConfirmation() {
        String authToken = AuthFixture.getTestUserToken();

        // Step 1: Add item to cart
        String cartId =
            given()
                .header("Authorization", "Bearer " + authToken)
                .contentType(ContentType.JSON)
                .body("""
                    {"productId":"PROD-PERF-1","quantity":2}
                """)
            .when()
                .post(API_BASE + "/api/v1/cart/items")
            .then()
                .statusCode(200)
                .extract().path("cartId");

        // Step 2: Checkout
        String orderId =
            given()
                .header("Authorization", "Bearer " + authToken)
                .contentType(ContentType.JSON)
                .body("""
                    {"cartId":"%s","paymentMethodId":"pm-test-visa"}
                """.formatted(cartId))
            .when()
                .post(API_BASE + "/api/v1/orders")
            .then()
                .statusCode(201)
                .body("status", equalTo("PENDING"))
                .extract().path("orderId");

        // Step 3: Confirm order reaches CONFIRMED state (async payment processing)
        await()
            .atMost(Duration.ofSeconds(30))
            .untilAsserted(() ->
                given()
                    .header("Authorization", "Bearer " + authToken)
                .when()
                    .get(API_BASE + "/api/v1/orders/" + orderId)
                .then()
                    .statusCode(200)
                    .body("status", equalTo("CONFIRMED")));
    }
}

// Database cleaner — truncates all tables before each test
@Component
@Profile("integration-test")
public class DatabaseCleaner {
    @Autowired DataSource dataSource;

    @BeforeEach
    public void clean() throws SQLException {
        try (Connection conn = dataSource.getConnection();
             Statement stmt = conn.createStatement()) {
            stmt.execute("SET session_replication_role = 'replica'"); // disable FK checks
            ResultSet tables = conn.getMetaData().getTables(
                null, "public", "%", new String[]{"TABLE"});
            while (tables.next()) {
                String tableName = tables.getString("TABLE_NAME");
                if (!tableName.startsWith("flyway_")) {
                    stmt.execute("TRUNCATE TABLE " + tableName + " CASCADE");
                }
            }
            stmt.execute("SET session_replication_role = 'origin'");
        }
    }
}

// Fluent fixture factory — readable test data construction
public class OrderFixture {
    public static OrderBuilder anOrder() { return new OrderBuilder(); }
    public static Order aConfirmedOrder(String orderId, String customerId) {
        return anOrder()
            .withId(orderId)
            .withCustomerId(customerId)
            .withStatus(OrderStatus.CONFIRMED)
            .withItem("PROD-DEFAULT", Quantity.of(1), Money.of(99, "USD"))
            .build();
    }

    public static class OrderBuilder {
        private String id = UUID.randomUUID().toString();
        private String customerId = "cust-default";
        private OrderStatus status = OrderStatus.PENDING;
        private List<OrderItem> items = new ArrayList<>();
        private Instant createdAt = Instant.now();

        public OrderBuilder withId(String id)               { this.id = id; return this; }
        public OrderBuilder withCustomerId(String cid)      { this.customerId = cid; return this; }
        public OrderBuilder withStatus(OrderStatus status)  { this.status = status; return this; }
        public OrderBuilder withItem(String pid, Quantity q, Money p) {
            this.items.add(OrderItem.of(ProductId.of(pid), q, p)); return this;
        }
        public OrderBuilder createdAt(Instant t)            { this.createdAt = t; return this; }
        public Order build() {
            return Order.builder().id(id).customerId(CustomerId.of(customerId))
                .status(status).items(items).createdAt(createdAt).build();
        }
    }
}

# GitHub Actions CI pipeline with staged test execution
name: Order Service CI

on: [push, pull_request]

jobs:
  unit-tests:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-java@v4
        with: { java-version: '21', distribution: 'temurin' }
      - name: Run unit tests
        run: ./mvnw test -Dgroups="unit" -T 4 # 4 parallel forks

  integration-tests:
    runs-on: ubuntu-latest
    needs: unit-tests
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-java@v4
        with: { java-version: '21', distribution: 'temurin' }
      - name: Run integration tests
        run: ./mvnw test -Dgroups="integration" -Dtestcontainers.reuse.enable=false
      - name: Upload test reports
        uses: actions/upload-artifact@v4
        if: failure()
        with:
          name: integration-test-reports
          path: target/surefire-reports/

  component-and-contract-tests:
    runs-on: ubuntu-latest
    needs: integration-tests
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-java@v4
        with: { java-version: '21', distribution: 'temurin' }
      - name: Run component tests
        run: ./mvnw test -Dgroups="component"
      - name: Publish Pact contracts
        run: ./mvnw pact:publish -Dpact.broker.url=${{ secrets.PACT_BROKER_URL }}
        env:
          PACT_BROKER_TOKEN: ${{ secrets.PACT_BROKER_TOKEN }}

  e2e-tests:
    runs-on: ubuntu-latest
    needs: component-and-contract-tests
    if: github.ref == 'refs/heads/main'
    steps:
      - uses: actions/checkout@v4
      - name: Run E2E smoke tests
        run: ./mvnw test -Dgroups="e2e"
        env:
          STAGING_API_URL: ${{ secrets.STAGING_API_URL }}

Leave a Comment

Send Comment

Related Posts