Merge branch 'develop' into feat/72

mealkitary-api/src/docs/asciidoc/reservation.adoc

@@ -40,6 +40,20 @@ include::{snippets}/reservation-get/path-parameters.adoc[]
 
 include::{snippets}/reservation-get/http-response.adoc[]
 
+==== 대상 가게 예약 목록 조회
+
+가게 식별자를 기반으로 예약 목록을 조회합니다.
+
+===== 요청
+
+include::{snippets}/reservation-get-all/curl-request.adoc[]
+include::{snippets}/reservation-get-all/http-request.adoc[]
+include::{snippets}/reservation-get-all/request-parameters.adoc[]
+
+===== 응답
+
+include::{snippets}/reservation-get-all/http-response.adoc[]
+
 ==== 예약 결제
 
 미결제 상태의 예약에 대해 결제를 생성/승인합니다.

mealkitary-api/src/main/kotlin/com/mealkitary/reservation/web/GetReservationController.kt

@@ -1,10 +1,14 @@
 package com.mealkitary.reservation.web
 
+import com.mealkitary.common.utils.HttpResponseUtils
 import com.mealkitary.common.utils.UUIDUtils
 import com.mealkitary.reservation.application.port.input.GetReservationQuery
+import com.mealkitary.reservation.application.port.input.ReservationResponse
+import org.springframework.http.ResponseEntity
 import org.springframework.web.bind.annotation.GetMapping
 import org.springframework.web.bind.annotation.PathVariable
 import org.springframework.web.bind.annotation.RequestMapping
+import org.springframework.web.bind.annotation.RequestParam
 import org.springframework.web.bind.annotation.RestController
 
 @RestController
@@ -16,4 +20,12 @@ class GetReservationController(
     @GetMapping("/{reservationId}")
     fun getOneReservation(@PathVariable("reservationId") reservationId: String) =
         getReservationQuery.loadOneReservationById(UUIDUtils.fromString(reservationId))
+
+    @GetMapping
+    fun getAllReservation(@RequestParam("shopId") shopIdParam: Long?): ResponseEntity<List<ReservationResponse>> {
+        val shopId = requireNotNull(shopIdParam) { "가게 식별자는 필수입니다." }
+
+        return HttpResponseUtils
+            .mapToResponseEntity(emptiableList = getReservationQuery.loadAllReservationByShopId(shopId))
+    }
 }

mealkitary-api/src/test/kotlin/com/docs/reservation/GetReservationControllerDocsTest.kt

@@ -18,9 +18,12 @@ import org.springframework.restdocs.payload.PayloadDocumentation.fieldWithPath
 import org.springframework.restdocs.payload.PayloadDocumentation.responseFields
 import org.springframework.restdocs.request.RequestDocumentation.parameterWithName
 import org.springframework.restdocs.request.RequestDocumentation.pathParameters
+import org.springframework.restdocs.request.RequestDocumentation.requestParameters
 import org.springframework.test.web.servlet.result.MockMvcResultMatchers.content
 import org.springframework.test.web.servlet.result.MockMvcResultMatchers.status
+import java.time.LocalDate
 import java.time.LocalDateTime
+import java.time.LocalTime
 import java.util.UUID
 
 class GetReservationControllerDocsTest : RestDocsSupport() {
@@ -84,5 +87,67 @@ class GetReservationControllerDocsTest : RestDocsSupport() {
             )
     }
 
