src/test/java/roomescape/reservation/infrastructure/persistence/ReservationRepositoryTest.kt

@@ -0,0 +1,200 @@
+package roomescape.reservation.infrastructure.persistence
+
+import io.kotest.assertions.assertSoftly
+import io.kotest.core.spec.style.FunSpec
+import io.kotest.matchers.collections.shouldHaveSize
+import io.kotest.matchers.shouldBe
+import jakarta.persistence.EntityManager
+import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest
+import org.springframework.data.repository.findByIdOrNull
+import roomescape.payment.infrastructure.persistence.PaymentEntity
+import roomescape.reservation.web.MyReservationResponse
+import roomescape.theme.infrastructure.persistence.ThemeEntity
+import roomescape.util.PaymentFixture
+import roomescape.util.ReservationFixture
+import roomescape.util.ReservationTimeFixture
+import roomescape.util.ThemeFixture
+
+@DataJpaTest
+class ReservationRepositoryTest(
+        val entityManager: EntityManager,
+        val reservationRepository: ReservationRepository,
+) : FunSpec() {
+    init {
+        context("findByReservationTime") {
+            val time = ReservationTimeFixture.create()
+
+            beforeTest {
+                listOf(
+                        ReservationFixture.create(reservationTime = time),
+                        ReservationFixture.create(reservationTime = ReservationTimeFixture.create(
+                                startAt = time.startAt.plusSeconds(1)
+                        ))
+                ).forEach {
+                    persistReservation(it)
+                }
+
+                entityManager.flush()
+                entityManager.clear()
+            }
+
+            test("입력된 시간과 일치하는 예약을 반환한다.") {
+                assertSoftly(reservationRepository.findByReservationTime(time)) {
+                    it shouldHaveSize 1
+                    assertSoftly(it.first().reservationTime.startAt) { result ->
+                        result.hour shouldBe time.startAt.hour
+                        result.minute shouldBe time.startAt.minute
+                    }
+                }
+            }
+        }
+
+        context("findByDateAndThemeId") {
+            val date = ReservationFixture.create().date
+            lateinit var theme1: ThemeEntity
+            lateinit var theme2: ThemeEntity
+
+            beforeTest {
+                theme1 = ThemeFixture.create(name = "theme1").also {
+                    entityManager.persist(it)
+                }
+
+                theme2 = ThemeFixture.create(name = "theme2").also {
+                    entityManager.persist(it)
+                }
+
+                listOf(
+                        ReservationFixture.create(date = date, theme = theme1),
+                        ReservationFixture.create(date = date.plusDays(1), theme = theme1),
+                        ReservationFixture.create(date = date, theme = theme2),
+                ).forEach {
+                    entityManager.persist(it.reservationTime)
+                    entityManager.persist(it.member)
+                    entityManager.persist(it)
+                }
+            }
+
+            test("입력된 날짜와 테마 ID에 해당하는 예약을 반환한다.") {
+                assertSoftly(reservationRepository.findByDateAndThemeId(date, theme1.id!!)) {
+                    it shouldHaveSize 1
+                    it.first().theme shouldBe theme1
+                }
+            }
+        }
+
+        context("updateStatusByReservationId") {
+            lateinit var reservation: ReservationEntity
+
+            beforeTest {
+                reservation = ReservationFixture.create().also {
+                    persistReservation(it)
+                }
+
+                entityManager.flush()
+                entityManager.clear()
+            }
+
+            test("예약 상태를 업데이트한다.") {
+                ReservationStatus.entries.forEach {
+                    val reservationId = reservation.id!!
+                    val updatedRows = reservationRepository.updateStatusByReservationId(reservationId, it)
+                    updatedRows shouldBe 1
+
+                    entityManager.flush()
+                    entityManager.clear()
+
+                    reservationRepository.findByIdOrNull(reservationId)?.also { updated ->
+                        updated.reservationStatus shouldBe it
+                    }
+                }
+            }
+        }
+
+        context("isExistConfirmedReservation") {
+            lateinit var waiting: ReservationEntity
+            lateinit var confirmed: ReservationEntity
+            lateinit var confirmedPaymentRequired: ReservationEntity
+
+            beforeTest {
+                waiting = ReservationFixture.create(status = ReservationStatus.WAITING).also {
+                    persistReservation(it)
+                }
+
+                confirmed = ReservationFixture.create(status = ReservationStatus.CONFIRMED_PAYMENT_REQUIRED).also {
+                    persistReservation(it)
+                }
+
+                confirmedPaymentRequired = ReservationFixture.create(status = ReservationStatus.CONFIRMED_PAYMENT_REQUIRED).also {
+                    persistReservation(it)
+                }
+
+                entityManager.flush()
+                entityManager.clear()
+            }
+
+            test("예약이 없으면 false를 반환한다.") {
+                val maxId: Long = listOf(waiting, confirmed, confirmedPaymentRequired)
+                        .maxOfOrNull { it.id ?: 0L } ?: 0L
+                reservationRepository.isExistConfirmedReservation(maxId + 1L) shouldBe false
+            }
+
+            test("예약이 대기중이면 false를 반환한다.") {
+                reservationRepository.isExistConfirmedReservation(waiting.id!!) shouldBe false
+            }
+
+            test("예약이 결제 완료 상태이면 true를 반환한다.") {
+                reservationRepository.isExistConfirmedReservation(confirmed.id!!) shouldBe true
+            }
+
+            test("예약이 결제 대기 상태이면 true를 반환한다.") {
+                reservationRepository.isExistConfirmedReservation(confirmedPaymentRequired.id!!) shouldBe true
+            }
+        }
+
+        context("findMyReservations") {
+            lateinit var reservation: ReservationEntity
+
+            beforeTest {
+                reservation = ReservationFixture.create()
+                persistReservation(reservation)
+            }
+
+            test("결제 정보를 포함한 회원의 예약 목록을 반환한다.") {
+                val payment: PaymentEntity = PaymentFixture.create(
+                        reservationId = reservation.id!!
+                ).also {
+                    entityManager.persist(it)
+                    entityManager.flush()
+                    entityManager.clear()
+                }
+
+                val result: List<MyReservationResponse> = reservationRepository.findMyReservations(reservation.member.id!!)
+
+                result shouldHaveSize 1
+                assertSoftly(result.first()) {
+                    it.id shouldBe reservation.id
+                    it.paymentKey shouldBe payment.paymentKey
+                    it.amount shouldBe payment.totalAmount
+                }
+            }
+
+            test("결제 정보가 없다면 paymentKey와 amount는 null로 반환한다.") {
+                val result: List<MyReservationResponse> = reservationRepository.findMyReservations(reservation.member.id!!)
+
+                result shouldHaveSize 1
+                assertSoftly(result.first()) {
+                    it.id shouldBe reservation.id
+                    it.paymentKey shouldBe null
+                    it.amount shouldBe null
+                }
+            }
+        }
+    }
+
+    fun persistReservation(reservation: ReservationEntity) {
+        entityManager.persist(reservation.reservationTime)
+        entityManager.persist(reservation.theme)
+        entityManager.persist(reservation.member)
+        entityManager.persist(reservation)
+    }
+}