Unit testing services in Microservices - System Design Guide

Problem Statement

When microservices are developed without unit tests, bugs can go unnoticed until later stages, causing costly fixes and unreliable service behavior. Without isolating each service's logic, developers cannot confidently change code or detect regressions early.

Solution

Unit testing services means writing small, focused tests that check each service's internal logic independently from other services or external systems. This isolation helps catch errors early, ensures code correctness, and supports safe refactoring by verifying expected behavior in controlled conditions.

Architecture

Service A

┌───────────┐

↓

External APIs

This diagram shows each microservice with its own unit tests that mock external dependencies like other services or databases, isolating the service logic for testing.

Trade-offs

✓ Pros

→

Detects bugs early in the development cycle before integration.

→

Enables safe refactoring by verifying service logic independently.

→

Speeds up development feedback with fast, isolated tests.

→

Improves code quality and documentation through test cases.

✗ Cons

→

Requires effort to write and maintain mocks for external dependencies.

→

Does not catch integration issues between services or systems.

→

May give false confidence if tests do not cover real-world scenarios.

Always use unit testing for microservices development, especially when services have complex business logic or frequent changes. Essential when teams practice continuous integration and delivery.

Avoid relying solely on unit tests when the system is very simple with minimal logic, or when integration and end-to-end tests cover all critical paths sufficiently.

Real World Examples

Netflix

Netflix writes unit tests for each microservice to ensure individual service logic correctness before deploying to their large distributed streaming platform.

Uber

Uber uses unit testing in their microservices to catch errors early in ride matching and pricing logic, reducing failures in production.

Amazon

Amazon applies unit tests to microservices handling order processing to maintain high reliability and fast iteration.

Code Example

The before code calls an external payment gateway directly, making tests unreliable and slow. The after code uses mocking to simulate the external call, isolating the service logic and enabling fast, reliable unit tests.

Microservices

### Before: No unit test, direct call to external service
class PaymentService:
    def charge(self, user_id, amount):
        # Calls external payment gateway
        response = external_gateway.charge(user_id, amount)
        return response.success

### After: Unit test with mock for external dependency
import unittest
from unittest.mock import Mock, patch

class PaymentService:
    def charge(self, user_id, amount):
        response = external_gateway.charge(user_id, amount)
        return response.success

class TestPaymentService(unittest.TestCase):
    @patch('__main__.external_gateway.charge')
    def test_charge_success(self, mock_charge):
        mock_charge.return_value = Mock(success=True)
        service = PaymentService()
        result = service.charge('user123', 100)
        self.assertTrue(result)

if __name__ == '__main__':
    unittest.main()

Alternatives

Integration testing

Tests multiple services or components working together rather than isolated units.

Use when: Choose integration testing when verifying communication and data flow between services is critical.

End-to-end testing

Tests the entire system flow from user interface to backend services.

Use when: Choose end-to-end testing to validate complete user scenarios and system behavior.

Summary

Unit testing services isolates and verifies each microservice's internal logic independently.

It helps catch bugs early and supports safe code changes with fast feedback.

Mocks replace external dependencies to keep tests focused and reliable.

Practice

1. What is the main purpose of unit testing in microservices?

easy

A. To deploy the service automatically

B. To test the entire system end-to-end

C. To monitor service performance in production

D. To test small parts of a service independently

Solution

1. Step 1: Understand unit testing scope

   Unit testing focuses on testing small, isolated parts of a service, not the whole system.

2. Step 2: Differentiate from other testing types

   End-to-end tests check the entire system, while unit tests check individual components.

3. Final Answer:

   To test small parts of a service independently -> Option D

4. Quick Check:

   Unit testing = small parts tested independently [OK]

Hint: Unit tests check small parts, not whole system [OK]

Common Mistakes:

• Confusing unit tests with integration or end-to-end tests
• Thinking unit tests deploy or monitor services
• Believing unit tests require full system setup

2. Which of the following is the correct way to mock a database call in a unit test for a microservice?

easy

A. Replace the database call with a mock object returning fixed data

B. Call the real database and check results

C. Skip the database call and do nothing

D. Use the production database credentials in the test

Solution

1. Step 1: Understand mocking purpose

   Mocks replace real dependencies to isolate the unit under test and control test data.

2. Step 2: Identify correct mocking practice

   Replacing the database call with a mock object returning fixed data allows testing without real DB access.

3. Final Answer:

   Replace the database call with a mock object returning fixed data -> Option A

4. Quick Check:

   Mocking = replace real calls with controlled fake ones [OK]

Hint: Mocks replace real calls with fake data in tests [OK]

Common Mistakes:

• Using real database in unit tests
• Skipping important calls without replacement
• Using production credentials in tests

3. Consider this Python unit test snippet for a microservice method that fetches user data:

def test_get_user_data(mocker):
    mock_db = mocker.patch('service.database.get_user')
    mock_db.return_value = {'id': 1, 'name': 'Alice'}
    result = service.get_user_data(1)
    assert result['name'] == 'Alice'

What will this test verify?

medium

A. That get_user_data returns user name 'Alice' using mocked DB

B. That the real database returns user Alice

C. That the database call is skipped entirely

D. That the service raises an error for user 1

Solution

1. Step 1: Analyze mocking effect

   The database call get_user is replaced by a mock returning fixed user data with name 'Alice'.

2. Step 2: Understand test assertion

   The test checks if get_user_data returns a result with name 'Alice', confirming it uses the mocked data.

3. Final Answer:

   That get_user_data returns user name 'Alice' using mocked DB -> Option A

4. Quick Check:

   Mocked DB returns Alice, test checks service uses it [OK]

Hint: Mock return_value sets test data; assert checks service output [OK]

Common Mistakes:

• Assuming real DB is called
• Thinking database call is skipped without replacement
• Expecting error instead of valid data

4. A developer writes this unit test for a microservice method:

def test_process_order():
    result = process_order(123)
    assert result == 'Success'

But the test fails because process_order calls an external payment service. What is the best fix?

medium

A. Rewrite process_order to not call payment service

B. Add a mock for the external payment service call

C. Run the test only when payment service is available

D. Remove the assertion to avoid failure

Solution

1. Step 1: Identify external dependency issue

   process_order calls an external service, causing test failure due to dependency.

2. Step 2: Apply mocking to isolate test

   Mocking the external payment service call isolates the unit test and avoids real external calls.

3. Final Answer:

   Add a mock for the external payment service call -> Option B

4. Quick Check:

   Mock external calls to isolate unit tests [OK]

Hint: Mock external services to avoid test failures [OK]

Common Mistakes:

• Removing assertions instead of fixing dependencies
• Running tests only when external services are up
• Changing production code to fix tests

5. You want to unit test a microservice method that calls two other services: a user service and an inventory service. Which approach best ensures your unit test is reliable and fast?

hard

A. Skip testing this method because it depends on other services

B. Call both real services during the test to check integration

C. Mock both user and inventory service calls with fixed responses

D. Test only the user service call and ignore inventory service

Solution

1. Step 1: Understand unit test isolation

   Unit tests should isolate the method by mocking external service calls to avoid flakiness and slowness.

2. Step 2: Apply mocks to all external dependencies

   Mocking both user and inventory service calls ensures the test is reliable and fast without real network calls.

3. Final Answer:

   Mock both user and inventory service calls with fixed responses -> Option C

4. Quick Check:

   Mock all external calls for reliable, fast unit tests [OK]

Hint: Mock all external services for isolated unit tests [OK]

Common Mistakes:

• Calling real services in unit tests
• Skipping tests due to dependencies
• Partially mocking dependencies leading to flaky tests