Testing Strategies — Deep Dive

         /\
        /  \
       /E2E \        [Slow, Expensive, Few]
      /----- \
     /Contract\      [Medium, Moderate, More]
    /----------\
   / Integration\    [Faster, Cheaper, More]
  /--------------\
 /   Unit Tests   \  [Fast, Cheap, Many]
/------------------\

         /\
        /  \
       /E2E \     [Many slow tests]
      /------\
     /  Few   \   [Expensive, brittle]
    /----------\
   /    Few     \
  /              \

class DiscountCalculatorTest {

    @Test
    void applyDiscount_validCustomer_returnsDiscountedPrice() {
        // Arrange
        DiscountCalculator calc = new DiscountCalculator();
        double price = 100.0;
        Customer customer = new Customer("gold", 5); // gold tier, 5 years

        // Act
        double result = calc.applyDiscount(price, customer);

        // Assert
        assertEquals(85.0, result); // 15% off for gold tier
    }

    @Test
    void applyDiscount_newCustomer_noDiscount() {
        DiscountCalculator calc = new DiscountCalculator();
        Customer customer = new Customer("bronze", 0);
        assertEquals(100.0, calc.applyDiscount(100.0, customer));
    }
}

@SpringBootTest
@Testcontainers
class OrderServiceIntegrationTest {

    @Autowired
    private OrderService orderService;

    @Container
    static PostgreSQLContainer<?> postgres = 
        new PostgreSQLContainer<>("postgres:15");

    @Test
    void createOrder_validData_persistsToDatabase() throws Exception {
        // Arrange
        OrderRequest request = new OrderRequest("PROD-123", 5);

        // Act
        Order order = orderService.createOrder(request);

        // Assert
        assertNotNull(order.getId());
        assertEquals("PROD-123", order.getProductId());

        // Verify persisted
        Order fetched = orderRepository.findById(order.getId()).orElseThrow();
        assertEquals(5, fetched.getQuantity());
    }

    @Test
    void createOrder_insufficientInventory_throwsException() {
        OrderRequest request = new OrderRequest("OUT-OF-STOCK", 1000);

        assertThrows(InsufficientInventoryException.class,
            () -> orderService.createOrder(request));
    }
}

Timeline:
  Day 1: Service A deployed; calls Payment API
  Day 2: Payment team refactors response: {price} → {amount}
  Day 3: A's calls to Payment start failing in prod 🔥

Timeline:
  Day 1: A and Payment define contract (pact)
  Day 2: Payment refactors; Pact tests fail in CI ✓ Caught!
  Day 2b: Payment team updates contract; A's PR updated
  Day 3: Both deployed; no surprises

@ExtendWith(PactConsumerTestExt.class)
@PactTestFor(providerName = "PaymentService", port = "8888")
class PaymentServicePactTest {

    @Pact(consumer = "OrderService")
    public V4Pact createPact(PactBuilder builder) {
        return builder
            .uponReceiving("a payment request")
            .path("/api/v1/payments")
            .method("POST")
            .body(json()
                .stringValue("orderId", "ORD-123")
                .numberValue("amount", 99.99)
            )
            .willRespondWith()
            .status(200)
            .body(json()
                .stringValue("transactionId", "TXN-abc")
                .stringValue("status", "SUCCESS")
            )
            .toPact();
    }

    @Test
    void orderService_callsPayment_succeeds(MockServer mockServer) {
        PaymentClient client = new PaymentClient(mockServer.getUrl());
        PaymentResponse resp = client.charge("ORD-123", 99.99);

        assertEquals("SUCCESS", resp.getStatus());
    }
}

# Run in Payment Service CI
mvn pact:verify
# Loads pact from consumer; verifies Payment API satisfies it

