Integration testing

Basic Concepts of Integration Testing

Integration testing is an indispensable part of software development, focusing on whether the interactions between multiple modules or components are correct. Unlike unit testing, integration testing does not isolate and test individual functions or classes but verifies the behavior when multiple parts are combined. In a Node.js environment, integration testing is particularly important because Node.js applications typically consist of multiple modules, services, and external dependencies.

For example, an e-commerce application might include modules for user authentication, product management, and order processing. Unit tests can ensure the internal logic of each module is correct, but integration testing can verify whether a user can successfully browse products and place an order after logging in.

Integration Testing Tools in Node.js

In the Node.js ecosystem, there are several tools available for integration testing. Jest and Mocha are two popular choices that not only support unit testing but also handle integration testing scenarios well.

// Example of integration testing using Jest
const request = require('supertest');
const app = require('../app');

describe('User API Integration Test', () => {
  test('Create a user and fetch user information', async () => {
    // Create a user
    const createResponse = await request(app)
      .post('/users')
      .send({ name: 'Zhang San', email: 'zhangsan@example.com' });
    
    expect(createResponse.statusCode).toBe(201);
    
    // Fetch user information
    const userId = createResponse.body.id;
    const getResponse = await request(app)
      .get(`/users/${userId}`);
    
    expect(getResponse.statusCode).toBe(200);
    expect(getResponse.body.name).toBe('Zhang San');
  });
});

Testing Database Interactions

Database operations are a common scenario in integration testing. Typically, a dedicated test database is used, or the database state is reset before and after each test case.

const { MongoClient } = require('mongodb');
const UserRepository = require('../repositories/userRepository');

describe('User Repository Integration Test', () => {
  let connection;
  let db;
  let userRepository;

  beforeAll(async () => {
    connection = await MongoClient.connect(global.__MONGO_URI__);
    db = await connection.db(global.__MONGO_DB_NAME__);
    userRepository = new UserRepository(db);
  });

  afterEach(async () => {
    await db.collection('users').deleteMany({});
  });

  afterAll(async () => {
    await connection.close();
  });

  test('Create and find a user', async () => {
    await userRepository.create({ name: 'Li Si', email: 'lisi@example.com' });
    const user = await userRepository.findByEmail('lisi@example.com');
    
    expect(user).not.toBeNull();
    expect(user.name).toBe('Li Si');
  });
});

Testing External API Calls

Modern Node.js applications often need to interact with external APIs. Integration testing needs to verify whether these interactions work as expected, typically using libraries like nock to mock HTTP requests.

const nock = require('nock');
const WeatherService = require('../services/weatherService');

describe('Weather Service Integration Test', () => {
  beforeEach(() => {
    nock('https://api.weather.com')
      .get('/v1/current?city=Beijing')
      .reply(200, {
        temperature: 25,
        condition: 'Sunny'
      });
  });

  test('Fetch Beijing weather', async () => {
    const weather = await WeatherService.getCurrent('Beijing');
    
    expect(weather.temperature).toBe(25);
    expect(weather.condition).toBe('Sunny');
  });
});

Testing Authentication and Authorization

For API endpoints that require authentication, integration testing needs to simulate the complete authentication flow.

const jwt = require('jsonwebtoken');
const config = require('../config');

describe('Protected API Integration Test', () => {
  test('Access an authenticated endpoint', async () => {
    // Generate a test JWT token
    const token = jwt.sign({ userId: '123' }, config.jwtSecret);
    
    const response = await request(app)
      .get('/api/protected')
      .set('Authorization', `Bearer ${token}`);
    
    expect(response.statusCode).toBe(200);
    expect(response.body.message).toBe('This is protected content');
  });

  test('Access without a token should return 401', async () => {
    const response = await request(app)
      .get('/api/protected');
    
    expect(response.statusCode).toBe(401);
  });
});

Testing Asynchronous Operations

Node.js applications are full of asynchronous operations, and integration testing needs to handle these scenarios properly.

describe('Asynchronous Operation Integration Test', () => {
  test('Concurrent user registration', async () => {
    const promises = [];
    
    // Simulate 10 concurrent registration requests
    for (let i = 0; i < 10; i++) {
      promises.push(
        request(app)
          .post('/users')
          .send({ name: `User ${i}`, email: `user${i}@test.com` })
      );
    }
    
    const responses = await Promise.all(promises);
    
    // Verify all requests succeeded
    responses.forEach(response => {
      expect(response.statusCode).toBe(201);
    });
    
    // Verify there are indeed 10 users in the database
    const count = await User.countDocuments();
    expect(count).toBe(10);
  });
});

Best Practices for Integration Testing

1. Keep tests independent: Each test case should be able to run independently without relying on the state of other test cases.

2. Use real dependencies: Whenever possible, use real databases, caches, and other services instead of mocking everything.

3. Clean up test data: Clean up created data after tests to avoid affecting subsequent tests.

4. Set reasonable timeouts: Integration tests typically take longer than unit tests, so timeout settings should be adjusted appropriately.

// Setting test timeout in Jest
jest.setTimeout(30000); // 30-second timeout

describe('Long-running Integration Test', () => {
  test('Large data import', async () => {
    // Code for testing large data operations
  });
});

Integration Testing and Continuous Integration

In CI/CD pipelines, integration tests are typically run as part of the build process. Example configuration:

# GitHub Actions example configuration
name: Node.js CI

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    
    services:
      mongodb:
        image: mongo
        ports:
          - 27017:27017
    
    steps:
      - uses: actions/checkout@v2
      - uses: actions/setup-node@v2
        with:
          node-version: '14'
      - run: npm install
      - run: npm test

Test Coverage Reports

Coverage reports for integration tests can help identify blind spots in testing. Using Istanbul/nyc, coverage reports can be generated:

// package.json configuration
{
  "scripts": {
    "test": "jest --coverage",
    "test:integration": "jest --config jest.integration.config.js --coverage"
  }
}

Performance Testing and Integration Testing

Sometimes integration tests can also include performance validation:

describe('API Performance Test', () => {
  test('Response time should be less than 500ms', async () => {
    const start = Date.now();
    const response = await request(app).get('/api/products');
    const duration = Date.now() - start;
    
    expect(response.statusCode).toBe(200);
    expect(duration).toBeLessThan(500);
  });
});