service/src/main/kotlin/com/sangdol/roomescape/reservation/business/ReservationService.kt

@@ -4,10 +4,17 @@ import com.sangdol.common.persistence.IDGenerator
 import com.sangdol.roomescape.common.types.CurrentUserContext
 import com.sangdol.roomescape.payment.business.PaymentService
 import com.sangdol.roomescape.payment.web.PaymentWithDetailResponse
+import com.sangdol.roomescape.reservation.dto.PendingReservationCreateRequest
+import com.sangdol.roomescape.reservation.dto.PendingReservationCreateResponse
+import com.sangdol.roomescape.reservation.dto.ReservationCancelRequest
+import com.sangdol.roomescape.reservation.dto.ReservationAdditionalResponse
+import com.sangdol.roomescape.reservation.dto.ReservationOverviewListResponse
+import com.sangdol.roomescape.reservation.mapper.toEntity
+import com.sangdol.roomescape.reservation.mapper.toOverviewResponse
+import com.sangdol.roomescape.reservation.mapper.toAdditionalResponse
 import com.sangdol.roomescape.reservation.exception.ReservationErrorCode
 import com.sangdol.roomescape.reservation.exception.ReservationException
 import com.sangdol.roomescape.reservation.infrastructure.persistence.*
-import com.sangdol.roomescape.reservation.web.*
 import com.sangdol.roomescape.schedule.business.ScheduleService
 import com.sangdol.roomescape.schedule.dto.ScheduleStateResponse
 import com.sangdol.roomescape.schedule.dto.ScheduleWithThemeAndStoreResponse
@@ -120,14 +127,14 @@ class ReservationService(
     }
 
     @Transactional(readOnly = true)
