MENU
  1. ホーム
  2. Kotlin
  3. Kotlinでのテストダブルを用いたTDDの実践ガイド！モックとスタブを徹底解説

Kotlinでのテストダブルを用いたTDDの実践ガイド！モックとスタブを徹底解説

Kotlin

KotlinでのTDD（テスト駆動開発）は、ソフトウェア開発の品質向上とバグの早期発見に非常に有効な手法です。TDDのサイクルは、「テストを先に書き、その後コードを書く」というシンプルな流れですが、複雑な依存関係がある場合、効率的なテストを行うために「テストダブル」と呼ばれる技術が必要です。

テストダブルには、モックやスタブといった種類があり、これらを使いこなすことで、依存関係の影響を抑えながら正確なテストを実施できます。本記事では、Kotlinを使ってテストダブルを活用する方法を具体的なコード例とともに解説し、TDDを効率的に進めるための手法を紹介します。

目次
  1. TDD（テスト駆動開発）とは
    1. Red-Green-Refactorのサイクル
    2. TDDのメリット
    3. KotlinにおけるTDDの特徴
  2. テストダブルの種類と役割
    1. テストダブルの主な種類
    2. テストダブルの役割
    3. 使用例の選択基準
  3. Kotlinでのモックの作成方法
    1. Mockitoを使用したモックの作成
    2. MockKを使用したモックの作成
    3. MockitoとMockKの比較
    4. モックを使う際のポイント
  4. Kotlinでのスタブの作成方法
    1. MockKを使用したスタブの作成
    2. Mockitoを使用したスタブの作成
    3. スタブを使うシナリオ
    4. スタブ作成時のベストプラクティス
  5. モックを用いたTDDの実践例
    1. ユースケースの概要
    2. プロジェクト構成
    3. 本物のクラスの定義
    4. テストコードの作成（TDDの実践）
    5. 解説
    6. ポイントと注意点
  6. スタブを用いたTDDの実践例
    1. ユースケースの概要
    2. プロジェクト構成
    3. 本物のクラスの定義
    4. スタブを用いたテストコードの作成（TDDの実践）
    5. 解説
    6. スタブの活用ポイント
  7. Mockitoを使ったKotlinテストの実践
    1. Mockitoのセットアップ
    2. テスト対象クラスの定義
    3. Mockitoを使ったテストの作成
    4. テストコードの解説
    5. Mockitoを使う際のポイント
    6. まとめ
  8. テストダブルを使用する際の注意点
    1. 1. 過度なモック化を避ける
    2. 2. 適切なテストダブルの選択
    3. 3. モックやスタブの設定が複雑すぎないようにする
    4. 4. テストダブルの挙動を正確に定義する
    5. 5. モックの呼び出し検証は慎重に行う
    6. 6. テストが独立していることを確認する
    7. 7. 適切なテストカバレッジを確保する
    8. まとめ
  9. まとめ

TDD（テスト駆動開発）とは


TDD（Test-Driven Development：テスト駆動開発）とは、ソフトウェア開発におけるアプローチの一つで、「テストを先に書き、そのテストをパスするためのコードを書く」という手順を繰り返す方法です。TDDのサイクルは一般的にRed-Green-Refactorと呼ばれる3つのステップで構成されています。

Red-Green-Refactorのサイクル

  1. Red（テストが失敗する状態）
    最初に要件を満たすテストを書きます。この時点では、まだコードが存在しないためテストは失敗します。
  2. Green（テストが成功する状態）
    テストが成功するために必要最低限のコードを書きます。ここでは、シンプルにテストが通るようにすることが重要です。
  3. Refactor（リファクタリング）
    テストが成功した後、コードのクリーンアップや改善を行います。動作を変えずにコードを最適化します。

TDDのメリット

  • 高品質なコード：テストを先に書くことで、バグの混入を防ぎやすくなります。
  • 設計の改善：コードがテストしやすい設計になるため、シンプルで保守しやすい構造が自然に生まれます。
  • リグレッション防止：新しい機能追加や変更時に、既存テストがあることで、以前の動作が壊れていないことを確認できます。

