Kotlin TDDでエッジケースを洗い出すテスト戦略と実践ガイド

import org.junit.jupiter.api.Test
import kotlin.test.assertEquals

class CalculatorTest {
    @Test
    fun `should return sum of two numbers`() {
        val calculator = Calculator()
        val result = calculator.add(2, 3)
        assertEquals(5, result)
    }
}

class Calculator {
    fun add(a: Int, b: Int): Int {
        return a + b
    }
}

@Test
fun `should handle empty list`() {
    val result = processList(emptyList())
    assertEquals(0, result)
}

@Test
fun `should throw exception for null input`() {
    val exception = assertThrows<IllegalArgumentException> {
        validateInput(null)
    }
    assertEquals("Input must not be null", exception.message)
}

@Test
fun `should handle large input size`() {
    val largeInput = List(1000000) { it }
    val result = processLargeInput(largeInput)
    assertEquals(expectedOutput, result)
}

fun sumList(numbers: List<Int>): Int {
    return numbers.sum()
}

@Test
fun `should return 0 for empty list`() {
    val result = sumList(emptyList())
    assertEquals(0, result)
}

fun isPositive(number: Int): Boolean {
    return number > 0
}

@Test
fun `should return false for 0`() {
    val result = isPositive(0)
    assertEquals(false, result)
}

@Test
fun `should return false for negative number`() {
    val result = isPositive(-1)
    assertEquals(false, result)
}

fun parseNumber(input: String?): Int {
    return input?.toIntOrNull() ?: throw IllegalArgumentException("Invalid input")
}

@Test
fun `should throw exception for invalid input`() {
    val exception = assertThrows<IllegalArgumentException> {
        parseNumber("abc")
    }
    assertEquals("Invalid input", exception.message)
}

@Test
fun `should handle large list efficiently`() {
    val largeList = (1..1_000_000).shuffled()
    val sortedList = largeList.sorted()
    assertEquals(1, sortedList.first())
    assertEquals(1_000_000, sortedList.last())
}

data class Node(val value: Int, val children: List<Node>?)

fun countNodes(node: Node?): Int {
    return if (node == null) 0 else 1 + (node.children?.sumOf { countNodes(it) } ?: 0)
}

@Test
fun `should handle deeply nested nodes`() {
    val deepNode = (1..1000).fold(null as Node?) { acc, i -> Node(i, listOfNotNull(acc)) }
    val result = countNodes(deepNode)
    assertEquals(1000, result)
}

import org.junit.jupiter.api.Test
import kotlin.test.assertEquals

class CalculatorTest {
    @Test
    fun `should add two numbers`() {
        val result = Calculator().add(2, 3)
        assertEquals(5, result)
    }
}

import io.kotest.core.spec.style.StringSpec
import io.kotest.matchers.shouldBe

class CalculatorSpec : StringSpec({
    "should return the sum of two numbers" {
        val result = Calculator().add(2, 3)
        result shouldBe 5
    }
})

import io.mockk.every
import io.mockk.mockk
import kotlin.test.Test
import kotlin.test.assertEquals

class ServiceTest {
    private val mockRepository = mockk<Repository>()

    @Test
    fun `should return data from repository`() {
        every { mockRepository.getData() } returns "Mocked Data"

        val service = Service(mockRepository)
        val result = service.fetchData()

        assertEquals("Mocked Data", result)
    }
}

import org.hamcrest.MatcherAssert.assertThat
import org.hamcrest.Matchers.equalTo

@Test
fun `should check equality`() {
    val result = Calculator().add(2, 3)
    assertThat(result, equalTo(5))
}

import org.testcontainers.containers.PostgreSQLContainer

class DatabaseTest {
    private val postgres = PostgreSQLContainer<Nothing>("postgres:13").apply { start() }

