Java Spring Boot
Microservices Patterns

# application.yml
resilience4j:
  bulkhead:
    instances:
      inventoryService:
        maxConcurrentCalls: 20      # max parallel calls at any time
        maxWaitDuration: 100ms      # wait before rejecting with BulkheadFullException
  thread-pool-bulkhead:
    instances:
      paymentService:
        maxThreadPoolSize: 10
        coreThreadPoolSize: 5
        queueCapacity: 20           # queue before rejecting
        keepAliveDuration: 20ms

// ─────────────────────────────────────────────────────────────────────────────

@Service
public class ProductService {

    // Semaphore Bulkhead — lightweight, same thread
    @Bulkhead(name = "inventoryService", fallbackMethod = "inventoryFallback")
    @CircuitBreaker(name = "inventoryService")
    public InventoryStatus checkInventory(String productId) {
        return inventoryClient.check(productId);
    }

    // Thread Pool Bulkhead — dedicated pool for payment calls
    @Bulkhead(name = "paymentService",
              type = Bulkhead.Type.THREADPOOL,
              fallbackMethod = "paymentFallback")
    public CompletableFuture<PaymentResult> processPayment(PaymentRequest req) {
        return CompletableFuture.supplyAsync(() -> paymentClient.charge(req));
    }

    public InventoryStatus inventoryFallback(String productId,
            BulkheadFullException ex) {
        log.warn("Bulkhead full for inventoryService, productId={}", productId);
        return InventoryStatus.UNKNOWN; // safe degraded response
    }

    // Programmatic: per-tenant isolation (multi-tenancy)
    private final Map<String, Bulkhead> tenantBulkheads = new ConcurrentHashMap<>();

    public Object callWithTenantIsolation(String tenantId, Supplier<?> call) {
        Bulkhead bulkhead = tenantBulkheads.computeIfAbsent(tenantId, id ->
            Bulkhead.of("tenant-" + id, BulkheadConfig.custom()
                .maxConcurrentCalls(10)
                .maxWaitDuration(Duration.ofMillis(50))
                .build()));

        return Bulkhead.decorateSupplier(bulkhead, call).get();
    }
}

// ── Outbox Entity ─────────────────────────────────────────────────────────────
@Entity
@Table(name = "outbox_events")
@Data
public class OutboxEvent {
    @Id @GeneratedValue(strategy = GenerationType.UUID)
    private String id;
    private String aggregateId;   // e.g., orderId
    private String aggregateType; // e.g., "Order"
    private String eventType;    // e.g., "OrderCreated"
    @Column(columnDefinition = "jsonb")
    private String payload;
    @Enumerated(EnumType.STRING)
    private OutboxStatus status = OutboxStatus.PENDING;
    private Instant createdAt;
    private Instant processedAt;
    private int retryCount = 0;
}

// ── Service — BOTH writes in ONE @Transactional ───────────────────────────────
@Service
@Transactional  // KEY: atomicity guaranteed — if either fails, both rollback
public class OrderService {

    public Order createOrder(CreateOrderRequest req) {
        // 1. Save business entity
        Order order = Order.builder()
            .id(UUID.randomUUID().toString())
            .customerId(req.getCustomerId())
            .status(OrderStatus.PENDING)
            .build();
        orderRepo.save(order);

        // 2. Save outbox event IN SAME TRANSACTION
        OutboxEvent outbox = OutboxEvent.builder()
            .aggregateId(order.getId())
            .aggregateType("Order")
            .eventType("OrderCreated")
            .payload(mapper.writeValueAsString(OrderCreatedEvent.from(order)))
            .build();
        outboxRepo.save(outbox);

        return order;  // both committed or both rolled back
    }
}

// ── Outbox Poller — publishes pending events to Kafka ────────────────────────
@Component
@Slf4j
public class OutboxPoller {