KotlinにおけるTDDの特徴


Kotlinは簡潔なシンタックスとNull安全性を持つため、TDDを実践しやすい言語です。また、JUnitやMockitoなどのテスティングフレームワークとも相性が良く、効果的なテストの導入が可能です。

TDDを習得することで、エラーの早期発見や効率的な開発を実現できます。次項からは、TDDにおける「テストダブル」の役割とその具体的な活用方法について解説します。

テストダブルの種類と役割


テストダブル（Test Double）とは、単体テストを行う際に本物のオブジェクトの代わりとして使用する代替オブジェクトのことです。依存する外部コンポーネントの影響を避け、効率的かつ独立したテストが可能になります。

テストダブルの主な種類

モック（Mock）


モックは、特定の動作や呼び出しが行われたかどうかを検証するためのテストダブルです。呼び出し回数や引数の検証が可能で、動作の確認に使います。

スタブ（Stub）


スタブは、事前に定義した値を返すように設定されたテストダブルです。特定のメソッドに対して、予測可能なレスポンスを返す際に使います。

フェイク（Fake）


フェイクは、本物の代わりとして簡易的な動作を実装したテストダブルです。例えば、データベースの代わりにメモリ内でデータを保持する簡易な実装がフェイクにあたります。

ダミー（Dummy）


ダミーは、テストの実行に必要だが、使用されないオブジェクトです。引数の数合わせに使われ、動作には関与しません。

テストダブルの役割

  • 依存関係の分離：外部コンポーネントに依存せず、単体テストに集中できます。
  • テストの高速化：本物のデータベースやAPIを使わないため、テストが高速に実行されます。
  • エラーケースの検証：本物の環境では再現が難しいエラーケースをシミュレーションできます。

使用例の選択基準

  • モック：動作検証やメソッドの呼び出し確認が必要な場合
  • スタブ：特定の戻り値を返してテストしたい場合
  • フェイク：簡易的な実装で代替したい場合
  • ダミー：不要な依存関係を無効にしたい場合

次項では、Kotlinでのモックの具体的な作成方法について詳しく解説します。

Kotlinでのモックの作成方法


モック（Mock）は、メソッドの呼び出しや引数、回数を検証するためのテストダブルです。Kotlinでモックを作成するには、一般的にMockitoやMockKといったライブラリを使用します。以下では、これらのライブラリを使ったモックの作成方法を解説します。

Mockitoを使用したモックの作成

KotlinでMockitoを使用するには、まず依存関係を追加します。build.gradle.ktsに以下を追加します。

testImplementation("org.mockito:mockito-core:4.0.0")
testImplementation("org.mockito.kotlin:mockito-kotlin:4.0.0")

基本的なモックの作成

import org.junit.jupiter.api.Test
import org.mockito.Mockito.*

class UserServiceTest {
    @Test
    fun `ユーザー情報を正しく取得する`() {
        val userRepository = mock(UserRepository::class.java)
        val userService = UserService(userRepository)

        `when`(userRepository.getUserById(1)).thenReturn(User(1, "John Doe"))

        val user = userService.getUserById(1)

        assert(user.name == "John Doe")
        verify(userRepository).getUserById(1)
    }
}

MockKを使用したモックの作成

MockKは、Kotlin向けに設計されたモックライブラリです。Kotlinの特性を活かし、よりシンプルに記述できます。

build.gradle.ktsに以下を追加します。

testImplementation("io.mockk:mockk:1.12.0")

基本的なモックの作成

import io.mockk.every
import io.mockk.mockk
import io.mockk.verify
import org.junit.jupiter.api.Test

class UserServiceTest {
    @Test
    fun `ユーザー情報を正しく取得する`() {
        val userRepository = mockk<UserRepository>()
        val userService = UserService(userRepository)

        every { userRepository.getUserById(1) } returns User(1, "John Doe")

        val user = userService.getUserById(1)

        assert(user.name == "John Doe")
        verify { userRepository.getUserById(1) }
    }
}

