How Dependency Injection Improves Code Maintainability and Testability

Takahiro Iwasa

3/12/2023

3 min read

Architecting

This note describes how to create loosely coupled code using Dependency Injection.

Example of Tight Coupling

The following example demonstrates an employee management feature written in TypeScript. For simplicity, this example assumes that mocks cannot be dynamically configured.

1
export class Salary {
2
  readonly employeeId: number;
3

4
  constructor(employeeId: number) {
5
    this.employeeId = employeeId;
6
  }
7

8
  calculate(): number {
9
    let salary = 0;
10
    // ...
11
    salary = 200000;
12
    return salary;
13
  }
14
}
15

16
export class Employee {
17
  private employeeId: number;
18
  private name: string;
19
  private salary: Salary;
20

21
  constructor(employeeId: number, name: string) {
22
    this.employeeId = employeeId;
23
    this.name = name;
24
    this.salary = new Salary(this.employeeId);
25
  }
26

27
  // Send an email by Amazon SES. Message text depends on time.
28
  notify(): void {
29
    const hour = (new Date()).getHours();
30
    let title = `Hi ${this.name}`;
31
    const body = `Current Salary: ${this.salary.calculate()}`;
32

33
    if (6 <= hour && hour <= 9) {
34
      title = `Good morning ${this.name}`;
35
    } else if (10 <= hour && hour <= 18) {
36
      title = `How's it going, ${this.name}?`;
37
    }
38
    (new SES()).sendEmail({title: title, body: body});
39
  }
40
}

The problems are:

Tightly coupled to the Salary class:
- The line this.salary = new Salary(this.employeeId); directly couples the Employee and Salary classes.
- Testing Employee#notify becomes challenging because it depends on the actual Salary#calculate method, making it harder to simulate different salary calculations or handle edge cases during testing.
Tightly coupled to the system clock:
- The line const hour = (new Date()).getHours(); couples the Employee class with the system clock.
- Conditional logic testing for specific times becomes difficult.
Tightly coupled to AWS SES:
- The line (new SES()).sendEmail(...) directly couples Employee with the AWS SES service.
- Testing the notify method results in actual email sends, which may not be feasible in development.

Refactoring with Dependency Injection

Using Dependency Injection (DI), we can make the code more modular and testable.

1
export interface ISalary {
2
  readonly employeeId: number;
3
  calculate(): number;
4
}
5

6
export interface ISystemDate {
7
  now(): Date;
8
}
9

10
export interface IMailer {
11
  send(config: any): void;
12
}
13

14
export class Salary implements ISalary {
15
  readonly employeeId: number;
16

17
  constructor(employeeId: number) {
18
    this.employeeId = employeeId;
19
  }
20

21
  calculate(): number {
22
    let salary = 0;
23
    // ...
24
    salary = 200000;
25
    return salary;
26
  }
27
}
28

29
export class SystemDate implements ISystemDate {
30
  now(): Date {
31
    return new Date();
32
  }
33
}
34

35
export class EmployeeSes implements IMailer {
36
  send(config: any): void {
37
    (new SES()).sendEmail(config);
38
  }
39
}
40

41
export class Employee {
42
  private employeeId: number;
43
  private name: string;
44
  private salary: ISalary;
45

46
  constructor(employeeId: number, name: string, salary: ISalary) {
47
    this.employeeId = employeeId;
48
    this.name = name;
49
    this.salary = salary;
50
  }
51

52
  // Send an email by Amazon SES. Message text depends on time.
53
  notify(systemDate: ISystemDate, mailer: IMailer): void {
54
    const hour = systemDate.now().getHours();
55
    let title = `Hi ${this.name}`;
56
    const body = `Current Salary: ${this.salary.calculate()}`;
57

58
    if (6 <= hour && hour <= 9) {
59
      title = `Good morning ${this.name}`;
60
    } else if (10 <= hour && hour <= 18) {
61
      title = `How's it going, ${this.name}?`;
62
    }
63
    mailer.send({title: title, body: body});
64
  }
65
}

Key improvements:

Reduced Coupling:
- Components like Salary, SystemDate, and EmployeeSes are now injected via interfaces.
- The Employee class is no longer directly dependent on specific implementations.
Easier Testing:
- Mock implementations of ISalary, ISystemDate, and IMailer can be used for testing.
- System dependencies like clocks and SES services are decoupled.
Dependency Inversion Principle:
- High-level modules (Employee) are independent of low-level modules (Salary, Date, SES).