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
- Checks that production behavior works with real dependencies, complementing faster tests that keep dependencies under control.
- How deep it goes
- Defines the unit-test boundary, works through network-dependent asynchronous tests, and weighs practical failure modes and testing strategy.
- Examples
- Uses a website availability check, real databases and filesystems, and XML configuration save-and-load tests.
- What you can do after
- Practice/perform integration checks with real dependencies, separate them from fast unit tests, and use a few as safeguards during 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
- Uses integration tests to verify cache operations and client-visible service flows across components.
- How deep it goes
- Works through server setup, client calls, assertions, cleanup, and short-mode execution; leaves real-database testing to mocking or a local instance.
- Examples
- Exercises cache reads and writes and a habit tracker’s create, list, delete, tick, and status flows.
- What you can do after
- Apply integration testing using Go’s testing package to run a gRPC service and verify client-driven 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
- Tests middleware and application components together in the ASP.NET Core request pipeline.
- How deep it goes
- Demonstrates in-memory hosts, request assertions, dependency replacement, and reusable factory configuration.
- Examples
- Uses a ping middleware request and a currency endpoint with a stub converter.
- What you can do after
- Apply it via TestServer and WebApplicationFactory to send in-memory requests and check responses.
Read how ASP.NET Core in Action, 3e explains integration test →
Data-Oriented Programming in Java
Integration testing evaluates interactions between multiple software components or external dependencies.
- How it is used
- Verifies how application code behaves with real I/O dependencies beyond the reach of isolated unit tests.
- How deep it goes
- Develops data-driven designs, algebraic dependency checks, isolation, provisioning, cleanup, and test-pruning practices.
- Examples
- Uses database repository reads and writes, CSV ingestion, task-state transitions, queues, and buckets.
- What you can do after
- Build from scratch reliable tests that exercise real dependencies, expose data flow, and isolate infrastructure.
Read how Data-Oriented Programming in Java explains integration test →
Spring Start Here, Second Edition
An integration test verifies behavior across multiple integrated components or systems.
- How it is used
- Checks application components and Spring capabilities together, complementing isolated unit tests.
- How deep it goes
- Explains test setup, execution, validation, dependency selection, and controller request checks through Spring examples.
- Examples
- Uses a money-transfer service and a simulated transfer endpoint to illustrate integration tests.
- What you can do after
- Apply integration testing via Spring Boot and MockMvc to check framework interactions and endpoint contracts.
Read how Spring Start Here, Second Edition explains integration test →
Test Driven: Practical TDD and Acceptance TDD for Java Developers
An integration test checks whether multiple software components work together correctly.
- How it is used
- Uses integration tests to drive data-access development and verify persistence components against a database.
- How deep it goes
- Works through test setup, schema creation, cleanup and a DbUnit test-driven cycle, alongside environment and speed trade-offs.
- Examples
- Uses a Hibernate Person DAO save-and-retrieve test, an in-memory HSQLDB configuration and DbUnit data files.
- What you can do after
- Apply integration testing using Hibernate and HSQLDB to test-drive a DAO and combine database checks with unit tests.
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
- Tests microservices through their normal interfaces to find problems in integrated code.
- How deep it goes
- Walks through database setup, service lifecycle, HTTP requests, fixtures, and test execution.
- Examples
- Tests a metadata microservice’s /videos route with a real HTTP server and MongoDB database.
- What you can do after
- Apply integration testing via Jest and Axios to a running microservice backed by a test database.
Testing Spring Boot Applications
An integration test verifies that multiple independently developed units work correctly together, often including framework capabilities and selected external dependencies.
- How it is used
- Checks that application code works together with Spring capabilities, between focused unit tests and full end-to-end tests.
- How deep it goes
- Defines the scope and outlines startup, bean access, HTTP checks, and dependency replacement without deeply developing any one technique.
- Examples
- Uses an empty @SpringBootTest startup check and a weather-scoring unit test to distinguish integration checks from focused logic tests.
- What you can do after
- Apply it via Spring Boot Test to check cooperating application parts while reserving focused unit tests for complex conditional logic.
Read how Testing Spring Boot Applications explains integration test →
Rust Web Development
Integration testing evaluates whether interacting parts of a software system work together as expected.
- How it is used
- Checks critical web-service workflows across interacting modules in a local environment.
- How deep it goes
- Walks through a separate test crate, server shutdown, registration request, and database reset, while noting alternative environment setups.
- Examples
- Uses user registration, login, and question creation as target workflows, with a worked registration request and response-parsing failure.
- What you can do after
- Apply it via Rust, Warp, Reqwest, and SQLx to run a local service test with controlled startup and database setup.
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
- Checks functional requirements and interactions across subsystem boundaries in a production-like environment.
- How deep it goes
- Demonstrates real-interpreter and database tests, including environment configuration, while noting that controlled subsystem failures require other techniques.
- Examples
- Uses labyrinth generation and RocksDB loading to demonstrate real-interpreter assertions and a separate test database.
- What you can do after
- Apply integration testing with real interpreters and externally configured test databases.
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 →
Vibe Engineering
An integration test evaluates interactions between multiple software components or with external infrastructure rather than isolating a single unit.
- How it is used
- Uses integration tests to protect migrations and verify affected components before merge.
- How deep it goes
- Explains cross-component assertions, infrastructure setup, migration coupling, and review of generated tests.
- Examples
- Demonstrates a Markdown content pipeline, a containerized MongoDB registration test, and an OpenAI SQL-generation test.
- What you can do after
- Apply integration testing through Spring Boot and Testcontainers, or through API, database, and rendering assertions.
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 High Value Software Systems
A test that verifies interactions among software components or between software and an external system.
- How it is used
- Contains failures at component boundaries during build/test, before they reach later delivery stages.
- How deep it goes
- Defines the test layer, compares its risks and feedback time with other layers, and describes staging-data practice without providing test code.
- Examples
- Uses authentication, database queries, and a notification-preferences migration to show where integration checks can catch boundary failures.
- What you can do after
- Practice/perform it by assigning boundary risks to integration checks and running them against production-like staging data.
Read how Build High Value Software Systems explains integration test →
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 across AI application components, routes, services, and workflows as features evolve.
- How deep it goes
- Defines integration testing and identifies test targets, but gives a worked RAG unit test rather than a complete integration-test implementation.
- Examples
- Uses an LLM API route and a document-summarization chain as integration-test candidates, alongside a RAG unit test with fake dependencies.
- What you can do after
- Practice it by identifying component interactions to test and choosing controlled dependencies or a more realistic local model.
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
- Uses public-interface tests to check behavior and expose API usability problems alongside unit tests.
- How deep it goes
- Explains test layout, assertions, generated inputs, side-effect handling, and trade-offs between built-in and external harnesses.
- Examples
- Uses quicksort function and trait tests, an executable documentation example, and generated vectors compared with standard sorting.
- What you can do after
- Apply it via Cargo and proptest to exercise public interfaces and check results across generated inputs.
Read how Code Like a Pro in Rust explains integration test →
Software Engineering for Data Scientists
Integration testing checks whether multiple software components work together correctly as a combined system.
- How it is used
- Verifies that combined data-pipeline and model components run together as an end-to-end ML pipeline.
- How deep it goes
- Defines integration testing through pipeline handoffs and contrasts it with unit and regression tests, without showing an implementation.
- Examples
- Uses a combined ML pipeline where pipeline data must be correctly ingested by model code.
- What you can do after
- Evaluate/understand whether separately developed pipeline and model components function together properly.
Read how Software Engineering for Data Scientists 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 →
Clean Applications with Hexagonal Architecture
A test that verifies interactions between multiple application components or an application and an external system.
- How it is used
- Verifies transaction behavior that an application depends on, such as rollback, propagation, or transaction boundaries.
- How deep it goes
- Traces Spring proxy behavior for same-class calls and focuses verification on transaction outcomes rather than annotations.
- Examples
- Checks rollback, propagation, and transaction boundaries, including the same-class call that bypasses the proxy.
- What you can do after
- Apply focused Spring integration tests to verify transaction outcomes instead of annotation presence.
Read how Clean Applications with Hexagonal Architecture 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.
Also covered in
- Software Testing with Generative AI
- Spring Security in Action, Second Edition
- Terraform in Depth: Infrastructure as Code with Terraform and OpenTofu
- Learn PowerShell Scripting in a Month of Lunches, Second Edition: Write and organize scripts and tools
- Developer Experience on KubernetesIn early access (MEAP)
- Java Persistence with Spring Data and Hibernate epub
- Building Distributed Applications that Work
- Rust Servers, Services, and Apps
- Effective Behavior-Driven DevelopmentIn early access (MEAP)
- Automating API Delivery
- Enterprise RAGIn early access (MEAP)
- Graph Neural Networks in Action
What to know first
- software testingSoftware testing is the systematic evaluation of software under specified inputs or conditions to assess its behavior against expected results or requirements and identify defects.
- mockingMocking is a testing technique that replaces a dependency or collaborator with a controlled substitute to simulate behavior, isolate code, or inspect interactions.
- contractA contract is an agreed specification of the conditions, expectations, rights, or obligations that govern behavior or interactions between parties or software components.
- deployment pipelineA deployment pipeline is a repeatable sequence of stages that builds, tests or validates, packages, and delivers software changes toward release or deployment.
Related concepts
- end-to-end testingcontrasts with · End-to-end testing evaluates a complete system workflow across integrated components, from an external entry point to its observable outcome.
- databaseuses · A database is an organized persistent data store, typically managed by software, that supports storing, retrieving, and modifying data.
- unit testcontrasts with · A unit test is an automated test that checks whether a relatively small unit of software behaves as expected, typically in isolation from external dependencies.
- mockinguses · Mocking is a testing technique that replaces a dependency or collaborator with a controlled substitute to simulate behavior, isolate code, or inspect interactions.
- shared mutable stateuses · Shared mutable state is data or computational state that multiple components or execution contexts can access and modify.
- automated testingkind of · Automated testing is the execution and evaluation of software tests by programs or tools rather than by manually performing each test procedure.
Questions about integration test
What is integration test?
An integration test evaluates whether multiple software components, or a component and an external dependency, interact and behave correctly together.
Which Manning books explain integration test?
Unit Testing Principles, Practices, and Patterns, The Art of Unit Testing 3e, Learn Go with Pocket-Sized Projects, .NET in Action, Second Edition, ASP.NET Core in Action, 3e, Data-Oriented Programming in Java, Spring Start Here, Second Edition, Test Driven: Practical TDD and Acceptance TDD for Java Developers and 32 more.
What should I know before learning integration test?
Manning books that teach integration test usually introduce software testing, mocking, contract and deployment pipeline first.
What is the difference between integration test and end-to-end testing?
An integration test evaluates whether multiple software components, or a component and an external dependency, interact and behave correctly together. End-to-end testing evaluates a complete system workflow across integrated components, from an external entry point to its observable outcome.
What is integration test a kind of?
Integration test is a kind of automated testing. Automated testing is the execution and evaluation of software tests by programs or tools rather than by manually performing each test procedure.
What is integration test also called?
Integration test is also called integration testing.
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.







