MockitoとMockKの比較

特徴MockitoMockK
サポートJavaとKotlinKotlinに特化
DSLサポートなしDSLによるシンプルな記述が可能
非ファイナルクラスのモック特別な設定が必要デフォルトでサポート

モックを使う際のポイント

  • 最小限のモック：テストのために必要最低限のモックを作成する。
  • 呼び出しの検証：verifyを活用して、正しいメソッドが呼び出されたことを確認する。
  • テストの読みやすさ：過度なモックの使用を避け、テストが分かりやすくなるようにする。

次項では、Kotlinでのスタブの作成方法について詳しく解説します。

Kotlinでのスタブの作成方法


スタブ（Stub）は、特定のメソッド呼び出しに対して、事前に定義した戻り値を返すテストダブルです。依存する外部コンポーネントの結果を固定化し、テストの安定性を向上させるために使用します。Kotlinでは、MockKやMockitoを利用してスタブを簡単に作成できます。

MockKを使用したスタブの作成

まず、依存関係をbuild.gradle.ktsに追加します。

testImplementation("io.mockk:mockk:1.12.0")

基本的なスタブの作成

以下は、UserRepositoryをスタブとして作成し、固定の値を返す例です。

import io.mockk.every
import io.mockk.mockk
import org.junit.jupiter.api.Test
import kotlin.test.assertEquals

class UserServiceTest {

    @Test
    fun `スタブを使用してユーザー情報を取得する`() {
        // UserRepositoryのスタブを作成
        val userRepository = mockk<UserRepository>()
        val userService = UserService(userRepository)

        // 特定の呼び出しに対して固定値を返すようにスタブを設定
        every { userRepository.getUserById(1) } returns User(1, "Alice")

        val user = userService.getUserById(1)

        // 戻り値が期待通りであることを確認
        assertEquals("Alice", user.name)
    }
}

Mockitoを使用したスタブの作成

依存関係をbuild.gradle.ktsに追加します。

testImplementation("org.mockito:mockito-core:4.0.0")
testImplementation("org.mockito.kotlin:mockito-kotlin:4.0.0")

基本的なスタブの作成

import org.junit.jupiter.api.Test
import org.mockito.Mockito.*
import kotlin.test.assertEquals

class UserServiceTest {

    @Test
    fun `Mockitoでスタブを作成してユーザー情報を取得する`() {
        val userRepository = mock(UserRepository::class.java)
        val userService = UserService(userRepository)

        // 特定の呼び出しに対して戻り値を設定
        `when`(userRepository.getUserById(2)).thenReturn(User(2, "Bob"))

        val user = userService.getUserById(2)

        assertEquals("Bob", user.name)
    }
}

スタブを使うシナリオ

  1. 外部サービス依存のテスト：
    APIやデータベースに依存するメソッドをテストする場合、スタブで戻り値を固定することで効率的なテストが可能です。
  2. エラーケースのシミュレーション：
    例外やエラーレスポンスを返すスタブを作成し、エラーハンドリングを検証します。

スタブ作成時のベストプラクティス

  • 単純な戻り値設定：複雑なロジックをスタブに含めない。
  • 再現性のあるテスト：毎回同じ結果が返るように設定する。
  • 依存関係を明示：スタブが依存する外部コンポーネントを明確にする。

次項では、モックを用いたTDDの実践例について解説します。

モックを用いたTDDの実践例


モックを使ったTDD（テスト駆動開発）の実践例を、Kotlinの具体的なコードとともに解説します。ここでは、ユーザー情報を管理するサービスのテストを行い、モックを活用して依存関係を分離した効率的なTDDを実現します。

ユースケースの概要


シナリオ：

  • UserServiceがUserRepositoryからユーザー情報を取得する。
  • UserRepositoryは外部データベースに依存しているため、テスト時にはモックを使用する。

