Testing Microservices: Strategies for Distributed Systems

Testing microservices requires different strategies than monolithic applications. This guide covers testing patterns from unit tests to production verification.

The Testing Pyramid for Microservices#

                    ┌───────────────┐
                    │   E2E Tests   │  Few, slow, expensive
                    ├───────────────┤
                    │  Contract     │
                    │  Tests        │  Verify service contracts
                    ├───────────────┤
                    │  Integration  │
                    │  Tests        │  Test with real dependencies
                    ├───────────────┤
                    │  Component    │
                    │  Tests        │  Test service in isolation
                    ├───────────────┤
                    │  Unit Tests   │  Many, fast, cheap
                    └───────────────┘

Unit Testing#

Test business logic in isolation:

// order.service.test.ts
import { OrderService } from './order.service';
import { mockOrderRepository, mockPaymentGateway } from '../test/mocks';

describe('OrderService', () => {
  let service: OrderService;

  beforeEach(() => {
    service = new OrderService(
      mockOrderRepository,
      mockPaymentGateway
    );
  });

  describe('createOrder', () => {
    it('should create order with valid items', async () => {
      const items = [
        { productId: '1', quantity: 2, price: 29.99 },
      ];

      const order = await service.createOrder('user-123', items);

      expect(order.status).toBe('pending');
      expect(order.total).toBe(59.98);
      expect(mockOrderRepository.save).toHaveBeenCalledWith(
        expect.objectContaining({ userId: 'user-123' })
      );
    });

    it('should reject empty orders', async () => {
      await expect(service.createOrder('user-123', []))
        .rejects.toThrow('Order must have at least one item');
    });

    it('should apply discount codes', async () => {
      const items = [{ productId: '1', quantity: 1, price: 100 }];

      const order = await service.createOrder('user-123', items, {
        discountCode: 'SAVE20',
      });

      expect(order.discount).toBe(20);
      expect(order.total).toBe(80);
    });
  });
});

Component Testing#

Test a service with its direct dependencies:

// order.component.test.ts
import { Test, TestingModule } from '@nestjs/testing';
import { OrderController } from './order.controller';
import { OrderService } from './order.service';
import { PrismaService } from '../prisma/prisma.service';
import { TestDatabase } from '../test/test-database';

describe('Order Component', () => {
  let app: TestingModule;
  let controller: OrderController;
  let db: TestDatabase;

  beforeAll(async () => {
    db = await TestDatabase.create();

    app = await Test.createTestingModule({
      controllers: [OrderController],
      providers: [
        OrderService,
        {
          provide: PrismaService,
          useValue: db.prisma,
        },
        // Mock external services
        {
          provide: 'PAYMENT_SERVICE',
          useValue: {
            charge: jest.fn().mockResolvedValue({ id: 'payment-123' }),
          },
        },
      ],
    }).compile();

    controller = app.get<OrderController>(OrderController);
  });

  afterAll(async () => {
    await db.cleanup();
  });

  beforeEach(async () => {
    await db.reset();
  });

  it('should create and retrieve order', async () => {
    // Create order
    const createResult = await controller.create({
      userId: 'user-1',
      items: [{ productId: 'prod-1', quantity: 2 }],
    });

    expect(createResult.id).toBeDefined();

    // Retrieve order
    const order = await controller.findOne(createResult.id);

    expect(order.userId).toBe('user-1');
    expect(order.items).toHaveLength(1);
  });
});

Contract Testing with Pact#

Consumer Side#

// order-consumer.pact.test.ts
import { PactV3, MatchersV3 } from '@pact-foundation/pact';
import { ProductClient } from './product.client';

const { like, eachLike } = MatchersV3;

const provider = new PactV3({
  consumer: 'OrderService',
  provider: 'ProductService',
  dir: './pacts',
});

describe('Product Service Contract', () => {
  it('should get product details', async () => {
    await provider
      .given('product 123 exists')
      .uponReceiving('a request for product 123')
      .withRequest({
        method: 'GET',
        path: '/api/products/123',
      })
      .willRespondWith({
        status: 200,
        headers: { 'Content-Type': 'application/json' },
        body: {
          id: like('123'),
          name: like('Test Product'),
          price: like(29.99),
          inventory: like(100),
        },
      })
      .executeTest(async (mockServer) => {
        const client = new ProductClient(mockServer.url);
        const product = await client.getProduct('123');

        expect(product.name).toBe('Test Product');
        expect(product.price).toBe(29.99);
      });
  });

  it('should return 404 for non-existent product', async () => {
    await provider
      .given('product 999 does not exist')
      .uponReceiving('a request for non-existent product')
      .withRequest({
        method: 'GET',
        path: '/api/products/999',
      })
      .willRespondWith({
        status: 404,
        body: { error: like('Product not found') },
      })
      .executeTest(async (mockServer) => {
        const client = new ProductClient(mockServer.url);

        await expect(client.getProduct('999'))
          .rejects.toThrow('Product not found');
      });
  });
});

Provider Side#

// product-provider.pact.test.ts
import { Verifier } from '@pact-foundation/pact';
import { app } from '../src/app';

