モック・スタブの使い方完全ガイド - テストダブルの種類と実践パターン

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

// userService.js - 外部APIに依存するサービス
export async function getUserProfile(userId) {
  const response = await fetch(`https://api.example.com/users/${userId}`)
  if (!response.ok) {
    throw new Error('User not found')
  }
  const user = await response.json()
  return {
    displayName: `${user.firstName} ${user.lastName}`,
    email: user.email,
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// priceCalculator.js
export class PriceCalculator {
  constructor(taxService) {
    this.taxService = taxService
  }

  calculateTotalPrice(basePrice) {
    const taxRate = this.taxService.getTaxRate()
    return Math.floor(basePrice * (1 + taxRate))
  }
}

 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

// priceCalculator.test.js
import { PriceCalculator } from './priceCalculator'

describe('PriceCalculator', () => {
  describe('calculateTotalPrice', () => {
    it('税率10%で税込価格を計算する', () => {
      // スタブの作成: 固定値を返すオブジェクト
      const taxServiceStub = {
        getTaxRate: () => 0.1, // 常に10%を返す
      }

      const calculator = new PriceCalculator(taxServiceStub)
      const result = calculator.calculateTotalPrice(1000)

      // 状態の検証: 戻り値が正しいか
      expect(result).toBe(1100)
    })

    it('税率8%で税込価格を計算する', () => {
      const taxServiceStub = {
        getTaxRate: () => 0.08, // 軽減税率8%
      }

      const calculator = new PriceCalculator(taxServiceStub)
      const result = calculator.calculateTotalPrice(1000)

      expect(result).toBe(1080)
    })

    it('小数点以下は切り捨てられる', () => {
      const taxServiceStub = {
        getTaxRate: () => 0.1,
      }

      const calculator = new PriceCalculator(taxServiceStub)
      const result = calculator.calculateTotalPrice(999)

      expect(result).toBe(1098) // 999 * 1.1 = 1098.9 → 1098
    })
  })
})

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

// TaxService.java
public interface TaxService {
    double getTaxRate();
}

// PriceCalculator.java
public class PriceCalculator {
    private final TaxService taxService;

    public PriceCalculator(TaxService taxService) {
        this.taxService = taxService;
    }

    public int calculateTotalPrice(int basePrice) {
        double taxRate = taxService.getTaxRate();
        return (int) Math.floor(basePrice * (1 + taxRate));
    }
}

 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

// PriceCalculatorTest.java
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.when;

@ExtendWith(MockitoExtension.class)
class PriceCalculatorTest {

    @Mock
    TaxService taxService;

    @Nested
    @DisplayName("calculateTotalPrice")
    class CalculateTotalPrice {

        @Test
        @DisplayName("税率10%で税込価格を計算する")
        void calculatesWith10PercentTax() {
            // スタブの設定: getTaxRate()が呼ばれたら0.1を返す
            when(taxService.getTaxRate()).thenReturn(0.1);

            PriceCalculator calculator = new PriceCalculator(taxService);
            int result = calculator.calculateTotalPrice(1000);

            // 状態の検証
            assertThat(result).isEqualTo(1100);
        }

        @Test
        @DisplayName("税率8%で税込価格を計算する")
        void calculatesWith8PercentTax() {
            when(taxService.getTaxRate()).thenReturn(0.08);

            PriceCalculator calculator = new PriceCalculator(taxService);
            int result = calculator.calculateTotalPrice(1000);

            assertThat(result).isEqualTo(1080);
        }

        @Test
        @DisplayName("小数点以下は切り捨てられる")
        void truncatesDecimalPart() {
            when(taxService.getTaxRate()).thenReturn(0.1);

            PriceCalculator calculator = new PriceCalculator(taxService);
            int result = calculator.calculateTotalPrice(999);

            assertThat(result).isEqualTo(1098);
        }
    }
}

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

// orderService.js
export class OrderService {
  constructor(emailService) {
    this.emailService = emailService
  }

  placeOrder(order) {
    // 注文処理（省略）
    const orderId = `ORD-${Date.now()}`

    // 注文確認メールを送信
    this.emailService.sendEmail(
      order.customerEmail,
      '注文確認',
      `ご注文ありがとうございます。注文番号: ${orderId}`
    )

    return orderId
  }
}

 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

// orderService.test.js
import { OrderService } from './orderService'

describe('OrderService', () => {
  describe('placeOrder', () => {
    it('注文確認メールを顧客に送信する', () => {
      // モックの作成
      const emailServiceMock = {
        sendEmail: jest.fn(), // 呼び出しを記録するモック関数
      }

      const orderService = new OrderService(emailServiceMock)
      const order = {
        customerEmail: 'customer@example.com',
        items: [{ name: '商品A', price: 1000 }],
      }

      orderService.placeOrder(order)

      // 振る舞いの検証: sendEmailが正しく呼び出されたか
      expect(emailServiceMock.sendEmail).toHaveBeenCalledTimes(1)
      expect(emailServiceMock.sendEmail).toHaveBeenCalledWith(
        'customer@example.com',
        '注文確認',
        expect.stringContaining('ご注文ありがとうございます')
      )
    })

    it('注文がなくてもメールは1回だけ送信される', () => {
      const emailServiceMock = {
        sendEmail: jest.fn(),
      }

      const orderService = new OrderService(emailServiceMock)
      orderService.placeOrder({ customerEmail: 'test@example.com', items: [] })

      expect(emailServiceMock.sendEmail).toHaveBeenCalledTimes(1)
    })
  })
})

 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

// EmailService.java
public interface EmailService {
    void sendEmail(String to, String subject, String body);
}

// OrderService.java
public class OrderService {
    private final EmailService emailService;

    public OrderService(EmailService emailService) {
        this.emailService = emailService;
    }

    public String placeOrder(Order order) {
        String orderId = "ORD-" + System.currentTimeMillis();

        emailService.sendEmail(
            order.getCustomerEmail(),
            "注文確認",
            "ご注文ありがとうございます。注文番号: " + orderId
        );

        return orderId;
    }
}

 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

// OrderServiceTest.java
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;

import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.*;

@ExtendWith(MockitoExtension.class)
class OrderServiceTest {

    @Mock
    EmailService emailService;

    @Test
    @DisplayName("注文確認メールを顧客に送信する")
    void sendsConfirmationEmailToCustomer() {
        OrderService orderService = new OrderService(emailService);
        Order order = new Order("customer@example.com");

        orderService.placeOrder(order);

        // 振る舞いの検証: sendEmailが呼び出されたか
        verify(emailService, times(1)).sendEmail(
            eq("customer@example.com"),
            eq("注文確認"),
            contains("ご注文ありがとうございます")
        );
    }

    @Test
    @DisplayName("送信されたメール本文に注文番号が含まれる")
    void emailBodyContainsOrderId() {
        OrderService orderService = new OrderService(emailService);
        Order order = new Order("customer@example.com");

        String orderId = orderService.placeOrder(order);

        // ArgumentCaptorで引数をキャプチャ
        ArgumentCaptor<String> bodyCaptor = ArgumentCaptor.forClass(String.class);
        verify(emailService).sendEmail(any(), any(), bodyCaptor.capture());

        assertThat(bodyCaptor.getValue()).contains(orderId);
    }
}

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

// userRepository.js
export class UserRepository {
  constructor(database) {
    this.database = database
  }

  findById(id) {
    return this.database.query('SELECT * FROM users WHERE id = ?', [id])
  }

  save(user) {
    this.database.execute('INSERT INTO users VALUES (?, ?, ?)', [
      user.id,
      user.name,
      user.email,
    ])
  }
}

 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

// userRepository.test.js
describe('UserRepository', () => {
  describe('findById - スタブを使用', () => {
    it('ユーザーを取得できる', async () => {
      // スタブ: クエリ結果を固定
      const databaseStub = {
        query: jest.fn().mockResolvedValue({ id: 1, name: 'Alice' }),
      }

      const repository = new UserRepository(databaseStub)
      const user = await repository.findById(1)

      // 状態を検証
      expect(user).toEqual({ id: 1, name: 'Alice' })
    })
  })

  describe('save - モックを使用', () => {
    it('ユーザーをデータベースに保存する', () => {
      // モック: 呼び出しを検証
      const databaseMock = {
        execute: jest.fn(),
      }

      const repository = new UserRepository(databaseMock)
      repository.save({ id: 1, name: 'Alice', email: 'alice@example.com' })

      // 振る舞いを検証
      expect(databaseMock.execute).toHaveBeenCalledWith(
        'INSERT INTO users VALUES (?, ?, ?)',
        [1, 'Alice', 'alice@example.com']
      )
    })
  })
})

1
2
3
4
5
6
7
8
9

// logger.js
export const logger = {
  log(message) {
    console.log(`[LOG] ${new Date().toISOString()}: ${message}`)
  },
  error(message) {
    console.error(`[ERROR] ${new Date().toISOString()}: ${message}`)
  },
}

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

// logger.test.js
import { logger } from './logger'

describe('logger', () => {
  it('logメソッドの呼び出しを記録できる', () => {
    // 実際のconsole.logにスパイを設定
    const consoleSpy = jest.spyOn(console, 'log').mockImplementation()

    logger.log('テストメッセージ')

    expect(consoleSpy).toHaveBeenCalledTimes(1)
    expect(consoleSpy).toHaveBeenCalledWith(
      expect.stringContaining('テストメッセージ')
    )

    consoleSpy.mockRestore() // 元に戻す
  })
})

 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

import org.junit.jupiter.api.Test;
import java.util.ArrayList;
import java.util.List;

import static org.assertj.core.api.Assertions.assertThat;
import static org.mockito.Mockito.*;

class SpyExampleTest {

    @Test
    @DisplayName("スパイは実際のメソッドを呼び出しつつ記録する")
    void spyCallsRealMethodAndRecords() {
        List<String> list = new ArrayList<>();
        List<String> spyList = spy(list);

        // 実際のaddメソッドが呼ばれる
        spyList.add("one");
        spyList.add("two");

        // 状態の検証: 実際に追加されている
        assertThat(spyList).hasSize(2);

        // 振る舞いの検証: 呼び出しを記録している
        verify(spyList, times(2)).add(anyString());
    }

    @Test
    @DisplayName("スパイの一部メソッドだけスタブ化できる")
    void canStubSomeMethodsOfSpy() {
        List<String> list = new ArrayList<>();
        List<String> spyList = spy(list);

        // sizeメソッドだけスタブ化
        doReturn(100).when(spyList).size();

        spyList.add("one");

        // size()はスタブの値を返す
        assertThat(spyList.size()).isEqualTo(100);
        // get()は実際の値を返す
        assertThat(spyList.get(0)).isEqualTo("one");
    }
}

 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

// fakeUserRepository.js - インメモリ実装
export class FakeUserRepository {
  constructor() {
    this.users = new Map()
  }

  async findById(id) {
    return this.users.get(id) || null
  }

  async save(user) {
    this.users.set(user.id, user)
  }

  async findAll() {
    return Array.from(this.users.values())
  }

  async deleteById(id) {
    this.users.delete(id)
  }

  // テスト用ヘルパー
  clear() {
    this.users.clear()
  }
}

 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

// userService.test.js
import { UserService } from './userService'
import { FakeUserRepository } from './fakeUserRepository'

describe('UserService with FakeRepository', () => {
  let userService
  let fakeRepository

  beforeEach(() => {
    fakeRepository = new FakeUserRepository()
    userService = new UserService(fakeRepository)
  })

  it('ユーザーを作成して取得できる', async () => {
    await userService.createUser({ id: 1, name: 'Alice' })

    const user = await userService.getUser(1)

    expect(user).toEqual({ id: 1, name: 'Alice' })
  })

  it('存在しないユーザーはnullを返す', async () => {
    const user = await userService.getUser(999)

    expect(user).toBeNull()
  })

  it('複数ユーザーを扱える', async () => {
    await userService.createUser({ id: 1, name: 'Alice' })
    await userService.createUser({ id: 2, name: 'Bob' })

    const users = await fakeRepository.findAll()

    expect(users).toHaveLength(2)
  })
})

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

// weatherService.js
export class WeatherService {
  constructor(httpClient) {
    this.httpClient = httpClient
  }

  async getCurrentWeather(city) {
    const response = await this.httpClient.get(
      `https://api.weather.example.com/current?city=${city}`
    )
    return {
      city: response.data.name,
      temperature: response.data.main.temp,
      description: response.data.weather[0].description,
    }
  }
}

 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

// weatherService.test.js
import { WeatherService } from './weatherService'

describe('WeatherService', () => {
  it('天気情報を取得して整形する', async () => {
    // HTTPクライアントのスタブ
    const httpClientStub = {
      get: jest.fn().mockResolvedValue({
        data: {
          name: 'Tokyo',
          main: { temp: 25.5 },
          weather: [{ description: 'sunny' }],
        },
      }),
    }

    const service = new WeatherService(httpClientStub)
    const weather = await service.getCurrentWeather('Tokyo')

    expect(weather).toEqual({
      city: 'Tokyo',
      temperature: 25.5,
      description: 'sunny',
    })
  })

  it('APIエラー時に例外をスローする', async () => {
    const httpClientStub = {
      get: jest.fn().mockRejectedValue(new Error('API Error')),
    }

    const service = new WeatherService(httpClientStub)

    await expect(service.getCurrentWeather('Unknown')).rejects.toThrow(
      'API Error'
    )
  })
})

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

// subscriptionService.js
export class SubscriptionService {
  constructor(clock = () => new Date()) {
    this.clock = clock
  }

  isExpired(subscription) {
    const now = this.clock()
    return new Date(subscription.expiresAt) < now
  }

  getDaysUntilExpiry(subscription) {
    const now = this.clock()
    const expiresAt = new Date(subscription.expiresAt)
    const diffTime = expiresAt - now
    return Math.ceil(diffTime / (1000 * 60 * 60 * 24))
  }
}

 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

// subscriptionService.test.js
import { SubscriptionService } from './subscriptionService'

describe('SubscriptionService', () => {
  // 固定日時を返すスタブ
  const fixedDate = new Date('2026-01-05T12:00:00Z')
  const clockStub = () => fixedDate

  describe('isExpired', () => {
    it('期限切れの場合trueを返す', () => {
      const service = new SubscriptionService(clockStub)
      const subscription = { expiresAt: '2026-01-04T00:00:00Z' }

      expect(service.isExpired(subscription)).toBe(true)
    })

    it('期限内の場合falseを返す', () => {
      const service = new SubscriptionService(clockStub)
      const subscription = { expiresAt: '2026-01-10T00:00:00Z' }

      expect(service.isExpired(subscription)).toBe(false)
    })
  })

  describe('getDaysUntilExpiry', () => {
    it('残り日数を計算する', () => {
      const service = new SubscriptionService(clockStub)
      const subscription = { expiresAt: '2026-01-10T12:00:00Z' }

      expect(service.getDaysUntilExpiry(subscription)).toBe(5)
    })
  })
})

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

// 悪い例: すべてをモックしすぎ
it('ユーザーを作成する（過剰なモック）', async () => {
  const mockValidator = { validate: jest.fn().mockReturnValue(true) }
  const mockHasher = { hash: jest.fn().mockReturnValue('hashed') }
  const mockRepository = { save: jest.fn() }
  const mockLogger = { log: jest.fn() }
  const mockEventEmitter = { emit: jest.fn() }

  const service = new UserService(
    mockValidator,
    mockHasher,
    mockRepository,
    mockLogger,
    mockEventEmitter
  )

  await service.createUser({ name: 'Alice', password: 'secret' })

  // 何をテストしているのかわからない
  expect(mockValidator.validate).toHaveBeenCalled()
  expect(mockHasher.hash).toHaveBeenCalled()
  expect(mockRepository.save).toHaveBeenCalled()
})

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

// 悪い例: 実装の詳細に依存
it('save時にvalidateが先に呼ばれる（順序に依存）', () => {
  const mock = {
    validate: jest.fn().mockReturnValue(true),
    save: jest.fn(),
  }

  service.process(data)

  // 呼び出し順序をテスト - 実装変更で壊れやすい
  const validateCallOrder = mock.validate.mock.invocationCallOrder[0]
  const saveCallOrder = mock.save.mock.invocationCallOrder[0]
  expect(validateCallOrder).toBeLessThan(saveCallOrder)
})

1
2
3
4
5
6

// 悪い例: 実際のAPIレスポンスと異なる構造
const apiStub = {
  getUser: jest.fn().mockResolvedValue({
    name: 'Alice', // 実際のAPIは { user: { name: 'Alice' } }
  }),
}