プロジェクト構成

src/
 └─ main/
 │    └─ UserService.kt
 │    └─ UserRepository.kt
 └─ test/
      └─ UserServiceTest.kt

本物のクラスの定義

まず、Userデータクラスと、ユーザー情報を取得するUserRepositoryインターフェースを定義します。

User.kt

data class User(val id: Int, val name: String)

UserRepository.kt

interface UserRepository {
    fun getUserById(id: Int): User?
}

UserService.kt

class UserService(private val userRepository: UserRepository) {
    fun getUserNameById(id: Int): String {
        val user = userRepository.getUserById(id)
        return user?.name ?: "User not found"
    }
}

テストコードの作成（TDDの実践）

テストを先に書いて、TDDのサイクルに従って進めます。

UserServiceTest.kt

import io.mockk.every
import io.mockk.mockk
import io.mockk.verify
import org.junit.jupiter.api.Test
import kotlin.test.assertEquals

class UserServiceTest {

    @Test
    fun `モックを使用してユーザー名を正しく取得する`() {
        // 1. モックの作成
        val userRepository = mockk<UserRepository>()
        val userService = UserService(userRepository)

        // 2. モックの挙動を定義
        every { userRepository.getUserById(1) } returns User(1, "Alice")

        // 3. テストの実行
        val userName = userService.getUserNameById(1)

        // 4. 検証
        assertEquals("Alice", userName)

        // 5. モックが正しく呼ばれたことを確認
        verify { userRepository.getUserById(1) }
    }

    @Test
    fun `存在しないユーザーIDでデフォルトメッセージを返す`() {
        // モックの作成
        val userRepository = mockk<UserRepository>()
        val userService = UserService(userRepository)

        // モックがnullを返すように設定
        every { userRepository.getUserById(2) } returns null

        // テストの実行
        val userName = userService.getUserNameById(2)

        // 検証
        assertEquals("User not found", userName)
    }
}

解説

  1. モックの作成
  • mockk<UserRepository>()でUserRepositoryのモックを作成します。
  1. モックの挙動を定義
  • every { userRepository.getUserById(1) } returns User(1, "Alice")のように、特定の呼び出しに対して戻り値を設定します。
  1. テストの実行
  • userService.getUserNameById(1)を呼び出し、返されるユーザー名を検証します。
  1. 検証
  • assertEqualsで結果が期待通りであることを確認します。
  1. モック呼び出しの確認
  • verify { userRepository.getUserById(1) }で、モックのメソッドが正しく呼ばれたことを検証します。

ポイントと注意点

  • 依存関係の分離：データベースに依存しないため、テストが高速で安定します。
  • エラーハンドリング：存在しないIDへの対応など、異常系のテストも容易に行えます。
  • モックの検証：verifyを活用し、期待したメソッド呼び出しが行われたか確認することで、ロジックの正当性を保証します。

次項では、スタブを用いたTDDの実践例について解説します。

スタブを用いたTDDの実践例


スタブを使ったTDD（テスト駆動開発）の実践例を、Kotlinの具体的なコードとともに解説します。スタブは、特定のメソッド呼び出しに対して事前に決められた値を返すテストダブルです。外部依存をシンプルにし、テストの安定性を高めるのに役立ちます。

ユースケースの概要


シナリオ：

  • OrderServiceがOrderRepositoryから注文データを取得する。
  • OrderRepositoryはデータベースに依存しているため、テスト時にはスタブを使用して固定の値を返すようにします。

プロジェクト構成

src/
 └─ main/
 │    └─ OrderService.kt
 │    └─ OrderRepository.kt
 └─ test/
      └─ OrderServiceTest.kt

本物のクラスの定義

Order.kt

data class Order(val id: Int, val amount: Double)

OrderRepository.kt

interface OrderRepository {
    fun getOrderById(id: Int): Order?
}

OrderService.kt

