Smart Test Automation: Ship Faster Without Breaking Things

          ▲
         /E\       End-to-End: 5–10%
        / 2E \     (slow, brittle, expensive)
       /───────\
      / Integr. \  Integration: 20–30%
     / Tests 🔗  \ (medium speed, real deps)
    /─────────────\
   /  Unit Tests   \ Unit: 60–70%
  / ⚡ Fast & Many  \ (fast, isolated, cheap)
 /─────────────────────\

// The class under test
public class OrderService
{
    private readonly IOrderRepository _repo;
    private readonly IInventoryService _inventory;
    private readonly IEventBus _events;

    public OrderService(IOrderRepository repo, IInventoryService inventory, IEventBus events)
    {
        _repo = repo;
        _inventory = inventory;
        _events = events;
    }

    public async Task<OrderResult> PlaceOrderAsync(PlaceOrderCommand cmd)
    {
        var available = await _inventory.CheckAvailabilityAsync(cmd.Sku, cmd.Quantity);
        if (!available)
            return OrderResult.InsufficientStock();

        var order = Order.Create(cmd.UserId, cmd.Sku, cmd.Quantity, cmd.UnitPrice);
        await _repo.SaveAsync(order);
        await _events.PublishAsync(new OrderPlacedEvent(order.Id));

        return OrderResult.Success(order.Id);
    }
}

// Tests — fast, no DB, no network
public class OrderServiceTests
{
    private readonly Mock<IOrderRepository>  _repoMock     = new();
    private readonly Mock<IInventoryService> _inventoryMock = new();
    private readonly Mock<IEventBus>         _eventsMock    = new();
    private readonly OrderService _sut;

    public OrderServiceTests()
    {
        _sut = new OrderService(_repoMock.Object, _inventoryMock.Object, _eventsMock.Object);
    }

    [Fact]
    public async Task PlaceOrder_WhenStockAvailable_ReturnsSuccess()
    {
        // Arrange
        var cmd = new PlaceOrderCommand(UserId: Guid.NewGuid(), Sku: "P001", Quantity: 2, UnitPrice: 4999);
        _inventoryMock.Setup(i => i.CheckAvailabilityAsync("P001", 2)).ReturnsAsync(true);
        _repoMock.Setup(r => r.SaveAsync(It.IsAny<Order>())).Returns(Task.CompletedTask);
        _eventsMock.Setup(e => e.PublishAsync(It.IsAny<OrderPlacedEvent>())).Returns(Task.CompletedTask);

        // Act
        var result = await _sut.PlaceOrderAsync(cmd);

        // Assert
        Assert.True(result.IsSuccess);
        _repoMock.Verify(r => r.SaveAsync(It.IsAny<Order>()), Times.Once);
        _eventsMock.Verify(e => e.PublishAsync(It.IsAny<OrderPlacedEvent>()), Times.Once);
    }

    [Fact]
    public async Task PlaceOrder_WhenOutOfStock_ReturnsInsufficientStock()
    {
        var cmd = new PlaceOrderCommand(Guid.NewGuid(), "P001", 5, 4999);
        _inventoryMock.Setup(i => i.CheckAvailabilityAsync("P001", 5)).ReturnsAsync(false);

        var result = await _sut.PlaceOrderAsync(cmd);

        Assert.False(result.IsSuccess);
        Assert.Equal(OrderResultCode.InsufficientStock, result.Code);
        _repoMock.Verify(r => r.SaveAsync(It.IsAny<Order>()), Times.Never);
        _eventsMock.Verify(e => e.PublishAsync(It.IsAny<IEvent>()), Times.Never);
    }

    // Data-driven tests
    [Theory]
    [InlineData(0)]
    [InlineData(-1)]
    [InlineData(-100)]
    public async Task PlaceOrder_WithInvalidQuantity_ThrowsArgumentException(int qty)
    {
        var cmd = new PlaceOrderCommand(Guid.NewGuid(), "P001", qty, 4999);
        await Assert.ThrowsAsync<ArgumentException>(() => _sut.PlaceOrderAsync(cmd));
    }
}