    @Scheduled(fixedDelay = 1000)  // every 1 second
    @Transactional
    public void processOutbox() {
        List<OutboxEvent> pending = outboxRepo
            .findTop100ByStatusOrderByCreatedAtAsc(OutboxStatus.PENDING);

        for (OutboxEvent event : pending) {
            try {
                kafka.send(
                    toTopic(event.getEventType()),
                    event.getAggregateId(),  // partition key — preserves order
                    event.getPayload()
                ).get(5, TimeUnit.SECONDS);  // wait for broker ack

                event.setStatus(OutboxStatus.PROCESSED);
                event.setProcessedAt(Instant.now());

            } catch (Exception ex) {
                log.error("Outbox publish failed id={}", event.getId(), ex);
                event.setRetryCount(event.getRetryCount() + 1);
                if (event.getRetryCount() >= 5)
                    event.setStatus(OutboxStatus.DEAD_LETTER);
            }
            outboxRepo.save(event);
        }
    }
}

// ── Command Side — writes to PostgreSQL ──────────────────────────────────────
public record CreateProductCommand(String name, BigDecimal price, int quantity) {}

@Service
@Transactional
public class ProductCommandHandler {

    public String handle(CreateProductCommand cmd) {
        if (cmd.price().compareTo(BigDecimal.ZERO) <= 0)
            throw new InvalidCommandException("Price must be positive");

        Product product = Product.builder()
            .id(UUID.randomUUID().toString())
            .name(cmd.name())
            .price(cmd.price())
            .build();
        writeRepo.save(product);

        // Publish via Outbox to update read model asynchronously
        outboxRepo.save(OutboxEvent.of(
            product.getId(), "ProductCreated",
            mapper.writeValueAsString(ProductCreatedEvent.from(product))));

        return product.getId();
    }
}

// ── Read Model — denormalized Elasticsearch document ─────────────────────────
@Document(indexName = "products")
@Data
public class ProductReadModel {
    @Id private String id;
    private String     name;
    private BigDecimal price;
    private String     categoryName;  // Denormalized — no join needed at query time
    private double     averageRating; // Pre-computed aggregate
    private int        reviewCount;
    private Instant    lastUpdated;
}

// ── Query Handler — rich Elasticsearch queries ────────────────────────────────
@Service
public class ProductQueryHandler {

    public Page<ProductReadModel> search(ProductSearchQuery query) {
        NativeQuery nq = NativeQuery.builder()
            .withQuery(q -> q.bool(b -> b
                .must(m -> m.match(match ->
                    match.field("name").query(query.keyword())))
                .filter(f -> f.range(r -> r.field("price")
                    .gte(JsonData.of(query.minPrice()))
                    .lte(JsonData.of(query.maxPrice()))))))
            .withSort(Sort.by("averageRating").descending())
            .withPageable(PageRequest.of(query.page(), query.size()))
            .build();
        return esOps.searchForPage(nq, ProductReadModel.class);
    }
}

// ── Read Model Updater — keeps ES in sync via Kafka events ───────────────────
@Service
public class ProductReadModelUpdater {

    @KafkaListener(topics = "product.created", groupId = "product-read-model")
    public void onProductCreated(ProductCreatedEvent event) {
        readRepo.save(ProductReadModel.from(event));
    }

    @KafkaListener(topics = "review.added", groupId = "product-read-model")
    public void onReviewAdded(ReviewAddedEvent event) {
        ProductReadModel model = readRepo.findById(event.getProductId()).orElseThrow();
        model.setAverageRating(event.getNewAverageRating()); // pre-computed update
        model.setReviewCount(model.getReviewCount() + 1);
        model.setLastUpdated(Instant.now());
        readRepo.save(model);
    }
}

// ── Domain Aggregate — state derived entirely from events ─────────────────────
public class BankAccount {
    private String     accountId;
    private BigDecimal balance;
    private AccountStatus status;
    private long       version = 0;
    private final List<DomainEvent> uncommittedEvents = new ArrayList<>();

    // Static factory — raises AccountOpenedEvent
    public static BankAccount open(String id, BigDecimal initialDeposit) {
        BankAccount account = new BankAccount();
        account.applyEvent(new AccountOpenedEvent(id, initialDeposit, Instant.now()));
        return account;
    }

    public void deposit(BigDecimal amount) {
        if (amount.compareTo(BigDecimal.ZERO) <= 0)
            throw new IllegalArgumentException("Deposit must be positive");
        applyEvent(new MoneyDepositedEvent(accountId, amount, Instant.now()));
    }

    public void withdraw(BigDecimal amount) {
        if (balance.compareTo(amount) < 0)
            throw new InsufficientFundsException(accountId, amount, balance);
        applyEvent(new MoneyWithdrawnEvent(accountId, amount, Instant.now()));
    }

