What is Integration Testing?

Integration testing verifies that multiple components, modules, or services work correctly when combined. Where unit tests confirm that individual pieces behave as expected in isolation, integration tests confirm that those pieces work together as intended. Integration tests catch a class of bugs that are invisible to unit testing: interface mismatches, incorrect data transformations between layers, and unexpected behavior arising from component interactions.

What Integration Tests Cover

• Database interactions — queries, writes, transactions, and schema behavior
• API contracts — that a client and server agree on request/response shapes
• Message queues — that producers and consumers handle message formats correctly
• Third-party service integrations — that external APIs behave as expected
• Internal service-to-service communication in microservices architectures

Integration Test Patterns

Big Bang Integration

All components are integrated at once and tested together. Simple to set up but difficult to isolate the source of failures. Suitable for small systems.

Incremental Integration

Components are integrated and tested one at a time, in a defined order. Failures are easier to isolate because only one new component is added per test cycle.

Contract Testing

Rather than running full integration tests against live dependencies, contract testing verifies that the producer and consumer of an API agree on its shape. Tools like Pact record consumer expectations and verify them against the provider independently, enabling fast parallel testing without requiring both services to run simultaneously.

Testcontainers

Testcontainers is a library that spins up real Docker containers for dependencies like PostgreSQL, Redis, and Kafka during test runs. Integration tests run against the actual software stack rather than mocks, catching real compatibility issues while remaining self-contained and reproducible.

Integration Testing in CI

Integration tests are slower than unit tests and should be structured to run in parallel where possible. They typically run after unit tests pass and before end-to-end tests. Failures in integration tests are a signal to investigate component interactions, not just individual unit logic.

Integration Testing and Autonomous Code Governance

When Hydra generates automated fixes or dependency updates, integration tests provide critical validation that component interfaces are preserved. A dependency update might pass all unit tests but break the contract between services in ways that only integration tests reveal. Hydra validates against the full test suite before marking a change as safe to merge.

Frequently Asked Questions

What is the difference between integration testing and end-to-end testing?

Integration tests verify that components work together, typically without a full UI or user workflow. End-to-end tests simulate complete user journeys through the full system stack, including UI, APIs, and databases.

What is contract testing and when should I use it?

Contract testing is ideal for microservices where running all services simultaneously for every test is impractical. Pact and Spring Cloud Contract are popular tools. It is most valuable when team boundaries align with service boundaries.

Should integration tests use real databases or mocks?

Real databases via Testcontainers provide higher confidence but are slower. Mocks are faster but may not catch database-specific behavior. The recommendation is real databases for critical integration points and mocks for less critical auxiliary systems.

How do I isolate integration test data?

Use transactions that roll back at the end of each test, or spin up a fresh container per test run. Never run integration tests against shared persistent environments where data accumulates.