KotlinでTDDを活用したAPIレスポンスのテスト方法を徹底解説

plugins {
    kotlin("jvm") version "1.8.0"
}

dependencies {
    // テストライブラリ
    testImplementation("org.jetbrains.kotlin:kotlin-test")
    testImplementation("io.kotest:kotest-runner-junit5:5.5.5")
    testImplementation("io.mockk:mockk:1.13.4") // モックライブラリ

    // HTTPクライアント (APIテスト用)
    implementation("io.ktor:ktor-client-core:2.3.0")
    implementation("io.ktor:ktor-client-cio:2.3.0")
}

tasks.test {
    useJUnitPlatform()
}

src/
 ├── main/
 │    └── kotlin/
 │         └── com.example.api/
 │              └── ApiService.kt
 └── test/
      └── kotlin/
           └── com.example.api/
                └── ApiServiceTest.kt

./gradlew test

@Test
fun `should return 200 OK with valid response`() {
    val response = apiService.getUserDetails(userId = 123)
    assertEquals(200, response.status)
    assertEquals("John Doe", response.body?.name)
}

@Test
fun `should return 404 Not Found for non-existing user`() {
    val response = apiService.getUserDetails(userId = 999)
    assertEquals(404, response.status)
}

@Test
fun `should handle empty userId input`() {
    val response = apiService.getUserDetails(userId = null)
    assertEquals(400, response.status)
}

import io.ktor.client.*
import io.ktor.client.request.*
import io.ktor.client.statement.*

class ApiService(private val client: HttpClient) {
    suspend fun getUserDetails(userId: Int?): HttpResponse {
        return client.get("https://example.com/api/users/$userId")
    }
}

import io.ktor.client.engine.mock.*
import io.ktor.client.request.*
import io.ktor.http.*
import io.mockk.coEvery
import io.mockk.mockk
import kotlin.test.*
import kotlinx.coroutines.runBlocking

class ApiServiceTest {

    private val mockEngine = MockEngine { request ->
        respond(
            content = """{"name": "John Doe", "id": 123}""",
            status = HttpStatusCode.OK,
            headers = headersOf(HttpHeaders.ContentType, "application/json")
        )
    }
    private val client = HttpClient(mockEngine)
    private val apiService = ApiService(client)

    @Test
    fun `should return 200 OK with valid response`() = runBlocking {
        val response = apiService.getUserDetails(userId = 123)

        assertEquals(HttpStatusCode.OK, response.status)
        assertTrue(response.bodyAsText().contains("John Doe"))
    }
}

@Test
fun `should return 404 Not Found for invalid user`() = runBlocking {
    val mockEngine = MockEngine { request ->
        respond(
            content = """{"error": "User not found"}""",
            status = HttpStatusCode.NotFound
        )
    }
    val client = HttpClient(mockEngine)
    val apiService = ApiService(client)

    val response = apiService.getUserDetails(userId = 999)

    assertEquals(HttpStatusCode.NotFound, response.status)
}

./gradlew test

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

import io.mockk.coEvery
import io.mockk.mockk
import io.ktor.client.*
import io.ktor.client.statement.*
import io.ktor.http.*
import kotlinx.coroutines.runBlocking
import kotlin.test.*

class ApiServiceTest {

    private val mockClient = mockk<HttpClient>()
    private val apiService = ApiService(mockClient)

    @Test
    fun `should return 200 OK with mock response`() = runBlocking {
        val mockResponse = HttpResponse(mockk(), HttpStatusCode.OK)

        coEvery { mockClient.get<HttpResponse>(any()) } returns mockResponse

        val response = apiService.getUserDetails(userId = 123)

        assertEquals(HttpStatusCode.OK, response.status)
    }
}

import io.ktor.client.*
import io.ktor.client.engine.mock.*
import io.ktor.client.request.*
import io.ktor.client.statement.*
import io.ktor.http.*
import kotlinx.coroutines.runBlocking
import kotlin.test.*

class ApiServiceTest {

    private val mockEngine = MockEngine { request ->
        when (request.url.toString()) {
            "https://example.com/api/users/123" -> respond(
                content = """{"id": 123, "name": "John Doe"}""",
                status = HttpStatusCode.OK,
                headers = headersOf(HttpHeaders.ContentType, "application/json")
            )
            else -> respondBadRequest()
        }
    }

    private val client = HttpClient(mockEngine)
    private val apiService = ApiService(client)

    @Test
    fun `should return user details for valid userId`() = runBlocking {
        val response = apiService.getUserDetails(userId = 123)
        assertEquals(HttpStatusCode.OK, response.status)
        assertTrue(response.bodyAsText().contains("John Doe"))
    }
}

./gradlew test

build/reports/tests/test/index.html

@Test
fun `should return 400 Bad Request for null userId`() = runBlocking {
    val response = apiService.getUserDetails(userId = null)
    assertEquals(HttpStatusCode.BadRequest, response.status)
}

val mockEngine = MockEngine { request ->
    respond(
        content = """{"id": 123, "name": "John Doe"}""",
        status = HttpStatusCode.OK,
        headers = headersOf(HttpHeaders.ContentType, "application/json")
    )
}

@Test
fun `should return 200 OK when user exists`() = runBlocking {
    // Given
    val userId = 123

    // When
    val response = apiService.getUserDetails(userId)

    // Then
    assertEquals(HttpStatusCode.OK, response.status)
}

@Before
fun setUp() {
    apiService = ApiService(client)
}

@Test
fun `should return 200 OK and token for valid credentials`() = runBlocking {
    val credentials = Credentials("validUser", "validPassword")
    val response = authService.login(credentials)

    assertEquals(HttpStatusCode.OK, response.status)
    assertTrue(response.bodyAsText().contains("token"))
}

class AuthService {
    suspend fun login(credentials: Credentials): HttpResponse {
        return if (credentials.username == "validUser" && credentials.password == "validPassword") {
            HttpResponse(mockk(), HttpStatusCode.OK, body = """{"token": "123abc"}""")
        } else {
            HttpResponse(mockk(), HttpStatusCode.Unauthorized)
        }
    }
}

@Test
fun `should return product details for valid product ID`() = runBlocking {
    val response = productService.getProductDetails(productId = 101)

    assertEquals(HttpStatusCode.OK, response.status)
    assertTrue(response.bodyAsText().contains("productName"))
}

class ProductService(private val client: HttpClient) {
    suspend fun getProductDetails(productId: Int): HttpResponse {
        return client.get("https://example.com/api/products/$productId")
    }
}

@Test
fun `should return 404 Not Found for invalid product ID`() = runBlocking {
    val mockEngine = MockEngine { request ->
        respond(
            content = """{"error": "Product not found"}""",
            status = HttpStatusCode.NotFound
        )
    }
    val client = HttpClient(mockEngine)
    val productService = ProductService(client)

    val response = productService.getProductDetails(productId = 999)

    assertEquals(HttpStatusCode.NotFound, response.status)
}

@Test
fun `should return 201 Created when posting a valid comment`() = runBlocking {
    val comment = Comment("Great article!", "user123")
    val response = commentService.postComment(comment)

    assertEquals(HttpStatusCode.Created, response.status)
}

class CommentService(private val client: HttpClient) {
    suspend fun postComment(comment: Comment): HttpResponse {
        return client.post("https://example.com/api/comments") {
            body = comment
        }
    }
}

@Test
fun `should return 400 Bad Request for invalid comment`() = runBlocking {
    val invalidComment = Comment("", "") // 空のコメント

    val response = commentService.postComment(invalidComment)

    assertEquals(HttpStatusCode.BadRequest, response.status)
}