class OrderService(private val orderRepository: OrderRepository) {
    fun getOrderAmountById(id: Int): Double {
        val order = orderRepository.getOrderById(id)
        return order?.amount ?: 0.0
    }
}

スタブを用いたテストコードの作成（TDDの実践）

スタブを活用して、OrderServiceのテストを行います。

OrderServiceTest.kt

import io.mockk.every
import io.mockk.mockk
import org.junit.jupiter.api.Test
import kotlin.test.assertEquals

class OrderServiceTest {

    @Test
    fun `スタブを使用して注文金額を正しく取得する`() {
        // 1. スタブの作成
        val orderRepository = mockk<OrderRepository>()
        val orderService = OrderService(orderRepository)

        // 2. スタブの挙動を定義
        every { orderRepository.getOrderById(1) } returns Order(1, 100.0)

        // 3. テストの実行
        val amount = orderService.getOrderAmountById(1)

        // 4. 検証
        assertEquals(100.0, amount)
    }

    @Test
    fun `存在しない注文IDでデフォルト金額を返す`() {
        // スタブの作成
        val orderRepository = mockk<OrderRepository>()
        val orderService = OrderService(orderRepository)

        // スタブがnullを返すように設定
        every { orderRepository.getOrderById(2) } returns null

        // テストの実行
        val amount = orderService.getOrderAmountById(2)

        // 検証
        assertEquals(0.0, amount)
    }
}

解説

  1. スタブの作成
  • mockk<OrderRepository>()でOrderRepositoryのスタブを作成します。
  1. スタブの挙動を定義
  • every { orderRepository.getOrderById(1) } returns Order(1, 100.0)のように、特定の呼び出しで固定の戻り値を返すよう設定します。
  1. テストの実行
  • orderService.getOrderAmountById(1)を呼び出して、スタブが返した値が正しいか確認します。
  1. デフォルト値の確認
  • every { orderRepository.getOrderById(2) } returns nullで、データが存在しない場合の動作をテストします。

スタブの活用ポイント

  • 依存関係の切り離し：データベースや外部サービスの依存を切り離し、テストを高速化します。
  • 再現性の向上：スタブで固定の戻り値を設定するため、毎回同じ結果が得られます。
  • エラーハンドリングの検証：エラーやnullのケースを簡単に再現し、適切に処理されるかテストできます。

次項では、Mockitoを使ったKotlinテストの実践方法について解説します。

Mockitoを使ったKotlinテストの実践


MockitoはJavaおよびKotlinで広く使われるモック作成ライブラリです。KotlinとMockitoを組み合わせることで、依存関係をモック化し、効率的に単体テストを行えます。ここでは、Mockitoを使ってKotlinでテストを行う具体的な方法を紹介します。

Mockitoのセットアップ

依存関係を追加
build.gradle.ktsに以下の依存関係を追加します。

testImplementation("org.mockito:mockito-core:4.0.0")
testImplementation("org.mockito.kotlin:mockito-kotlin:4.0.0")
testImplementation("org.junit.jupiter:junit-jupiter:5.7.1")

テスト対象クラスの定義

注文情報を扱うOrderServiceクラスとOrderRepositoryインターフェースを用意します。

Order.kt

data class Order(val id: Int, val amount: Double)

OrderRepository.kt

interface OrderRepository {
    fun getOrderById(id: Int): Order?
}

OrderService.kt

class OrderService(private val orderRepository: OrderRepository) {
    fun getOrderAmountById(id: Int): Double {
        val order = orderRepository.getOrderById(id)
        return order?.amount ?: 0.0
    }
}

Mockitoを使ったテストの作成

OrderServiceTest.kt

import org.junit.jupiter.api.Test
import org.mockito.Mockito.*
import org.mockito.kotlin.whenever
import kotlin.test.assertEquals

class OrderServiceTest {

