End-to-end testing
End-to-end testing evaluates a complete system workflow across integrated components, from an external or user-relevant input to an observable outcome.
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
- Checks user-visible behavior across a whole microservices application or a testable subset through its frontend.
- How deep it goes
- Works through application startup, fixtures, browser navigation, DOM assertions, and test commands, while limiting Playwright instruction to basics.
- Examples
- Uses a two-video fixture to check frontend entries and links, then runs the Playwright test against the full application.
- What you can do after
- Apply it via Playwright and Docker Compose to test frontend behavior across running microservices.
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
- Provides high-confidence checks that important functionality works through a complete running system.
- How deep it goes
- Explains E2E trade-offs and diminishing returns, but defers detailed test implementation and scenario design.
- Examples
- Illustrates an E2E-only build pattern and contrasts it with a low-level-only testing pattern.
- What you can do after
- Evaluate/understand where a small number of E2E tests adds confidence without creating an E2E-only build.
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 →
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 →
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 →
Related concepts
- integration testkind of · An integration test evaluates whether multiple software components, or a component and an external dependency, interact and behave correctly together.
- testkind of · A test is a procedure or check that evaluates behavior using specified inputs or evidence against expected results or criteria.
- testing pyramidpart of · The testing pyramid is a software-testing model that favors many fast, focused lower-level tests and progressively fewer, broader, slower tests at higher levels.
- browseruses · A web browser is software that retrieves, interprets, and renders web resources, executes supported web content, and enables interaction with web pages and applications.
- smoke testincludes · A brief, shallow test that checks whether a system’s essential functions work sufficiently for further testing or use.
- Playwrightimplemented by · Playwright is an open-source library for automating Chromium, Firefox, and WebKit browsers and testing web applications across supported programming languages.
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.