From ba0dc44e04591e30e912e037dfb7e3ee3427b45d Mon Sep 17 00:00:00 2001 From: pricelees Date: Mon, 21 Jul 2025 21:01:56 +0900 Subject: [PATCH] =?UTF-8?q?test:=20PaymentServiceTest=20=EC=BD=94=ED=8B=80?= =?UTF-8?q?=EB=A6=B0=20=EC=A0=84=ED=99=98?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../payment/business/PaymentServiceKTest.kt | 129 ---------- .../payment/business/PaymentServiceTest.kt | 241 ++++++++---------- 2 files changed, 107 insertions(+), 263 deletions(-) delete mode 100644 src/test/java/roomescape/payment/business/PaymentServiceKTest.kt diff --git a/src/test/java/roomescape/payment/business/PaymentServiceKTest.kt b/src/test/java/roomescape/payment/business/PaymentServiceKTest.kt deleted file mode 100644 index e72b228c..00000000 --- a/src/test/java/roomescape/payment/business/PaymentServiceKTest.kt +++ /dev/null @@ -1,129 +0,0 @@ -package roomescape.payment.business - -import io.kotest.assertions.assertSoftly -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.just -import io.mockk.mockk -import io.mockk.runs -import org.springframework.http.HttpStatus -import roomescape.common.exception.ErrorType -import roomescape.common.exception.RoomescapeException -import roomescape.payment.infrastructure.persistence.CanceledPaymentRepository -import roomescape.payment.infrastructure.persistence.PaymentRepository -import roomescape.payment.web.PaymentCancel -import roomescape.util.PaymentFixture -import java.time.OffsetDateTime - -class PaymentServiceKTest : FunSpec({ - val paymentRepository: PaymentRepository = mockk() - val canceledPaymentRepository: CanceledPaymentRepository = mockk() - - val paymentService = PaymentService(paymentRepository, canceledPaymentRepository) - - context("cancelPaymentByAdmin") { - val reservationId = 1L - test("reservationId로 paymentKey를 찾을 수 없으면 예외를 던진다.") { - every { paymentRepository.findPaymentKeyByReservationId(reservationId) } returns null - - val exception = shouldThrow { - paymentService.cancelPaymentByAdmin(reservationId) - } - - assertSoftly(exception) { - this.errorType shouldBe ErrorType.PAYMENT_NOT_FOUND - this.httpStatus shouldBe HttpStatus.NOT_FOUND - } - } - - context("reservationId로 paymentKey를 찾고난 후") { - val paymentKey = "test-payment-key" - - every { - paymentRepository.findPaymentKeyByReservationId(reservationId) - } returns paymentKey - - test("해당 paymentKey로 paymentEntity를 찾을 수 없으면 예외를 던진다.") { - every { - paymentRepository.findByPaymentKey(paymentKey) - } returns null - - val exception = shouldThrow { - paymentService.cancelPaymentByAdmin(reservationId) - } - - assertSoftly(exception) { - this.errorType shouldBe ErrorType.PAYMENT_NOT_FOUND - this.httpStatus shouldBe HttpStatus.NOT_FOUND - } - } - - test("해당 paymentKey로 paymentEntity를 찾고, cancelPaymentEntity를 저장한다.") { - val paymentEntity = PaymentFixture.create(paymentKey = paymentKey) - - every { - paymentRepository.findByPaymentKey(paymentKey) - } returns paymentEntity.also { - every { - paymentRepository.delete(it) - } just runs - } - - every { - canceledPaymentRepository.save(any()) - } returns PaymentFixture.createCanceled( - id = 1L, - paymentKey = paymentKey, - cancelAmount = paymentEntity.totalAmount, - ) - - val result: PaymentCancel.Request = paymentService.cancelPaymentByAdmin(reservationId) - - assertSoftly(result) { - this.paymentKey shouldBe paymentKey - this.amount shouldBe paymentEntity.totalAmount - this.cancelReason shouldBe "고객 요청" - } - } - } - } - - context("updateCanceledTime") { - val paymentKey = "test-payment-key" - val canceledAt = OffsetDateTime.now() - - test("paymentKey로 canceledPaymentEntity를 찾을 수 없으면 예외를 던진다.") { - every { - canceledPaymentRepository.findByPaymentKey(paymentKey) - } returns null - - val exception = shouldThrow { - paymentService.updateCanceledTime(paymentKey, canceledAt) - } - - assertSoftly(exception) { - this.errorType shouldBe ErrorType.PAYMENT_NOT_FOUND - this.httpStatus shouldBe HttpStatus.NOT_FOUND - } - } - - test("paymentKey로 canceledPaymentEntity를 찾고, canceledAt을 업데이트한다.") { - val canceledPaymentEntity = PaymentFixture.createCanceled( - paymentKey = paymentKey, - canceledAt = canceledAt.minusMinutes(1) - ) - - every { - canceledPaymentRepository.findByPaymentKey(paymentKey) - } returns canceledPaymentEntity - - paymentService.updateCanceledTime(paymentKey, canceledAt) - - assertSoftly(canceledPaymentEntity) { - this.canceledAt shouldBe canceledAt - } - } - } -}) diff --git a/src/test/java/roomescape/payment/business/PaymentServiceTest.kt b/src/test/java/roomescape/payment/business/PaymentServiceTest.kt index dffdd39a..be9c05fa 100644 --- a/src/test/java/roomescape/payment/business/PaymentServiceTest.kt +++ b/src/test/java/roomescape/payment/business/PaymentServiceTest.kt @@ -1,156 +1,129 @@ -package roomescape.payment.business; +package roomescape.payment.business -import static org.assertj.core.api.Assertions.*; +import io.kotest.assertions.assertSoftly +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.just +import io.mockk.mockk +import io.mockk.runs +import org.springframework.http.HttpStatus +import roomescape.common.exception.ErrorType +import roomescape.common.exception.RoomescapeException +import roomescape.payment.infrastructure.persistence.CanceledPaymentRepository +import roomescape.payment.infrastructure.persistence.PaymentRepository +import roomescape.payment.web.PaymentCancel +import roomescape.util.PaymentFixture +import java.time.OffsetDateTime -import java.time.LocalDate; -import java.time.LocalDateTime; -import java.time.OffsetDateTime; +class PaymentServiceTest : FunSpec({ + val paymentRepository: PaymentRepository = mockk() + val canceledPaymentRepository: CanceledPaymentRepository = mockk() -import org.junit.jupiter.api.DisplayName; -import org.junit.jupiter.api.Test; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import org.springframework.test.context.jdbc.Sql; -import org.springframework.test.context.jdbc.Sql.ExecutionPhase; + val paymentService = PaymentService(paymentRepository, canceledPaymentRepository) -import roomescape.common.exception.RoomescapeException; -import roomescape.member.infrastructure.persistence.MemberEntity; -import roomescape.member.infrastructure.persistence.MemberRepository; -import roomescape.member.infrastructure.persistence.Role; -import roomescape.payment.infrastructure.persistence.CanceledPaymentEntity; -import roomescape.payment.infrastructure.persistence.CanceledPaymentRepository; -import roomescape.payment.web.PaymentApprove; -import roomescape.payment.web.PaymentCancel; -import roomescape.payment.web.ReservationPaymentResponse; -import roomescape.reservation.infrastructure.persistence.ReservationEntity; -import roomescape.reservation.infrastructure.persistence.ReservationRepository; -import roomescape.reservation.infrastructure.persistence.ReservationStatus; -import roomescape.reservation.infrastructure.persistence.ReservationTimeEntity; -import roomescape.reservation.infrastructure.persistence.ReservationTimeRepository; -import roomescape.theme.infrastructure.persistence.ThemeEntity; -import roomescape.theme.infrastructure.persistence.ThemeRepository; + context("cancelPaymentByAdmin") { + val reservationId = 1L + test("reservationId로 paymentKey를 찾을 수 없으면 예외를 던진다.") { + every { paymentRepository.findPaymentKeyByReservationId(reservationId) } returns null -@SpringBootTest -@Sql(scripts = "/truncate.sql", executionPhase = ExecutionPhase.BEFORE_TEST_METHOD) -class PaymentServiceTest { + val exception = shouldThrow { + paymentService.cancelPaymentByAdmin(reservationId) + } - @Autowired - private PaymentService paymentService; - @Autowired - private ReservationRepository reservationRepository; - @Autowired - private MemberRepository memberRepository; - @Autowired - private ReservationTimeRepository reservationTimeRepository; - @Autowired - private ThemeRepository themeRepository; - @Autowired - private CanceledPaymentRepository canceledPaymentRepository; + assertSoftly(exception) { + this.errorType shouldBe ErrorType.PAYMENT_NOT_FOUND + this.httpStatus shouldBe HttpStatus.NOT_FOUND + } + } - @Test - @DisplayName("결제 정보를 저장한다.") - void savePayment() { - // given - PaymentApprove.Response paymentInfo = new PaymentApprove.Response("payment-key", "order-id", - OffsetDateTime.now(), 10000L); - LocalDateTime localDateTime = LocalDateTime.now().plusHours(1L); - LocalDate date = localDateTime.toLocalDate(); - ReservationTimeEntity time = reservationTimeRepository.save( - new ReservationTimeEntity(null, localDateTime.toLocalTime())); - MemberEntity member = memberRepository.save( - new MemberEntity(null, "member", "email@email.com", "password", Role.MEMBER)); - ThemeEntity theme = themeRepository.save(new ThemeEntity(null, "name", "desc", "thumbnail")); - ReservationEntity reservation = reservationRepository.save( - new ReservationEntity(null, date, time, theme, member, - ReservationStatus.CONFIRMED)); + context("reservationId로 paymentKey를 찾고난 후") { + val paymentKey = "test-payment-key" - // when - ReservationPaymentResponse reservationPaymentResponse = paymentService.savePayment(paymentInfo, reservation); + every { + paymentRepository.findPaymentKeyByReservationId(reservationId) + } returns paymentKey - // then - assertThat(reservationPaymentResponse.reservation().id).isEqualTo(reservation.getId()); - assertThat(reservationPaymentResponse.paymentKey()).isEqualTo(paymentInfo.paymentKey); - } + test("해당 paymentKey로 paymentEntity를 찾을 수 없으면 예외를 던진다.") { + every { + paymentRepository.findByPaymentKey(paymentKey) + } returns null - @Test - @DisplayName("예약 ID로 결제 정보를 제거하고, 결제 취소 테이블에 취소 정보를 저장한다.") - void cancelPaymentByAdmin() { - // given - PaymentApprove.Response paymentInfo = new PaymentApprove.Response("payment-key", "order-id", - OffsetDateTime.now(), 10000L); - LocalDateTime localDateTime = LocalDateTime.now().plusHours(1L); - LocalDate date = localDateTime.toLocalDate(); - ReservationTimeEntity time = reservationTimeRepository.save( - new ReservationTimeEntity(null, localDateTime.toLocalTime())); - MemberEntity member = memberRepository.save( - new MemberEntity(null, "member", "email@email.com", "password", Role.MEMBER)); - ThemeEntity theme = themeRepository.save(new ThemeEntity(null, "name", "desc", "thumbnail")); - ReservationEntity reservation = reservationRepository.save( - new ReservationEntity(null, date, time, theme, member, - ReservationStatus.CONFIRMED)); + val exception = shouldThrow { + paymentService.cancelPaymentByAdmin(reservationId) + } - paymentService.savePayment(paymentInfo, reservation); + assertSoftly(exception) { + this.errorType shouldBe ErrorType.PAYMENT_NOT_FOUND + this.httpStatus shouldBe HttpStatus.NOT_FOUND + } + } - // when - PaymentCancel.Request paymentCancelRequest = paymentService.cancelPaymentByAdmin(reservation.getId()); + test("해당 paymentKey로 paymentEntity를 찾고, cancelPaymentEntity를 저장한다.") { + val paymentEntity = PaymentFixture.create(paymentKey = paymentKey) - // then - assertThat(canceledPaymentRepository.findByPaymentKey("payment-key")).isNotNull(); - assertThat(paymentCancelRequest.paymentKey).isEqualTo(paymentInfo.paymentKey); - assertThat(paymentCancelRequest.cancelReason).isEqualTo("고객 요청"); - assertThat(paymentCancelRequest.amount).isEqualTo(10000L); - } + every { + paymentRepository.findByPaymentKey(paymentKey) + } returns paymentEntity.also { + every { + paymentRepository.delete(it) + } just runs + } - @Test - @DisplayName("입력된 예약 ID에 대한 결제 정보가 없으면 예외가 발생한다.") - void cancelPaymentByAdminWithNonExistentReservationId() { - // given - Long nonExistentReservationId = 1L; + every { + canceledPaymentRepository.save(any()) + } returns PaymentFixture.createCanceled( + id = 1L, + paymentKey = paymentKey, + cancelAmount = paymentEntity.totalAmount, + ) - // when - assertThatThrownBy(() -> paymentService.cancelPaymentByAdmin(nonExistentReservationId)) - .isInstanceOf(RoomescapeException.class); - } + val result: PaymentCancel.Request = paymentService.cancelPaymentByAdmin(reservationId) - @Test - @DisplayName("결제 취소 정보에 있는 취소 시간을 업데이트한다.") - void updateCanceledTime() { - // given - PaymentApprove.Response paymentInfo = new PaymentApprove.Response("payment-key", "order-id", - OffsetDateTime.now(), 10000L); - LocalDateTime localDateTime = LocalDateTime.now().plusHours(1L); - LocalDate date = localDateTime.toLocalDate(); - ReservationTimeEntity time = reservationTimeRepository.save( - new ReservationTimeEntity(null, localDateTime.toLocalTime())); - MemberEntity member = memberRepository.save( - new MemberEntity(null, "member", "email@email.com", "password", Role.MEMBER)); - ThemeEntity theme = themeRepository.save(new ThemeEntity(null, "name", "desc", "thumbnail")); - ReservationEntity reservation = reservationRepository.save( - new ReservationEntity(null, date, time, theme, member, - ReservationStatus.CONFIRMED)); + assertSoftly(result) { + this.paymentKey shouldBe paymentKey + this.amount shouldBe paymentEntity.totalAmount + this.cancelReason shouldBe "고객 요청" + } + } + } + } - paymentService.savePayment(paymentInfo, reservation); - paymentService.cancelPaymentByAdmin(reservation.getId()); + context("updateCanceledTime") { + val paymentKey = "test-payment-key" + val canceledAt = OffsetDateTime.now() - // when - OffsetDateTime canceledAt = OffsetDateTime.now().plusHours(2L); - paymentService.updateCanceledTime(paymentInfo.paymentKey, canceledAt); + test("paymentKey로 canceledPaymentEntity를 찾을 수 없으면 예외를 던진다.") { + every { + canceledPaymentRepository.findByPaymentKey(paymentKey) + } returns null - // then - CanceledPaymentEntity canceledPayment = canceledPaymentRepository.findByPaymentKey(paymentInfo.paymentKey); + val exception = shouldThrow { + paymentService.updateCanceledTime(paymentKey, canceledAt) + } - assertThat(canceledPayment).isNotNull(); - assertThat(canceledPayment.getCanceledAt()).isEqualTo(canceledAt); - } + assertSoftly(exception) { + this.errorType shouldBe ErrorType.PAYMENT_NOT_FOUND + this.httpStatus shouldBe HttpStatus.NOT_FOUND + } + } - @Test - @DisplayName("결제 취소 시간을 업데이트 할 때, 입력한 paymentKey가 존재하지 않으면 예외가 발생한다.") - void updateCanceledTimeWithNonExistentPaymentKey() { - // given - OffsetDateTime canceledAt = OffsetDateTime.now().plusHours(2L); + test("paymentKey로 canceledPaymentEntity를 찾고, canceledAt을 업데이트한다.") { + val canceledPaymentEntity = PaymentFixture.createCanceled( + paymentKey = paymentKey, + canceledAt = canceledAt.minusMinutes(1) + ) - // when - assertThatThrownBy(() -> paymentService.updateCanceledTime("non-existent-payment-key", canceledAt)) - .isInstanceOf(RoomescapeException.class); - } -} + every { + canceledPaymentRepository.findByPaymentKey(paymentKey) + } returns canceledPaymentEntity + + paymentService.updateCanceledTime(paymentKey, canceledAt) + + assertSoftly(canceledPaymentEntity) { + this.canceledAt shouldBe canceledAt + } + } + } +})