# test_order_service.py
import pytest
from unittest.mock import AsyncMock, MagicMock, patch
from services.order_service import OrderService, PlaceOrderCommand

@pytest.fixture
def mock_repo():
    return AsyncMock()

@pytest.fixture
def mock_inventory():
    return AsyncMock()

@pytest.fixture
def mock_events():
    return AsyncMock()

@pytest.fixture
def sut(mock_repo, mock_inventory, mock_events):
    return OrderService(repo=mock_repo, inventory=mock_inventory, events=mock_events)


@pytest.mark.asyncio
async def test_place_order_success(sut, mock_repo, mock_inventory, mock_events):
    mock_inventory.check_availability.return_value = True
    cmd = PlaceOrderCommand(user_id="u_99", sku="P001", quantity=2, unit_price=4999)

    result = await sut.place_order(cmd)

    assert result.is_success
    mock_repo.save.assert_called_once()
    mock_events.publish.assert_called_once()


@pytest.mark.asyncio
async def test_place_order_out_of_stock(sut, mock_inventory, mock_repo):
    mock_inventory.check_availability.return_value = False
    cmd = PlaceOrderCommand(user_id="u_99", sku="P001", quantity=10, unit_price=4999)

    result = await sut.place_order(cmd)

    assert not result.is_success
    assert result.code == "INSUFFICIENT_STOCK"
    mock_repo.save.assert_not_called()


@pytest.mark.parametrize("quantity", [0, -1, -100])
@pytest.mark.asyncio
async def test_place_order_invalid_quantity(sut, quantity):
    cmd = PlaceOrderCommand(user_id="u_99", sku="P001", quantity=quantity, unit_price=4999)
    with pytest.raises(ValueError):
        await sut.place_order(cmd)

// Spin up a real PostgreSQL container for the test session
[Collection("integration")]
public class OrderRepositoryTests : IAsyncLifetime
{
    private readonly PostgreSqlContainer _pg = new PostgreSqlBuilder()
        .WithImage("postgres:16-alpine")
        .WithDatabase("testdb")
        .WithUsername("test")
        .WithPassword("test")
        .Build();

    private IOrderRepository _repo = null!;

    public async Task InitializeAsync()
    {
        await _pg.StartAsync();
        var conn = new NpgsqlConnection(_pg.GetConnectionString());
        // Run migrations
        await MigrationRunner.RunAsync(conn);
        _repo = new OrderRepository(conn);
    }

    public Task DisposeAsync() => _pg.DisposeAsync().AsTask();

    [Fact]
    public async Task SaveAndRetrieveOrder_RoundTrips()
    {
        var order = Order.Create(Guid.NewGuid(), "P001", 2, 4999);
        await _repo.SaveAsync(order);

        var retrieved = await _repo.GetByIdAsync(order.Id);

        Assert.NotNull(retrieved);
        Assert.Equal(order.Id, retrieved!.Id);
        Assert.Equal("P001", retrieved.Sku);
        Assert.Equal(OrderStatus.Pending, retrieved.Status);
    }

    [Fact]
    public async Task GetPendingOrders_ReturnsOnlyPending()
    {
        var pending    = Order.Create(Guid.NewGuid(), "P001", 1, 999);
        var delivered  = Order.Create(Guid.NewGuid(), "P002", 1, 999);
        delivered.MarkDelivered();

        await _repo.SaveAsync(pending);
        await _repo.SaveAsync(delivered);

        var results = await _repo.GetByStatusAsync(OrderStatus.Pending);

        Assert.Contains(results, o => o.Id == pending.Id);
        Assert.DoesNotContain(results, o => o.Id == delivered.Id);
    }
}

// Test the full HTTP layer without a real server
public class OrdersApiTests : IClassFixture<WebApplicationFactory<Program>>
{
    private readonly HttpClient _client;

