package roomescape.payment.implement

import io.kotest.assertions.throwables.shouldThrow
import io.kotest.core.spec.style.FunSpec
import io.kotest.matchers.shouldBe
import io.mockk.every
import io.mockk.mockk
import io.mockk.verify
import roomescape.payment.exception.PaymentErrorCode
import roomescape.payment.exception.PaymentException
import roomescape.payment.infrastructure.persistence.CanceledPaymentRepository
import roomescape.payment.infrastructure.persistence.PaymentRepository

class PaymentFinderTest : FunSpec({
    val paymentRepository: PaymentRepository = mockk()
    val canceledPaymentRepository: CanceledPaymentRepository = mockk()

    val paymentFinder = PaymentFinder(paymentRepository, canceledPaymentRepository)

    context("existsPaymentByReservationId") {
        val reservationId = 1L
        test("결제 정보가 있으면 true를 반환한다.") {
            every {
                paymentRepository.existsByReservationId(reservationId)
            } returns true

            paymentFinder.existsPaymentByReservationId(reservationId) shouldBe true
        }

        test("결제 정보가 없으면 false를 반환한다.") {
            every {
                paymentRepository.existsByReservationId(reservationId)
            } returns false

            paymentFinder.existsPaymentByReservationId(reservationId) shouldBe false
        }
    }

    context("findByReservationId") {
        val reservationId = 1L
        test("결제 정보를 조회한다.") {
            every {
                paymentRepository.findByReservationId(reservationId)
            } returns mockk()

            paymentFinder.findByReservationId(reservationId)

            verify(exactly = 1) {
                paymentRepository.findByReservationId(reservationId)
            }
        }

        test("결제 정보가 없으면 실패한다.") {
            every {
                paymentRepository.findByReservationId(reservationId)
            } returns null

            shouldThrow<PaymentException> {
                paymentFinder.findByReservationId(reservationId)
            }.also {
                it.errorCode shouldBe PaymentErrorCode.PAYMENT_NOT_FOUND
            }
        }
    }

    context("findCanceledByKey") {
        val paymentKey = "paymentKey"

        test("결제 취소 정보를 조회한다.") {
            every {
                canceledPaymentRepository.findByPaymentKey(paymentKey)
            } returns mockk()

            paymentFinder.findCanceledByKey(paymentKey)

            verify(exactly = 1) {
                canceledPaymentRepository.findByPaymentKey(paymentKey)
            }
        }

        test("결제 취소 정보가 없으면 실패한다.") {
            every {
                canceledPaymentRepository.findByPaymentKey(paymentKey)
            } returns null

            shouldThrow<PaymentException> {
                paymentFinder.findCanceledByKey(paymentKey)
            }.also {
                it.errorCode shouldBe PaymentErrorCode.CANCELED_PAYMENT_NOT_FOUND
            }
        }
    }
})