Unit testing services in Microservices - System Design Exercise

Design: Unit Testing Framework for Microservices

Design focuses on the architecture of a unit testing framework and environment for microservices. It excludes integration or end-to-end testing frameworks.

Functional Requirements

FR1: Support writing and running unit tests for individual microservices

FR2: Isolate each microservice's logic from external dependencies during tests

FR3: Provide fast feedback with low latency test execution

FR4: Allow mocking of dependent services and databases

FR5: Integrate with CI/CD pipelines for automated testing

FR6: Support test result reporting and logs for debugging

Non-Functional Requirements

NFR1: Must handle up to 100 microservices independently

NFR2: Test execution latency should be under 5 seconds per test suite

NFR3: Availability of testing framework should be 99.9%

NFR4: Tests must not require network calls to other services or databases

Think Before You Design

Questions to Ask

❓ Question 1

❓ Question 2

❓ Question 3

❓ Question 4

❓ Question 5

❓ Question 6

Key Components

Test runner service

Mocking/stubbing library

Test isolation environment

Test result storage and reporting

CI/CD integration hooks

Design Patterns

Dependency injection for mocks

Test doubles (mocks, stubs, fakes)

Test isolation and sandboxing

Continuous testing in CI/CD

Parallel test execution

Reference Architecture

 +-------------------+       +---------------------+       +---------------------+
 | Microservice Code  | <---> | Unit Test Framework  | <---> | Mocking Library     |
 +-------------------+       +---------------------+       +---------------------+
          |                             |                             |
          |                             |                             |
          v                             v                             v
 +-------------------+       +---------------------+       +---------------------+
 | Test Runner       |       | Test Isolation Env  |       | Test Result Storage  |
 +-------------------+       +---------------------+       +---------------------+

Components

Test Runner

Jest, JUnit, or equivalent

Executes unit tests for each microservice and reports results

Mocking Library

Sinon.js, Mockito, or equivalent

Provides mocks and stubs to isolate microservice dependencies

Test Isolation Environment

Docker containers or in-memory sandboxes

Ensures tests run isolated from external services and databases

Test Result Storage

Elasticsearch, or CI/CD test reporting tools

Stores test results and logs for analysis and debugging

CI/CD Integration

Jenkins, GitHub Actions, GitLab CI

Triggers tests automatically on code changes and collects results

Request Flow

1. Developer writes unit tests using the mocking library to replace dependencies.

2. Test runner executes the tests inside the isolated environment to prevent external calls.

3. Mocks simulate dependent services and databases during test execution.

4. Test runner collects pass/fail results and logs.

5. Results are stored in the test result storage system.

6. CI/CD pipeline triggers test runs on code commits and fetches results for reporting.

7. Developers review test reports and debug failures using logs.

Database Schema

Entities: - TestCase: id, microservice_id, name, description, code - TestRun: id, test_case_id, status (pass/fail), start_time, end_time, logs - Microservice: id, name, language, repository_url Relationships: - Microservice 1:N TestCase - TestCase 1:N TestRun

Scaling Discussion

Bottlenecks

Test execution time grows with number of microservices and test cases

Resource contention in test isolation environments

Storage size and query performance for test results

Mocking complexity for highly coupled services

Solutions

Run tests in parallel across multiple isolated containers or machines

Use lightweight sandboxing or in-memory mocks to reduce resource use

Archive old test results and optimize indexing for fast queries

Encourage loose coupling and clear interfaces to simplify mocking

Interview Tips

Time: Spend 10 minutes clarifying requirements and constraints, 20 minutes designing components and data flow, 10 minutes discussing scaling and trade-offs, 5 minutes summarizing.

Importance of isolating microservices for unit testing

Use of mocks and stubs to replace dependencies

Integration with CI/CD for automated testing

Handling test result storage and reporting

Scaling tests with parallel execution and resource management