    public OrdersApiTests(WebApplicationFactory<Program> factory)
    {
        _client = factory
            .WithWebHostBuilder(b => b.ConfigureServices(services =>
            {
                // Swap real DB for test DB
                services.RemoveAll<DbContextOptions<AppDbContext>>();
                services.AddDbContext<AppDbContext>(o =>
                    o.UseNpgsql(TestDatabase.ConnectionString));
            }))
            .CreateClient();
    }

    [Fact]
    public async Task POST_Orders_ReturnsCreated()
    {
        var body = new { userId = "user-99", sku = "P001", quantity = 2 };
        var response = await _client.PostAsJsonAsync("/api/orders", body);

        Assert.Equal(HttpStatusCode.Created, response.StatusCode);
        var order = await response.Content.ReadFromJsonAsync<OrderResponse>();
        Assert.NotNull(order?.OrderId);
    }

    [Fact]
    public async Task POST_Orders_WithInvalidQuantity_Returns422()
    {
        var body = new { userId = "user-99", sku = "P001", quantity = -1 };
        var response = await _client.PostAsJsonAsync("/api/orders", body);

        Assert.Equal(HttpStatusCode.UnprocessableEntity, response.StatusCode);
    }
}

// tests/checkout.spec.ts
import { test, expect } from '@playwright/test';

test.describe('Checkout flow', () => {
  test.beforeEach(async ({ page }) => {
    // Seed test data and log in
    await page.goto('/');
    await page.evaluate(() => localStorage.setItem('auth_token', 'test-token'));
  });

  test('user can complete a purchase', async ({ page }) => {
    // Browse to product
    await page.goto('/products/laptop-001');
    await expect(page.getByRole('heading', { name: 'ThinkPad X1' })).toBeVisible();

    // Add to cart
    await page.getByRole('button', { name: 'Add to cart' }).click();
    await expect(page.getByTestId('cart-count')).toHaveText('1');

    // Go to checkout
    await page.getByRole('link', { name: 'View cart' }).click();
    await page.getByRole('button', { name: 'Proceed to checkout' }).click();

    // Fill payment (uses Stripe test card)
    await page.locator('[data-testid="card-number"]').fill('4242 4242 4242 4242');
    await page.locator('[data-testid="card-expiry"]').fill('12/30');
    await page.locator('[data-testid="card-cvc"]').fill('123');
    await page.getByRole('button', { name: 'Pay now' }).click();

    // Confirm success
    await expect(page.getByRole('heading', { name: 'Order confirmed' })).toBeVisible({ timeout: 10_000 });
    await expect(page.getByTestId('order-id')).not.toBeEmpty();
  });

  test('out-of-stock product shows correct state', async ({ page }) => {
    await page.goto('/products/oos-product');
    const addButton = page.getByRole('button', { name: 'Add to cart' });
    await expect(addButton).toBeDisabled();
    await expect(page.getByText('Out of stock')).toBeVisible();
  });
});

# playwright.config.ts
export default defineConfig({
  testDir: './tests',
  fullyParallel: true,
  retries: process.env.CI ? 2 : 0,      // retry flaky tests in CI only
  workers: process.env.CI ? 4 : undefined,
  reporter: [['html'], ['github']],
  use: {
    baseURL: 'http://localhost:3000',
    trace: 'on-first-retry',            // capture trace on failure
    screenshot: 'only-on-failure',
  },
});

// tests/load/orders-api.js
import http from 'k6/http';
import { check, sleep } from 'k6';
import { Rate, Trend } from 'k6/metrics';

const errorRate   = new Rate('error_rate');
const orderLatency = new Trend('order_latency');

export const options = {
  stages: [
    { duration: '30s', target: 10  },   // ramp up
    { duration: '1m',  target: 50  },   // sustain
    { duration: '30s', target: 100 },   // spike
    { duration: '30s', target: 0   },   // ramp down
  ],
  thresholds: {
    http_req_duration: ['p(95)<500'],    // 95th percentile under 500ms
    error_rate:        ['rate<0.01'],    // less than 1% errors
  },
};

