refactor: 중복된 시간을 확인할 때 findByStartAt 대신 existsByStartAt를 사용하도록 수정 및 테스트 추가

src/main/java/roomescape/reservation/business/ReservationTimeService.kt

@@ -12,6 +12,7 @@ import roomescape.reservation.infrastructure.persistence.ReservationTimeEntity
 import roomescape.reservation.infrastructure.persistence.ReservationTimeRepository
 import roomescape.reservation.web.*
 import java.time.LocalDate
+import java.time.LocalTime
 
 @Service
 class ReservationTimeService(
@@ -28,30 +29,24 @@ class ReservationTimeService(
 
 
     @Transactional(readOnly = true)
-    fun findAllTimes(): ReservationTimesResponse =  reservationTimeRepository.findAll()
+    fun findAllTimes(): ReservationTimesResponse = reservationTimeRepository.findAll()
-                .toResponses()
+            .toResponses()
-
 
     @Transactional
     fun addTime(reservationTimeRequest: ReservationTimeRequest): ReservationTimeResponse {
-        validateIsDuplicatedTimeExists(reservationTimeRequest)
+        val startAt: LocalTime = reservationTimeRequest.startAt
 
-        return ReservationTimeEntity(startAt = reservationTimeRequest.startAt)
+        if (reservationTimeRepository.existsByStartAt(startAt)) {
+            throw RoomescapeException(
+                    ErrorType.TIME_DUPLICATED, "[startAt: $startAt]", HttpStatus.CONFLICT
+            )
+        }
+
+        return ReservationTimeEntity(startAt = startAt)
                 .also { reservationTimeRepository.save(it) }
                 .toResponse()
     }
 
-    private fun validateIsDuplicatedTimeExists(reservationTimeRequest: ReservationTimeRequest) {
-        reservationTimeRepository.findByStartAt(reservationTimeRequest.startAt)
-                .also {
-                    if (it.isNotEmpty()) {
-                        throw RoomescapeException(
-                                ErrorType.TIME_DUPLICATED, "[startAt: $it]", HttpStatus.CONFLICT
-                        )
-                    }
-                }
-    }
-
     @Transactional
     fun removeTimeById(id: Long) {
         val reservationTime: ReservationTimeEntity = findTimeById(id)

src/main/java/roomescape/reservation/infrastructure/persistence/ReservationTimeRepository.kt

@@ -4,5 +4,5 @@ import org.springframework.data.jpa.repository.JpaRepository
 import java.time.LocalTime
 
 interface ReservationTimeRepository : JpaRepository<ReservationTimeEntity, Long> {
-    fun findByStartAt(startAt: LocalTime): List<ReservationTimeEntity>
+    fun existsByStartAt(startAt: LocalTime): Boolean
 }

src/test/java/roomescape/reservation/business/ReservationTimeServiceTest.kt

@@ -45,7 +45,7 @@ class ReservationTimeServiceTest : FunSpec({
             val request = ReservationTimeRequest(startAt = LocalTime.of(10, 0))
 
             // Mocking the behavior of reservationTimeRepository.findByStartAt
-            every { reservationTimeRepository.findByStartAt(request.startAt) } returns listOf(mockk())
+            every { reservationTimeRepository.existsByStartAt(request.startAt) } returns true
 
             shouldThrow<RoomescapeException> {
                 reservationTimeService.addTime(request)

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

@@ -0,0 +1,33 @@
+package roomescape.reservation.infrastructure.persistence
+
+import io.kotest.core.spec.style.FunSpec
+import io.kotest.matchers.shouldBe
+import jakarta.persistence.EntityManager
+import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest
+import roomescape.util.ReservationTimeFixture
+import java.time.LocalTime
+
+@DataJpaTest
+class ReservationTimeRepositoryTest(
+        val entityManager: EntityManager,
+        val reservationTimeRepository: ReservationTimeRepository,
+) : FunSpec({
+
+    context("existsByStartAt") {
+        val startAt = LocalTime.of(10, 0)
+
+        beforeTest {
+            entityManager.persist(ReservationTimeFixture.create(startAt = startAt))
+            entityManager.flush()
+            entityManager.clear()
+        }
+
+        test("동일한 시간이 있으면 true 반환") {
+            reservationTimeRepository.existsByStartAt(startAt) shouldBe true
+        }
+
+        test("동일한 시간이 없으면 false 반환") {
+            reservationTimeRepository.existsByStartAt(startAt.plusSeconds(1)) shouldBe false
+        }
+    }
+})