依存性注入（DI）とテスタビリティ - TDDを支える設計パターン完全ガイド

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

// userService.js - DIなし（密結合）
class UserService {
  constructor() {
    // 依存関係がハードコーディングされている
    this.repository = new UserRepository()
    this.emailClient = new EmailClient()
    this.logger = new ConsoleLogger()
  }

  async createUser(userData) {
    const user = await this.repository.save(userData)
    await this.emailClient.sendWelcomeEmail(user.email)
    this.logger.info(`User created: ${user.id}`)
    return user
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

// userService.js - DIあり（疎結合）
class UserService {
  constructor(repository, emailClient, logger) {
    // 依存関係は外部から注入される
    this.repository = repository
    this.emailClient = emailClient
    this.logger = logger
  }

  async createUser(userData) {
    const user = await this.repository.save(userData)
    await this.emailClient.sendWelcomeEmail(user.email)
    this.logger.info(`User created: ${user.id}`)
    return user
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

// Java - コンストラクタインジェクション
public class UserService {
    private final UserRepository repository;
    private final EmailClient emailClient;
    
    // コンストラクタで依存関係を受け取る
    public UserService(UserRepository repository, EmailClient emailClient) {
        if (repository == null || emailClient == null) {
            throw new IllegalArgumentException("Dependencies must not be null");
        }
        this.repository = repository;
        this.emailClient = emailClient;
    }
    
    public User createUser(UserData userData) {
        User user = repository.save(userData);
        emailClient.sendWelcomeEmail(user.getEmail());
        return user;
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

// Java - セッターインジェクション
public class UserService {
    private UserRepository repository;
    private EmailClient emailClient;
    
    // setterで依存関係を受け取る
    public void setRepository(UserRepository repository) {
        if (repository == null) {
            throw new IllegalArgumentException("Repository must not be null");
        }
        this.repository = repository;
    }
    
    public void setEmailClient(EmailClient emailClient) {
        if (emailClient == null) {
            throw new IllegalArgumentException("EmailClient must not be null");
        }
        this.emailClient = emailClient;
    }
    
    public User createUser(UserData userData) {
        User user = repository.save(userData);
        emailClient.sendWelcomeEmail(user.getEmail());
        return user;
    }
}

1
2
3
4
5
6
7
8
9

// Java - メソッドインジェクション
public class ReportGenerator {
    
    // メソッドの引数として依存関係を受け取る
    public Report generate(ReportData data, Formatter formatter) {
        String content = formatter.format(data);
        return new Report(content);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

// 問題のあるコード - DIなし
class OrderService {
  constructor() {
    this.paymentGateway = new StripePaymentGateway() // 実際のStripeに接続
    this.inventory = new DatabaseInventory()         // 実際のDBに接続
    this.notifier = new SlackNotifier()              // 実際のSlackに送信
  }

  async placeOrder(order) {
    const stock = await this.inventory.checkStock(order.productId)
    if (stock < order.quantity) {
      throw new Error('在庫不足')
    }
    
    const payment = await this.paymentGateway.charge(order.customerId, order.amount)
    await this.inventory.decreaseStock(order.productId, order.quantity)
    await this.notifier.sendOrderConfirmation(order)
    
    return { orderId: payment.transactionId }
  }
}

// このコードをテストするには...
// - 実際のStripe APIキーが必要
// - テスト用のデータベースが必要
// - テストのたびにSlackに通知が飛ぶ
// - テストが遅く、不安定になる

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

// テスタブルなコード - DIあり
class OrderService {
  constructor(paymentGateway, inventory, notifier) {
    this.paymentGateway = paymentGateway
    this.inventory = inventory
    this.notifier = notifier
  }

  async placeOrder(order) {
    const stock = await this.inventory.checkStock(order.productId)
    if (stock < order.quantity) {
      throw new Error('在庫不足')
    }
    
    const payment = await this.paymentGateway.charge(order.customerId, order.amount)
    await this.inventory.decreaseStock(order.productId, order.quantity)
    await this.notifier.sendOrderConfirmation(order)
    
    return { orderId: payment.transactionId }
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

// orderService.test.js
describe('OrderService', () => {
  let orderService
  let mockPaymentGateway
  let mockInventory
  let mockNotifier

  beforeEach(() => {
    // スタブを作成
    mockPaymentGateway = {
      charge: jest.fn().mockResolvedValue({ transactionId: 'txn_123' })
    }
    mockInventory = {
      checkStock: jest.fn().mockResolvedValue(10),
      decreaseStock: jest.fn().mockResolvedValue(undefined)
    }
    mockNotifier = {
      sendOrderConfirmation: jest.fn().mockResolvedValue(undefined)
    }

    // スタブを注入
    orderService = new OrderService(mockPaymentGateway, mockInventory, mockNotifier)
  })

  it('在庫があれば注文を処理できる', async () => {
    const order = { productId: 'prod_1', quantity: 2, customerId: 'cust_1', amount: 1000 }

    const result = await orderService.placeOrder(order)

    expect(result.orderId).toBe('txn_123')
    expect(mockPaymentGateway.charge).toHaveBeenCalledWith('cust_1', 1000)
    expect(mockInventory.decreaseStock).toHaveBeenCalledWith('prod_1', 2)
    expect(mockNotifier.sendOrderConfirmation).toHaveBeenCalledWith(order)
  })

  it('在庫不足の場合はエラーをスローする', async () => {
    mockInventory.checkStock.mockResolvedValue(0) // 在庫なし

    const order = { productId: 'prod_1', quantity: 2, customerId: 'cust_1', amount: 1000 }

    await expect(orderService.placeOrder(order)).rejects.toThrow('在庫不足')
    expect(mockPaymentGateway.charge).not.toHaveBeenCalled() // 決済は実行されない
  })
})

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

// OrderServiceTest.java
@ExtendWith(MockitoExtension.class)
class OrderServiceTest {

    @Mock
    private PaymentGateway paymentGateway;
    
    @Mock
    private Inventory inventory;
    
    @Mock
    private Notifier notifier;
    
    @InjectMocks
    private OrderService orderService;

    @Test
    @DisplayName("在庫があれば注文を処理できる")
    void placeOrder_WithSufficientStock_ProcessesOrder() {
        // Arrange
        Order order = new Order("prod_1", 2, "cust_1", 1000);
        when(inventory.checkStock("prod_1")).thenReturn(10);
        when(paymentGateway.charge("cust_1", 1000))
            .thenReturn(new PaymentResult("txn_123"));
        
        // Act
        OrderResult result = orderService.placeOrder(order);
        
        // Assert
        assertThat(result.getOrderId()).isEqualTo("txn_123");
        verify(inventory).decreaseStock("prod_1", 2);
        verify(notifier).sendOrderConfirmation(order);
    }

    @Test
    @DisplayName("在庫不足の場合はInsufficientStockExceptionをスローする")
    void placeOrder_WithInsufficientStock_ThrowsException() {
        // Arrange
        Order order = new Order("prod_1", 2, "cust_1", 1000);
        when(inventory.checkStock("prod_1")).thenReturn(0);
        
        // Act & Assert
        assertThatThrownBy(() -> orderService.placeOrder(order))
            .isInstanceOf(InsufficientStockException.class)
            .hasMessage("在庫不足");
        
        verify(paymentGateway, never()).charge(anyString(), anyInt());
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

// interfaces.js - インターフェースの定義（型の契約）
/**
 * @typedef {Object} IUserRepository
 * @property {function(Object): Promise<Object>} save
 * @property {function(string): Promise<Object|null>} findByEmail
 */

/**
 * @typedef {Object} IPasswordHasher
 * @property {function(string): Promise<string>} hash
 */

/**
 * @typedef {Object} IEmailValidator
 * @property {function(string): boolean} isValid
 */

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

// userRegistrationService.test.js
describe('UserRegistrationService', () => {
  let service
  let mockRepository
  let mockPasswordHasher
  let mockEmailValidator

  beforeEach(() => {
    // スタブを準備
    mockRepository = {
      save: jest.fn(),
      findByEmail: jest.fn()
    }
    mockPasswordHasher = {
      hash: jest.fn()
    }
    mockEmailValidator = {
      isValid: jest.fn()
    }

    service = new UserRegistrationService(
      mockRepository,
      mockPasswordHasher,
      mockEmailValidator
    )
  })

  describe('register', () => {
    it('有効なデータで新規ユーザーを登録できる', async () => {
      // Arrange
      mockEmailValidator.isValid.mockReturnValue(true)
      mockRepository.findByEmail.mockResolvedValue(null) // 既存ユーザーなし
      mockPasswordHasher.hash.mockResolvedValue('hashed_password')
      mockRepository.save.mockResolvedValue({ id: 'user_1', email: 'test@example.com' })

      // Act
      const result = await service.register({
        email: 'test@example.com',
        password: 'SecurePass123!'
      })

      // Assert
      expect(result.id).toBe('user_1')
      expect(mockPasswordHasher.hash).toHaveBeenCalledWith('SecurePass123!')
      expect(mockRepository.save).toHaveBeenCalledWith({
        email: 'test@example.com',
        passwordHash: 'hashed_password'
      })
    })

    it('無効なメールアドレスの場合はエラーをスローする', async () => {
      mockEmailValidator.isValid.mockReturnValue(false)

      await expect(service.register({
        email: 'invalid-email',
        password: 'SecurePass123!'
      })).rejects.toThrow('Invalid email address')
    })

    it('既に登録済みのメールアドレスの場合はエラーをスローする', async () => {
      mockEmailValidator.isValid.mockReturnValue(true)
      mockRepository.findByEmail.mockResolvedValue({ id: 'existing_user' })

      await expect(service.register({
        email: 'existing@example.com',
        password: 'SecurePass123!'
      })).rejects.toThrow('Email already registered')
    })
  })
})

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

// userRegistrationService.js
class UserRegistrationService {
  constructor(repository, passwordHasher, emailValidator) {
    this.repository = repository
    this.passwordHasher = passwordHasher
    this.emailValidator = emailValidator
  }

  async register({ email, password }) {
    // メールアドレスの検証
    if (!this.emailValidator.isValid(email)) {
      throw new Error('Invalid email address')
    }

    // 既存ユーザーのチェック
    const existingUser = await this.repository.findByEmail(email)
    if (existingUser) {
      throw new Error('Email already registered')
    }

    // パスワードのハッシュ化と保存
    const passwordHash = await this.passwordHasher.hash(password)
    const user = await this.repository.save({ email, passwordHash })

    return user
  }
}

module.exports = { UserRegistrationService }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

// userRegistrationService.js - リファクタリング後
class UserRegistrationService {
  constructor(repository, passwordHasher, emailValidator) {
    this.repository = repository
    this.passwordHasher = passwordHasher
    this.emailValidator = emailValidator
  }

  async register({ email, password }) {
    await this.#validateEmail(email)
    await this.#ensureEmailNotRegistered(email)
    
    const passwordHash = await this.passwordHasher.hash(password)
    return this.repository.save({ email, passwordHash })
  }

  async #validateEmail(email) {
    if (!this.emailValidator.isValid(email)) {
      throw new Error('Invalid email address')
    }
  }

  async #ensureEmailNotRegistered(email) {
    const existingUser = await this.repository.findByEmail(email)
    if (existingUser) {
      throw new Error('Email already registered')
    }
  }
}

module.exports = { UserRegistrationService }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

// main.js - Composition Root（組み立て場所）
const { UserRegistrationService } = require('./userRegistrationService')
const { PostgresUserRepository } = require('./infrastructure/postgresUserRepository')
const { BcryptPasswordHasher } = require('./infrastructure/bcryptPasswordHasher')
const { RegexEmailValidator } = require('./infrastructure/regexEmailValidator')

// 本番用の依存関係を生成
const repository = new PostgresUserRepository(process.env.DATABASE_URL)
const passwordHasher = new BcryptPasswordHasher(12) // salt rounds
const emailValidator = new RegexEmailValidator()

// 依存関係を注入してサービスを生成
const userRegistrationService = new UserRegistrationService(
  repository,
  passwordHasher,
  emailValidator
)

// アプリケーションで使用
module.exports = { userRegistrationService }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

// Spring Framework での設定
@Configuration
public class AppConfig {

    @Bean
    public UserRepository userRepository(DataSource dataSource) {
        return new JdbcUserRepository(dataSource);
    }

    @Bean
    public PasswordHasher passwordHasher() {
        return new BcryptPasswordHasher(12);
    }

    @Bean
    public EmailValidator emailValidator() {
        return new RegexEmailValidator();
    }

    @Bean
    public UserRegistrationService userRegistrationService(
            UserRepository userRepository,
            PasswordHasher passwordHasher,
            EmailValidator emailValidator) {
        return new UserRegistrationService(userRepository, passwordHasher, emailValidator);
    }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

// アノテーションベースの自動注入
@Service
public class UserRegistrationService {

    private final UserRepository userRepository;
    private final PasswordHasher passwordHasher;
    private final EmailValidator emailValidator;

    @Autowired // コンストラクタが1つの場合は省略可能
    public UserRegistrationService(
            UserRepository userRepository,
            PasswordHasher passwordHasher,
            EmailValidator emailValidator) {
        this.userRepository = userRepository;
        this.passwordHasher = passwordHasher;
        this.emailValidator = emailValidator;
    }
}

1
2
3
4
5
6
7
8

// アンチパターン: Service Locator
class UserService {
  constructor() {
    // 依存関係が隠れている
    this.repository = ServiceLocator.get('UserRepository')
    this.emailClient = ServiceLocator.get('EmailClient')
  }
}

1
2
3
4
5
6
7
8

// 推奨: コンストラクタインジェクション
class UserService {
  constructor(repository, emailClient) {
    // 依存関係が明示的
    this.repository = repository
    this.emailClient = emailClient
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

// アンチパターン: 過剰な依存関係（God Class）
public class OrderProcessor {
    public OrderProcessor(
        OrderRepository orderRepo,
        CustomerRepository customerRepo,
        ProductRepository productRepo,
        InventoryService inventory,
        PaymentGateway payment,
        ShippingService shipping,
        NotificationService notification,
        DiscountCalculator discount,
        TaxCalculator tax,
        AuditLogger audit) {
        // 10個の依存関係は多すぎる
    }
}

1
2
3
4
5
6
7
8
9

// 改善: 責務を分割
public class OrderProcessor {
    public OrderProcessor(
        OrderValidationService validation,
        PaymentProcessingService payment,
        FulfillmentService fulfillment) {
        // 3つの高レベルなサービスに集約
    }
}