    @Test
    fun `Mockitoを使用して注文金額を正しく取得する`() {
        // 1. モックの作成
        val orderRepository = mock(OrderRepository::class.java)
        val orderService = OrderService(orderRepository)

        // 2. モックの挙動を設定
        whenever(orderRepository.getOrderById(1)).thenReturn(Order(1, 200.0))

        // 3. テストの実行
        val amount = orderService.getOrderAmountById(1)

        // 4. 検証
        assertEquals(200.0, amount)

        // 5. メソッド呼び出しの検証
        verify(orderRepository).getOrderById(1)
    }

    @Test
    fun `存在しない注文IDでデフォルト金額を返す`() {
        // モックの作成
        val orderRepository = mock(OrderRepository::class.java)
        val orderService = OrderService(orderRepository)

        // モックがnullを返すよう設定
        whenever(orderRepository.getOrderById(2)).thenReturn(null)

        // テストの実行
        val amount = orderService.getOrderAmountById(2)

        // 検証
        assertEquals(0.0, amount)

        // メソッド呼び出しの検証
        verify(orderRepository).getOrderById(2)
    }
}

テストコードの解説

  1. モックの作成
  • mock(OrderRepository::class.java)でOrderRepositoryのモックを作成します。
  1. モックの挙動設定
  • whenever(orderRepository.getOrderById(1)).thenReturn(Order(1, 200.0))で、特定の呼び出しに対する戻り値を設定します。
  1. テストの実行
  • orderService.getOrderAmountById(1)を呼び出して結果を検証します。
  1. 検証
  • assertEqualsで期待される結果を検証します。
  • verify(orderRepository).getOrderById(1)で、正しいメソッドが呼び出されたことを確認します。

Mockitoを使う際のポイント

  • モックの作成：mock()を使用して依存するインターフェースやクラスのモックを作成します。
  • 挙動の設定：whenever().thenReturn()でモックの戻り値を設定します。
  • 呼び出しの検証：verify()を使用してメソッドが正しく呼ばれたか確認します。
  • 例外のシミュレーション：whenever().thenThrow()で例外を発生させることも可能です。

まとめ

Mockitoを活用することで、依存関係をモック化し、Kotlinで効率的な単体テストが可能になります。これにより、テスト駆動開発（TDD）をスムーズに進め、コード品質を高めることができます。

次項では、テストダブルを使用する際の注意点について解説します。

テストダブルを使用する際の注意点


テストダブル（モック、スタブ、フェイク、ダミー）を効果的に使うことで、TDD（テスト駆動開発）や単体テストの品質が向上しますが、使い方を誤るとテストの信頼性や保守性が低下する可能性があります。ここでは、テストダブルを使用する際の注意点とベストプラクティスについて解説します。

1. 過度なモック化を避ける


モックを多用すると、テストが複雑になり、テスト対象のコードが過度に依存する可能性があります。

問題点

  • テストが壊れやすい：実装の詳細に依存するため、コードの変更に伴いテストが頻繁に壊れる。
  • テストの意図が不明確：何をテストしているのかが分かりづらくなる。

対策

  • モックを必要最低限に抑える。
  • テスト対象のクラスが単純である場合は、実際のオブジェクトを使う。

2. 適切なテストダブルの選択


モックやスタブなど、目的に合ったテストダブルを選びましょう。

選択基準

  • モック：動作やメソッドの呼び出しを検証したい場合。
  • スタブ：固定の戻り値を返して動作確認したい場合。
  • フェイク：簡易な代替実装でシミュレーションする場合。
  • ダミー：テストに不要な引数を満たすために使う場合。

3. モックやスタブの設定が複雑すぎないようにする


複雑なモックやスタブの設定は、テストコードの可読性や保守性を損ないます。

対策

  • テストが複雑になりすぎる場合、設計を見直す。
  • テスト対象のクラスが単一責任原則（SRP）を満たしているか確認する。

4. テストダブルの挙動を正確に定義する


テストダブルの挙動が不正確だと、テスト結果が信頼できなくなります。

ベストプラクティス

  • 期待する動作やエラーケースを正確に定義する。
  • 実際のデータや振る舞いに近い挙動をシミュレートする。