    // applyEvent mutates state ONLY — never saves
    private void applyEvent(DomainEvent event) {
        if (event instanceof AccountOpenedEvent e) {
            this.accountId = e.getAccountId();
            this.balance   = e.getInitialDeposit();
            this.status    = AccountStatus.ACTIVE;
        } else if (event instanceof MoneyDepositedEvent e) {
            this.balance = this.balance.add(e.getAmount());
        } else if (event instanceof MoneyWithdrawnEvent e) {
            this.balance = this.balance.subtract(e.getAmount());
        }
        this.version++;
        uncommittedEvents.add(event);
    }

    // Reconstitute from event history (replay)
    public static BankAccount reconstitute(List<DomainEvent> history) {
        BankAccount account = new BankAccount();
        history.forEach(account::applyEvent);
        account.uncommittedEvents.clear();  // historical events already committed
        return account;
    }
}

// ── Event Store — save with optimistic locking ───────────────────────────────
@Repository
public class EventStoreRepository {

    @Transactional
    public void save(String aggregateId, List<DomainEvent> events, long expectedVersion) {
        long currentVersion = getCurrentVersion(aggregateId);
        if (currentVersion != expectedVersion)
            throw new OptimisticLockingException(
                "Expected: " + expectedVersion + ", Got: " + currentVersion);

        long version = expectedVersion;
        for (DomainEvent event : events) {
            version++;
            jdbc.update(
                "INSERT INTO event_store (aggregate_id, version, event_type, event_data) VALUES (?, ?, ?, ?::jsonb)",
                aggregateId, version,
                event.getClass().getSimpleName(),
                mapper.writeValueAsString(event));
        }
    }

    // Load from snapshot + subsequent events for performance
    public List<DomainEvent> loadEvents(String aggregateId) {
        Optional<Snapshot> snapshot = loadLatestSnapshot(aggregateId);
        long fromVersion = snapshot.map(Snapshot::getVersion).orElse(0L);

        return jdbc.query(
            "SELECT * FROM event_store WHERE aggregate_id = ? AND version > ? ORDER BY version ASC",
            eventRowMapper, aggregateId, fromVersion)
            .stream().map(this::deserialize).collect(Collectors.toList());
    }
}

// ── Gateway Strangler Routing ─────────────────────────────────────────────────
@Component
public class StranglerFigFilter implements GlobalFilter, Ordered {

    private final MigrationConfigService migrationConfig;

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        String path = exchange.getRequest().getPath().value();
        MigrationStatus status = migrationConfig.getStatus(path);

        return switch (status) {
            case FULLY_MIGRATED -> routeToNewService(exchange, chain);
            case CANARY -> Math.random() < 0.10
                ? routeToNewService(exchange, chain)   // 10% canary
                : routeToMonolith(exchange, chain);    // 90% legacy
            default -> routeToMonolith(exchange, chain);
        };
    }
}

// ── Anti-Corruption Layer — translates legacy → new domain model ─────────────
@Service
public class LegacyOrderAdapter {

    private final LegacyOrderRepository legacyRepo;  // points to monolith DB
    private final NewOrderRepository    newRepo;

    public Order findById(String orderId) {
        // Try new service DB first, fall back to monolith with translation
        return newRepo.findById(orderId)
            .orElseGet(() -> translateFromLegacy(
                legacyRepo.findByOrderNumber(orderId).orElseThrow()));
    }

    private Order translateFromLegacy(LegacyOrder legacy) {
        return Order.builder()
            .id(legacy.getOrderNumber())           // renamed field
            .customerId(legacy.getCustId())        // abbreviated → full name
            .status(mapLegacyStatus(legacy.getStatusCode())) // code → enum
            .totalAmount(legacy.getTotalCents()    // cents → BigDecimal
                .divide(BigDecimal.valueOf(100)))
            .createdAt(legacy.getCreateDttm().toInstant())
            .build();
    }

    private OrderStatus mapLegacyStatus(String code) {
        return switch (code) {
            case "P" -> OrderStatus.PENDING;
            case "A" -> OrderStatus.PROCESSING;   // 'A' = Active in legacy system
            case "C" -> OrderStatus.COMPLETED;
            case "X" -> OrderStatus.CANCELLED;
            default -> throw new UnknownStatusException(code);
        };
    }
}

