Integration Testing Strategies for Modern Applications

Integration tests verify that different parts of your system work together correctly. They catch issues that unit tests miss—configuration problems, database interactions, and API contracts.

Unit vs Integration Tests#

Unit Tests:
- Test single functions/classes
- Mock all dependencies
- Fast (< 10ms each)
- Run frequently

Integration Tests:
- Test multiple components together
- Real databases, APIs, services
- Slower (100ms - 5s each)
- Run before deployment

API Integration Tests#

import supertest from 'supertest';
import { app } from '../app';
import { prisma } from '../lib/prisma';

const request = supertest(app);

describe('POST /api/users', () => {
  beforeEach(async () => {
    // Clean database before each test
    await prisma.user.deleteMany();
  });

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

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

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

    // Verify in database
    const user = await prisma.user.findUnique({
      where: { email: 'test@example.com' },
    });
    expect(user).not.toBeNull();
  });

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

    expect(response.body.error.code).toBe('VALIDATION_ERROR');
  });

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

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

    expect(response.body.error.code).toBe('EMAIL_EXISTS');
  });
});

Database Integration Tests#

import { prisma } from '../lib/prisma';
import { createOrder, getOrderWithItems } from '../services/order';

describe('Order Service', () => {
  let testUser: User;

  beforeAll(async () => {
    // Create test user
    testUser = await prisma.user.create({
      data: {
        email: 'test@example.com',
        name: 'Test User',
      },
    });
  });

  beforeEach(async () => {
    // Clean orders between tests
    await prisma.orderItem.deleteMany();
    await prisma.order.deleteMany();
  });

  afterAll(async () => {
    await prisma.user.deleteMany();
    await prisma.$disconnect();
  });

  it('should create order with items in a transaction', async () => {
    const items = [
      { productId: 'prod-1', quantity: 2, price: 1000 },
      { productId: 'prod-2', quantity: 1, price: 500 },
    ];

    const order = await createOrder(testUser.id, items);

    expect(order.total).toBe(2500);
    expect(order.items).toHaveLength(2);

    // Verify database state
    const dbOrder = await prisma.order.findUnique({
      where: { id: order.id },
      include: { items: true },
    });

    expect(dbOrder?.items).toHaveLength(2);
    expect(dbOrder?.total).toBe(2500);
  });

  it('should rollback transaction on failure', async () => {
    const items = [
      { productId: 'prod-1', quantity: 2, price: 1000 },
      { productId: 'invalid', quantity: -1, price: 500 }, // Invalid
    ];

    await expect(createOrder(testUser.id, items)).rejects.toThrow();

    // Verify nothing was created
    const orders = await prisma.order.findMany({
      where: { userId: testUser.id },
    });
    expect(orders).toHaveLength(0);
  });
});

Test Database Setup#

// test/setup.ts
import { execSync } from 'child_process';
import { prisma } from '../lib/prisma';

beforeAll(async () => {
  // Use test database
  process.env.DATABASE_URL = process.env.TEST_DATABASE_URL;

  // Reset database schema
  execSync('npx prisma db push --force-reset', {
    env: { ...process.env, DATABASE_URL: process.env.TEST_DATABASE_URL },
  });
});

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

// jest.config.js
module.exports = {
  setupFilesAfterEnv: ['./test/setup.ts'],
  testEnvironment: 'node',
  testMatch: ['**/*.integration.test.ts'],
};

External Service Mocking#

import nock from 'nock';
import { PaymentService } from '../services/payment';

describe('PaymentService', () => {
  beforeEach(() => {
    nock.cleanAll();
  });

  it('should process payment successfully', async () => {
    // Mock Stripe API
    nock('https://api.stripe.com')
      .post('/v1/charges')
      .reply(200, {
        id: 'ch_123',
        status: 'succeeded',
        amount: 1000,
      });

    const payment = new PaymentService();
    const result = await payment.charge({
      amount: 1000,
      currency: 'usd',
      source: 'tok_visa',
    });

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

  it('should handle payment failure', async () => {
    nock('https://api.stripe.com')
      .post('/v1/charges')
      .reply(402, {
        error: {
          type: 'card_error',
          message: 'Card declined',
        },
      });

    const payment = new PaymentService();

    await expect(
      payment.charge({ amount: 1000, currency: 'usd', source: 'tok_declined' })
    ).rejects.toThrow('Card declined');
  });

  it('should retry on network failure', async () => {
    // First two calls fail, third succeeds
    nock('https://api.stripe.com')
      .post('/v1/charges')
      .replyWithError('Network error')
      .post('/v1/charges')
      .replyWithError('Network error')
      .post('/v1/charges')
      .reply(200, { id: 'ch_123', status: 'succeeded' });

    const payment = new PaymentService({ retries: 3 });
    const result = await payment.charge({
      amount: 1000,
      currency: 'usd',
      source: 'tok_visa',
    });

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

Docker Test Environment#

# docker-compose.test.yml
version: '3.8'

services:
  test-db:
    image: postgres:15
    environment:
      POSTGRES_USER: test
      POSTGRES_PASSWORD: test
      POSTGRES_DB: test_db
    ports:
      - '5433:5432'
    tmpfs:
      - /var/lib/postgresql/data

  test-redis:
    image: redis:7
    ports:
      - '6380:6379'

# Run tests with Docker
docker-compose -f docker-compose.test.yml up -d
npm run test:integration
docker-compose -f docker-compose.test.yml down

Test Fixtures#

// fixtures/users.ts
export const fixtures = {
  users: {
    admin: {
      id: 'user-admin',
      email: 'admin@example.com',
      name: 'Admin User',
      role: 'admin',
    },
    regular: {
      id: 'user-regular',
      email: 'user@example.com',
      name: 'Regular User',
      role: 'user',
    },
  },
  products: {
    laptop: {
      id: 'prod-laptop',
      name: 'Laptop',
      price: 99900,
      stock: 10,
    },
    mouse: {
      id: 'prod-mouse',
      name: 'Mouse',
      price: 2900,
      stock: 50,
    },
  },
};

// Load fixtures
async function loadFixtures() {
  await prisma.user.createMany({
    data: Object.values(fixtures.users),
  });
  await prisma.product.createMany({
    data: Object.values(fixtures.products),
  });
}

CI Pipeline#

# .github/workflows/test.yml
name: Integration Tests

on: [push, pull_request]

jobs:
  integration-tests:
    runs-on: ubuntu-latest

    services:
      postgres:
        image: postgres:15
        env:
          POSTGRES_USER: test
          POSTGRES_PASSWORD: test
          POSTGRES_DB: test_db
        ports:
          - 5432:5432
        options: >-
          --health-cmd pg_isready
          --health-interval 10s
          --health-timeout 5s
          --health-retries 5

    steps:
      - uses: actions/checkout@v4

      - name: Setup Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: 'npm'

      - name: Install dependencies
        run: npm ci

      - name: Run migrations
        run: npx prisma db push
        env:
          DATABASE_URL: postgresql://test:test@localhost:5432/test_db

      - name: Run integration tests
        run: npm run test:integration
        env:
          DATABASE_URL: postgresql://test:test@localhost:5432/test_db

Conclusion#

Integration tests are your safety net for system behavior. They catch real bugs that unit tests miss—database constraints, API contracts, and configuration issues.

Invest in a fast, reliable test database setup, and run integration tests before every deployment.

Share this article