Integration Testing Concepts

1. Introduction

Integration Testing verifies that different modules, classes, or database services interact correctly with each other. While unit tests focus on isolated blocks of code, integration tests focus on the integration boundaries between them.

2. Why It Matters

An application can fail even if all individual units pass their tests. For example, a validation helper may format values correctly, and a database connector may save objects correctly, but if the save method passes arguments in the wrong order, the application will crash. Integration testing catches these integration failures.

3. Real-World Analogy

Think of a Plumbing system:

• Unit Test (Pipe Check): The factory tests each pipe to ensure it holds pressure and doesn't leak. Every pipe passes inspection.
• Integration Test (Connected Pipes): You connect the pipes to a water tap. Even if all pipes are perfect, if the threads do not match or the joints are loose, water will leak at the connection point. Testing the flow of water through the connected system is an integration test.

4. Integration Test Flow

Integration tests focus on testing a subsystem of components without mocking the connections between them:

Instead of mocking the database layer (unit test), an integration test runs both components, verifying that the validated payload is correctly written to a database:

5. DOM Testing Integration

In frontend applications, integration testing often involves rendering components in a simulated DOM (using jsdom) and asserting that DOM updates trigger state updates correctly:

6. Common Mistakes

• Over-mocking in integration tests: Mocking internal layers inside an integration test defeats its purpose. If you replace the database layer with a mock, the test becomes a unit test, failing to verify that database triggers function correctly. Mock only external, network-boundary resources.

7. Quick Quiz

8. Scenario-Based Challenge

9. Debugging Exercise

// Integration test file
import { db } from './db-connection';
beforeEach(async () => {
  // Bug: clearing the shared dev database tables before every test!
  await db.query('DELETE FROM users'); 
});
test('adds a user', async () => {
  await db.addUser({ id: 1, name: 'Alice' });
  const list = await db.getUsers();
  expect(list.length).toBe(1);
});
// When running tests concurrently, sibling tests delete tables during execution, causing random failures! Why?

// Use transactions and roll back after each test
beforeEach(async () => {
  await db.query('BEGIN TRANSACTION');
});

afterEach(async () => {
  await db.query('ROLLBACK'); // Restores database state instantly, leaving tables untouched!
});

10. Interview Questions

11. Production Considerations

• • Isolated Environments: Run integration tests in containerized environments (such as using Docker) that spawn isolated databases and services, ensuring tests do not contaminate local development data.