# ── VirtualService — traffic splitting + retries + fault injection ────────────
apiVersion: networking.istio.io/v1beta1
kind: VirtualService
metadata:
  name: order-service
spec:
  hosts:
    - order-service
  http:
    - match:
        - headers:
            x-canary: {exact: 'true'}
      route:
        - destination:
            host: order-service
            subset: v2
          weight: 100
    - route:
        - destination:
            host: order-service
            subset: v1
          weight: 90
        - destination:
            host: order-service
            subset: v2
          weight: 10  # 10% canary
      retries:
        attempts: 3
        perTryTimeout: 2s
        retryOn: gateway-error,connect-failure,retriable-4xx
      timeout: 10s
      fault:  # chaos engineering — inject 5% delays in staging
        delay:
          percentage: {value: 5.0}
          fixedDelay: 5s
---
# ── DestinationRule — CB + mTLS + connection pool (Bulkhead at mesh level) ────
apiVersion: networking.istio.io/v1beta1
kind: DestinationRule
metadata:
  name: order-service
spec:
  host: order-service
  trafficPolicy:
    connectionPool:
      tcp:
        maxConnections: 100          # Bulkhead at mesh level
      http:
        http1MaxPendingRequests: 50
    outlierDetection:              # Circuit Breaker at mesh level
      consecutive5xxErrors: 5
      interval: 30s
      baseEjectionTime: 30s
      maxEjectionPercent: 50
    tls:
      mode: ISTIO_MUTUAL  # automatic mTLS — zero code change
  subsets:
    - name: v1
      labels: {version: v1}
    - name: v2
      labels: {version: v2}

@Configuration
@EnableWebSecurity
@EnableMethodSecurity  // enables @PreAuthorize on methods
public class SecurityConfig {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        return http
            .csrf(AbstractHttpConfigurer::disable)
            .sessionManagement(s ->
                s.sessionCreationPolicy(SessionCreationPolicy.STATELESS))
            .authorizeHttpRequests(auth -> auth
                .requestMatchers("/actuator/health").permitAll()
                .requestMatchers("/actuator/**").hasRole("ADMIN")
                .requestMatchers(HttpMethod.GET, "/api/v1/products/**")
                    .hasAnyRole("USER", "ADMIN", "SERVICE")
                .requestMatchers("/api/v1/admin/**").hasRole("ADMIN")
                .anyRequest().authenticated())
            .oauth2ResourceServer(oauth2 -> oauth2
                .jwt(jwt -> jwt
                    .jwtAuthenticationConverter(jwtAuthConverter())))
            .build();
    }

    @Bean
    public JwtAuthenticationConverter jwtAuthConverter() {
        JwtGrantedAuthoritiesConverter converter = new JwtGrantedAuthoritiesConverter();
        converter.setAuthoritiesClaimName("roles");  // custom claim name
        converter.setAuthorityPrefix("ROLE_");
        JwtAuthenticationConverter jwtConverter = new JwtAuthenticationConverter();
        jwtConverter.setJwtGrantedAuthoritiesConverter(converter);
        return jwtConverter;
    }
}

// ── Service-to-Service — Client Credentials WebClient ────────────────────────
@Bean
public WebClient paymentServiceClient(OAuth2AuthorizedClientManager clientManager) {
    // Automatically fetches, caches, and refreshes client_credentials token
    ServerOAuth2AuthorizedClientExchangeFilterFunction oauth =
        new ServerOAuth2AuthorizedClientExchangeFilterFunction(clientManager);
    oauth.setDefaultClientRegistrationId("payment-service");

    return WebClient.builder()
        .baseUrl("http://payment-service")
        .filter(oauth)  // auto-attaches Bearer token to every request
        .build();
}

// ── application.yml — client registration ────────────────────────────────────
// spring.security.oauth2.client.registration.payment-service:
//   client-id: order-service
//   client-secret: ${ORDER_SERVICE_SECRET}  # from Vault
//   authorization-grant-type: client_credentials
//   scope: payment:write payment:read

