End-to-end testing
End-to-end testing evaluates a complete system workflow across integrated components, from an external entry point to its observable outcome.
Test Driven: Practical TDD and Acceptance TDD for Java Developers
End-to-end testing checks a system's behavior through its external interfaces across the interactions needed to deliver a feature.
- How it is used
- Checks acceptance behavior through external interfaces while weighing broader coverage against testing cost.
- How deep it goes
- Explains interface choices and trade-offs across application types, with fixture-level implementation steps.
- Examples
- Uses a web login fixture, session-timeout redirect, FTP command, and web navigation test.
- What you can do after
- Apply it via jWebUnit by translating web operations into navigation and checks, and evaluate when to combine external-interface and internal tests.
Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform
End-to-end testing evaluates an application through its user-facing interfaces across the components needed to deliver a user-visible behavior.
- How it is used
- Tests user-visible behavior across microservices through the frontend, using a full application or a smaller configuration.
- How deep it goes
- Walks through application startup, fixture loading, browser assertions, and test execution, while limiting Playwright coverage to its basics.
- Examples
- Checks a fixture-backed video list’s count, names, and links in both cut-down and full application configurations.
- What you can do after
- Applies end-to-end testing with Playwright and Docker Compose to a running microservices application.
Unit Testing Principles, Practices, and Patterns
An automated test that verifies a complete user-relevant workflow across the system and its integrated components.
- How it is used
- Verifies system behavior from the end user’s point of view across nearly all external dependencies.
- How deep it goes
- Defines end-to-end testing and contrasts its scope and trade-offs with integration and unit tests, without detailing implementation procedures.
- Examples
- Uses a database, file system, and payment gateway to contrast broad end-to-end scope with narrower integration testing.
- What you can do after
- Evaluate regression protection and feedback-speed trade-offs when deciding how many end-to-end tests a suite should contain.
Read how Unit Testing Principles, Practices, and Patterns explains end-to-end testing →
Infrastructure as Code, Patterns and Practices: With examples in Python and Terraform
End-to-end testing verifies the behavior of an entire system across its integrated components and external interfaces.
- How it is used
- Verifies that infrastructure changes preserve complete end-user functionality across integrated resources and application endpoints.
- How deep it goes
- Explains endpoint-driven execution, environment sequencing, cleanup, and reliability trade-offs without descending into application internals.
- Examples
- Uses a GCP Cloud Run service, a public application URL, an HTTP GET request, and a Python pytest fixture with cleanup.
- What you can do after
- Apply via pytest and HTTP requests to validate deployed infrastructure workflows in testing and production environments.
The Art of Unit Testing 3e
A system end-to-end test verifies behavior through the complete running system and its operational boundaries.
- How it is used
- Checks important functionality across the running application to provide confidence that its parts work together.
- How deep it goes
- Compares test levels and diminishing returns, but gives no E2E implementation procedure.
- Examples
- Uses a changed combo-box choice alongside unchanged database and third-party dependencies to illustrate a low-value additional E2E test.
- What you can do after
- Practice/perform test selection by reserving a few E2E tests for important functionality and placing suitable variations at lower levels.
Read how The Art of Unit Testing 3e explains end-to-end testing →
Build Python Web Apps with Streamlit
An end-to-end test evaluates the behavior of an entire application under conditions that include its real dependencies and external services.
- How it is used
- Validates an application's complete user workflow before deployment and after changes.
- How deep it goes
- Demonstrates a complete AppTest flow with live API data, but stops short of comprehensive condition coverage.
- Examples
- Uses a MovieScout search, the Inception query, session-state results, expanders, and live TMDB responses.
- What you can do after
- Diagnose/debug with it by reproducing a user flow and locating failures in the combined application system.
Read how Build Python Web Apps with Streamlit explains end-to-end testing →
gRPC Microservices in Go
End-to-end testing verifies a complete user or business workflow across all relevant application components and external dependencies.
- How it is used
- Verifies a create-order flow against a running MySQL, Payment, and Order service stack.
- How deep it goes
- Works through stack setup, gRPC assertions, and teardown, without specifying a wider catalog of workflows.
- Examples
- Uses a containerized create-order test that retrieves the order and checks response fields.
- What you can do after
- Build it from scratch using a Go test suite, Docker Compose, and Testcontainers to verify a running order workflow.
Read how gRPC Microservices in Go explains end-to-end testing →
Microservices Patterns, Second Edition
An end-to-end test exercises a complete application workflow across multiple services or system components.
- How it is used
- Frames end-to-end tests as a release gate that can obstruct independently deployable services.
- How deep it goes
- Identifies delays, random failures, and manual release review, but does not describe test design or execution.
- Examples
- Uses testing the entire application before deploying an updated service as the release-gating example.
- What you can do after
- Evaluate release pipelines and move end-to-end tests out of them to avoid slowing service deployment.
Read how Microservices Patterns, Second Edition explains end-to-end testing →
Testing Spring Boot Applications
A test that exercises an application or system from the user’s perspective across its fully assembled components and dependencies.
- How it is used
- Positions end-to-end checks at the broadest level, validating a running system from the user’s perspective.
- How deep it goes
- Defines scope and trade-offs, but stops short of implementation details, tooling, or executable test configuration.
- Examples
- Uses a deployed staging environment and a car assembled from engine components to illustrate system-level testing.
- What you can do after
- Evaluate whether a fully assembled system works as expected from the user’s perspective.
Read how Testing Spring Boot Applications explains end-to-end testing →
Contract Testing in Action
An end-to-end test exercises a complete user-facing workflow across the systems involved in delivering it.
- How it is used
- Uses a small, high-confidence layer to validate complete user-facing workflows across deployed services.
- How deep it goes
- Explains UI-driven execution, dedicated environments, tradeoffs, and division with contract tests without detailing framework internals.
- Examples
- Uses a Cypress GitHub search workflow, mocked API responses, and a Pact contract asserting a suggested repository href.
- What you can do after
- Apply it via a UI-driven test that validates a complete workflow while isolating unstable service responses with contracts.
Read how Contract Testing in Action explains end-to-end testing →
Learn Docker in a Month of Lunches, Second Edition
An end-to-end test verifies an application workflow across its externally observable components to simulate real user interaction.
- How it is used
- Uses automated smoke tests in containerized CI to validate key user journeys on application builds.
- How deep it goes
- Provides a procedural Docker Compose workflow and smoke-test commands, but limits checks to minimal application-level validation.
- Examples
- Uses web requests, a PowerShell smoke-test script, local images, staging images, and Linux and Windows CI workflows.
- What you can do after
- Apply it via Docker Compose and smoke-test scripts to verify that a complete application starts and serves requests.
Read how Learn Docker in a Month of Lunches, Second Edition explains end-to-end testing →
Claude at Work
An end-to-end test verifies an application flow across its user interface, services, and persistent data.
- How it is used
- Verifies a feature flow by driving a browser and checking the resulting database writes.
- How deep it goes
- Explains browser interaction, database checks, clean-state requirements, and separate test containers.
- Examples
- Tests Ada creating a public channel, landing in it, and seeing it in her channel list.
- What you can do after
- Operate tests against a separate stack and database that can be reset without losing exploratory data.
Automating API Delivery
An end-to-end test verifies behavior across an entire application or service interaction path, including its external interfaces and dependent components.
- How it is used
- Places schema conformance checks at the deployed API gateway and service boundary, especially for external or public APIs.
- How deep it goes
- Walks from environment startup through request validation, failure interpretation, schema correction, and rerun, while noting maintenance and debugging costs.
- Examples
- Uses a product-catalog GET request, Kong, Rest Assured, OpenApiValidationFilter, and undocumented response fields.
- What you can do after
- Diagnose API conformance by running an end-to-end schema test and updating the validated OpenAPI definition when responses diverge.
Read how Automating API Delivery explains end-to-end testing →
Building Reliable AI Systems
Testing that evaluates a system by simulating a complete task from its initial input through its final outcome.
- How it is used
- Validates complete agent and multi-agent workflows, especially orchestration and user-facing task completion.
- How deep it goes
- Moves from task simulation to checks of intent, actions, and outcomes, then recommends stage-level diagnosis for hidden errors.
- Examples
- Tests blended and ambiguous queries, agent failures, state flow, and e-commerce refund requests.
- What you can do after
- Evaluate whether an agent completes a real-world task and identify stages that may need closer inspection.
Read how Building Reliable AI Systems explains end-to-end testing →
Think Like a Software Engineering Manager
End-to-end testing evaluates an entire application or system through behavior that represents real-world use.
- How it is used
- Validates an entire application’s behavior by simulating real-world production functionality.
- How deep it goes
- Examines whole-application behavior but stops short of implementation guidance, test design steps, or tool details.
- Examples
- Simulates real-world production functionality and appears as the top layer of the test automation pyramid.
- What you can do after
- Evaluate whether an application behaves correctly as a complete system, while recognizing its slower pace and higher maintenance cost.
Read how Think Like a Software Engineering Manager explains end-to-end testing →
Write Powerful Rust Macros
An end-to-end test evaluates the workings of an entire system using most or all of its real dependencies.
- How it is used
- Verifies that a complete deployed system works across real dependencies, particularly when continuous delivery could introduce breakage.
- How deep it goes
- Defines system-wide scope and trade-offs, then sketches AWS verification and cleanup without implementing a CI/CD test suite.
- Examples
- Uses deployment smoke paths and an infrastructure macro verified through the AWS SDK in CI/CD and AWS Lambda.
- What you can do after
- Evaluate complete system behavior with real dependencies and diagnose whether deployment-critical paths remain functional.
Read how Write Powerful Rust Macros explains end-to-end testing →
Web Component Development with Modern Libraries and Tooling
An end-to-end test exercises an application through a complete user-facing workflow across its integrated components.
- How it is used
- Uses browser-level workflows to verify integrated web-component rendering and interaction behavior.
- How deep it goes
- Demonstrates page setup, rendering assertions, user clicks, asynchronous waits, and coverage measurement for a component.
- Examples
- Tests a radio-group's rendered options, hydration state, radio-button click, selected state, and resulting value.
- What you can do after
- Apply it via Stencil test commands to verify component workflows and inspect uncovered code.
Read how Web Component Development with Modern Libraries and Tooling explains end-to-end testing →
Also covered in
- Shipping Go: Develop, deliver, discuss, design, and go again
- Build High Value Software SystemsIn early access (MEAP)
- GitHub Actions in Action: Continuous integration and delivery for DevOps
- The Art of AI Product Development
- BDD in Action, Second Edition
- Build Financial Software with Generative AI (From Scratch)
- Vibe EngineeringIn early access (MEAP)
- Secrets of the JavaScript Ninja, Third EditionIn early access (MEAP)
- Practices of the Python Pro
- Lead Developer Career Guide
- Cloud Observability in Action
- Systems Programming with ZigIn early access (MEAP)
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.
- deployment pipelineA deployment pipeline is a repeatable sequence of stages that builds, tests or validates, packages, and delivers software changes toward release or deployment.
- integration testAn integration test evaluates whether multiple software components, or a component and an external dependency, interact and behave correctly together.
- unit testA unit test is an automated test that checks whether a relatively small unit of software behaves as expected, typically in isolation from external dependencies.
Related concepts
- integration testcontrasts with · An integration test evaluates whether multiple software components, or a component and an external dependency, interact and behave correctly together.
- software testingkind of · Software testing is the systematic evaluation of software under specified inputs or conditions to assess its behavior against expected results or requirements and identify defects.
- browseruses · A web browser is software that retrieves, interprets, and renders web resources, executes supported web content, and enables interaction with web applications.
- testing pyramidpart of · The testing pyramid is a software-testing heuristic that recommends many fast, narrow-scope tests and progressively fewer, broader, slower tests at higher levels.
- deployment pipelineused by · A deployment pipeline is a repeatable sequence of stages that builds, tests or validates, packages, and delivers software changes toward release or deployment.
- Docker Composeused by · Docker Compose is a tool for defining and running applications composed of multiple containers through declarative configuration.
Questions about end-to-end testing
What is end-to-end testing?
End-to-end testing evaluates a complete system workflow across integrated components, from an external entry point to its observable outcome.
Which Manning books explain end-to-end testing?
Test Driven: Practical TDD and Acceptance TDD for Java Developers, Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform, Unit Testing Principles, Practices, and Patterns, Infrastructure as Code, Patterns and Practices: With examples in Python and Terraform, The Art of Unit Testing 3e, Build Python Web Apps with Streamlit, gRPC Microservices in Go, Microservices Patterns, Second Edition and 9 more.
What should I know before learning end-to-end testing?
Manning books that teach end-to-end testing usually introduce software testing, deployment pipeline, integration test and unit test first.
What is the difference between end-to-end testing and integration test?
End-to-end testing evaluates a complete system workflow across integrated components, from an external entry point to its observable outcome. An integration test evaluates whether multiple software components, or a component and an external dependency, interact and behave correctly together.
What is end-to-end testing a kind of?
End-to-end testing is a kind of software testing. Software testing is the systematic evaluation of software under specified inputs or conditions to assess its behavior against expected results or requirements and identify defects.
What is end-to-end testing part of?
End-to-end testing is part of testing pyramid. The testing pyramid is a software-testing heuristic that recommends many fast, narrow-scope tests and progressively fewer, broader, slower tests at higher levels.
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.
















