Testing pyramid

As explained in gRPC Microservices in Go

The testing pyramid is a test-distribution model that places isolated unit tests below integration tests and end-to-end tests, with progressively fewer tests and greater execution cost at higher levels.

The testing pyramid distributes tests across unit, integration, and end-to-end categories. Unit tests form the broad base, integration tests occupy the middle, and end-to-end tests form the narrow top. section 7.1

The distribution reflects isolation, speed, and cost. Unit tests isolate one component and mock dependencies; integration tests involve multiple modules and may require tools such as test containers; end-to-end tests exercise complete application behavior with the greatest resource use. section 7.1

Use the pyramid as a proportioning guideline rather than an exclusion rule:

• Keep unit tests numerous because they provide fast feedback with low infrastructure cost. section 7.1 section 7.6
• Add integration tests to verify that modules, such as a data layer and real database, work together. section 7.6
• Retain end-to-end tests for complete flows even though they run more slowly and consume more resources. section 7.1 section 7.6

Order service

Test an Order service in isolation by focusing on its context and mocking dependencies. Use integration tests with a database dependency when verifying the data layer, then use end-to-end tests to validate the complete service flow. section 7.0 section 7.6

Figure 7.1 Testing pyramid

Use the pyramid diagram to compare test categories, their relative percentages, isolation levels, and execution costs. section 7.1

How gRPC Microservices in Go covers it

How deep it goes

Defines three test levels and explains their isolation, dependencies, execution speed, and cost, but does not prescribe exact percentages.

Examples

Uses an Order service, mocked dependencies, a real database, test containers, and complete application flows as testing examples.

What it assumes

Assumes familiarity with software components and dependencies while defining unit, integration, and end-to-end testing contexts.

What you can do after

Apply it to arrange unit, integration, and end-to-end suites for faster feedback while preserving cross-component verification.

How it connects

Connects unit testing, integration testing, end-to-end testing, test containers, test coverage, and CI pipelines.

liveBookmanning.com

Read gRPC Microservices in Go on liveBook Get the book at manning.com

Also explained in

• 

  liveBookmanning.com
  Unit Testing Principles, Practices, and PatternsThe Test Pyramid is a testing strategy that recommends a relative distribution of unit, integration, and end-to-end tests, with more tests in lower layers.
• 

  liveBookmanning.com
  Contract Testing in ActionThe test automation pyramid is a model that recommends distributing automated tests across unit, integration, and end-to-end layers, with fewer tests at slower and more expensive higher layers.
• 

  liveBookmanning.com
  Shipping Go: Develop, deliver, discuss, design, and go againA testing pyramid is a testing strategy with many fast unit tests at the base and progressively fewer broader, more expensive tests above them.
• 

  liveBookmanning.com
  Django in ActionA testing pyramid is a model that organizes software tests into levels based on scope, speed, and execution cost.
• 

  liveBookmanning.com
  Bootstrapping Microservices, Second Edition: With Docker, Kubernetes, GitHub Actions, and TerraformThe testing pyramid is a model that organizes tests into layers, with broader and generally slower tests placed above narrower and generally faster tests.
• 

  liveBookmanning.com
  Build Financial Software with Generative AI (From Scratch)A testing pyramid is a model that organizes software tests by scope, with numerous fast isolated tests at the base and fewer slower broader tests toward the top.
• 

  liveBookmanning.com
  Think Like a Software Engineering ManagerThe testing pyramid is a test-suite design framework that emphasizes an appropriate distribution of automated tests across testing levels.

Compare how 8 books explain testing pyramid →

Related concepts

• testhas part · A test is a procedure or check that evaluates behavior using specified inputs or evidence against expected results or criteria.
• integration testhas part · An integration test evaluates whether multiple software components, or a component and an external dependency, interact and behave correctly together.
• end-to-end testinghas part · End-to-end testing evaluates a complete system workflow across integrated components, from an external or user-relevant input to an observable outcome.
• unit testhas part · A unit test is a test that evaluates the behavior of a small, isolated unit of software against expected behavior.
• acceptance testinghas part · Acceptance testing evaluates whether a system or software satisfies specified user, business, or other stakeholder requirements and is acceptable for its intended purpose.

This explainer was generated by Manning's knowledge graph from the text of gRPC Microservices in Go. The section links point to the parts of the book it draws on.