End-to-end testing

As explained in 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.

End-to-end testing starts the whole application and runs automated checks for key user journeys. It verifies that the application holds together across its components rather than testing one component in isolation. section 16.3

A practical containerized workflow is:

• Start the application and its supporting services with Docker Compose. section 16.3
• Run a small automated smoke-test suite that makes web requests against the running application. section 16.3
• Stop the application and supporting containers after the checks finish. section 16.3
• Run the longer test stage after earlier build checks provide confidence, and fail the CI job when the workflow does not work. section 11.1 section 16.3

Run the smoke test locally

Use ./smoke-test.ps1 -Local to test locally built images. Run the script without the local flag when reproducing an issue with the latest images from the staging repository. section 16.3

Figure 11.1 The basic steps of a CI pipeline to build, test, and publish apps are all executed with Docker.

Trace how containerized CI builds, tests, packages, and publishes application images. section 11.1

How Learn Docker in a Month of Lunches, Second Edition covers it

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 it assumes

Assumes a Dockerized application and CI pipeline, while demonstrating how to assemble its services for automated checks.

What you can do after

Apply it via Docker Compose and smoke-test scripts to verify that a complete application starts and serves requests.

How it connects

Connects Docker Compose, containers, smoke testing, continuous integration, Docker images, and staging repositories.

liveBookmanning.com

Read Learn Docker in a Month of Lunches, Second Edition on liveBook Get the book at manning.com

Also explained in

• 

  liveBookmanning.com
  Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and TerraformEnd-to-end testing evaluates an application through its user-facing interfaces across the components needed to deliver a user-visible behavior.
• 

  liveBookmanning.com
  Unit Testing Principles, Practices, and PatternsAn automated test that verifies a complete user-relevant workflow across the system and its integrated components.
• 

  liveBookmanning.com
  Infrastructure as Code, Patterns and Practices: With examples in Python and TerraformEnd-to-end testing verifies the behavior of an entire system across its integrated components and external interfaces.
• 

  liveBookmanning.com
  The Art of Unit Testing 3eA system end-to-end test verifies behavior through the complete running system and its operational boundaries.
• 

  liveBookmanning.com
  Build Python Web Apps with StreamlitAn end-to-end test evaluates the behavior of an entire application under conditions that include its real dependencies and external services.
• 

  liveBookmanning.com
  gRPC Microservices in GoEnd-to-end testing verifies a complete user or business workflow across all relevant application components and external dependencies.
• 

  liveBookmanning.com
  Contract Testing in ActionAn end-to-end test exercises a complete user-facing workflow across the systems involved in delivering it.
• 

  liveBookmanning.com
  Automating API DeliveryAn end-to-end test verifies behavior across an entire application or service interaction path, including its external interfaces and dependent components.
• 

  liveBookmanning.com
  Building Reliable AI SystemsTesting that evaluates a system by simulating a complete task from its initial input through its final outcome.
• 

  liveBookmanning.com
  Think Like a Software Engineering ManagerEnd-to-end testing evaluates an entire application or system through behavior that represents real-world use.
• 

  liveBookmanning.com
  Write Powerful Rust MacrosAn end-to-end test evaluates the workings of an entire system using most or all of its real dependencies.

Compare how 12 books explain 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.

This explainer was generated by Manning's knowledge graph from the text of Learn Docker in a Month of Lunches, Second Edition. The section links point to the parts of the book it draws on.