describe('Product Provider Verification', () => {
  let server: any;

  beforeAll(async () => {
    server = app.listen(3001);
  });

  afterAll(() => {
    server.close();
  });

  it('should validate the expectations of OrderService', async () => {
    const verifier = new Verifier({
      providerBaseUrl: 'http://localhost:3001',
      pactUrls: ['./pacts/OrderService-ProductService.json'],
      stateHandlers: {
        'product 123 exists': async () => {
          await db.products.create({
            id: '123',
            name: 'Test Product',
            price: 29.99,
            inventory: 100,
          });
        },
        'product 999 does not exist': async () => {
          await db.products.deleteMany({ where: { id: '999' } });
        },
      },
    });

    await verifier.verifyProvider();
  });
});

Integration Testing#

Test service interactions with real dependencies:

// order-integration.test.ts
import { Test } from '@nestjs/testing';
import { INestApplication } from '@nestjs/common';
import request from 'supertest';
import { AppModule } from '../src/app.module';
import { setupTestContainers } from './test-containers';

describe('Order Integration Tests', () => {
  let app: INestApplication;
  let containers: Awaited<ReturnType<typeof setupTestContainers>>;

  beforeAll(async () => {
    // Start test containers
    containers = await setupTestContainers();

    const moduleRef = await Test.createTestingModule({
      imports: [AppModule],
    })
      .overrideProvider('DATABASE_URL')
      .useValue(containers.postgresUrl)
      .overrideProvider('REDIS_URL')
      .useValue(containers.redisUrl)
      .compile();

    app = moduleRef.createNestApplication();
    await app.init();
  });

  afterAll(async () => {
    await app.close();
    await containers.stop();
  });

  describe('POST /orders', () => {
    it('should create order and publish event', async () => {
      const response = await request(app.getHttpServer())
        .post('/orders')
        .send({
          userId: 'user-123',
          items: [{ productId: 'prod-1', quantity: 2 }],
        })
        .expect(201);

      expect(response.body).toMatchObject({
        status: 'pending',
        userId: 'user-123',
      });

      // Verify event was published
      const events = await containers.getPublishedEvents('orders');
      expect(events).toContainEqual(
        expect.objectContaining({
          type: 'OrderCreated',
          orderId: response.body.id,
        })
      );
    });
  });
});

Using Testcontainers#

// test-containers.ts
import { PostgreSqlContainer } from '@testcontainers/postgresql';
import { RedisContainer } from '@testcontainers/redis';
import { KafkaContainer } from '@testcontainers/kafka';

export async function setupTestContainers() {
  const postgres = await new PostgreSqlContainer()
    .withDatabase('test')
    .start();

  const redis = await new RedisContainer().start();

  const kafka = await new KafkaContainer().start();

  return {
    postgresUrl: postgres.getConnectionUri(),
    redisUrl: redis.getConnectionUrl(),
    kafkaUrl: `${kafka.getHost()}:${kafka.getMappedPort(9093)}`,

    async stop() {
      await Promise.all([
        postgres.stop(),
        redis.stop(),
        kafka.stop(),
      ]);
    },

    async getPublishedEvents(topic: string) {
      // Read from Kafka topic
    },
  };
}

End-to-End Testing#

// e2e/checkout-flow.test.ts
import { test, expect } from '@playwright/test';

test.describe('Checkout Flow', () => {
  test('should complete purchase', async ({ page }) => {
    // Add item to cart
    await page.goto('/products/123');
    await page.click('button:has-text("Add to Cart")');

    // Go to checkout
    await page.click('a:has-text("Cart")');
    await page.click('button:has-text("Checkout")');

    // Fill shipping info
    await page.fill('[name="address"]', '123 Main St');
    await page.fill('[name="city"]', 'New York');
    await page.fill('[name="zip"]', '10001');

    // Submit order
    await page.click('button:has-text("Place Order")');

    // Verify confirmation
    await expect(page.locator('h1')).toHaveText('Order Confirmed');
    await expect(page.locator('.order-id')).toBeVisible();
  });
});

Testing Strategies#

Chaos Testing#

// chaos.test.ts
describe('Resilience Tests', () => {
  it('should handle database timeout gracefully', async () => {
    // Inject latency
    await toxiproxy.addToxic('postgres', {
      type: 'latency',
      attributes: { latency: 5000 },
    });

    const response = await request(app)
      .get('/api/orders/123')
      .timeout(3000);

    expect(response.status).toBe(503);
    expect(response.body.error).toBe('Service temporarily unavailable');
  });

  it('should use circuit breaker on repeated failures', async () => {
    // Simulate service down
    await mockServer.stubFor(
      get('/products/123').willReturn(
        aResponse().withStatus(500)
      )
    );

    // First 5 requests fail
    for (let i = 0; i < 5; i++) {
      await request(app).post('/orders').send(orderData);
    }

    // Circuit should be open now - fast fail
    const start = Date.now();
    const response = await request(app).post('/orders').send(orderData);
    const duration = Date.now() - start;

    expect(duration).toBeLessThan(100); // Fast fail
    expect(response.body.error).toBe('Service unavailable');
  });
});

Best Practices#

Test at the right level: Most tests should be unit/component tests
Use contract tests: Catch breaking changes early
Test failure modes: Services will fail, test handling
Parallelize tests: Use containers for isolation
Mock external services: Don't depend on third parties in CI

Conclusion#

Testing microservices requires a layered approach. Start with unit tests for business logic, use contract tests for service boundaries, and reserve E2E tests for critical user journeys.

Share this article