export default function () {
  const payload = JSON.stringify({
    userId: `user-${Math.floor(Math.random() * 1000)}`,
    sku: 'P001',
    quantity: 1,
  });

  const start = Date.now();
  const res = http.post('http://localhost:5000/api/orders', payload, {
    headers: { 'Content-Type': 'application/json' },
  });
  orderLatency.add(Date.now() - start);

  errorRate.add(res.status !== 201);
  check(res, {
    'status is 201':          (r) => r.status === 201,
    'has order id':           (r) => JSON.parse(r.body).orderId !== undefined,
    'response time < 500ms':  (r) => r.timings.duration < 500,
  });

  sleep(0.5);
}

# .github/workflows/ci.yml
name: CI

on: [push, pull_request]

jobs:
  unit-tests:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-dotnet@v4
        with: { dotnet-version: '9.x' }
      - run: dotnet test --filter "Category=Unit" --no-build
        # Target: < 30 seconds

  integration-tests:
    runs-on: ubuntu-latest
    needs: unit-tests     # only run if unit tests pass
    services:
      postgres:
        image: postgres:16-alpine
        env: { POSTGRES_PASSWORD: test, POSTGRES_DB: testdb }
        options: --health-cmd pg_isready
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-dotnet@v4
        with: { dotnet-version: '9.x' }
      - run: dotnet test --filter "Category=Integration"
        env: { CONNECTION_STRING: "Host=localhost;Database=testdb;Username=postgres;Password=test" }
        # Target: < 5 minutes

  e2e-tests:
    runs-on: ubuntu-latest
    needs: integration-tests    # gate on integration passing
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
      - run: npm ci && npx playwright install --with-deps
      - run: npx playwright test --workers=4
      - uses: actions/upload-artifact@v4
        if: failure()
        with: { name: playwright-report, path: playwright-report/ }
        # Target: < 10 minutes

  load-test:
    runs-on: ubuntu-latest
    needs: e2e-tests
    if: github.ref == 'refs/heads/main'   # only on main branch
    steps:
      - uses: actions/checkout@v4
      - uses: grafana/setup-k6-action@v1
      - run: k6 run tests/load/orders-api.js
        # Fails build if p95 > 500ms or error rate > 1%

// Using Pact (consumer side)
const provider = new PactV3({
  consumer: 'OrderService',
  provider: 'InventoryService',
});

test('inventory check request', () => {
  return provider
    .given('product P001 has 10 in stock')
    .uponReceiving('a stock availability request')
    .withRequest({ method: 'GET', path: '/inventory/P001' })
    .willRespondWith({
      status: 200,
      body: { sku: 'P001', available: 10 },
    })
    .executeTest(async (mockServer) => {
      const client = new InventoryClient(mockServer.url);
      const result = await client.checkAvailability('P001');
      expect(result.available).toBe(10);
    });
});

[Fact]
public async Task Migrations_ApplyCleanly_ToEmptyDatabase()
{
    await using var pg = await new PostgreSqlBuilder().Build().StartAsync();
    var conn = new NpgsqlConnection(pg.GetConnectionString());

    // Should not throw
    await Assert.DoesNotThrowAsync(() =>
        MigrationRunner.RunAsync(conn));

    // Verify expected tables exist
    var tables = await conn.QueryAsync<string>(
        "SELECT tablename FROM pg_tables WHERE schemaname='public'");
    Assert.Contains("users", tables);
    Assert.Contains("orders", tables);
    Assert.Contains("order_items", tables);
}

[Fact]
public async Task OrderService_WhenDatabaseIsDown_ReturnsServiceUnavailable()
{
    // Use Testcontainers to start then stop the DB mid-test
    await _pg.StopAsync();

    var result = await _sut.PlaceOrderAsync(validCommand);

    // Should return a graceful error, not an unhandled exception
    Assert.Equal(OrderResultCode.ServiceUnavailable, result.Code);
}