describe('Checkout flow', () => {

    it('User completes purchase end-to-end', async () => {
        // Navigate to store
        await page.goto('https://store.example.com');

        // Search for product
        await page.fill('[data-testid="search"]', 'laptop');
        await page.click('button:has-text("Search")');

        // Add to cart
        await page.click('button:has-text("Add to Cart")');

        // Checkout
        await page.click('button:has-text("Proceed to Checkout")');

        // Enter payment
        await page.fill('[data-testid="card-number"]', '4111-1111-1111-1111');
        await page.fill('[data-testid="expiry"]', '12/26');
        await page.click('button:has-text("Pay Now")');

        // Verify order confirmation
        await expect(page).toHaveURL(/\/order-confirmation\/\d+/);
        await expect(page.locator('text=Order Confirmed')).toBeVisible();
    });
});

Test Plan:
  - Ramp-up: 0–100 concurrent users over 5 min
  - Sustained: 100 users for 10 min
  - Ramp-down: 100–0 over 2 min

Assertions:
  - P95 latency < 500ms
  - Error rate < 0.1%
  - Throughput > 500 RPS

Endpoints:
  - GET /api/products (40%)
  - GET /api/products/{id} (40%)
  - POST /api/orders (20%)

Results:
  Throughput: 400 RPS
  P95 latency: 800ms ← exceeds 500ms target

Bottleneck: Database connection pool (max 20, depleted at ~300 RPS)

Action: Increase pool size from 20 → 50; re-test

Post-fix:
  Throughput: 600 RPS ✓
  P95 latency: 300ms ✓
  Error rate: 0.05% ✓

# Tool: Gremlin, Chaos Monkey, Kyverno

1. Baseline: Order service has 3 replicas, P95 latency 100ms, error rate 0.001%
2. Kill 1 pod
3. Monitor: Does error rate stay < 0.1%? Does latency spike > 200ms?
4. Observation: Error rate jumps to 5% for 10 seconds ✗ Hypothesis broken
5. Root cause: No graceful shutdown (SIGTERM handler); requests drop mid-flight
6. Fix: Add SIGTERM handler; drain in-flight requests before exit
7. Retest: Error rate stays 0.001% ✓ Hypothesis confirmed

// Original
public int calculateDiscount(int years) {
    return years > 5 ? 10 : 0;
}

// Mutation 1
public int calculateDiscount(int years) {
    return years > 4 ? 10 : 0;  // Changed 5 → 4
}

// Mutation 2
public int calculateDiscount(int years) {
    return years >= 5 ? 10 : 0;  // Changed > to >=
}

// Step 1: Red — Write test first (test fails)
@Test
void applyDiscount_goldCustomer_returns15Percent() {
    DiscountCalculator calc = new DiscountCalculator();
    Customer customer = new Customer("gold", 5);

    double result = calc.applyDiscount(100.0, customer);

    assertEquals(85.0, result);  // Test fails: method doesn't exist yet
}

// Step 2: Green — Write minimal code to pass
public class DiscountCalculator {
    public double applyDiscount(double price, Customer customer) {
        if ("gold".equals(customer.getTier())) {
            return price * 0.85;  // Minimal code: hardcoded for gold
        }
        return price;
    }
}

// Step 3: Refactor — Add more tests; improve implementation
@Test
void applyDiscount_silverCustomer_returns10Percent() {
    // Test for silver tier
}

// Refactor: Extract to method
private double getDiscount(String tier) {
    return switch(tier) {
        case "gold" -> 0.15;
        case "silver" -> 0.10;
        default -> 0.0;
    };
}

Feature: Order checkout discount
  Scenario: Gold customer gets 15% discount
    Given a gold-tier customer with 5 years tenure
    When they checkout with $100 order
    Then they pay $85

  Scenario: New customer gets no discount
    Given a new customer with no history
    When they checkout with $100 order
    Then they pay $100

public class OrderSteps {

    private Customer customer;
    private double totalPrice;
    private double discountedPrice;

