Integration Testing: Testing Components Together

Integration tests verify that components work correctly together. This guide covers patterns for testing real interactions.

API Integration Tests#

Testing Express Routes#

import request from 'supertest';
import { app } from '../app';
import { db } from '../db';

describe('POST /api/users', () => {
  beforeEach(async () => {
    await db.users.deleteMany();
  });

  it('should create a new user', async () => {
    const response = await request(app)
      .post('/api/users')
      .send({
        email: 'test@example.com',
        name: 'Test User',
        password: 'securePassword123',
      })
      .expect(201);

    expect(response.body).toMatchObject({
      email: 'test@example.com',
      name: 'Test User',
    });
    expect(response.body).not.toHaveProperty('password');

    // Verify in database
    const user = await db.users.findByEmail('test@example.com');
    expect(user).toBeTruthy();
  });

  it('should return 400 for invalid email', async () => {
    const response = await request(app)
      .post('/api/users')
      .send({
        email: 'invalid-email',
        name: 'Test',
        password: 'password123',
      })
      .expect(400);

    expect(response.body.error).toContain('email');
  });

  it('should return 409 for duplicate email', async () => {
    // Create first user
    await request(app)
      .post('/api/users')
      .send({
        email: 'test@example.com',
        name: 'First User',
        password: 'password123',
      });

    // Try to create duplicate
    const response = await request(app)
      .post('/api/users')
      .send({
        email: 'test@example.com',
        name: 'Second User',
        password: 'password456',
      })
      .expect(409);

    expect(response.body.error).toContain('already exists');
  });
});

Testing Authentication#

describe('Protected Routes', () => {
  let authToken: string;

  beforeAll(async () => {
    // Create test user and get token
    await request(app)
      .post('/api/users')
      .send({ email: 'auth@test.com', password: 'password123' });

    const loginResponse = await request(app)
      .post('/api/auth/login')
      .send({ email: 'auth@test.com', password: 'password123' });

    authToken = loginResponse.body.token;
  });

  it('should access protected route with valid token', async () => {
    const response = await request(app)
      .get('/api/profile')
      .set('Authorization', `Bearer ${authToken}`)
      .expect(200);

    expect(response.body.email).toBe('auth@test.com');
  });

  it('should reject request without token', async () => {
    await request(app)
      .get('/api/profile')
      .expect(401);
  });

  it('should reject request with invalid token', async () => {
    await request(app)
      .get('/api/profile')
      .set('Authorization', 'Bearer invalid-token')
      .expect(401);
  });
});

Database Integration Tests#

Using Test Containers#

import { PostgreSqlContainer, StartedPostgreSqlContainer } from '@testcontainers/postgresql';
import { PrismaClient } from '@prisma/client';

describe('UserRepository', () => {
  let container: StartedPostgreSqlContainer;
  let prisma: PrismaClient;

  beforeAll(async () => {
    // Start PostgreSQL container
    container = await new PostgreSqlContainer()
      .withDatabase('test')
      .start();

    // Connect Prisma to test database
    prisma = new PrismaClient({
      datasources: {
        db: { url: container.getConnectionUri() },
      },
    });

    // Run migrations
    await prisma.$executeRawUnsafe(`
      CREATE TABLE users (
        id SERIAL PRIMARY KEY,
        email VARCHAR(255) UNIQUE NOT NULL,
        name VARCHAR(255)
      )
    `);
  });

  afterAll(async () => {
    await prisma.$disconnect();
    await container.stop();
  });

  beforeEach(async () => {
    await prisma.user.deleteMany();
  });

  it('should create and retrieve user', async () => {
    const created = await prisma.user.create({
      data: { email: 'test@example.com', name: 'Test' },
    });

    const found = await prisma.user.findUnique({
      where: { id: created.id },
    });

    expect(found).toMatchObject({
      email: 'test@example.com',
      name: 'Test',
    });
  });
});

Transaction Testing#

describe('Order Processing', () => {
  it('should rollback on payment failure', async () => {
    const user = await createTestUser();
    const product = await createTestProduct({ inventory: 10 });

    // Mock payment to fail
    paymentService.charge.mockRejectedValue(new Error('Payment declined'));

    await expect(
      orderService.createOrder({
        userId: user.id,
        items: [{ productId: product.id, quantity: 2 }],
      })
    ).rejects.toThrow('Payment declined');

    // Verify inventory wasn't deducted
    const updatedProduct = await db.products.findById(product.id);
    expect(updatedProduct.inventory).toBe(10);

    // Verify no order was created
    const orders = await db.orders.findByUser(user.id);
    expect(orders).toHaveLength(0);
  });
});

External Service Integration#

Using MSW for API Mocking#

import { setupServer } from 'msw/node';
import { http, HttpResponse } from 'msw';

const server = setupServer(
  http.get('https://api.stripe.com/v1/customers/:id', ({ params }) => {
    return HttpResponse.json({
      id: params.id,
      email: 'customer@example.com',
      name: 'Test Customer',
    });
  }),

  http.post('https://api.stripe.com/v1/charges', async ({ request }) => {
    const body = await request.json();

    if (body.amount > 100000) {
      return HttpResponse.json(
        { error: { message: 'Amount too large' } },
        { status: 400 }
      );
    }

    return HttpResponse.json({
      id: 'ch_test123',
      amount: body.amount,
      status: 'succeeded',
    });
  })
);

beforeAll(() => server.listen());
afterEach(() => server.resetHandlers());
afterAll(() => server.close());

describe('PaymentService', () => {
  it('should process payment successfully', async () => {
    const result = await paymentService.charge({
      customerId: 'cus_123',
      amount: 5000,
    });

    expect(result.status).toBe('succeeded');
  });

  it('should handle large amount error', async () => {
    await expect(
      paymentService.charge({
        customerId: 'cus_123',
        amount: 200000,
      })
    ).rejects.toThrow('Amount too large');
  });
});

Redis Integration#

import Redis from 'ioredis';
import { GenericContainer } from 'testcontainers';

describe('CacheService', () => {
  let redis: Redis;
  let container: StartedTestContainer;

  beforeAll(async () => {
    container = await new GenericContainer('redis:7-alpine')
      .withExposedPorts(6379)
      .start();

    redis = new Redis({
      host: container.getHost(),
      port: container.getMappedPort(6379),
    });
  });

  afterAll(async () => {
    await redis.quit();
    await container.stop();
  });

  beforeEach(async () => {
    await redis.flushall();
  });

  it('should cache and retrieve values', async () => {
    const cacheService = new CacheService(redis);

    await cacheService.set('user:1', { name: 'John' }, 3600);
    const cached = await cacheService.get('user:1');

    expect(cached).toEqual({ name: 'John' });
  });

  it('should return null for expired keys', async () => {
    const cacheService = new CacheService(redis);

    await cacheService.set('temp', 'value', 1); // 1 second TTL

    await new Promise(resolve => setTimeout(resolve, 1100));

    const result = await cacheService.get('temp');
    expect(result).toBeNull();
  });
});

Best Practices#

Use real databases in containers: More realistic than mocks
Clean up between tests: Prevent test pollution
Test failure scenarios: Network errors, timeouts, invalid data
Keep tests focused: One integration point per test
Use factories for test data: Consistent, maintainable setup

Integration tests verify real interactions between components. Use test containers for databases, MSW for external APIs, and ensure proper cleanup between tests. Balance coverage with test execution time.