Practice : Integration Testing

Purpose and Strategic Importance

Integration Testing ensures that individual components or systems work together as expected. It goes beyond unit testing to validate interactions, data flow, and the correctness of integrated functionality - typically between services, modules, or systems.

This practice helps teams detect issues such as contract mismatches, environment misconfiguration, and cascading failures that unit tests can’t uncover. It provides essential confidence for delivery in complex, interconnected systems.

Description of the Practice

  • Integration tests validate that multiple parts of the system interact correctly.
  • Tests may include database access, service-to-service communication, or external APIs.
  • Integration tests are automated, run regularly, and included in the CI pipeline.
  • Environments for integration testing are isolated, repeatable, and stable.
  • Integration testing complements unit and end-to-end testing - not a replacement.

How to Practise It (Playbook)

1. Getting Started

  • Identify critical system boundaries and dependencies for integration coverage.
  • Write tests that exercise real interactions (e.g. API calls, DB queries, queues).
  • Use test doubles (mocks, stubs) selectively when full integration is infeasible.
  • Run integration tests in an isolated environment that reflects production-like conditions.

2. Scaling and Maturing

  • Structure tests to be reliable, fast, and focused on system contracts.
  • Tag or group tests to allow selective execution (e.g. smoke vs. full suite).
  • Use containerisation (e.g. Docker Compose, TestContainers) to simulate dependencies.
  • Validate all integration points before deployment with green builds.
  • Capture and log interactions to support debugging and observability.

3. Team Behaviours to Encourage

  • Prioritise integration tests where failures are most costly.
  • Pair test design with developers and testers to share context and expertise.
  • Make test results visible and actionable - don’t ignore flakiness.
  • Review and improve integration coverage regularly in retros and planning.

4. Watch Out For…

  • Tests that are slow, flaky, or dependent on unstable environments.
  • Coupling tests too tightly to implementation details - focus on contracts.
  • Overlapping coverage with end-to-end tests, leading to redundancy.
  • Ignoring integration issues in favour of unit pass rates.

5. Signals of Success

  • Integration tests run automatically and reliably in CI/CD pipelines.
  • Failures indicate real integration issues and are resolved quickly.
  • Confidence increases in service compatibility and release readiness.
  • Teams use integration tests as part of their development feedback loop.
  • System changes are deployed with minimal integration surprises.