+    @Test
+    fun `api integration test - getAllReservation`() {
+        val reservationId = UUID.randomUUID()
+        val reserveAt = LocalDateTime.of(
+            LocalDate.of(2023, 6, 23), LocalTime.of(6, 30)
+        )
+        every { getReservationQuery.loadAllReservationByShopId(1L) } answers {
+            listOf(
+                ReservationResponse(
+                    reservationId,
+                    "집밥뚝딱 안양점",
+                    "부대찌개 외 1건",
+                    reserveAt,
+                    "PAID",
+                    listOf(
+                        ReservedProduct(
+                            1L,
+                            "부대찌개",
+                            20000,
+                            2
+                        ),
+                        ReservedProduct(
+                            2L,
+                            "김치찌개",
+                            20000,
+                            1
+                        )
+                    )
+                )
+            )
+        }
+
+        mvc.perform(RestDocumentationRequestBuilders.get("/reservations?shopId=1"))
+            .andExpect(status().isOk())
+            .andExpect(content().contentType(MediaType.APPLICATION_JSON))
+            .andDo(
+                document(
+                    "reservation-get-all",
+                    preprocessRequest(prettyPrint()),
+                    preprocessResponse(prettyPrint()),
+                    requestParameters(
+                        parameterWithName("shopId").description("예약 조회 대상 가게 식별자")
+                    ),
+                    responseFields(
+                        fieldWithPath("[].reservationId").type(JsonFieldType.STRING).description("예약 식별자"),
+                        fieldWithPath("[].shopName").type(JsonFieldType.STRING).description("예약 대상 가게의 이름"),
+                        fieldWithPath("[].description").type(JsonFieldType.STRING).description("예약 개요"),
+                        fieldWithPath("[].reserveAt").type(JsonFieldType.STRING)
+                            .description("예약 시간(yyyy-mm-ddThh:mm:ss)"),
+                        fieldWithPath("[].status").type(JsonFieldType.STRING).description("예약 상태"),
+                        fieldWithPath("[].reservedProduct.[].productId").type(JsonFieldType.NUMBER)
+                            .description("예약 상품 식별자"),
+                        fieldWithPath("[].reservedProduct.[].name").type(JsonFieldType.STRING)
+                            .description("예약 상품명"),
+                        fieldWithPath("[].reservedProduct.[].price").type(JsonFieldType.NUMBER)
+                            .description("예약 상품 가격"),
+                        fieldWithPath("[].reservedProduct.[].count").type(JsonFieldType.NUMBER).description("예약 수량")
+                    )
+                )
+            )
+    }
+
     override fun initController() = GetReservationController(getReservationQuery)
 }

mealkitary-api/src/test/kotlin/com/mealkitary/reservation/web/GetReservationControllerTest.kt

@@ -4,6 +4,7 @@ import com.mealkitary.WebIntegrationTestSupport
 import com.mealkitary.common.exception.EntityNotFoundException
 import com.mealkitary.reservation.application.port.input.ReservationResponse
 import com.mealkitary.reservation.application.port.input.ReservedProduct
+import io.kotest.inspectors.forAll
 import io.mockk.every
 import org.springframework.http.MediaType
 import org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get
@@ -66,17 +67,88 @@ class GetReservationControllerTest : WebIntegrationTestSupport() {
     }
 
     @Test