    @Given("a gold-tier customer with {int} years tenure")
    public void createGoldCustomer(int years) {
        customer = new Customer("gold", years);
    }

    @When("they checkout with ${double} order")
    public void checkout(double price) {
        totalPrice = price;
        DiscountCalculator calc = new DiscountCalculator();
        discountedPrice = calc.applyDiscount(price, customer);
    }

    @Then("they pay ${double}")
    public void verifyPrice(double expected) {
        assertEquals(expected, discountedPrice);
    }
}

@SpringBootTest
class PaymentServiceComponentTest {

    @Autowired
    private PaymentService paymentService;

    @MockBean
    private PaymentGatewayClient gatewayClient;  // Mock external API

    @Autowired
    private PaymentRepository repository;

    @Test
    void processPayment_validCard_recordsTransaction() {
        // Test the entire Payment Service; external calls mocked
        when(gatewayClient.charge(any())).thenReturn(ChargeResponse.success());

        Payment payment = paymentService.process(
            new PaymentRequest("4111-1111-1111-1111", 99.99)
        );

        assertNotNull(payment.getId());
        verify(repository).save(any());  // Verify DB interaction
    }
}

@Test
void orderCheckout_appliesLoyaltyDiscount_correctly() {
    // Functional: Does the discount feature work end-to-end?

    // Setup
    Customer customer = new Customer("gold", 5);
    Order order = new Order(100.0);

    // Execute
    OrderProcessor processor = new OrderProcessor();
    double finalPrice = processor.checkout(customer, order);

    // Verify
    assertEquals(85.0, finalPrice);  // 15% discount applied
}

You add a new feature: "Silver customers get 10% discount"

Regression tests:
  ✓ Gold customers still get 15% (didn't break)
  ✓ New customers get 0% (didn't break)
  ✓ Silver customers get 10% (new feature)

# Smoke test suite (runs in < 2 minutes)
POST /api/login → 200 OK
GET /api/products → 200 OK (not empty)
POST /api/orders → 201 OK (order created)
GET /api/orders/{id} → 200 OK (order retrieved)

@SpringBootTest
class SmokeTests {

    @Autowired
    private WebTestClient webClient;

    @Test
    void systemIsUp_returnsHealthOK() {
        webClient.get()
            .uri("/actuator/health")
            .exchange()
            .expectStatus().isOk();
    }

    @Test
    void canCreateOrder() {
        webClient.post()
            .uri("/api/orders")
            .bodyValue(new CreateOrderRequest("PROD-123", 5))
            .exchange()
            .expectStatus().isCreated();
    }
}

┌─────────────────────────────────────────────────────┐
│  E2E Test: Full checkout flow (UI → API → DB)       │
│  "Customer adds item, checks out, sees confirmation"│
│  Tool: Selenium, Cypress                            │
│  Speed: 5–10 seconds                                │
└─────────────────────────────────────────────────────┘
                          ↓
┌─────────────────────────────────────────────────────┐
│  Contract Test: Order Service ↔ Payment Service     │
│  "Order expects Payment to return {txnId, status}"  │
│  Tool: Pact                                         │
│  Speed: < 1 second                                  │
└─────────────────────────────────────────────────────┘
                          ↓
┌─────────────────────────────────────────────────────┐
│  Component Test: Order Service (Payment mocked)     │
│  "Given order with gold customer, discount applied" │
│  Tool: Spring Boot Test                             │
│  Speed: 100ms–1s                                    │
└─────────────────────────────────────────────────────┘
                          ↓
┌─────────────────────────────────────────────────────┐
│  Unit Test: Discount calculation                    │
│  "Gold tier + $100 = $85"                           │
│  Tool: JUnit + Mockito                              │
│  Speed: < 100ms                                     │
└─────────────────────────────────────────────────────┘

Each layer tests a different scope:
- Unit: Single function
- Component: Service + internal logic
- Contract: Service boundaries
- E2E: Entire user flow