Bird
Raised Fist0
Microservicessystem_design~10 mins

Integration testing in Microservices - Interactive Code Practice

Choose your learning style10 modes available

Start learning this pattern below

Jump into concepts and practice - no test required

or
Recommended
Test this pattern10 questions across easy, medium, and hard to know if this pattern is strong
Practice - 5 Tasks
Answer the questions below
1fill in blank
easy

Complete the code to define an integration test that checks communication between two microservices.

Microservices
def test_service_communication():
    response = service_a.call_service_b()
    assert response.status_code == [1]
Drag options to blanks, or click blank then click option'
A200
B404
C500
D302
Attempts:
3 left
💡 Hint
Common Mistakes
Using 404 or 500 as success codes.
2fill in blank
medium

Complete the code to mock a dependent microservice during integration testing.

Microservices
with mock.patch('service_b.api_call') as mocked_call:
    mocked_call.return_value = [1]
    result = service_a.call_service_b()
    assert result == 'success'
Drag options to blanks, or click blank then click option'
A'error'
B'timeout'
CNone
D'success'
Attempts:
3 left
💡 Hint
Common Mistakes
Returning error or None causing test failures.
3fill in blank
hard

Fix the error in the integration test setup to correctly start the test environment.

Microservices
def setup_test_env():
    [1].start()
    service_a.reset()
    service_b.reset()
Drag options to blanks, or click blank then click option'
Atest_environment
Btest_env
Cenv
Denvironment
Attempts:
3 left
💡 Hint
Common Mistakes
Using undefined or incorrect variable names.
4fill in blank
hard

Fill both blanks to create a test that waits for service B to be ready before calling it.

Microservices
def test_service_b_ready():
    while not service_b.[1]():
        time.[2](1)
    response = service_a.call_service_b()
    assert response.status_code == 200
Drag options to blanks, or click blank then click option'
Ais_ready
Bsleep
Cwait
Dstart
Attempts:
3 left
💡 Hint
Common Mistakes
Using 'wait' instead of 'sleep', or wrong readiness method.
5fill in blank
hard

Fill all three blanks to build a dictionary comprehension that maps service names to their health status if status is 'healthy'.

Microservices
health_status = { [1]: status for [2], status in services.items() if status [3] 'healthy' }
Drag options to blanks, or click blank then click option'
Aname
Bstatus
C==
D!=
Attempts:
3 left
💡 Hint
Common Mistakes
Using '!=' instead of '==' causing wrong filtering.

Practice

(1/5)
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