5. モックの呼び出し検証は慎重に行う


モックの呼び出し回数や引数の検証は、必要な場合だけに絞りましょう。

問題点

  • 呼び出し検証が多すぎると、テストが壊れやすくなる。
  • 実装の詳細に依存しすぎてしまう。

対策

  • ビジネスロジックの結果を重視し、モックの呼び出し検証は最小限にする。

6. テストが独立していることを確認する


テストが互いに依存しないようにし、単独で実行できることを保証します。

ベストプラクティス

  • 各テストケースが独立していることを確認する。
  • テストデータや状態が他のテストに影響を与えないようにする。

7. 適切なテストカバレッジを確保する


テストダブルを使用する際も、必要なシナリオやエッジケースを網羅するようにします。

ポイント

  • 正常系だけでなく、異常系やエラーケースもテストする。
  • システム全体の振る舞いを保証する統合テストも追加する。

まとめ


テストダブルを使うことで、依存関係を分離し効率的にテストが行えますが、過度な使用や不適切な設定はテストの信頼性を損なうリスクがあります。適切な種類のテストダブルを選び、シンプルで保守しやすいテストコードを心がけましょう。

次項では、本記事の内容をまとめます。

まとめ


本記事では、KotlinにおけるTDD（テスト駆動開発）を効率的に進めるために、テストダブル（モック、スタブ）の使い方について解説しました。テストダブルの種類や役割、MockitoやMockKを使った具体的なモックやスタブの作成方法、そしてTDDの実践例を通して、依存関係を分離しながらテストを行う重要性を学びました。

テストダブルを適切に活用することで、テストの信頼性と効率が向上し、バグの早期発見や保守性の高いコードが実現できます。また、注意点として、過度なモック化を避け、シンプルで独立したテストを心がけることが大切です。

Kotlinを使ったTDDとテストダブルの技術を習得し、品質の高いソフトウェア開発に役立てましょう。

Kotlin
TDD モック スタブ テストダブル Kotlin

コメント

コメントする

目次
  1. TDD（テスト駆動開発）とは
    1. Red-Green-Refactorのサイクル
    2. TDDのメリット
    3. KotlinにおけるTDDの特徴
  2. テストダブルの種類と役割
    1. テストダブルの主な種類
    2. テストダブルの役割
    3. 使用例の選択基準
  3. Kotlinでのモックの作成方法
    1. Mockitoを使用したモックの作成
    2. MockKを使用したモックの作成
    3. MockitoとMockKの比較
    4. モックを使う際のポイント
  4. Kotlinでのスタブの作成方法
    1. MockKを使用したスタブの作成
    2. Mockitoを使用したスタブの作成
    3. スタブを使うシナリオ
    4. スタブ作成時のベストプラクティス
  5. モックを用いたTDDの実践例
    1. ユースケースの概要
    2. プロジェクト構成
    3. 本物のクラスの定義
    4. テストコードの作成（TDDの実践）
    5. 解説
    6. ポイントと注意点
  6. スタブを用いたTDDの実践例
    1. ユースケースの概要
    2. プロジェクト構成
    3. 本物のクラスの定義
    4. スタブを用いたテストコードの作成（TDDの実践）
    5. 解説
    6. スタブの活用ポイント
  7. Mockitoを使ったKotlinテストの実践
    1. Mockitoのセットアップ
    2. テスト対象クラスの定義
    3. Mockitoを使ったテストの作成
    4. テストコードの解説
    5. Mockitoを使う際のポイント
    6. まとめ
  8. テストダブルを使用する際の注意点
    1. 1. 過度なモック化を避ける
    2. 2. 適切なテストダブルの選択
    3. 3. モックやスタブの設定が複雑すぎないようにする
    4. 4. テストダブルの挙動を正確に定義する
    5. 5. モックの呼び出し検証は慎重に行う
    6. 6. テストが独立していることを確認する
    7. 7. 適切なテストカバレッジを確保する
    8. まとめ
  9. まとめ