pricelees/roomescape-refactored
1
0
Fork 0
generated from pricelees/issue-pr-template
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity

[#44] 매장 기능 도입 #45

Merged
pricelees merged 116 commits from feat/#44 into main 2025-09-20 03:15:06 +00:00
Conversation 0 Commits 116 Files Changed 133 +67 -123
1 changed files with 67 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit 75f628c991 - Show all commits

190
src/test/kotlin/roomescape/supports/DummyInitializer.kt
View File

@ -1,11 +1,8 @@
package roomescape.supports
import io.restassured.module.kotlin.extensions.Extract
import io.restassured.module.kotlin.extensions.Given
import io.restassured.module.kotlin.extensions.When
import org.springframework.data.repository.findByIdOrNull
import org.springframework.http.MediaType
import roomescape.common.config.next
import roomescape.common.util.MdcPrincipalId
import roomescape.payment.business.PaymentWriter
import roomescape.payment.infrastructure.client.CardDetail
import roomescape.payment.infrastructure.client.EasyPayDetail
@ -16,22 +13,25 @@ import roomescape.payment.infrastructure.persistence.PaymentEntity
import roomescape.payment.infrastructure.persistence.PaymentRepository
import roomescape.payment.web.PaymentConfirmRequest
import roomescape.payment.web.PaymentWithDetailResponse
import roomescape.payment.web.toPaymentDetailResponse
import roomescape.payment.web.toDetailResponse
import roomescape.payment.web.toPaymentDetailResponse
import roomescape.reservation.infrastructure.persistence.ReservationEntity
import roomescape.reservation.infrastructure.persistence.ReservationRepository
import roomescape.reservation.infrastructure.persistence.ReservationStatus
import roomescape.reservation.web.PendingReservationCreateRequest
import roomescape.reservation.web.toEntity
import roomescape.schedule.infrastructure.persistence.ScheduleEntity
import roomescape.schedule.infrastructure.persistence.ScheduleRepository
import roomescape.schedule.infrastructure.persistence.ScheduleStatus
import roomescape.schedule.web.ScheduleCreateRequest
import roomescape.schedule.web.ScheduleUpdateRequest
import roomescape.store.infrastructure.persistence.StoreEntity
import roomescape.store.infrastructure.persistence.StoreRepository
import roomescape.store.infrastructure.persistence.StoreStatus
import roomescape.theme.infrastructure.persistence.ThemeEntity
import roomescape.theme.infrastructure.persistence.ThemeRepository
import roomescape.theme.web.ThemeCreateRequest
import roomescape.theme.web.toEntity
import roomescape.user.infrastructure.persistence.UserEntity
import java.time.LocalDateTime
class DummyInitializer(
@ -42,132 +42,109 @@ class DummyInitializer(
private val paymentRepository: PaymentRepository,
private val paymentWriter: PaymentWriter
) {
fun createTheme(adminToken: String, request: ThemeCreateRequest): ThemeEntity {
val createdThemeId: Long = Given {
contentType(MediaType.APPLICATION_JSON_VALUE)
header("Authorization", "Bearer $adminToken")
body(request)
} When {
post("/admin/themes")
} Extract {
path("data.id")
}
return themeRepository.findByIdOrNull(createdThemeId)
?: throw RuntimeException("unexpected error occurred")
fun createStore(
id: Long = tsidFactory.next(),
name: String = "행복${randomPhoneNumber()}호점",
address: String = "강북구 행복로 $name",
contact: String = randomPhoneNumber(),
businessRegNum: String = randomBusinessRegNum(),
regionCode: String = "1111000000",
status: StoreStatus = StoreStatus.ACTIVE
): StoreEntity {
return StoreEntity(
id = id,
name = name,
address = address,
contact = contact,
businessRegNum = businessRegNum,
regionCode = regionCode,
status = status
).also {
storeRepository.save(it)
}
}
fun createTheme(
request: ThemeCreateRequest = ThemeFixture.createRequest
): ThemeEntity {
return request.toEntity(tsidFactory.next()).also { themeRepository.save(it) }
}
fun createSchedule(
adminToken: String,
request: ScheduleCreateRequest,
storeId: Long = tsidFactory.next(),
request: ScheduleCreateRequest = ScheduleFixture.createRequest,
status: ScheduleStatus = ScheduleStatus.AVAILABLE
): ScheduleEntity {
val themeId: Long = if (themeRepository.existsById(request.themeId)) {
request.themeId
} else {
createTheme(
adminToken = adminToken,
request = ThemeFixture.createRequest.copy(name = "theme-${System.currentTimeMillis()}")
).id
}
val createdScheduleId: Long = Given {
contentType(MediaType.APPLICATION_JSON_VALUE)
header("Authorization", "Bearer $adminToken")
body(request.copy(themeId = themeId))
} When {
post("/schedules")
} Extract {
path("data.id")
createTheme().id
}
Given {
contentType(MediaType.APPLICATION_JSON_VALUE)
header("Authorization", "Bearer $adminToken")
body(ScheduleUpdateRequest(status = status))
} When {
patch("/schedules/$createdScheduleId")
val storeId: Long = if (storeRepository.existsById(storeId)) {
storeId
} else {
createStore(id = storeId).id
}
return scheduleRepository.findByIdOrNull(createdScheduleId)
?: throw RuntimeException("unexpected error occurred")
val schedule: ScheduleEntity = ScheduleFixture.create(
date = request.date, time = request.time, storeId = storeId, themeId = themeId,
).apply {
this.status = status
}
return scheduleRepository.save(schedule)
}
fun createPendingReservation(
adminToken: String,
reserverToken: String,
user: UserEntity,
themeRequest: ThemeCreateRequest = ThemeFixture.createRequest,
scheduleRequest: ScheduleCreateRequest = ScheduleFixture.createRequest,
reservationRequest: PendingReservationCreateRequest = ReservationFixture.pendingCreateRequest,
): ReservationEntity {
val themeId: Long = if (themeRepository.existsById(scheduleRequest.themeId)) {
scheduleRequest.themeId
} else if (themeRepository.existsById(reservationRequest.scheduleId)) {
reservationRequest.scheduleId
} else {
createTheme(
adminToken = adminToken,
request = themeRequest
).id
createTheme(themeRequest).id
}
val scheduleId: Long = if (scheduleRepository.existsById(reservationRequest.scheduleId)) {
reservationRequest.scheduleId
} else {
createSchedule(
adminToken = adminToken,
request = scheduleRequest.copy(themeId = themeId),
status = ScheduleStatus.HOLD
).id
}
return createPendingReservation(
reserverToken = reserverToken,
request = reservationRequest.copy(scheduleId = scheduleId)
)
val reservation = ReservationFixture.pendingCreateRequest.copy(
scheduleId = scheduleId,
reserverName = reservationRequest.reserverName,
reserverContact = reservationRequest.reserverContact,
participantCount = reservationRequest.participantCount,
requirement = reservationRequest.requirement,
).toEntity(id = tsidFactory.next(), userId = user.id)
return reservationRepository.save(reservation)
}
fun createConfirmReservation(
adminToken: String,
reserverToken: String,
user: UserEntity,
themeRequest: ThemeCreateRequest = ThemeFixture.createRequest,
scheduleRequest: ScheduleCreateRequest = ScheduleFixture.createRequest,
reservationRequest: PendingReservationCreateRequest = ReservationFixture.pendingCreateRequest,
): ReservationEntity {
val themeId: Long = if (themeRepository.existsById(scheduleRequest.themeId)) {
scheduleRequest.themeId
} else if (themeRepository.existsById(reservationRequest.scheduleId)) {
reservationRequest.scheduleId
} else {
createTheme(
adminToken = adminToken,
request = themeRequest
).id
return createPendingReservation(user, themeRequest, scheduleRequest, reservationRequest).apply {
this.status = ReservationStatus.CONFIRMED
}.also {
reservationRepository.save(it)
scheduleRepository.findByIdOrNull(it.scheduleId)?.let { schedule ->
schedule.status = ScheduleStatus.RESERVED
scheduleRepository.save(schedule)
}
}
val scheduleId: Long = if (scheduleRepository.existsById(reservationRequest.scheduleId)) {
reservationRequest.scheduleId
} else {
createSchedule(
adminToken = adminToken,
request = scheduleRequest.copy(themeId = themeId),
status = ScheduleStatus.HOLD
).id
}
val reservation = createPendingReservation(
reserverToken = reserverToken,
request = reservationRequest.copy(scheduleId = scheduleId)
)
Given {
contentType(MediaType.APPLICATION_JSON_VALUE)
header("Authorization", "Bearer $reserverToken")
} When {
post("/reservations/${reservation.id}/confirm")
}
return reservationRepository.findByIdOrNull(reservation.id)
?: throw RuntimeException("unexpected error occurred")
}
fun createPayment(
@ -228,37 +205,4 @@ class DummyInitializer(
clientCancelResponse
)
}
private fun createPendingReservation(
reserverToken: String,
request: PendingReservationCreateRequest,
): ReservationEntity {
val createdReservationId: Long = Given {
contentType(MediaType.APPLICATION_JSON_VALUE)
header("Authorization", "Bearer $reserverToken")
body(request.copy(scheduleId = request.scheduleId))
} When {
post("/reservations/pending")
} Extract {
path("data.id")
}
return reservationRepository.findByIdOrNull(createdReservationId)
?: throw RuntimeException("unexpected error occurred")
}
fun createStore(): StoreEntity {
return StoreEntity(
id = tsidFactory.next(),
name = "Hello 매장-${System.currentTimeMillis()}",
address = "강북구 행복로 123",
contact = randomPhoneNumber(),
businessRegNum = randomBusinessRegNum(),
regionCode = "1111000000",
status = StoreStatus.ACTIVE
).also {
storeRepository.save(it)
}
}
}