-    fun `api integration test - 예약 식별자가 UUID 형태가 아니라면 400 에러를 발생한다`() {
+    fun `api integration test - getAllReservation`() {
+        val reservationId = UUID.randomUUID()
+        val reserveAt = LocalDateTime.of(
+            LocalDate.of(2023, 6, 23), LocalTime.of(6, 30)
+        )
+        every { getReservationQuery.loadAllReservationByShopId(1L) } answers {
+            listOf(
+                ReservationResponse(
+                    reservationId,
+                    "집밥뚝딱 안양점",
+                    "부대찌개 외 1건",
+                    reserveAt,
+                    "PAID",
+                    listOf(
+                        ReservedProduct(
+                            1L,
+                            "부대찌개",
+                            20000,
+                            2
+                        ),
+                        ReservedProduct(
+                            2L,
+                            "김치찌개",
+                            20000,
+                            1
+                        )
+                    )
+                )
+            )
+        }
+
+        mvc.perform(get("/reservations?shopId=1"))
+            .andExpect(status().isOk())
+            .andExpect(content().contentType(MediaType.APPLICATION_JSON))
+            .andExpect(jsonPath("$.[0].reservationId").value(reservationId.toString()))
+            .andExpect(jsonPath("$.[0].shopName").value("집밥뚝딱 안양점"))
+            .andExpect(jsonPath("$.[0].reserveAt").value(reserveAt.format(DateTimeFormatter.ISO_DATE_TIME)))
+            .andExpect(jsonPath("$.[0].status").value("PAID"))
+            .andExpect(jsonPath("$.[0].reservedProduct[0].productId").value(1L))
+            .andExpect(jsonPath("$.[0].reservedProduct[0].name").value("부대찌개"))
+            .andExpect(jsonPath("$.[0].reservedProduct[0].price").value(20000))
+            .andExpect(jsonPath("$.[0].reservedProduct[0].count").value(2))
+            .andExpect(jsonPath("$.[0].reservedProduct[1].productId").value(2L))
+            .andExpect(jsonPath("$.[0].reservedProduct[1].name").value("김치찌개"))
+            .andExpect(jsonPath("$.[0].reservedProduct[1].price").value(20000))
+            .andExpect(jsonPath("$.[0].reservedProduct[1].count").value(1))
+    }
+
+    @Test
+    fun `api integration test - getAllReservation - 쿼리 파라미터에 가게 식별자가 누락된 경우 400 에러를 발생한다`() {
+        every { getReservationQuery.loadAllReservationByShopId(any()) } answers { emptyList() }
+
+        listOf("/reservations?shopId=", "/reservations", "/reservations?shopId")
+            .forAll {
+                mvc.perform(get(it))
+                    .andExpect(status().isBadRequest())
+                    .andExpect(content().contentType(MediaType.APPLICATION_JSON))
+                    .andExpect(jsonPath("$.status").value(400))
+                    .andExpect(jsonPath("$.message").value("가게 식별자는 필수입니다."))
+            }
+    }
+
+    @Test
+    fun `api integration test - getAllReservation - 해당 가게의 예약이 존재하지 않으면 204 NoContent를 반환한다`() {
+        every { getReservationQuery.loadAllReservationByShopId(any()) } answers { emptyList() }
+
+        mvc.perform(get("/reservations?shopId=1"))
+            .andExpect(status().isNoContent())
+    }
+
+    @Test
+    fun `api integration test - getOneReservation - 예약 식별자가 UUID 형태가 아니라면 400 에러를 발생한다`() {
         mvc.perform(
             get("/reservations/{reservationId}", "invalid-uuid-test")
         )
-            .andExpect(status().isBadRequest)
+            .andExpect(status().isBadRequest())
             .andExpect(jsonPath("$.status").value("400"))
             .andExpect(jsonPath("$.message").value("잘못된 UUID 형식입니다."))
     }
 
     @Test
-    fun `api integration test - 내부에서 EntityNotFound 에러가 발생하면 404 에러를 발생한다`() {
+    fun `api integration test - getOneReservation - 내부에서 EntityNotFound 에러가 발생하면 404 에러를 발생한다`() {
         every { getReservationQuery.loadOneReservationById(any()) }
             .throws(EntityNotFoundException("존재하지 않는 예약입니다."))
 

mealkitary-application/src/main/kotlin/com/mealkitary/reservation/application/port/input/GetReservationQuery.kt

@@ -5,4 +5,6 @@ import java.util.UUID
 interface GetReservationQuery {
 
     fun loadOneReservationById(reservationId: UUID): ReservationResponse
+
+    fun loadAllReservationByShopId(shopId: Long): List<ReservationResponse>
 }

mealkitary-application/src/main/kotlin/com/mealkitary/reservation/application/port/output/LoadReservationPort.kt

@@ -9,4 +9,6 @@ interface LoadReservationPort {
     fun loadOneReservationById(reservationId: UUID): Reservation
 
     fun queryOneReservationById(reservationId: UUID): ReservationResponse
+
+    fun queryAllReservationByShopId(shopId: Long): List<ReservationResponse>
 }

mealkitary-application/src/main/kotlin/com/mealkitary/reservation/application/service/GetReservationService.kt

@@ -1,6 +1,7 @@
 package com.mealkitary.reservation.application.service
 
 import com.mealkitary.reservation.application.port.input.GetReservationQuery
+import com.mealkitary.reservation.application.port.input.ReservationResponse
 import com.mealkitary.reservation.application.port.output.LoadReservationPort
 import org.springframework.stereotype.Service
 import org.springframework.transaction.annotation.Transactional
@@ -14,4 +15,7 @@ class GetReservationService(
 
     override fun loadOneReservationById(reservationId: UUID) =
         loadReservationPort.queryOneReservationById(reservationId)
+
+    override fun loadAllReservationByShopId(shopId: Long): List<ReservationResponse> =
+        loadReservationPort.queryAllReservationByShopId(shopId)
 }

mealkitary-application/src/test/kotlin/com/mealkitary/reservation/application/service/GetReservationServiceTest.kt

@@ -36,4 +36,38 @@ class GetReservationServiceTest : AnnotationSpec() {
         result.status shouldBe "PAID"
         result.reservedProduct.isEmpty().shouldBeTrue()
     }
+
+    @Test
+    fun `service unit test - 가게 식별자로 예약의 상세 정보 목록을 조회한다`() {
+        val reservationId = UUID.randomUUID()
+        every { loadReservationPort.queryAllReservationByShopId(any()) } answers {
+            listOf(
+                ReservationResponse(
+                    reservationId,
+                    "집밥뚝딱 안양점",
+                    "부대찌개 외 1건",
+                    LocalDateTime.now(),
+                    "PAID",
+                    emptyList()
+                ),
+                ReservationResponse(
+                    reservationId,
+                    "집밥뚝딱 안양점",
+                    "부대찌개 외 1건",
+                    LocalDateTime.now(),
+                    "PAID",
+                    emptyList()
+                )
+            )
+        }
+
+        val result = getReservationService.loadAllReservationByShopId(1L)
+
+        val resultReservation = result.get(0)
+        result.size shouldBe 2
+        resultReservation.reservationId shouldBe reservationId
+        resultReservation.shopName shouldBe "집밥뚝딱 안양점"
+        resultReservation.status shouldBe "PAID"
+        resultReservation.reservedProduct.isEmpty().shouldBeTrue()
+    }
 }

mealkitary-infrastructure/adapter-persistence-spring-data-jpa/src/main/kotlin/com/mealkitary/reservation/persistence/ReservationRepository.kt

@@ -12,4 +12,6 @@ interface ReservationRepository : JpaRepository<Reservation, UUID> {
     fun findOneWithShopById(reservationId: UUID): Optional<Reservation>
 
     fun existsReservationByShopId(shopId: Long): Boolean
+
+    fun findAllByShopId(shopId: Long): List<Reservation>
 }

mealkitary-infrastructure/adapter-persistence-spring-data-jpa/src/main/kotlin/com/mealkitary/reservation/persistence/SpringDataJpaReservationPersistenceAdapter.kt

@@ -47,7 +47,17 @@ class SpringDataJpaReservationPersistenceAdapter(
         val reservation = reservationRepository.findOneWithShopById(reservationId)
             .orElseThrow { throw EntityNotFoundException(NOT_FOUND_RESERVATION_MESSAGE) }
 
-        return ReservationResponse(
+        return mapToReservationResponse(reservation)
+    }
+
+    override fun queryAllReservationByShopId(shopId: Long): List<ReservationResponse> {
+        val reservations = reservationRepository.findAllByShopId(shopId)
+
+        return reservations.map { mapToReservationResponse(it) }
+    }
+
+    private fun mapToReservationResponse(reservation: Reservation) =
+        ReservationResponse(
             reservation.id,
             reservation.shop.title,
             reservation.buildDescription(),
@@ -62,5 +72,4 @@ class SpringDataJpaReservationPersistenceAdapter(
                 )
             }
         )
-    }
 }

