Integration testing in Microservices - Architecture Diagram

System Overview - Integration testing

This system demonstrates integration testing in a microservices environment. It ensures that multiple services work together correctly by simulating real user requests flowing through the system. Key requirements include verifying communication between services, data consistency, and error handling across service boundaries.

Architecture Diagram

User
  |
  v
Load Balancer
  |
  v
API Gateway
  |
  +---------------------+
  |                     |
  v                     v
Service A             Service B
  |                     |
  v                     v
Database A            Database B
  |
  v
Cache

Components

User

client

Initiates requests to the system

Load Balancer

load_balancer

Distributes incoming requests evenly to API Gateway instances

API Gateway

api_gateway

Routes requests to appropriate microservices and handles authentication

Service A

service

Handles part of the business logic and communicates with Database A

Service B

service

Handles another part of business logic and communicates with Database B

Database A

database

Stores data related to Service A

Database B

database

Stores data related to Service B

Cache

cache

Speeds up data retrieval for frequently accessed data

Request Flow - 14 Hops

User → Load Balancer

Load Balancer → API Gateway

API Gateway → Service A

Service A → Cache

Cache → Service A

Service A → Database A

Database A → Service A

Service A → Service B

Service B → Database B

Database B → Service B

Service B → Service A

Service A → API Gateway

API Gateway → Load Balancer

Load Balancer → User

Failure Scenario

Component Fails:Database A

Impact:Service A cannot retrieve or store data, causing partial failure in response. Cache may serve stale data but writes fail.

Mitigation:Use database replication for failover. Service A returns error message or degraded response. Cache serves read requests if data is available.

Architecture Quiz - 3 Questions

Which component routes user requests to the correct microservice?

A API Gateway

B Load Balancer

C Cache

D Database

Design Principle

This architecture shows how integration testing verifies communication and data flow between multiple microservices, databases, and caches. It highlights the importance of routing, caching, and fallback mechanisms to ensure system reliability and correctness.

Practice

1. What is the main purpose of integration testing in a microservices architecture?

easy

A. To verify that different microservices communicate and work together correctly

B. To test the user interface of a single microservice

C. To check the performance of a single microservice under load

D. To test the database schema independently

Solution

1. Step 1: Understand integration testing role

   Integration testing focuses on checking how different parts of a system interact and work together.

2. Step 2: Apply to microservices context

   In microservices, integration testing ensures that services communicate and exchange data correctly.

3. Final Answer:

   To verify that different microservices communicate and work together correctly -> Option A

4. Quick Check:

   Integration testing = verify communication [OK]

Hint: Integration tests check service communication, not UI or performance [OK]

Common Mistakes:

• Confusing integration testing with UI testing
• Thinking integration tests check only one service
• Mixing integration testing with performance testing

2. Which of the following is the correct way to write a simple integration test for two microservices communicating via HTTP?

easy

A. Call one service's API and verify the response includes data from the other service

B. Test only the database queries inside one service

C. Run unit tests on each microservice separately

D. Check the UI elements of the frontend application

Solution

1. Step 1: Identify integration test action

   Integration tests call APIs to check if services interact and data flows correctly.

2. Step 2: Match with options

   Call one service's API and verify the response includes data from the other service describes calling one service and verifying response includes data from another, which is correct.

3. Final Answer:

   Call one service's API and verify the response includes data from the other service -> Option A

4. Quick Check:

   Integration test = API call + response check [OK]

Hint: Integration test means calling APIs and checking combined data [OK]

Common Mistakes:

• Testing only database queries (unit test scope)
• Running unit tests instead of integration tests
• Focusing on UI elements, not service communication

3. Consider this integration test code snippet for two microservices A and B:

response = serviceA.callEndpoint('/data')
assert 'user' in response
assert response['user']['id'] == 123
assert response['details']['status'] == 'active'

What is the expected outcome if microservice B fails to provide 'details' data?

medium

A. The test will ignore missing 'details' and succeed

B. The test will fail at the assertion checking 'details' key

C. The test will throw a syntax error

D. The test will pass because 'user' data is present

Solution

1. Step 1: Analyze test assertions

   The test checks for 'user' key and its 'id', then checks 'details' key's 'status'.

2. Step 2: Consider missing 'details' data

   If 'details' is missing, accessing response['details']['status'] causes failure or error.

3. Final Answer:

   The test will fail at the assertion checking 'details' key -> Option B

4. Quick Check:

   Missing data causes assertion failure [OK]

Hint: Missing keys cause assertion failures, not silent passes [OK]

Common Mistakes:

• Assuming test passes if some keys exist
• Confusing assertion failure with syntax error
• Thinking missing keys are ignored

4. You wrote an integration test that calls microservice A, which calls microservice B internally. The test fails intermittently with timeout errors. What is the most likely cause?

medium

A. The test code has syntax errors

B. Microservice A does not call microservice B at all

C. Microservice B is slow or unresponsive causing timeouts

D. The database schema is incorrect

Solution

1. Step 1: Understand timeout errors in integration tests

   Timeouts usually happen when a service does not respond in expected time.

2. Step 2: Analyze microservice call chain

   Since microservice A calls B internally, if B is slow or down, A's response delays causing timeout.

3. Final Answer:

   Microservice B is slow or unresponsive causing timeouts -> Option C

4. Quick Check:

   Timeout = slow/unresponsive downstream service [OK]

Hint: Timeouts usually mean slow or down called service [OK]

Common Mistakes:

• Blaming syntax errors for runtime timeouts
• Assuming no call happens without checking logs
• Confusing database issues with service timeouts

5. You want to design an automated integration test suite for a microservices system with 5 services communicating via REST APIs. Which approach best ensures reliable and scalable integration testing?

hard

A. Manually test service interactions without automation

B. Use test doubles (mocks) for all services to isolate each test

C. Test only one service at a time with unit tests

D. Deploy all services in a test environment and run end-to-end tests covering real API calls

Solution

1. Step 1: Consider integration testing goals

   Integration tests verify real communication between services, so mocks reduce test coverage.

2. Step 2: Evaluate options for reliability and scalability

   Deploying all services in a test environment and running automated end-to-end tests ensures real interactions and catches integration issues.

3. Final Answer:

   Deploy all services in a test environment and run end-to-end tests covering real API calls -> Option D

4. Quick Check:

   Real environment + automation = reliable integration tests [OK]

Hint: Run real services in test environment for true integration tests [OK]

Common Mistakes:

• Relying only on mocks, missing real integration bugs
• Skipping automation reduces test reliability
• Confusing unit tests with integration tests