roomescape-refactored/src/test/java/roomescape/auth/business/AuthServiceTest.kt

package roomescape.auth.business

import io.kotest.assertions.assertSoftly
import io.kotest.assertions.throwables.shouldThrow
import io.kotest.core.spec.style.BehaviorSpec
import io.kotest.matchers.shouldBe
import io.mockk.every
import io.mockk.mockk
import org.springframework.data.repository.findByIdOrNull
import roomescape.auth.infrastructure.jwt.JwtHandler
import roomescape.auth.service.AuthService
import roomescape.common.exception.ErrorType
import roomescape.common.exception.RoomescapeException
import roomescape.member.business.MemberService
import roomescape.member.infrastructure.persistence.MemberEntity
import roomescape.member.infrastructure.persistence.MemberRepository
import roomescape.util.JwtFixture
import roomescape.util.MemberFixture


class AuthServiceTest : BehaviorSpec({
    val memberRepository: MemberRepository = mockk()
    val memberService: MemberService = MemberService(memberRepository)
    val jwtHandler: JwtHandler = JwtFixture.create()

    val authService = AuthService(memberService, jwtHandler)
    val user: MemberEntity = MemberFixture.user()

    Given("로그인 요청을 받으면") {
        When("이메일과 비밀번호로 회원을 찾고") {
            val request = MemberFixture.userLoginRequest()

            Then("회원이 있다면 JWT 토큰을 생성한 뒤 반환한다.") {
                every {
                    memberRepository.findByEmailAndPassword(request.email, request.password)
                } returns user

                val accessToken: String = authService.login(request).accessToken

                accessToken.isNotBlank() shouldBe true
                jwtHandler.getMemberIdFromToken(accessToken) shouldBe user.id
            }

            Then("회원이 없다면 예외를 던진다.") {
                every {
                    memberRepository.findByEmailAndPassword(request.email, request.password)
                } returns null

                val exception = shouldThrow<RoomescapeException> {
                    authService.login(request)
                }

                exception.errorType shouldBe ErrorType.MEMBER_NOT_FOUND
            }
        }
    }

    Given("로그인 확인 요청을 받으면") {
        When("회원 ID로 회원을 찾고") {
            val userId: Long = user.id!!

            Then("회원이 있다면 회원의 이름을 반환한다.") {
                every { memberRepository.findByIdOrNull(userId) } returns user

                val response = authService.checkLogin(userId)

                assertSoftly(response) {
                    this.name shouldBe user.name
                }
            }

            Then("회원이 없다면 예외를 던진다.") {
                every { memberRepository.findByIdOrNull(userId) } returns null

                val exception = shouldThrow<RoomescapeException> {
                    authService.checkLogin(userId)
                }

                exception.errorType shouldBe ErrorType.MEMBER_NOT_FOUND
            }
        }
    }
})