스프링부트 kotest, mockk

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

class CalculatorTest : StringSpec({

    "더하기 테스트" {
        val calculator = Calculator()
        val result = calculator.add(2, 3)
        result shouldBe 5
    }

    "빼기 테스트" {
        val calculator = Calculator()
        val result = calculator.subtract(5, 3)
        result shouldBe 2
    }
})

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

    fun subtract(a: Int, b: Int): Int {
        return a - b
    }
}

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

class BankAccountTest : BehaviorSpec({

    given("잔고가 100인 계좌") {
        val bankAccount = BankAccount(100)

        `when`("100을 입금하면") {
            bankAccount.deposit(100)

            then("잔고는 200이어야 한다") {
                bankAccount.balance shouldBe 200
            }
        }

        `when`("50을 출금하면") {
            bankAccount.withdraw(50)

            then("잔고는 50이어야 한다") {
                bankAccount.balance shouldBe 50
            }
        }
    }
})

class BankAccount(initialBalance: Int) {
    var balance: Int = initialBalance

    fun deposit(amount: Int) {
        balance += amount
    }

    fun withdraw(amount: Int) {
        balance -= amount
    }
}

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

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

class UserService(private val userRepository: UserRepository) {
    fun getUser(id: Int): User? {
        return userRepository.getUser(id)
    }
}

@RestController
class UserController(private val userService: UserService) {

    @GetMapping("/user/{id}")
    fun getUser(@PathVariable id: Int): ResponseEntity<User> {
        val user = userService.getUser(id) ?: return ResponseEntity.notFound().build()
        return ResponseEntity.ok(user)
    }
}

import io.kotest.matchers.shouldBe
import io.mockk.every
import io.mockk.mockk
import org.springframework.http.HttpStatus
import org.springframework.http.ResponseEntity

class UserControllerTest: StringSpec({
    val userService = mockk<UserService>()
    val userController = UserController(userService)

    "만약 유저가 존재한다면 getUser()메서드는 user객체를 반환합니다. " {
        val mockUser = User(id = 1, name = "John Doe")

        every { userService.getUser(1) } returns mockUser

        val response = userController.getUser(1)

        response.statusCode shouldBe HttpStatus.OK
        response.body shouldBe mockUser
    }

    "만약 유저가 존재하지 않다면 getUser() 메서드는 404 에러 메시지를 전달합니다." {
        every { userService.getUser(2) } returns null

        val response = userController.getUser(2)

        response.statusCode shouldBe HttpStatus.NOT_FOUND
    }
})

class UserServiceTest: StringSpec({
    val userRepository = mockk<UserRepository>()
    val userService = UserService(userRepository)

    "getUser() 메서드는 userId에 맞는 user를 반환해야 합니다." {
        val mockUser = User(id = 1, name = "John Doe")

        every { userRepository.getUser(1) } returns mockUser

        userService.getUser(1) shouldBe mockUser
    }

    "getUser() 메서드는 존재하지 않는 유저에 대해서 null을 반환합니다." {
        every { userRepository.getUser(2) } returns null

        userService.getUser(2) shouldBe null
    }
})

import io.kotest.core.spec.style.FunSpec
import io.kotest.matchers.shouldBe
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest
import org.springframework.boot.test.context.SpringBootTest
import org.springframework.test.context.ContextConfiguration

@DataJpaTest
@ContextConfiguration(classes = [UserRepository::class])
class UserRepositoryTest(@Autowired val userRepository: UserRepository): FunSpec({
    test("getUser() 메서드는 userId에 맞는 user를 반환해야 합니다.") {
        val user = User(1, "John Doe") 

        val result = userRepository.getUser(1) // DB에도 User(1, "John Doe")객체가 있다고 가정합니다.
        result shouldBe user
    }

    test("getUser() 메서드는 존재하지 않는 유저에 대해서 null을 반환합니다.") {
        val result = userRepository.getUser(2)
        result shouldBe null
    }
})

import io.kotest.core.spec.style.BehaviorSpec
import io.kotest.matchers.shouldBe
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc
import org.springframework.boot.test.context.SpringBootTest
import org.springframework.http.HttpStatus
import org.springframework.test.web.servlet.MockMvc
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get
import org.springframework.test.web.servlet.result.MockMvcResultMatchers.status

@SpringBootTest
@AutoConfigureMockMvc
class UserControllerIntegrationTest(@Autowired val mockMvc: MockMvc) : BehaviorSpec({

    Given("UserController's `/user/{id}` endpoint") {
        When("유저가 존재할 때") {
            val user = User(1, "John Doe") // DB에 있다고 가정합니다!

            Then("UserId에 해당하는 유저를 반환합니다.") {
                val result = mockMvc.perform(get("/user/1"))
                    .andExpect(status().isOk)
                    .andReturn()

                val responseBody = result.response.contentAsString
                responseBody shouldBe "{\"id\":1,\"name\":\"John Doe\"}"
            }
        }

        When("유저가 존재하지 않을때") {
            Then("404 상태코드를 보냅니다.") {
                val result = mockMvc.perform(get("/user/2"))
                    .andExpect(status().isNotFound)
                    .andReturn()

                result.response.status shouldBe HttpStatus.NOT_FOUND.value()
            }
        }
    }
})