Integration Testing

Integration testing is the phase in software testing where individual software modules are combined and tested as a group. It occurs after unit testing and before system testing. The goal is to uncover faults in the interaction between integrated units.

Purpose of Integration Testing

Even if every unit works perfectly in isolation (unit tests), the system can still fail because:

• Data Mismatches: One module expects an integer while another sends a string.
• Protocol Errors: Incorrect HTTP status codes or header handling between microservices.
• State Conflicts: Two modules sharing a global state or database records in conflicting ways.
• Third-Party Dependencies: Issues with databases, message brokers, or external APIs.

Integration Testing Strategies

1. Big Bang Integration

Everything is integrated at once, and then the entire system is tested. While simple, it makes debugging extremely difficult because failure can be anywhere.

2. Top-Down Integration

Testing begins from the top-level modules (e.g., UI) and moves down to low-level modules. Missing low-level modules are replaced with stubs.

3. Bottom-Up Integration

Testing starts from the lowest-level modules and moves up. Higher-level modules are replaced with drivers.

4. Sandwich (Hybrid) Integration

A combination of Top-Down and Bottom-Up approaches.

Modern Approaches: Consumer-Driven Contract Testing

In microservice architectures, integration tests can become very slow and brittle. Contract Testing (e.g., using Pact) allows you to test the interface between services without needing both services running at the same time.

• Consumer: Defines a “contract” of what it expects from the provider.
• Provider: Verifies that it can fulfill the contract.
• Benefit: Catches breaking changes in APIs immediately without full end-to-end environment setup.

The Testing Trophy

While the “Testing Pyramid” emphasizes unit tests, some modern developers (like Kent C. Dodds) advocate for the Testing Trophy. The trophy emphasizes Integration Tests as the “sweet spot” of testing—providing the best balance between speed, confidence, and cost. It suggests that since many bugs occur at the integration points, that is where the bulk of the testing effort should go.

Testing External Systems with Docker (Testcontainers)

Modern integration testing often uses tools like Testcontainers to spin up real databases or message brokers in Docker containers during the test run.

Example: Spring Boot Integration Test with Testcontainers (Java)

@SpringBootTest
@Testcontainers
class OrderIntegrationTest {

    @Container
    static PostgreSQLContainer<?> postgres = new PostgreSQLContainer<>("postgres:15-alphine");

    @Autowired
    private OrderRepository orderRepository;

    @Test
    void shouldSaveAndRetrieveOrder() {
        // Arrange
        Order order = new Order("item-123", 2);

        // Act
        orderRepository.save(order);
        List<Order> orders = orderRepository.findAll();

        // Assert
        assertEquals(1, orders.size());
        assertEquals("item-123", orders.get(0).getItemId());
    }
}

API Integration Testing (REST)

Testing how your application interacts with RESTful APIs is a common form of integration testing.

Example: API Testing with Supertest (Node.js)

const request = require('supertest');
const app = require('../src/app');

describe('POST /api/orders', () => {
  it('should create a new order and return 201', async () => {
    const res = await request(app)
      .post('/api/orders')
      .send({
        itemId: 'SKU-001',
        quantity: 5
      });

    expect(res.statusCode).toEqual(201);
    expect(res.body).toHaveProperty('id');
    expect(res.body.itemId).toBe('SKU-001');
  });
});

Challenges in Integration Testing

• Environment Parity: Ensuring the test environment closely matches production.
• Data Cleanup: Ensuring that one test doesn’t leave data in the database that affects the next test.
• Speed: Integration tests are slower than unit tests because they involve network calls and disk I/O.
• Flakiness: Network issues or external service downtime can cause tests to fail intermittently.

Integration testing is crucial for ensuring that the various “cogs” of your software machine work together smoothly, preventing costly “integration hell” late in the development cycle.