    @Test
    fun `should connect to database`() {
        val connection = DriverManager.getConnection(postgres.jdbcUrl, postgres.username, postgres.password)
        val result = connection.createStatement().executeQuery("SELECT 1")
        assert(result.next())
    }
}

import io.kotest.property.forAll

@Test
fun `should handle all edge cases for addition`() {
    forAll<Int, Int> { a, b ->
        Calculator().add(a, b) == a + b
    }
}

@Test
fun `should handle boundary values correctly`() {
    assertEquals(0, processValue(0))
    assertEquals(100, processValue(100))
    assertEquals(-1, processValue(-1))
}

@Test
fun `should throw exception for invalid inputs`() {
    val exception = assertThrows<IllegalArgumentException> {
        processInput("invalid_data")
    }
    assertEquals("Input is not valid", exception.message)
}

import kotlin.random.Random

@Test
fun `should process random numbers correctly`() {
    val randomValue = Random.nextInt(0, 100)
    assertTrue(processValue(randomValue) >= 0)
}

@Test
fun `should handle large data set`() {
    val largeData = List(1_000_000) { it }
    val result = processLargeData(largeData)
    assertEquals(largeData.sum(), result)
}

@Test
fun `should process user data correctly`() {
    val mockUserData = listOf("user1", "user2", "user3")
    val result = processUserData(mockUserData)
    assertEquals(3, result.size)
}

val mockResponse = """{"id":1,"name":"test"}"""
@Test
fun `should parse API response correctly`() {
    val user = parseApiResponse(mockResponse)
    assertEquals(1, user.id)
    assertEquals("test", user.name)
}

@Test
fun `should handle multiple scenarios`() {
    val scenarios = listOf(
        Pair(1, "valid"),
        Pair(0, "invalid"),
        Pair(-1, "error")
    )
    scenarios.forEach { (input, expected) ->
        val result = processScenario(input)
        assertEquals(expected, result)
    }
}

@Test
fun `should handle zero input`() {
    val result = calculate(0)
    println("Debug result: $result") // デバッグ出力を追加
    assertEquals(0, result)
}

import kotlinx.coroutines.runBlocking

@Test
fun `should test asynchronous logic`() = runBlocking {
    val result = performAsyncOperation()
    assertEquals(expectedValue, result)
}

val mockApi = mockk<ApiService>()
every { mockApi.getData() } returns "Mocked Response"

@ParameterizedTest
@ValueSource(ints = [0, -1, 100])
fun `should process multiple inputs`(input: Int) {
    val result = processValue(input)
    assertTrue(result >= 0)
}

import org.testcontainers.containers.Network

val network = Network.newNetwork()
val service = GenericContainer("my-service-image").apply {
    withNetwork(network)
    withNetworkAliases("my-service")
    withEnv("SIMULATE_LATENCY", "true")
    start()
}

@Test
fun `should handle network latency gracefully`() {
    val response = callService("http://my-service")
    assertEquals("fallback", response)
}

@Test
fun `should handle high volume of requests`() {
    repeat(1000) {
        val response = makeApiCall()
        assertEquals(200, response.statusCode)
    }
}

@Test
fun `should reject invalid data formats`() {
    val invalidData = """{"id":"abc","value":123}"""
    val exception = assertThrows<ValidationException> {
        processData(invalidData)
    }
    assertEquals("Invalid ID format", exception.message)
}

@Test
fun `should maintain data consistency under concurrent updates`() = runBlocking {
    val jobs = List(10) {
        launch {
            updateSharedResource()
        }
    }
    jobs.forEach { it.join() }

    assertEquals(expectedFinalState, getSharedResourceState())
}

@Test
fun `should handle repeated user actions gracefully`() {
    repeat(100) {
        val response = performUserAction()
        assertEquals("success", response)
    }
}

@Test
fun `should handle unexpected data from dependent module`() {
    val mockResponse = """{"unexpected_field":"value"}"""
    val result = processModuleResponse(mockResponse)
    assertEquals("fallback", result)
}