# application.yml
management:
  tracing:
    sampling:
      probability: 1.0  # 100% in dev, 0.1 (10%) in prod
  zipkin:
    tracing:
      endpoint: http://zipkin:9411/api/v2/spans
logging:
  pattern:
    # traceId + spanId auto-injected into every log line
    level: '%5p [${spring.application.name},%X{traceId},%X{spanId}]'

// ─────────────────────────────────────────────────────────────────────────────

@Service @Slf4j
public class OrderProcessingService {

    private final Tracer tracer;

    public OrderResult processOrder(Order order) {
        Span span = tracer.nextSpan()
            .name("process-order")
            .tag("order.id",     order.getId())
            .tag("order.amount", order.getAmount().toString())
            .start();

        try (Tracer.SpanInScope ws = tracer.withSpan(span)) {
            log.info("Processing order");  // traceId auto-injected in log
            OrderResult result = executeOrder(order);
            span.tag("order.status", result.getStatus().name());
            return result;
        } catch (Exception ex) {
            span.error(ex);   // marks span as ERROR in Zipkin/Tempo
            throw ex;
        } finally {
            span.end();
        }
    }
}

// ── Kafka Consumer — MUST extract trace context from message headers ──────────
@Component
public class TracingKafkaConsumer {

    @KafkaListener(topics = "order.created")
    public void consume(ConsumerRecord<String, String> record) {
        // Extract parent trace from Kafka headers to continue the same trace
        TraceContext parentCtx = propagator.extract(
            record.headers(),
            (headers, key) -> {
                Header h = headers.lastHeader(key);
                return h != null ? new String(h.value()) : null;
            }
        );

        Span span = tracer.nextSpan(parentCtx).name("consume-order-created").start();
        try (Tracer.SpanInScope ws = tracer.withSpan(span)) {
            processMessage(record);
        } finally { span.end(); }
    }
}

// ── Custom Health Indicator — Kafka Consumer Lag ──────────────────────────────
@Component
public class KafkaHealthIndicator implements HealthIndicator {

    @Override
    public Health health() {
        try {
            long maxLag = offsetService.getMaxConsumerLag("order-processor");
            Map<String, Object> details = Map.of(
                "maxConsumerLag", maxLag,
                "brokerCount",  getBrokerCount());

            if (maxLag > 10000) {
                return Health.down()
                    .withDetails(details)
                    .withDetail("reason", "Consumer lag too high")
                    .build();
            }
            return Health.up().withDetails(details).build();

        } catch (Exception ex) {
            return Health.down(ex).build();
        }
    }
}

// ── RED Metrics with Micrometer ───────────────────────────────────────────────
@Service
public class OrderMetricsService {

    private final Counter orderCreatedCounter;
    private final Counter orderFailedCounter;
    private final Timer   orderProcessingTimer;

    public OrderMetricsService(MeterRegistry registry) {
        // RED: Rate
        orderCreatedCounter = Counter.builder("orders.created.total")
            .description("Total orders created")
            .register(registry);
        // RED: Errors
        orderFailedCounter = Counter.builder("orders.failed.total")
            .register(registry);
        // RED: Duration — auto-calculates p50, p95, p99
        orderProcessingTimer = Timer.builder("orders.processing.duration")
            .publishPercentiles(0.5, 0.95, 0.99)
            .publishPercentileHistogram(true)
            .sla(Duration.ofMillis(100), Duration.ofMillis(500))
            .register(registry);
    }

    public Order createOrder(CreateOrderRequest req) {
        return orderProcessingTimer.record(() -> {
            try {
                Order o = doCreateOrder(req);
                orderCreatedCounter.increment();
                // Tag-based breakdown by region/channel
                registry.counter("orders.created.by.region",
                    "region",  req.getRegion(),
                    "channel", req.getChannel())
                    .increment();
                return o;
            } catch (Exception ex) {
                orderFailedCounter.increment();
                registry.counter("orders.failed.by.reason",
                    "reason", ex.getClass().getSimpleName()).increment();
                throw ex;
            }
        });
    }
}

