Outside-In TDDとは - ユーザー視点から始めるテスト駆動開発の実践ガイド

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

ユーザーストーリー:
「新規ユーザーとして、メールアドレスとパスワードで登録できる。
 登録後、ウェルカムメールを受け取る。」

受け入れ基準:
- メールアドレスとパスワードで登録できる
- パスワードは8文字以上必須
- 登録成功時、ユーザー情報がデータベースに保存される
- 登録成功時、ウェルカムメールが送信される
- 既存のメールアドレスでは登録できない

 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

// tests/acceptance/userRegistration.test.js
describe('ユーザー登録', () => {
  it('新規ユーザーを登録し、ウェルカムメールを送信する', async () => {
    // Arrange
    const registrationData = {
      email: 'test@example.com',
      password: 'securePassword123',
    }

    // Act
    const response = await request(app)
      .post('/api/users/register')
      .send(registrationData)

    // Assert
    expect(response.status).toBe(201)
    expect(response.body).toEqual({
      id: expect.any(String),
      email: 'test@example.com',
      createdAt: expect.any(String),
    })

    // ウェルカムメールが送信されたことを確認
    const sentEmails = await getTestEmails()
    expect(sentEmails).toHaveLength(1)
    expect(sentEmails[0].to).toBe('test@example.com')
    expect(sentEmails[0].subject).toContain('ようこそ')
  })
})

 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

// tests/unit/userController.test.js
describe('UserController', () => {
  describe('register', () => {
    it('有効なデータで登録し、201を返す', async () => {
      // Arrange
      const mockUserService = {
        registerUser: jest.fn().mockResolvedValue({
          id: 'user-123',
          email: 'test@example.com',
          createdAt: new Date('2026-01-05'),
        }),
      }
      
      const controller = new UserController(mockUserService)
      const req = {
        body: { email: 'test@example.com', password: 'securePassword123' },
      }
      const res = {
        status: jest.fn().mockReturnThis(),
        json: jest.fn(),
      }

      // Act
      await controller.register(req, res)

      // Assert
      expect(mockUserService.registerUser).toHaveBeenCalledWith({
        email: 'test@example.com',
        password: 'securePassword123',
      })
      expect(res.status).toHaveBeenCalledWith(201)
      expect(res.json).toHaveBeenCalledWith({
        id: 'user-123',
        email: 'test@example.com',
        createdAt: expect.any(Date),
      })
    })
  })
})

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

// src/controllers/UserController.js
class UserController {
  constructor(userService) {
    this.userService = userService
  }

  async register(req, res) {
    const { email, password } = req.body
    
    const user = await this.userService.registerUser({ email, password })
    
    res.status(201).json({
      id: user.id,
      email: user.email,
      createdAt: user.createdAt,
    })
  }
}

module.exports = { UserController }

 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

// tests/unit/userService.test.js
describe('UserService', () => {
  describe('registerUser', () => {
    it('ユーザーを保存し、ウェルカムメールを送信する', async () => {
      // Arrange
      const mockUserRepository = {
        findByEmail: jest.fn().mockResolvedValue(null),
        save: jest.fn().mockResolvedValue({
          id: 'user-123',
          email: 'test@example.com',
          passwordHash: 'hashed-password',
          createdAt: new Date('2026-01-05'),
        }),
      }
      
      const mockEmailService = {
        sendWelcomeEmail: jest.fn().mockResolvedValue(true),
      }
      
      const mockPasswordHasher = {
        hash: jest.fn().mockResolvedValue('hashed-password'),
      }
      
      const userService = new UserService(
        mockUserRepository,
        mockEmailService,
        mockPasswordHasher
      )

      // Act
      const result = await userService.registerUser({
        email: 'test@example.com',
        password: 'securePassword123',
      })

      // Assert
      expect(mockUserRepository.findByEmail).toHaveBeenCalledWith('test@example.com')
      expect(mockPasswordHasher.hash).toHaveBeenCalledWith('securePassword123')
      expect(mockUserRepository.save).toHaveBeenCalledWith({
        email: 'test@example.com',
        passwordHash: 'hashed-password',
      })
      expect(mockEmailService.sendWelcomeEmail).toHaveBeenCalledWith('test@example.com')
      expect(result.id).toBe('user-123')
    })

    it('既存のメールアドレスの場合、エラーをスローする', async () => {
      // Arrange
      const mockUserRepository = {
        findByEmail: jest.fn().mockResolvedValue({ id: 'existing-user' }),
      }
      
      const userService = new UserService(
        mockUserRepository,
        {},
        {}
      )

      // Act & Assert
      await expect(
        userService.registerUser({
          email: 'existing@example.com',
          password: 'password123',
        })
      ).rejects.toThrow('このメールアドレスは既に登録されています')
    })
  })
})

 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

// src/services/UserService.js
class UserService {
  constructor(userRepository, emailService, passwordHasher) {
    this.userRepository = userRepository
    this.emailService = emailService
    this.passwordHasher = passwordHasher
  }

  async registerUser({ email, password }) {
    // 既存ユーザーの確認
    const existingUser = await this.userRepository.findByEmail(email)
    if (existingUser) {
      throw new Error('このメールアドレスは既に登録されています')
    }

    // パスワードのハッシュ化
    const passwordHash = await this.passwordHasher.hash(password)

    // ユーザーの保存
    const user = await this.userRepository.save({
      email,
      passwordHash,
    })

    // ウェルカムメールの送信
    await this.emailService.sendWelcomeEmail(email)

    return user
  }
}

module.exports = { UserService }

1
2
3
4
5
6
7
8

// 問題のあるテスト例：実装の詳細に依存しすぎ
it('正確な順序でメソッドが呼ばれることを検証', () => {
  const order = service.createOrder(data)
  
  expect(mockValidator.validate).toHaveBeenCalledBefore(mockRepository.save)
  expect(mockRepository.save).toHaveBeenCalledBefore(mockNotifier.notify)
  // 実装の順序を変えるとテストが壊れる
})

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

ユーザー登録機能 テストリスト:
受け入れテスト:
- [ ] 正常な登録フロー
- [ ] 重複メールアドレスでのエラー
- [ ] 無効なパスワードでのエラー

コントローラー:
- [ ] 有効なリクエストで201を返す
- [ ] 無効なリクエストで400を返す
- [ ] サービスエラーで500を返す

サービス:
- [ ] ユーザーを保存する
- [ ] ウェルカムメールを送信する
- [ ] 重複チェックを行う

1
2
3
4
5
6
7

// 良い例：協調オブジェクトをモック
const mockRepository = { save: jest.fn() }

// 避けるべき例：値オブジェクトをモック
const mockUser = { getName: jest.fn().mockReturnValue('田中') }
// 代わりに実際のオブジェクトを使う
const user = new User('田中')