Integration test
An integration test evaluates whether multiple software components, or a component and an external dependency, interact and behave correctly together.
Unit Testing Principles, Practices, and Patterns
An integration test is a software test that verifies interactions and cooperation between integrated components or subsystems.
- How it is used
- Validates that controllers connect domain behavior correctly to databases, message buses, and other external systems.
- How deep it goes
- Explains definitions, dependency categorization, scenario selection, mocking boundaries, and a complete database-backed example.
- Examples
- Uses a CRM email-change workflow with a real database, mocked message bus, persisted state, and verified outgoing message.
- What you can do after
- Apply it by selecting high-value system scenarios, using real managed dependencies, mocking unmanaged ones, and asserting observable outcomes.
Read how Unit Testing Principles, Practices, and Patterns explains integration test →
The Art of Unit Testing 3e
Testing that verifies behavior across multiple integrated components or against external systems such as databases and networks.
- How it is used
- Verifies that production code works with real dependencies and supplements lower-level tests with broader confidence.
- How deep it goes
- Defines real-dependency boundaries and details speed, flakiness, debugging, simulation, and legacy-refactoring trade-offs.
- Examples
- Demonstrates a website-status assertion and real-system XML configuration save-and-load tests.
- What you can do after
- Apply it by testing selected real dependencies, separating these tests from unit tests, and using them to protect refactoring.
Read how The Art of Unit Testing 3e explains integration test →
Learn Go with Pocket-Sized Projects
Integration testing evaluates interactions between multiple components or a component and an external dependency as an integrated system.
- How it is used
- Checks multi-operation cache behavior and client-visible service flows without relying only on isolated function tests.
- How deep it goes
- Works through gRPC server setup, client calls, assertions, cleanup, and test commands; leaves real-database integration as a choice.
- Examples
- Uses cache read/write operations and habit-tracker create, list, tick, and status scenarios.
- What you can do after
- Build it from scratch using Go tests to run a gRPC service and verify client-visible scenarios.
Read how Learn Go with Pocket-Sized Projects explains integration test →
.NET in Action, Second Edition
Integration testing evaluates whether multiple software components work together correctly through their real integration points.
- How it is used
- Checks that repository, HTTP client, application service, and API components work together across selected real integration points.
- How deep it goes
- Builds narrow database tests and broader service and API tests, including fixture setup, controlled HTTP responses, dependency injection, and assertions.
- Examples
- Tests a comic repository against in-memory SQLite and searches an ASP.NET Core endpoint with faked comic responses.
- What you can do after
- Build it from scratch with SQLite, a faked HttpMessageHandler, and WebApplicationFactory to verify repository, service, and API behavior.
Read how .NET in Action, Second Edition explains integration test →
ASP.NET Core in Action, 3e
An integration test evaluates the interaction of multiple application components or a substantial vertical slice of an application.
- How it is used
- Checks whether ASP.NET Core components work together in a middleware pipeline or a running application.
- How deep it goes
- Works through in-memory hosts, HTTP assertions, and dependency replacement; distinguishes focused component tests from whole-application tests.
- Examples
- Uses a middleware status request and a currency endpoint whose response is checked with a stubbed converter.
- What you can do after
- Build it from scratch with TestServer, or apply it via WebApplicationFactory to check in-memory application responses.
Read how ASP.NET Core in Action, 3e explains integration test →
Effective Platform Engineering
An integration test evaluates whether multiple software or infrastructure components work together correctly through their real interfaces.
- How it is used
- Validates infrastructure modules and deployed control-plane services against intended configuration and health.
- How deep it goes
- Develops a test-first infrastructure workflow and shows post-deployment Kubernetes checks, without detailing a complete test suite.
- Examples
- Uses Terraform resource checks, subnet-tag conventions, kube-state-metrics health checks, and customer-like test applications.
- What you can do after
- Apply it via infrastructure and Kubernetes pipelines to verify intended resources, enforce conventions, and check deployed service health.
Read how Effective Platform Engineering explains integration test →
Infrastructure as Code, Patterns and Practices: With examples in Python and Terraform
Integration testing is the evaluation of interactions among multiple infrastructure resources or modules against expected configuration and behavior.
- How it is used
- Evaluates whether infrastructure modules and configurations work against live resources in a testing environment.
- How deep it goes
- Explains deployment, provider-API comparison, lifecycle choices, and teardown, but defers provider-specific implementation details beyond examples.
- Examples
- Uses GCP server provisioning, DNS record validation, database deployment, pytest output, and persistent testing environments.
- What you can do after
- Diagnose module or configuration failures by deploying test infrastructure, checking provider state, and validating resource interactions.
Contract Testing in Action
Testing that verifies interactions and compatibility between integrated software components or services.
- How it is used
- Validates interactions among components, services, databases, infrastructure, and deployed configuration.
- How deep it goes
- Explains test-pyramid placement, actual dependencies, API assertions, and migration boundaries without detailing general integration-test implementation.
- Examples
- Uses login failure scenarios and Supertest checks against GET /movies on an Express movies API.
- What you can do after
- Evaluate/understand which integrated risks require integration tests and which API-structure checks can move to contract tests.
Read how Contract Testing in Action explains integration test →
Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform
Integration testing evaluates how multiple software components work together through their real interfaces and interactions.
- How it is used
- Checks a whole microservice through its normal interface to catch problems between integrated code modules.
- How deep it goes
- Works through starting a service, loading a database fixture, sending HTTP requests, checking responses, and shutting down; does not explore test-framework internals.
- Examples
- Tests a metadata microservice’s /videos route using Jest, Axios, a real HTTP server, and MongoDB test data.
- What you can do after
- Apply it via Jest to start and stop a microservice, exercise its HTTP interface, and check responses against a test database.
Think Like a Software Engineering Manager
Integration testing evaluates whether combined software modules or components interact correctly as a group.
- How it is used
- Checks module interactions during implementation so combined components fulfill system requirements.
- How deep it goes
- Defines group testing and its purpose, but does not give steps for writing an integration test.
- Examples
- Uses combined software modules as the testing case and a test automation pyramid to show its scope.
- What you can do after
- Evaluate/understand whether tests check component interactions rather than only individual units or the whole application.
Read how Think Like a Software Engineering Manager explains integration test →
Functional Design and Architecture: Examples in Haskell
An integration test verifies that multiple software components work together correctly in an environment representing their actual integration conditions.
- How it is used
- Validates functional requirements and subsystem interactions in an environment resembling production.
- How deep it goes
- Defines black-box integration testing, demonstrates real-interpreter execution, and details environment separation for database-backed scenarios.
- Examples
- Uses a spaceship-control simulator and Labyrinth generation and RocksDB-loading scenarios.
- What you can do after
- Apply it via real interpreters and externally supplied test configuration to verify integrated behavior safely.
Read how Functional Design and Architecture: Examples in Haskell explains integration test →
Kafka Streams in Action, Second Edition
Integration testing verifies interactions and behavior among multiple software components and their dependencies.
- How it is used
- Validates that Kafka producers, consumers, streams, topics, and broker interactions work together under realistic application conditions.
- How deep it goes
- Explains real-dependency execution, container lifecycle, stream startup, stateful caching, timestamped input, output consumption, and teardown.
- Examples
- Uses a Kafka Streams hopping-window count with timestamped records, a live broker, producer input, consumer output, and expected count assertions.
- What you can do after
- Build integration tests with JUnit 5 and Testcontainers that exercise a Kafka Streams topology against a live Kafka broker.
Read how Kafka Streams in Action, Second Edition explains integration test →
Build Python Web Apps with Streamlit
An integration test evaluates whether multiple software components and their dependencies interact correctly as a combined system.
- How it is used
- Validates that connected application components and selected dependencies behave correctly together.
- How deep it goes
- Builds two integration paths with fixtures, simulated interaction, selective mocking, live API calls, and assertions.
- Examples
- Uses a Streamlit movie search, mocked HTTP results, session-state assertions, rendered expanders, and a live Ferris Bueller API search.
- What you can do after
- Diagnose integration failures by testing component boundaries separately from isolated units and complete end-to-end flows.
Read how Build Python Web Apps with Streamlit explains integration test →
Kafka for Architects
Integration testing is the practice of verifying that multiple software components communicate and interoperate correctly through their defined contracts and protocols.
- How it is used
- Verifies that Kafka-connected components exchange and process messages through their intended contracts, beyond what isolated unit tests establish.
- How deep it goes
- Works through producer and consumer verification and broker setup options, but does not provide a code-level test walkthrough.
- Examples
- Uses service-to-Kafka producer and consumer tests, an embedded broker, and a Testcontainers-launched broker.
- What you can do after
- Practice/perform producer and consumer integration tests that verify messages or processing through Kafka rather than mocks alone.
Build AI-Enhanced Web Apps
Integration testing evaluates interactions and data exchange among multiple software components, application boundaries, or external services.
- How it is used
- Checks interactions among components, API routes, external services, and AI chains in web applications.
- How deep it goes
- Defines the test boundary and gives workflow examples, but does not provide a complete integration-test implementation.
- Examples
- Uses an LLM-backed API route and a LangChain.js document-summarization workflow as test scenarios.
- What you can do after
- Practice/perform integration checks that verify requests, responses, and interactions when application features change.
Read how Build AI-Enhanced Web Apps explains integration test →
Code Like a Pro in Rust
An integration test is a software test that compiles and executes code exercising a component through interfaces similar to those used by other components or external clients.
- How it is used
- Checks public-facing behavior and exposes API usability from a consumer’s perspective.
- How deep it goes
- Works through Cargo test placement, imports and assertions, then weighs harness choices and generated-test side effects; does not detail framework internals.
- Examples
- Uses a quicksort test over two vectors, generated vectors checked against sorting, and an asserted rustdoc example.
- What you can do after
- Apply it via Cargo to test a Rust crate’s exported behavior and choose an external harness when the interface warrants one.
Read how Code Like a Pro in Rust explains integration test →
AI-Powered Developer: Build software with ChatGPT and Copilot
Integration testing evaluates the interactions and combined behavior of multiple software components or systems.
- How it is used
- Verifies that software components or modules interact seamlessly and exposes communication problems.
- How deep it goes
- Demonstrates an end-to-end FastAPI controller test with a test client and in-memory repository, without detailing assertions or execution results.
- Examples
- Uses an AssetController with an in-memory asset repository, REST port, FastAPI TestClient, and seeded assets.
- What you can do after
- Apply it via FastAPI’s test client to exercise an end-to-end controller path with collaborating components.
Read how AI-Powered Developer: Build software with ChatGPT and Copilot explains integration test →
Django in Action
An integration test is an automated test that verifies interactions between multiple software components or systems.
- How it is used
- Verifies that multiple software components interact correctly at the business-logic or server level.
- How deep it goes
- Defines the category, Django database support, assertions, discovery, and cleanup, but stops short of UI interaction.
- Examples
- Uses populated model objects, Django's test database, assertEqual(), and test methods discovered by the test runner.
- What you can do after
- Apply it via Django's test runner to verify interactions across several units with isolated database state.
Practical Automation with PowerShell: Effective scripting from the console to the cloud
Integration testing verifies that multiple software components or systems function correctly together.
- How it is used
- Verifies a PowerShell vulnerability-checking workflow after its functions are composed into one automation.
- How deep it goes
- Explains mocking boundaries and builds multi-function Pester scenarios, then extends assertions to live external data.
- Examples
- Demonstrates KB4521858, KB4565912, Get-VulnerabilityStatus, Get-HotFix, and Microsoft Update Catalog results.
- What you can do after
- Apply it via Pester to validate collaborating PowerShell functions while controlling external cmdlet responses.
Delivering Machine Learning Projects: From design to deployment
Integration testing evaluates whether interacting software components or systems work together correctly through their interfaces.
- How it is used
- Validates that integrated ML-system components work together before production release and operational acceptance.
- How deep it goes
- Defines integration tests, distinguishes them from unit, system, and acceptance tests, and specifies planning, automation, execution, and sign-off.
- Examples
- Uses a production database with feature-extraction code, UI-to-model interactions, and confidential medical-image testing pipelines.
- What you can do after
- Operate/configure an automated preproduction test system that demonstrates whole-system correctness and supports release sign-off.
Read how Delivering Machine Learning Projects: From design to deployment explains integration test →
gRPC Microservices in Go
An integration test verifies interactions among multiple software components or with external systems.
- How it is used
- Verifies that an Order database adapter works with a running MySQL database.
- How deep it goes
- Walks through container setup, suite execution, and save-and-retrieve assertions; leaves full application-flow testing to end-to-end tests.
- Examples
- Tests saving an order and retrieving its customer ID through an adapter backed by containerized MySQL.
- What you can do after
- Apply it via Testcontainers to run a Go database-adapter suite against MySQL and check persisted order data.
Read how gRPC Microservices in Go explains integration test →
Shipping Go: Develop, deliver, discuss, design, and go again
Integration testing verifies functionality between units of software, often including interactions with external dependencies.
- How it is used
- Verifies connected components and external dependencies while a system is being changed or migrated.
- How deep it goes
- Explains placement, cost, reliability, and a database migration workflow, but stops short of detailed test code.
- Examples
- Uses a translation-service migration involving a legacy client, database connection, configuration, and hybrid fallback.
- What you can do after
- Build integration checks that validate existing behavior and user experience across an application and database.
Read how Shipping Go: Develop, deliver, discuss, design, and go again explains integration test →
Build Financial Software with Generative AI (From Scratch)
Integration testing evaluates whether multiple software components work together correctly across their dependencies.
- How it is used
- Uses coordinated application workflows to verify components and dependencies before release and support regression testing.
- How deep it goes
- Explains the testing-pyramid position and implements setup, browser actions, API waits, assertions, fixtures, and screenshots.
- Examples
- Demonstrates FastAPI endpoint checks, BDD scenarios, ACH-file setup, transaction search, browser assertions, and screenshots.
- What you can do after
- Apply it via Pytest and Playwright to validate API responses, dependency-backed data, browser behavior, and regression evidence.
Read how Build Financial Software with Generative AI (From Scratch) explains integration test →
Lead Developer Career Guide
Testing that verifies interactions, interfaces, and data flow between integrated software components or subsystems.
- How it is used
- Uses interactions between integrated components to identify problems that isolated checks may miss.
- How deep it goes
- Defines the distinction from unit and manual testing, recommends early adoption, and stops short of implementation details.
- Examples
- Uses an e-commerce quality assurance process as its concrete example.
- What you can do after
- Apply it via a combined QA strategy that pairs integration checks with unit and manual testing.
Read how Lead Developer Career Guide explains integration test →
Secure APIs
An integration test verifies that multiple software components work together as intended.
- How it is used
- Validates expected API behavior and simulates user flows after implementation.
- How deep it goes
- Defines a suite-level testing role but does not specify individual test cases, code, or implementation internals.
- Examples
- Uses expected API behavior checks and simulated user flows as concrete test targets.
- What you can do after
- Apply it by building integration-test suites that validate API behavior and simulate user flows.
Write Powerful Rust Macros
Integration testing evaluates the behavior and interactions of multiple software components, often across external system boundaries.
- How it is used
- Verifies that multiple system parts work together, especially when macro-generated code communicates with external systems.
- How deep it goes
- Defines scope, speed, dependencies, and confidence, but stops short of procedural setup or implementation details.
- Examples
- Uses real dependencies, outside communication, and macro-generated behavior as testing boundaries.
- What you can do after
- Evaluate whether multiple components interact correctly and decide when broader tests should complement unit tests.
Read how Write Powerful Rust Macros explains integration test →
Practices of the Python Pro
An integration test is a test that evaluates interactions between integrated software components or external systems.
- How it is used
- Checks that software units or external systems work together, complementing isolated unit tests and user-perspective end-to-end tests.
- How deep it goes
- Explains scope, trade-offs, and a multi-method Python example, while stopping short of detailed database or framework configuration.
- Examples
- Demonstrates a ShoppingCart test that adds and removes a Product, verifies an empty cart, and uses unittest.
- What you can do after
- Apply it via Python's unittest or pytest to verify several cooperating units and automate regression checks.
Read how Practices of the Python Pro explains integration test →
Go by Example
An integration test verifies behavior involving interactions between a program and external systems or components.
- How it is used
- Verifies realistic behavior between Go services and external systems such as SQL databases.
- How deep it goes
- Builds a database-backed test with isolated setup, test-scoped context, assertions, failure diagnosis, and error translation.
- Examples
- Exercises link shortening, duplicate-key rejection, SQLite constraint failures, parallel tests, and cleanup.
- What you can do after
- Diagnose/debug with it by exposing integration failures and translating low-level database errors into stable application errors.
Spring in Action, Sixth Edition
An integration test verifies the interaction of multiple application components, often in a running application context with real dependencies.
- How it is used
- Verifies interactions among controllers, servers, repositories, and persistence infrastructure rather than isolated units.
- How deep it goes
- Demonstrates live-server and repository test setup, assertions, and reactive verification, but does not detail broader test strategy.
- Examples
- Uses a live taco endpoint test and an IngredientRepository test covering deletion, insertion, retrieval, and expected reactive values.
- What you can do after
- Builds integration tests with Spring Boot, WebTestClient, @DataR2dbcTest, and StepVerifier.
Read how Spring in Action, Sixth Edition explains integration test →
Machine Learning System Design
A test that evaluates interactions among multiple software components or between a component and an external system.
- How it is used
- Protects infrastructure releases by verifying component interactions and preserving existing service behavior.
- How deep it goes
- Explains comprehensive testing and backward compatibility but does not detail individual test cases or implementation techniques.
- Examples
- Uses a demand-prediction wrapper, third-party services, existing services, and a prediction API as integration contexts.
- What you can do after
- Diagnose release risks by checking component compatibility, pipeline consistency, and post-deployment system health.
Read how Machine Learning System Design explains integration test →
Quarkus in Action
An integration test evaluates an application or component together with externally packaged or connected components.
- How it is used
- Validates REST and messaging behavior against packaged application artifacts or connected brokers.
- How deep it goes
- Demonstrates separate-JVM execution, reusable REST assertions, mocked clients, and Kafka message verification.
- Examples
- Uses a GreetingResource endpoint and a rental workflow that verifies an invoices-adjust Kafka message.
- What you can do after
- Apply it via Quarkus annotations and KafkaCompanion to verify packaged APIs and produced broker messages.
Related concepts
- mockinguses · Mocking is a testing technique that replaces a real dependency with a controlled substitute to simulate behavior or inspect interactions.
- mutable shared stateuses · Mutable shared state is data or computational state that multiple components or execution contexts can access and whose value can change over time.
- end-to-end testingincludes · End-to-end testing evaluates a complete system workflow across integrated components, from an external or user-relevant input to an observable outcome.
- out-of-process dependencyuses · An out-of-process dependency is a dependency that runs outside the application's execution process and provides access to data or services external to in-memory execution.
- real dependencyuses · A real dependency is an actual implementation or external service whose behavior or state is used during a test instead of a test double.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.