liveBook · Manning

End-to-end testing

Also called end-to-end test, E2E test

End-to-end testing evaluates a complete system workflow across integrated components, from an external entry point to its observable outcome.

How 17 Manning books explain it

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.

Read how Test Driven: Practical TDD and Acceptance TDD for Java Developers explains end-to-end testing →

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.

Read how Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and Terraform explains end-to-end testing →

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.

Read how Infrastructure as Code, Patterns and Practices: With examples in Python and Terraform explains end-to-end testing →

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.

Read how Claude at Work explains end-to-end testing →

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

What to know first

Related concepts

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.