mealkitary-infrastructure/adapter-persistence-spring-data-jpa/src/test/kotlin/com/mealkitary/reservation/persistence/SpringDataJpaReservationPersistenceAdapterTest.kt

@@ -9,6 +9,7 @@ import com.mealkitary.reservation.domain.reservation.ReservationStatus
 import com.mealkitary.shop.persistence.ShopRepository
 import data.ReservationTestData
 import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.inspectors.forAll
 import io.kotest.matchers.booleans.shouldBeTrue
 import io.kotest.matchers.shouldBe
 import io.kotest.matchers.throwable.shouldHaveMessage
@@ -91,6 +92,40 @@ class SpringDataJpaReservationPersistenceAdapterTest(
         result.description shouldBe "부대찌개 외 1건"
     }
 
+    @Test
+    fun `db integration test - 가게 식별자로 예약의 상세 정보 목록을 조회한다`() {
+        val reservation = ReservationTestData.defaultReservation()
+            .withReservationStatus(ReservationStatus.NOTPAID)
+            .withShop(shopRepository.findOneWithProductsById(1L).orElseThrow())
+            .build()
+        val saved = adapterUnderTest.saveOne(reservation)
+        em.flush()
+        em.clear()
+
+        val result = adapterUnderTest.queryAllReservationByShopId(1L)
+
+        val resultReservation = result.get(0)
+        result.size shouldBe 1
+        resultReservation.reservationId shouldBe saved
+        resultReservation.status shouldBe "NOTPAID"
+        resultReservation.shopName shouldBe "집밥뚝딱 철산점"
+        resultReservation.reservedProduct.size shouldBe 2
+        resultReservation.description shouldBe "부대찌개 외 1건"
+    }
+
+    @Test
+    fun `db integration test - 가게 식별자로 예약의 상세 목록을 조회할 때, 관련 데이터가 없으면 빈 리스트를 반환한다`() {
+        val unknownShopId = 12345L
+        val noReservationShopId = 1L
+        val source = listOf(unknownShopId, noReservationShopId)
+
+        source.forAll {
+            val result = adapterUnderTest.queryAllReservationByShopId(it)
+
+            result.isEmpty().shouldBeTrue()
+        }
+    }
+
     @Test
     fun `db integration test - 결제를 조회한다`() {
         val reservation = ReservationTestData.defaultReservation()