-    fun findDetailById(id: Long): ReservationDetailResponse {
+    fun findDetailById(id: Long): ReservationAdditionalResponse {
         log.info { "[findDetailById] 예약 상세 조회 시작: reservationId=${id}" }
 
         val reservation: ReservationEntity = findOrThrow(id)
         val user: UserContactResponse = userService.findContactById(reservation.userId)
         val paymentDetail: PaymentWithDetailResponse? = paymentService.findDetailByReservationId(id)
 
-        return reservation.toReservationDetailRetrieveResponse(
+        return reservation.toAdditionalResponse(
             user = user,
             payment = paymentDetail
         ).also {
@@ -165,7 +172,6 @@ class ReservationService(
             status = CanceledReservationStatus.COMPLETED
         ).also {
             canceledReservationRepository.save(it)
-
         }
     }
 }

service/src/main/kotlin/com/sangdol/roomescape/reservation/business/ReservationValidator.kt

@@ -4,7 +4,7 @@ import com.sangdol.common.utils.KoreaDateTime
 import com.sangdol.common.utils.toKoreaDateTime
 import com.sangdol.roomescape.reservation.exception.ReservationErrorCode
 import com.sangdol.roomescape.reservation.exception.ReservationException
-import com.sangdol.roomescape.reservation.web.PendingReservationCreateRequest
+import com.sangdol.roomescape.reservation.dto.PendingReservationCreateRequest
 import com.sangdol.roomescape.schedule.dto.ScheduleStateResponse
 import com.sangdol.roomescape.schedule.infrastructure.persistence.ScheduleStatus
 import com.sangdol.roomescape.theme.dto.ThemeInfoResponse

service/src/main/kotlin/com/sangdol/roomescape/reservation/docs/ReservationAPI.kt

@@ -4,7 +4,11 @@ import com.sangdol.common.types.web.CommonApiResponse
 import com.sangdol.roomescape.auth.web.support.User
 import com.sangdol.roomescape.auth.web.support.UserOnly
 import com.sangdol.roomescape.common.types.CurrentUserContext
-import com.sangdol.roomescape.reservation.web.*
+import com.sangdol.roomescape.reservation.dto.PendingReservationCreateRequest
+import com.sangdol.roomescape.reservation.dto.PendingReservationCreateResponse
+import com.sangdol.roomescape.reservation.dto.ReservationCancelRequest
+import com.sangdol.roomescape.reservation.dto.ReservationAdditionalResponse
+import com.sangdol.roomescape.reservation.dto.ReservationOverviewListResponse
 import io.swagger.v3.oas.annotations.Operation
 import io.swagger.v3.oas.annotations.responses.ApiResponse
 import io.swagger.v3.oas.annotations.responses.ApiResponses
@@ -47,5 +51,5 @@ interface ReservationAPI {
     @ApiResponses(ApiResponse(responseCode = "200", useReturnTypeSchema = true))
     fun findDetailById(
         @PathVariable("id") id: Long
-    ): ResponseEntity<CommonApiResponse<ReservationDetailResponse>>
+    ): ResponseEntity<CommonApiResponse<ReservationAdditionalResponse>>
 }

service/src/main/kotlin/com/sangdol/roomescape/reservation/dto/ReservationFindDTO.kt

@@ -0,0 +1,37 @@
+package com.sangdol.roomescape.reservation.dto
+
+import com.sangdol.roomescape.payment.web.PaymentWithDetailResponse
+import com.sangdol.roomescape.reservation.infrastructure.persistence.ReservationStatus
+import com.sangdol.roomescape.user.dto.UserContactResponse
+import java.time.Instant
+import java.time.LocalDate
+import java.time.LocalTime
+
+data class ReservationOverviewResponse(
+    val id: Long,
+    val storeName: String,
+    val themeName: String,
+    val date: LocalDate,
+    val startFrom: LocalTime,
+    val endAt: LocalTime,
+    val status: ReservationStatus
+)
+
+data class ReservationAdditionalResponse(
+    val id: Long,
+    val reserver: ReserverInfo,
+    val user: UserContactResponse,
+    val applicationDateTime: Instant,
+    val payment: PaymentWithDetailResponse?,
+)
+
+data class ReserverInfo(
+    val name: String,
+    val contact: String,
+    val participantCount: Short,
+    val requirement: String
+)
+
+data class ReservationOverviewListResponse(
+    val reservations: List<ReservationOverviewResponse>
+)

service/src/main/kotlin/com/sangdol/roomescape/reservation/dto/ReservationWriteDTO.kt

@@ -0,0 +1,21 @@
+package com.sangdol.roomescape.reservation.dto
+
+import jakarta.validation.constraints.NotEmpty
+
+data class ReservationCancelRequest(
+    val cancelReason: String
+)
+
+data class PendingReservationCreateRequest(
+    val scheduleId: Long,
+    @NotEmpty
+    val reserverName: String,
+    @NotEmpty
+    val reserverContact: String,
+    val participantCount: Short,
+    val requirement: String
+)
+
+data class PendingReservationCreateResponse(
+    val id: Long
+)

service/src/main/kotlin/com/sangdol/roomescape/reservation/mapper/ReservationMappingExtensions.kt

@@ -1,24 +1,16 @@
-package com.sangdol.roomescape.reservation.web
+package com.sangdol.roomescape.reservation.mapper
 
 import com.sangdol.roomescape.payment.web.PaymentWithDetailResponse
+import com.sangdol.roomescape.reservation.dto.PendingReservationCreateRequest
+import com.sangdol.roomescape.reservation.dto.ReservationAdditionalResponse
+import com.sangdol.roomescape.reservation.dto.ReservationOverviewResponse
+import com.sangdol.roomescape.reservation.dto.ReserverInfo
 import com.sangdol.roomescape.reservation.infrastructure.persistence.ReservationEntity
 import com.sangdol.roomescape.reservation.infrastructure.persistence.ReservationStatus
 import com.sangdol.roomescape.user.dto.UserContactResponse
-import jakarta.validation.constraints.NotEmpty
-import java.time.Instant
 import java.time.LocalDate
 import java.time.LocalTime
 
-data class PendingReservationCreateRequest(
-    val scheduleId: Long,
-    @NotEmpty
-    val reserverName: String,
-    @NotEmpty
-    val reserverContact: String,
-    val participantCount: Short,
-    val requirement: String
-)
-
 fun PendingReservationCreateRequest.toEntity(id: Long, userId: Long) = ReservationEntity(
     id = id,
     userId = userId,
@@ -30,20 +22,6 @@ fun PendingReservationCreateRequest.toEntity(id: Long, userId: Long) = Reservati
     status = ReservationStatus.PENDING
 )
 
-data class PendingReservationCreateResponse(
-    val id: Long
-)
-
-data class ReservationOverviewResponse(
-    val id: Long,
-    val storeName: String,
-    val themeName: String,
-    val date: LocalDate,
-    val startFrom: LocalTime,
-    val endAt: LocalTime,
-    val status: ReservationStatus
-)
-
 fun ReservationEntity.toOverviewResponse(
     scheduleDate: LocalDate,
     scheduleStartFrom: LocalTime,
@@ -60,37 +38,11 @@ fun ReservationEntity.toOverviewResponse(
     status = this.status
 )
 
-data class ReservationOverviewListResponse(
-    val reservations: List<ReservationOverviewResponse>
-)
-
-data class ReserverInfo(
-    val name: String,
-    val contact: String,
-    val participantCount: Short,
-    val requirement: String
-)
-
-fun ReservationEntity.toReserverInfo() = ReserverInfo(
-    name = this.reserverName,
-    contact = this.reserverContact,
-    participantCount = this.participantCount,
-    requirement = this.requirement
-)
-
-data class ReservationDetailResponse(
-    val id: Long,
-    val reserver: ReserverInfo,
-    val user: UserContactResponse,
-    val applicationDateTime: Instant,
-    val payment: PaymentWithDetailResponse?,
-)
-
-fun ReservationEntity.toReservationDetailRetrieveResponse(
+fun ReservationEntity.toAdditionalResponse(
     user: UserContactResponse,
     payment: PaymentWithDetailResponse?,
-): ReservationDetailResponse {
-    return ReservationDetailResponse(
+): ReservationAdditionalResponse {
+    return ReservationAdditionalResponse(
         id = this.id,
         reserver = this.toReserverInfo(),
         user = user,
@@ -99,6 +51,9 @@ fun ReservationEntity.toReservationDetailRetrieveResponse(
     )
 }
 
-data class ReservationCancelRequest(
-    val cancelReason: String
+private fun ReservationEntity.toReserverInfo() = ReserverInfo(
+    name = this.reserverName,
+    contact = this.reserverContact,
+    participantCount = this.participantCount,
+    requirement = this.requirement
 )

service/src/main/kotlin/com/sangdol/roomescape/reservation/web/ReservationController.kt

@@ -5,6 +5,11 @@ import com.sangdol.roomescape.auth.web.support.User
 import com.sangdol.roomescape.common.types.CurrentUserContext
 import com.sangdol.roomescape.reservation.business.ReservationService
 import com.sangdol.roomescape.reservation.docs.ReservationAPI
+import com.sangdol.roomescape.reservation.dto.PendingReservationCreateRequest
+import com.sangdol.roomescape.reservation.dto.PendingReservationCreateResponse
+import com.sangdol.roomescape.reservation.dto.ReservationCancelRequest
+import com.sangdol.roomescape.reservation.dto.ReservationAdditionalResponse
+import com.sangdol.roomescape.reservation.dto.ReservationOverviewListResponse
 import jakarta.validation.Valid
 import org.springframework.http.ResponseEntity
 import org.springframework.web.bind.annotation.*
@@ -56,7 +61,7 @@ class ReservationController(
     @GetMapping("/{id}/detail")
     override fun findDetailById(
         @PathVariable("id") id: Long
-    ): ResponseEntity<CommonApiResponse<ReservationDetailResponse>> {
+    ): ResponseEntity<CommonApiResponse<ReservationAdditionalResponse>> {
         val response = reservationService.findDetailById(id)
 
         return ResponseEntity.ok(CommonApiResponse(response))

service/src/test/kotlin/com/sangdol/roomescape/payment/PaymentAPITest.kt

@@ -1,378 +1,378 @@
-package com.sangdol.roomescape.payment
-
-import com.ninjasquad.springmockk.MockkBean
-import com.sangdol.common.types.web.HttpStatus
-import com.sangdol.roomescape.auth.exception.AuthErrorCode
-import com.sangdol.roomescape.payment.business.PaymentService
-import com.sangdol.roomescape.payment.exception.PaymentErrorCode
-import com.sangdol.roomescape.payment.infrastructure.client.CardDetail
-import com.sangdol.roomescape.payment.infrastructure.client.EasyPayDetail
-import com.sangdol.roomescape.payment.infrastructure.client.TosspayClient
-import com.sangdol.roomescape.payment.infrastructure.client.TransferDetail
-import com.sangdol.roomescape.payment.infrastructure.common.*
-import com.sangdol.roomescape.payment.infrastructure.persistence.*
-import com.sangdol.roomescape.payment.web.PaymentConfirmRequest
-import com.sangdol.roomescape.payment.web.PaymentCreateResponse
-import com.sangdol.roomescape.supports.*
-import io.kotest.matchers.shouldBe
-import io.mockk.every
-import org.springframework.data.repository.findByIdOrNull
-import org.springframework.http.HttpMethod
-
-class PaymentAPITest(
-    @MockkBean
-    private val tosspayClient: TosspayClient,
-    private val paymentService: PaymentService,
-    private val paymentRepository: PaymentRepository,
-    private val paymentDetailRepository: PaymentDetailRepository,
-    private val canceledPaymentRepository: CanceledPaymentRepository
-) : FunSpecSpringbootTest() {
-    init {
-        context("결제를 승인한다.") {
-            context("권한이 없으면 접근할 수 없다.") {
-                val endpoint = "/payments?reservationId=$INVALID_PK"
-
-                test("비회원") {
-                    runExceptionTest(
-                        method = HttpMethod.POST,
-                        endpoint = endpoint,
-                        expectedErrorCode = AuthErrorCode.TOKEN_NOT_FOUND
-                    )
-                }
-
-                test("관리자") {
-                    runExceptionTest(
-                        token = testAuthUtil.defaultHqAdminLogin().second,
-                        method = HttpMethod.POST,
-                        endpoint = endpoint,
-                        expectedErrorCode = AuthErrorCode.ACCESS_DENIED
-                    )
-                }
-            }
-
-            val amount = 100_000
-            context("간편결제 + 카드로 ${amount}원을 결제한다.") {
-                context("일시불") {
-                    test("토스페이 + 토스뱅크카드(신용)") {
-                        runConfirmTest(
-                            amount = amount,
-                            cardDetail = PaymentFixture.cardDetail(
-                                amount = amount,
-                                issuerCode = CardIssuerCode.TOSS_BANK,
-                                cardType = CardType.CREDIT,
-                            ),
-                            easyPayDetail = PaymentFixture.easypayDetail(
-                                amount = 0,
-                                provider = EasyPayCompanyCode.TOSSPAY
-                            )
-                        )
-                    }
-
-                    test("삼성페이 + 삼성카드(법인)") {
-                        runConfirmTest(
-                            amount = amount,
-                            cardDetail = PaymentFixture.cardDetail(
-                                amount = amount,
-                                issuerCode = CardIssuerCode.SAMSUNG,
-                                cardType = CardType.CREDIT,
-                                ownerType = CardOwnerType.CORPORATE
-                            ),
-                            easyPayDetail = PaymentFixture.easypayDetail(
-                                amount = 0,
-                                provider = EasyPayCompanyCode.SAMSUNGPAY
-                            )
-                        )
-                    }
-                }
-
-                context("할부") {
-                    val installmentPlanMonths = 12
-                    test("네이버페이 + 신한카드 / 12개월") {
-                        runConfirmTest(
-                            amount = amount,
-                            cardDetail = PaymentFixture.cardDetail(
-                                amount = amount,
-                                issuerCode = CardIssuerCode.SHINHAN,
-                                installmentPlanMonths = installmentPlanMonths
-                            ),
-                            easyPayDetail = PaymentFixture.easypayDetail(
-                                amount = 0,
-                                provider = EasyPayCompanyCode.NAVERPAY
-                            )
-                        )
-                    }
-                }
-
-                context("간편결제사 포인트 일부 사용") {
-                    val point = (amount * 0.1).toInt()
-                    test("토스페이 + 국민카드(체크) / 일시불 / $point 포인트 사용") {
-                        runConfirmTest(
-                            amount = amount,
-                            cardDetail = PaymentFixture.cardDetail(
-                                amount = (amount - point),
-                                issuerCode = CardIssuerCode.KOOKMIN,
-                                cardType = CardType.CHECK
-                            ),
-                            easyPayDetail = PaymentFixture.easypayDetail(
-                                amount = 0,
-                                provider = EasyPayCompanyCode.TOSSPAY,
-                                discountAmount = point
-                            )
-                        )
-                    }
-                }
-            }
-
-            context("간편결제사의 선불 충전금액으로 ${amount}원을 결제한다.") {
-                test("토스페이 + 토스페이머니 / 전액") {
-                    runConfirmTest(
-                        easyPayDetail = PaymentFixture.easypayDetail(
-                            amount = amount,
-                            provider = EasyPayCompanyCode.TOSSPAY
-                        )
-                    )
-                }
-
-                val point = (amount * 0.05).toInt()
-
-                test("카카오페이 + 카카오페이머니 / $point 사용") {
-                    runConfirmTest(
-                        easyPayDetail = PaymentFixture.easypayDetail(
-                            amount = (amount - point),
-                            provider = EasyPayCompanyCode.KAKAOPAY,
-                            discountAmount = point
-                        )
-                    )
-                }
-            }
-
-            context("계좌이체로 결제한다.") {
-                test("토스뱅크") {
-                    runConfirmTest(
-                        transferDetail = PaymentFixture.transferDetail(bankCode = BankCode.TOSS_BANK)
-                    )
-                }
-            }
-
-            context("지원하지 않는 결제수단으로 요청시 실패한다.") {
-                val supportedMethod = listOf(
-                    PaymentMethod.CARD,
-                    PaymentMethod.EASY_PAY,
-                    PaymentMethod.TRANSFER,
-                )
-
-                PaymentMethod.entries.filter { it !in supportedMethod }.forEach {
-                    test("결제 수단: ${it.koreanName}") {
-                        val (user, token) = testAuthUtil.defaultUserLogin()
-                        val reservation = dummyInitializer.createConfirmReservation(user = user)
-
-                        val request = PaymentFixture.confirmRequest
-
-                        every {
-                            tosspayClient.confirm(request.paymentKey, request.orderId, request.amount)
-                        } returns PaymentFixture.confirmResponse(
-                            paymentKey = request.paymentKey,
-                            amount = request.amount,
-                            method = it,
-                            cardDetail = null,
-                            easyPayDetail = null,
-                            transferDetail = null,
-                        )
-
-                        runExceptionTest(
-                            token = token,
-                            method = HttpMethod.POST,
-                            endpoint = "/payments?reservationId=${reservation.id}",
-                            requestBody = PaymentFixture.confirmRequest,
-                            expectedErrorCode = PaymentErrorCode.NOT_SUPPORTED_PAYMENT_TYPE
-                        )
-                    }
-                }
-            }
-        }
-
-        context("결제를 취소한다.") {
-            context("권한이 없으면 접근할 수 없다.") {
-                val endpoint = "/payments/cancel"
-
-                test("비회원") {
-                    runExceptionTest(
-                        method = HttpMethod.POST,
-                        endpoint = endpoint,
-                        requestBody = PaymentFixture.cancelRequest,
-                        expectedErrorCode = AuthErrorCode.MEMBER_NOT_FOUND
-                    )
-                }
-
-                test("관리자") {
-                    runExceptionTest(
-                        token = testAuthUtil.defaultHqAdminLogin().second,
-                        method = HttpMethod.POST,
-                        endpoint = endpoint,
-                        requestBody = PaymentFixture.cancelRequest,
-                        expectedErrorCode = AuthErrorCode.MEMBER_NOT_FOUND
-                    )
-                }
-            }
-
-            test("정상 취소") {
-                val (user, token) = testAuthUtil.defaultUserLogin()
-                val reservation = dummyInitializer.createConfirmReservation(user = user)
-                val confirmRequest = PaymentFixture.confirmRequest
-
-                val paymentCreateResponse = createPayment(
-                    request = confirmRequest,
-                    reservationId = reservation.id
-                )
-
-                every {
-                    tosspayClient.cancel(
-                        confirmRequest.paymentKey,
-                        confirmRequest.amount,
-                        cancelReason = "cancelReason"
-                    )
-                } returns PaymentFixture.cancelResponse(confirmRequest.amount)
-
-                val requestBody = PaymentFixture.cancelRequest.copy(reservationId = reservation.id)
-
-                runTest(
-                    token = token,
-                    using = {
-                        body(requestBody)
-                    },
-                    on = {
-                        post("/payments/cancel")
-                    },
-                    expect = {
-                        statusCode(HttpStatus.OK.value())
-                    }
-                ).also {
-                    val payment = paymentRepository.findByIdOrNull(paymentCreateResponse.paymentId)
-                        ?: throw AssertionError("Unexpected Exception Occurred.")
-                    val canceledPayment =
-                        canceledPaymentRepository.findByPaymentId(paymentCreateResponse.paymentId)
-                            ?: throw AssertionError("Unexpected Exception Occurred.")
-
-                    payment.status shouldBe PaymentStatus.CANCELED
-                    canceledPayment.paymentId shouldBe payment.id
-                    canceledPayment.cancelAmount shouldBe payment.totalAmount
-                }
-            }
-
-            test("예약에 대한 결제 정보가 없으면 실패한다.") {
-                val (user, token) = testAuthUtil.defaultUserLogin()
-                val reservation = dummyInitializer.createConfirmReservation(user = user)
-
-                runExceptionTest(
-                    token = token,
-                    method = HttpMethod.POST,
-                    endpoint = "/payments/cancel",
-                    requestBody = PaymentFixture.cancelRequest.copy(reservationId = reservation.id),
-                    expectedErrorCode = PaymentErrorCode.PAYMENT_NOT_FOUND
-                )
-            }
-        }
-    }
-
-    private fun createPayment(
-        request: PaymentConfirmRequest,
-        reservationId: Long,
-    ): PaymentCreateResponse {
-        every {
-            tosspayClient.confirm(request.paymentKey, request.orderId, request.amount)
-        } returns PaymentFixture.confirmResponse(
-            request.paymentKey,
-            request.amount,
-            method = PaymentMethod.CARD,
-            cardDetail = PaymentFixture.cardDetail(request.amount),
-            easyPayDetail = null,
-            transferDetail = null,
-        )
-
-        return paymentService.confirm(reservationId, request)
-    }
-
-    fun runConfirmTest(
-        cardDetail: CardDetail? = null,
-        easyPayDetail: EasyPayDetail? = null,
-        transferDetail: TransferDetail? = null,
-        paymentKey: String = "paymentKey",
-        amount: Int = 10000,
-    ) {
-        val (user, token) = testAuthUtil.defaultUserLogin()
-        val reservation = dummyInitializer.createConfirmReservation(user = user)
-        val request = PaymentFixture.confirmRequest.copy(paymentKey = paymentKey, amount = amount)
-
-        val method = if (easyPayDetail != null) {
-            PaymentMethod.EASY_PAY
-        } else if (cardDetail != null) {
-            PaymentMethod.CARD
-        } else if (transferDetail != null) {
-            PaymentMethod.TRANSFER
-        } else {
-            throw AssertionError("결제타입 확인 필요.")
-        }
-
-        val clientResponse = PaymentFixture.confirmResponse(
-            paymentKey, amount, method, cardDetail, easyPayDetail, transferDetail
-        )
-
-        every {
-            tosspayClient.confirm(request.paymentKey, request.orderId, request.amount)
-        } returns clientResponse
-
-        runTest(
-            token = token,
-            using = {
-                body(request)
-            },
-            on = {
-                post("/payments?reservationId=${reservation.id}")
-            },
-            expect = {
-                statusCode(HttpStatus.OK.value())
-            }
-        ).also {
-            val createdPayment = paymentRepository.findByIdOrNull(it.extract().path("data.paymentId"))
-                ?: throw AssertionError("Unexpected Exception Occurred.")
-            val createdPaymentDetail =
-                paymentDetailRepository.findByIdOrNull(it.extract().path("data.detailId"))
-                    ?: throw AssertionError("Unexpected Exception Occurred.")
-
-            createdPayment.status shouldBe clientResponse.status
-            createdPayment.method shouldBe clientResponse.method
-            createdPayment.reservationId shouldBe reservation.id
-
-            when (createdPaymentDetail) {
-                is PaymentCardDetailEntity -> {
-                    createdPaymentDetail.issuerCode shouldBe clientResponse.card!!.issuerCode
-                    createdPaymentDetail.cardType shouldBe clientResponse.card.cardType
-                    createdPaymentDetail.cardNumber shouldBe clientResponse.card.number
-                    createdPaymentDetail.suppliedAmount shouldBe clientResponse.suppliedAmount
-                    createdPaymentDetail.vat shouldBe clientResponse.vat
-                    createdPaymentDetail.amount shouldBe (clientResponse.totalAmount - (clientResponse.easyPay?.discountAmount
-                        ?: 0))
-                    clientResponse.easyPay?.let { easypay ->
-                        createdPaymentDetail.easypayProviderCode shouldBe easypay.provider
-                        createdPaymentDetail.easypayDiscountAmount shouldBe easypay.discountAmount
-                    }
-                }
-
-                is PaymentBankTransferDetailEntity -> {
-                    createdPaymentDetail.suppliedAmount shouldBe clientResponse.suppliedAmount
-                    createdPaymentDetail.vat shouldBe clientResponse.vat
-                    createdPaymentDetail.bankCode shouldBe clientResponse.transfer!!.bankCode
-                    createdPaymentDetail.settlementStatus shouldBe clientResponse.transfer.settlementStatus
-                }
-
-                is PaymentEasypayPrepaidDetailEntity -> {
-                    createdPaymentDetail.suppliedAmount shouldBe clientResponse.suppliedAmount
-                    createdPaymentDetail.vat shouldBe clientResponse.vat
-                    createdPaymentDetail.easypayProviderCode shouldBe clientResponse.easyPay!!.provider
-                    createdPaymentDetail.amount shouldBe clientResponse.easyPay.amount
-                    createdPaymentDetail.discountAmount shouldBe clientResponse.easyPay.discountAmount
-                }
-            }
-        }
-    }
-}
+//package com.sangdol.roomescape.payment
+//
+//import com.ninjasquad.springmockk.MockkBean
+//import com.sangdol.common.types.web.HttpStatus
+//import com.sangdol.roomescape.auth.exception.AuthErrorCode
+//import com.sangdol.roomescape.payment.business.PaymentService
+//import com.sangdol.roomescape.payment.exception.PaymentErrorCode
+//import com.sangdol.roomescape.payment.infrastructure.client.CardDetail
+//import com.sangdol.roomescape.payment.infrastructure.client.EasyPayDetail
+//import com.sangdol.roomescape.payment.infrastructure.client.TosspayClient
+//import com.sangdol.roomescape.payment.infrastructure.client.TransferDetail
+//import com.sangdol.roomescape.payment.infrastructure.common.*
+//import com.sangdol.roomescape.payment.infrastructure.persistence.*
+//import com.sangdol.roomescape.payment.web.PaymentConfirmRequest
+//import com.sangdol.roomescape.payment.web.PaymentCreateResponse
+//import com.sangdol.roomescape.supports.*
+//import io.kotest.matchers.shouldBe
+//import io.mockk.every
+//import org.springframework.data.repository.findByIdOrNull
+//import org.springframework.http.HttpMethod
+//
+//class PaymentAPITest(
+//    @MockkBean
+//    private val tosspayClient: TosspayClient,
+//    private val paymentService: PaymentService,
+//    private val paymentRepository: PaymentRepository,
+//    private val paymentDetailRepository: PaymentDetailRepository,
+//    private val canceledPaymentRepository: CanceledPaymentRepository
+//) : FunSpecSpringbootTest() {
+//    init {
+//        context("결제를 승인한다.") {
+//            context("권한이 없으면 접근할 수 없다.") {
+//                val endpoint = "/payments?reservationId=$INVALID_PK"
+//
+//                test("비회원") {
+//                    runExceptionTest(
+//                        method = HttpMethod.POST,
+//                        endpoint = endpoint,
+//                        expectedErrorCode = AuthErrorCode.TOKEN_NOT_FOUND
+//                    )
+//                }
+//
+//                test("관리자") {
+//                    runExceptionTest(
+//                        token = testAuthUtil.defaultHqAdminLogin().second,
+//                        method = HttpMethod.POST,
+//                        endpoint = endpoint,
+//                        expectedErrorCode = AuthErrorCode.ACCESS_DENIED
+//                    )
+//                }
+//            }
+//
+//            val amount = 100_000
+//            context("간편결제 + 카드로 ${amount}원을 결제한다.") {
+//                context("일시불") {
+//                    test("토스페이 + 토스뱅크카드(신용)") {
+//                        runConfirmTest(
+//                            amount = amount,
+//                            cardDetail = PaymentFixture.cardDetail(
+//                                amount = amount,
+//                                issuerCode = CardIssuerCode.TOSS_BANK,
+//                                cardType = CardType.CREDIT,
+//                            ),
+//                            easyPayDetail = PaymentFixture.easypayDetail(
+//                                amount = 0,
+//                                provider = EasyPayCompanyCode.TOSSPAY
+//                            )
+//                        )
+//                    }
+//
+//                    test("삼성페이 + 삼성카드(법인)") {
+//                        runConfirmTest(
+//                            amount = amount,
+//                            cardDetail = PaymentFixture.cardDetail(
+//                                amount = amount,
+//                                issuerCode = CardIssuerCode.SAMSUNG,
+//                                cardType = CardType.CREDIT,
+//                                ownerType = CardOwnerType.CORPORATE
+//                            ),
+//                            easyPayDetail = PaymentFixture.easypayDetail(
+//                                amount = 0,
+//                                provider = EasyPayCompanyCode.SAMSUNGPAY
+//                            )
+//                        )
+//                    }
+//                }
+//
+//                context("할부") {
+//                    val installmentPlanMonths = 12
+//                    test("네이버페이 + 신한카드 / 12개월") {
+//                        runConfirmTest(
+//                            amount = amount,
+//                            cardDetail = PaymentFixture.cardDetail(
+//                                amount = amount,
+//                                issuerCode = CardIssuerCode.SHINHAN,
+//                                installmentPlanMonths = installmentPlanMonths
+//                            ),
+//                            easyPayDetail = PaymentFixture.easypayDetail(
+//                                amount = 0,
+//                                provider = EasyPayCompanyCode.NAVERPAY
+//                            )
+//                        )
+//                    }
+//                }
+//
+//                context("간편결제사 포인트 일부 사용") {
+//                    val point = (amount * 0.1).toInt()
+//                    test("토스페이 + 국민카드(체크) / 일시불 / $point 포인트 사용") {
+//                        runConfirmTest(
+//                            amount = amount,
+//                            cardDetail = PaymentFixture.cardDetail(
+//                                amount = (amount - point),
+//                                issuerCode = CardIssuerCode.KOOKMIN,
+//                                cardType = CardType.CHECK
+//                            ),
+//                            easyPayDetail = PaymentFixture.easypayDetail(
+//                                amount = 0,
+//                                provider = EasyPayCompanyCode.TOSSPAY,
+//                                discountAmount = point
+//                            )
+//                        )
+//                    }
+//                }
+//            }
+//
+//            context("간편결제사의 선불 충전금액으로 ${amount}원을 결제한다.") {
+//                test("토스페이 + 토스페이머니 / 전액") {
+//                    runConfirmTest(
+//                        easyPayDetail = PaymentFixture.easypayDetail(
+//                            amount = amount,
+//                            provider = EasyPayCompanyCode.TOSSPAY
+//                        )
+//                    )
+//                }
+//
+//                val point = (amount * 0.05).toInt()
+//
+//                test("카카오페이 + 카카오페이머니 / $point 사용") {
+//                    runConfirmTest(
+//                        easyPayDetail = PaymentFixture.easypayDetail(
+//                            amount = (amount - point),
+//                            provider = EasyPayCompanyCode.KAKAOPAY,
+//                            discountAmount = point
+//                        )
+//                    )
+//                }
+//            }
+//
+//            context("계좌이체로 결제한다.") {
+//                test("토스뱅크") {
+//                    runConfirmTest(
+//                        transferDetail = PaymentFixture.transferDetail(bankCode = BankCode.TOSS_BANK)
+//                    )
+//                }
+//            }
+//
+//            context("지원하지 않는 결제수단으로 요청시 실패한다.") {
+//                val supportedMethod = listOf(
+//                    PaymentMethod.CARD,
+//                    PaymentMethod.EASY_PAY,
+//                    PaymentMethod.TRANSFER,
+//                )
+//
+//                PaymentMethod.entries.filter { it !in supportedMethod }.forEach {
+//                    test("결제 수단: ${it.koreanName}") {
+//                        val (user, token) = testAuthUtil.defaultUserLogin()
+//                        val reservation = dummyInitializer.createConfirmReservation(user = user)
+//
+//                        val request = PaymentFixture.confirmRequest
+//
+//                        every {
+//                            tosspayClient.confirm(request.paymentKey, request.orderId, request.amount)
+//                        } returns PaymentFixture.confirmResponse(
+//                            paymentKey = request.paymentKey,
+//                            amount = request.amount,
+//                            method = it,
+//                            cardDetail = null,
+//                            easyPayDetail = null,
+//                            transferDetail = null,
+//                        )
+//
+//                        runExceptionTest(
+//                            token = token,
+//                            method = HttpMethod.POST,
+//                            endpoint = "/payments?reservationId=${reservation.id}",
+//                            requestBody = PaymentFixture.confirmRequest,
+//                            expectedErrorCode = PaymentErrorCode.NOT_SUPPORTED_PAYMENT_TYPE
+//                        )
+//                    }
+//                }
+//            }
+//        }
+//
+//        context("결제를 취소한다.") {
+//            context("권한이 없으면 접근할 수 없다.") {
+//                val endpoint = "/payments/cancel"
+//
+//                test("비회원") {
+//                    runExceptionTest(
+//                        method = HttpMethod.POST,
+//                        endpoint = endpoint,
+//                        requestBody = PaymentFixture.cancelRequest,
+//                        expectedErrorCode = AuthErrorCode.MEMBER_NOT_FOUND
+//                    )
+//                }
+//
+//                test("관리자") {
+//                    runExceptionTest(
+//                        token = testAuthUtil.defaultHqAdminLogin().second,
+//                        method = HttpMethod.POST,
+//                        endpoint = endpoint,
+//                        requestBody = PaymentFixture.cancelRequest,
+//                        expectedErrorCode = AuthErrorCode.MEMBER_NOT_FOUND
+//                    )
+//                }
+//            }
+//
+//            test("정상 취소") {
+//                val (user, token) = testAuthUtil.defaultUserLogin()
+//                val reservation = dummyInitializer.createConfirmReservation(user = user)
+//                val confirmRequest = PaymentFixture.confirmRequest
+//
+//                val paymentCreateResponse = createPayment(
+//                    request = confirmRequest,
+//                    reservationId = reservation.id
+//                )
+//
+//                every {
+//                    tosspayClient.cancel(
+//                        confirmRequest.paymentKey,
+//                        confirmRequest.amount,
+//                        cancelReason = "cancelReason"
+//                    )
+//                } returns PaymentFixture.cancelResponse(confirmRequest.amount)
+//
+//                val requestBody = PaymentFixture.cancelRequest.copy(reservationId = reservation.id)
+//
+//                runTest(
+//                    token = token,
+//                    using = {
+//                        body(requestBody)
+//                    },
+//                    on = {
+//                        post("/payments/cancel")
+//                    },
+//                    expect = {
+//                        statusCode(HttpStatus.OK.value())
+//                    }
+//                ).also {
+//                    val payment = paymentRepository.findByIdOrNull(paymentCreateResponse.paymentId)
+//                        ?: throw AssertionError("Unexpected Exception Occurred.")
+//                    val canceledPayment =
+//                        canceledPaymentRepository.findByPaymentId(paymentCreateResponse.paymentId)
+//                            ?: throw AssertionError("Unexpected Exception Occurred.")
+//
+//                    payment.status shouldBe PaymentStatus.CANCELED
+//                    canceledPayment.paymentId shouldBe payment.id
+//                    canceledPayment.cancelAmount shouldBe payment.totalAmount
+//                }
+//            }
+//
+//            test("예약에 대한 결제 정보가 없으면 실패한다.") {
+//                val (user, token) = testAuthUtil.defaultUserLogin()
+//                val reservation = dummyInitializer.createConfirmReservation(user = user)
+//
+//                runExceptionTest(
+//                    token = token,
+//                    method = HttpMethod.POST,
+//                    endpoint = "/payments/cancel",
+//                    requestBody = PaymentFixture.cancelRequest.copy(reservationId = reservation.id),
+//                    expectedErrorCode = PaymentErrorCode.PAYMENT_NOT_FOUND
+//                )
+//            }
+//        }
+//    }
+//
+//    private fun createPayment(
+//        request: PaymentConfirmRequest,
+//        reservationId: Long,
+//    ): PaymentCreateResponse {
+//        every {
+//            tosspayClient.confirm(request.paymentKey, request.orderId, request.amount)
+//        } returns PaymentFixture.confirmResponse(
+//            request.paymentKey,
+//            request.amount,
+//            method = PaymentMethod.CARD,
+//            cardDetail = PaymentFixture.cardDetail(request.amount),
+//            easyPayDetail = null,
+//            transferDetail = null,
+//        )
+//
+//        return paymentService.confirm(reservationId, request)
+//    }
+//
+//    fun runConfirmTest(
+//        cardDetail: CardDetail? = null,
+//        easyPayDetail: EasyPayDetail? = null,
+//        transferDetail: TransferDetail? = null,
+//        paymentKey: String = "paymentKey",
+//        amount: Int = 10000,
+//    ) {
+//        val (user, token) = testAuthUtil.defaultUserLogin()
+//        val reservation = dummyInitializer.createConfirmReservation(user = user)
+//        val request = PaymentFixture.confirmRequest.copy(paymentKey = paymentKey, amount = amount)
+//
+//        val method = if (easyPayDetail != null) {
+//            PaymentMethod.EASY_PAY
+//        } else if (cardDetail != null) {
+//            PaymentMethod.CARD
+//        } else if (transferDetail != null) {
+//            PaymentMethod.TRANSFER
+//        } else {
+//            throw AssertionError("결제타입 확인 필요.")
+//        }
+//
+//        val clientResponse = PaymentFixture.confirmResponse(
+//            paymentKey, amount, method, cardDetail, easyPayDetail, transferDetail
+//        )
+//
+//        every {
+//            tosspayClient.confirm(request.paymentKey, request.orderId, request.amount)
+//        } returns clientResponse
+//
+//        runTest(
+//            token = token,
+//            using = {
+//                body(request)
+//            },
+//            on = {
+//                post("/payments?reservationId=${reservation.id}")
+//            },
+//            expect = {
+//                statusCode(HttpStatus.OK.value())
+//            }
+//        ).also {
+//            val createdPayment = paymentRepository.findByIdOrNull(it.extract().path("data.paymentId"))
+//                ?: throw AssertionError("Unexpected Exception Occurred.")
+//            val createdPaymentDetail =
+//                paymentDetailRepository.findByIdOrNull(it.extract().path("data.detailId"))
+//                    ?: throw AssertionError("Unexpected Exception Occurred.")
+//
+//            createdPayment.status shouldBe clientResponse.status
+//            createdPayment.method shouldBe clientResponse.method
+//            createdPayment.reservationId shouldBe reservation.id
+//
+//            when (createdPaymentDetail) {
+//                is PaymentCardDetailEntity -> {
+//                    createdPaymentDetail.issuerCode shouldBe clientResponse.card!!.issuerCode
+//                    createdPaymentDetail.cardType shouldBe clientResponse.card.cardType
+//                    createdPaymentDetail.cardNumber shouldBe clientResponse.card.number
+//                    createdPaymentDetail.suppliedAmount shouldBe clientResponse.suppliedAmount
+//                    createdPaymentDetail.vat shouldBe clientResponse.vat
+//                    createdPaymentDetail.amount shouldBe (clientResponse.totalAmount - (clientResponse.easyPay?.discountAmount
+//                        ?: 0))
+//                    clientResponse.easyPay?.let { easypay ->
+//                        createdPaymentDetail.easypayProviderCode shouldBe easypay.provider
+//                        createdPaymentDetail.easypayDiscountAmount shouldBe easypay.discountAmount
+//                    }
+//                }
+//
+//                is PaymentBankTransferDetailEntity -> {
+//                    createdPaymentDetail.suppliedAmount shouldBe clientResponse.suppliedAmount
+//                    createdPaymentDetail.vat shouldBe clientResponse.vat
+//                    createdPaymentDetail.bankCode shouldBe clientResponse.transfer!!.bankCode
+//                    createdPaymentDetail.settlementStatus shouldBe clientResponse.transfer.settlementStatus
+//                }
+//
+//                is PaymentEasypayPrepaidDetailEntity -> {
+//                    createdPaymentDetail.suppliedAmount shouldBe clientResponse.suppliedAmount
+//                    createdPaymentDetail.vat shouldBe clientResponse.vat
+//                    createdPaymentDetail.easypayProviderCode shouldBe clientResponse.easyPay!!.provider
+//                    createdPaymentDetail.amount shouldBe clientResponse.easyPay.amount
+//                    createdPaymentDetail.discountAmount shouldBe clientResponse.easyPay.discountAmount
+//                }
+//            }
+//        }
+//    }
+//}

service/src/test/kotlin/com/sangdol/roomescape/reservation/ReservationApiTest.kt

@@ -14,8 +14,8 @@ import com.sangdol.roomescape.reservation.infrastructure.persistence.CanceledRes
 import com.sangdol.roomescape.reservation.infrastructure.persistence.ReservationEntity
 import com.sangdol.roomescape.reservation.infrastructure.persistence.ReservationRepository
 import com.sangdol.roomescape.reservation.infrastructure.persistence.ReservationStatus
-import com.sangdol.roomescape.reservation.web.ReservationCancelRequest
-import com.sangdol.roomescape.reservation.web.ReservationOverviewResponse
+import com.sangdol.roomescape.reservation.dto.ReservationCancelRequest
+import com.sangdol.roomescape.reservation.dto.ReservationOverviewResponse
 import com.sangdol.roomescape.schedule.infrastructure.persistence.ScheduleEntity
 import com.sangdol.roomescape.schedule.infrastructure.persistence.ScheduleRepository
 import com.sangdol.roomescape.schedule.infrastructure.persistence.ScheduleStatus

service/src/test/kotlin/com/sangdol/roomescape/reservation/ReservationConcurrencyTest.kt

@@ -7,8 +7,8 @@ import com.sangdol.roomescape.reservation.exception.ReservationErrorCode
 import com.sangdol.roomescape.reservation.exception.ReservationException
 import com.sangdol.roomescape.reservation.infrastructure.persistence.ReservationRepository
 import com.sangdol.roomescape.reservation.infrastructure.persistence.ReservationStatus
-import com.sangdol.roomescape.reservation.web.PendingReservationCreateRequest
-import com.sangdol.roomescape.reservation.web.PendingReservationCreateResponse
+import com.sangdol.roomescape.reservation.dto.PendingReservationCreateRequest
+import com.sangdol.roomescape.reservation.dto.PendingReservationCreateResponse
 import com.sangdol.roomescape.schedule.infrastructure.persistence.ScheduleEntity
 import com.sangdol.roomescape.schedule.infrastructure.persistence.ScheduleRepository
 import com.sangdol.roomescape.schedule.infrastructure.persistence.ScheduleStatus

service/src/test/kotlin/com/sangdol/roomescape/supports/DummyInitializer.kt

@@ -15,8 +15,8 @@ import com.sangdol.roomescape.payment.web.toPaymentDetailResponse
 import com.sangdol.roomescape.reservation.infrastructure.persistence.ReservationEntity
 import com.sangdol.roomescape.reservation.infrastructure.persistence.ReservationRepository
 import com.sangdol.roomescape.reservation.infrastructure.persistence.ReservationStatus
-import com.sangdol.roomescape.reservation.web.PendingReservationCreateRequest
-import com.sangdol.roomescape.reservation.web.toEntity
+import com.sangdol.roomescape.reservation.dto.PendingReservationCreateRequest
+import com.sangdol.roomescape.reservation.mapper.toEntity
 import com.sangdol.roomescape.schedule.infrastructure.persistence.ScheduleEntity
 import com.sangdol.roomescape.schedule.infrastructure.persistence.ScheduleRepository
 import com.sangdol.roomescape.schedule.infrastructure.persistence.ScheduleStatus

service/src/test/kotlin/com/sangdol/roomescape/supports/Fixtures.kt

@@ -10,7 +10,7 @@ import com.sangdol.roomescape.payment.infrastructure.client.*
 import com.sangdol.roomescape.payment.infrastructure.common.*
 import com.sangdol.roomescape.payment.web.PaymentCancelRequest
 import com.sangdol.roomescape.payment.web.PaymentConfirmRequest
-import com.sangdol.roomescape.reservation.web.PendingReservationCreateRequest
+import com.sangdol.roomescape.reservation.dto.PendingReservationCreateRequest
 import com.sangdol.roomescape.schedule.infrastructure.persistence.ScheduleEntity
 import com.sangdol.roomescape.schedule.infrastructure.persistence.ScheduleEntityFactory
 import com.sangdol.roomescape.schedule.dto.ScheduleCreateRequest