// ── Contract (lives in provider project's test resources) ─────────────────────
// src/test/resources/contracts/order/get-order-by-id.groovy
Contract.make {
    description 'should return order by ID'
    request {
        method GET()
        url '/api/v1/orders/12345'
        headers {
            header('Authorization', $(consumer(regex('Bearer .+')),
                                       producer('Bearer valid-token')))
        }
    }
    response {
        status OK()
        body(
            orderId:     '12345',
            status:      $(anyOf('PENDING', 'PROCESSING', 'SHIPPED')),
            customerId:  $(anyNonEmptyString()),
            totalAmount: $(anyPositiveDecimal())
        )
    }
}

// ── Provider Base Test — stub data the contract expects ───────────────────────
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT)
public class OrderContractBase {
    @MockBean OrderRepository orderRepo;

    @BeforeEach
    void setUp() {
        given(orderRepo.findById("12345")).willReturn(
            Optional.of(Order.builder()
                .id("12345")
                .status(OrderStatus.PROCESSING)
                .customerId("cust-99")
                .totalAmount(new BigDecimal("99.99"))
                .build()));
        RestAssured.baseURI = "http://localhost:" + port;
    }
    // Plugin auto-generates test classes from contracts that extend this base
}

// ── Consumer Test — uses generated WireMock stubs ─────────────────────────────
@SpringBootTest
@AutoConfigureStubRunner(
    ids = "com.example:order-service:+:stubs",    // pulls from Maven
    stubsMode = StubRunnerProperties.StubsMode.CLASSPATH
)
class OrderClientTest {

    @Autowired OrderClient orderClient;

    @Test
    void shouldFetchOrderById() {
        // Stub runner starts WireMock with contract stubs automatically
        OrderResponse response = orderClient.getOrder("12345");

        assertThat(response.getOrderId()).isEqualTo("12345");
        assertThat(response.getStatus()).isIn("PENDING", "PROCESSING", "SHIPPED");
        assertThat(response.getTotalAmount()).isPositive();
    }
}

// ── Integration Test — real PostgreSQL + Kafka in Docker ─────────────────────
@SpringBootTest
@Testcontainers
class OrderRepositoryIntegrationTest {

    @Container
    static PostgreSQLContainer<?> postgres =
        new PostgreSQLContainer<>("postgres:15")
            .withDatabaseName("testdb")
            .withInitScript("schema.sql");

    @Container
    static KafkaContainer kafka =
        new KafkaContainer(DockerImageName.parse("confluentinc/cp-kafka:7.4.0"));

    @DynamicPropertySource
    static void configure(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);
    }

    @Autowired OrderRepository orderRepo;

    @Test
    void shouldPersistOrder() {
        Order order = Order.builder()
            .id(UUID.randomUUID().toString())
            .customerId("cust-1")
            .status(OrderStatus.PENDING)
            .build();
        orderRepo.save(order);
        assertThat(orderRepo.findById(order.getId())).isPresent();
    }
}

// ── Component Test — real Spring context, mocked downstream ──────────────────
@SpringBootTest(webEnvironment = RANDOM_PORT)
class OrderServiceComponentTest {

    @RegisterExtension
    static WireMockExtension inventoryMock = WireMockExtension.newInstance()
        .options(wireMockConfig().port(8081)).build();

    @RegisterExtension
    static WireMockExtension paymentMock = WireMockExtension.newInstance()
        .options(wireMockConfig().port(8082)).build();

    @Test
    void shouldCreateOrderWhenInventoryAndPaymentSucceed() {
        inventoryMock.stubFor(get("/api/inventory/PROD-1")
            .willReturn(okJson("{\"available\":true,\"productId\":\"PROD-1\"}")));

        paymentMock.stubFor(post("/api/payment/charge")
            .willReturn(okJson("{\"transactionId\":\"TXN-99\",\"status\":\"SUCCESS\"}")));

        ResponseEntity<Order> response = restTemplate.postForEntity(
            "/api/v1/orders",
            new CreateOrderRequest("cust-1", "PROD-1", 2),
            Order.class);

        assertThat(response.getStatusCode()).isEqualTo(HttpStatus.CREATED);
        assertThat(response.getBody().getStatus()).isEqualTo(OrderStatus.CONFIRMED);

        // Verify downstream services were actually called
        inventoryMock.verify(1, getRequestedFor(urlEqualTo("/api/inventory/PROD-1")));
        paymentMock.verify(1, postRequestedFor(urlEqualTo("/api/payment/charge")));
    }
}