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

[#7] API 응답 형식 재정의 및 Swagger-UI 관련 코드 패키지 분리 (#8)

Browse Source 
<!-- 제목 양식 -->
<!-- [이슈번호] 작업 요약 (예시: [#10] Gitea 템플릿 생성) -->

## 📝 관련 이슈 및 PR

**PR과 관련된 이슈 번호**
- #7

## ✨ 작업 내용
<!-- 어떤 작업을 했는지 알려주세요! -->
1. 808c6675 에서 작업했던 정상 / 오류를 통합하는 객체를 사용하려 했으나, Swagger-UI상에서 응답 형식에 null 필드가 포함되는 문제로 다시 정상 / 오류 별도로 분리
2. Swagger-UI(문서화, 명세) 관련 코드는 인지하기 쉽도록 ../web -> ../docs 패키지로 이전
3. 현재까지 코틀린으로 마이그레이션 된 서비스를 대상으로, 응답에 ResponseEntity를 적용하고 \@ResponseStatus 제거

## 🧪 테스트
<!-- 어떤 테스트를 생각했고 진행했는지 알려주세요! -->
예정으로는 Issue에 작성했던 테스트까지 처리하려고 했으나, 테스트는 바로 다음에 진행 예정

## 📚 참고 자료 및 기타
<!-- 참고한 자료, 또는 논의할 사항이 있다면 알려주세요! -->

Reviewed-on: #8
Co-authored-by: pricelees <priceelees@gmail.com>
Co-committed-by: pricelees <priceelees@gmail.com>
This commit is contained in:
이상진 2025-07-15 05:37:41 +00:00 committed by 이상진
parent 38ef207c47
commit 5fb5d2650b
31 changed files with 513 additions and 502 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

45
src/main/java/roomescape/auth/docs/AuthAPI.kt Normal file
View File

@ -0,0 +1,45 @@
package roomescape.auth.docs
import io.swagger.v3.oas.annotations.Operation
import io.swagger.v3.oas.annotations.Parameter
import io.swagger.v3.oas.annotations.responses.ApiResponse
import io.swagger.v3.oas.annotations.responses.ApiResponses
import io.swagger.v3.oas.annotations.tags.Tag
import jakarta.validation.Valid
import org.springframework.http.ResponseEntity
import org.springframework.web.bind.annotation.RequestBody
import roomescape.auth.web.LoginCheckResponse
import roomescape.auth.web.LoginRequest
import roomescape.auth.web.support.LoginRequired
import roomescape.auth.web.support.MemberId
import roomescape.common.dto.response.CommonApiResponse
@Tag(name = "1. 인증 / 인가 API", description = "로그인, 로그아웃 및 로그인 상태를 확인합니다")
interface AuthAPI {
@Operation(summary = "로그인")
@ApiResponses(
ApiResponse(responseCode = "200", description = "로그인 성공시 쿠키에 토큰 정보를 저장합니다."),
)
fun login(
@Valid @RequestBody loginRequest: LoginRequest
): ResponseEntity<CommonApiResponse<Unit>>
@Operation(summary = "로그인 상태 확인")
@ApiResponses(
ApiResponse(
responseCode = "200",
description = "로그인 상태이며, 로그인된 회원의 이름을 반환합니다.",
useReturnTypeSchema = true
),
)
fun checkLogin(
@MemberId @Parameter(hidden = true) memberId: Long
): ResponseEntity<CommonApiResponse<LoginCheckResponse>>
@LoginRequired
@Operation(summary = "로그아웃", tags = ["로그인이 필요한 API"])
@ApiResponses(
ApiResponse(responseCode = "200", description = "로그아웃 성공시 쿠키에 저장된 토큰 정보를 삭제합니다."),
)
fun logout(): ResponseEntity<CommonApiResponse<Unit>>
}

4
src/main/java/roomescape/auth/service/AuthService.kt
View File

@ -1,12 +1,12 @@
package roomescape.auth.service package roomescape.auth.service
import org.springframework.stereotype.Service import org.springframework.stereotype.Service
import roomescape.member.business.MemberService
import roomescape.member.infrastructure.persistence.Member
import roomescape.auth.infrastructure.jwt.JwtHandler import roomescape.auth.infrastructure.jwt.JwtHandler
import roomescape.auth.web.LoginCheckResponse import roomescape.auth.web.LoginCheckResponse
import roomescape.auth.web.LoginRequest import roomescape.auth.web.LoginRequest
import roomescape.auth.web.TokenResponse import roomescape.auth.web.TokenResponse
import roomescape.member.business.MemberService
import roomescape.member.infrastructure.persistence.Member
@Service @Service
class AuthService( class AuthService(

67
src/main/java/roomescape/auth/web/AuthAPI.kt
View File

@ -1,67 +0,0 @@
package roomescape.auth.web
import io.swagger.v3.oas.annotations.Operation
import io.swagger.v3.oas.annotations.Parameter
import io.swagger.v3.oas.annotations.media.Content
import io.swagger.v3.oas.annotations.media.Schema
import io.swagger.v3.oas.annotations.responses.ApiResponse
import io.swagger.v3.oas.annotations.responses.ApiResponses
import io.swagger.v3.oas.annotations.tags.Tag
import jakarta.servlet.http.HttpServletRequest
import jakarta.servlet.http.HttpServletResponse
import jakarta.validation.Valid
import org.springframework.http.HttpStatus
import org.springframework.web.bind.annotation.RequestBody
import org.springframework.web.bind.annotation.ResponseStatus
import roomescape.auth.web.support.LoginRequired
import roomescape.auth.web.support.MemberId
import roomescape.common.dto.response.ErrorResponse
import roomescape.common.dto.response.RoomEscapeApiResponse
@Tag(name = "1. 인증 / 인가 API", description = "로그인, 로그아웃 및 로그인 상태를 확인합니다")
interface AuthAPI {
@ResponseStatus(HttpStatus.OK)
@Operation(summary = "로그인")
@ApiResponses(
ApiResponse(
responseCode = "200",
description = "로그인 성공시 쿠키에 토큰 정보를 저장합니다."
),
ApiResponse(
responseCode = "400",
description = "존재하지 않는 회원이거나, 이메일 또는 비밀번호가 잘못 입력되었습니다.",
content = [Content(schema = Schema(implementation = ErrorResponse::class))]
)
)
fun login(
@Valid @RequestBody loginRequest: LoginRequest,
response: HttpServletResponse
): RoomEscapeApiResponse<Void>
@ResponseStatus(HttpStatus.OK)
@Operation(summary = "로그인 상태 확인")
@ApiResponses(
ApiResponse(
responseCode = "200",
description = "로그인 상태이며, 로그인된 회원의 이름을 반환합니다."
),
ApiResponse(
responseCode = "400",
description = "쿠키에 있는 토큰 정보로 회원을 조회할 수 없습니다.",
content = [Content(schema = Schema(implementation = ErrorResponse::class))]
),
ApiResponse(
responseCode = "401",
description = "토큰 정보가 없거나, 만료되었습니다.",
content = [Content(schema = Schema(implementation = ErrorResponse::class))]
)
)
fun checkLogin(@MemberId @Parameter(hidden = true) memberId: Long): RoomEscapeApiResponse<LoginCheckResponse>
@LoginRequired
@ResponseStatus(HttpStatus.OK)
@Operation(summary = "로그아웃", tags = ["로그인이 필요한 API"])
@ApiResponses(ApiResponse(responseCode = "200", description = "로그아웃 성공시 쿠키에 저장된 토큰 정보를 삭제합니다."))
fun logout(request: HttpServletRequest, response: HttpServletResponse): RoomEscapeApiResponse<Void>
}

45
src/main/java/roomescape/auth/web/AuthController.kt
View File

@ -1,21 +1,19 @@
package roomescape.auth.web package roomescape.auth.web
import io.swagger.v3.oas.annotations.Parameter import io.swagger.v3.oas.annotations.Parameter
import jakarta.servlet.http.Cookie
import jakarta.servlet.http.HttpServletRequest
import jakarta.servlet.http.HttpServletResponse
import jakarta.validation.Valid import jakarta.validation.Valid
import org.springframework.http.HttpHeaders
import org.springframework.http.ResponseEntity
import org.springframework.web.bind.annotation.GetMapping import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.PostMapping import org.springframework.web.bind.annotation.PostMapping
import org.springframework.web.bind.annotation.RequestBody import org.springframework.web.bind.annotation.RequestBody
import org.springframework.web.bind.annotation.RestController import org.springframework.web.bind.annotation.RestController
import roomescape.auth.docs.AuthAPI
import roomescape.auth.service.AuthService import roomescape.auth.service.AuthService
import roomescape.auth.web.support.MemberId import roomescape.auth.web.support.MemberId
import roomescape.auth.web.support.accessTokenCookie import roomescape.auth.web.support.expiredAccessTokenCookie
import roomescape.auth.web.support.addAccessTokenCookie import roomescape.auth.web.support.toResponseCookie
import roomescape.auth.web.support.expire import roomescape.common.dto.response.CommonApiResponse
import roomescape.auth.web.support.toCookie
import roomescape.common.dto.response.RoomEscapeApiResponse
@RestController @RestController
class AuthController( class AuthController(
@ -25,34 +23,25 @@ class AuthController(
@PostMapping("/login") @PostMapping("/login")
override fun login( override fun login(
@Valid @RequestBody loginRequest: LoginRequest, @Valid @RequestBody loginRequest: LoginRequest,
response: HttpServletResponse ): ResponseEntity<CommonApiResponse<Unit>> {
): RoomEscapeApiResponse<Void> { val response: TokenResponse = authService.login(loginRequest)
val accessToken: TokenResponse = authService.login(loginRequest)
val cookie: Cookie = accessToken.toCookie()
response.addAccessTokenCookie(cookie) return ResponseEntity.ok()
.header(HttpHeaders.SET_COOKIE, response.toResponseCookie())
return RoomEscapeApiResponse.success() .body(CommonApiResponse())
} }
@GetMapping("/login/check") @GetMapping("/login/check")
override fun checkLogin( override fun checkLogin(
@MemberId @Parameter(hidden = true) memberId: Long @MemberId @Parameter(hidden = true) memberId: Long
): RoomEscapeApiResponse<LoginCheckResponse> { ): ResponseEntity<CommonApiResponse<LoginCheckResponse>> {
val response = authService.checkLogin(memberId) val response: LoginCheckResponse = authService.checkLogin(memberId)
return RoomEscapeApiResponse.success(response) return ResponseEntity.ok(CommonApiResponse(response))
} }
@PostMapping("/logout") @PostMapping("/logout")
override fun logout( override fun logout(): ResponseEntity<CommonApiResponse<Unit>> = ResponseEntity.ok()
request: HttpServletRequest, .header(HttpHeaders.SET_COOKIE, expiredAccessTokenCookie())
response: HttpServletResponse .body(CommonApiResponse())
): RoomEscapeApiResponse<Void> {
val cookie: Cookie = request.accessTokenCookie()
cookie.expire()
response.addAccessTokenCookie(cookie)
return RoomEscapeApiResponse.success()
}
} }

6
src/main/java/roomescape/auth/web/support/AuthInterceptors.kt
View File

@ -6,11 +6,11 @@ import org.springframework.http.HttpStatus
import org.springframework.stereotype.Component import org.springframework.stereotype.Component
import org.springframework.web.method.HandlerMethod import org.springframework.web.method.HandlerMethod
import org.springframework.web.servlet.HandlerInterceptor import org.springframework.web.servlet.HandlerInterceptor
import roomescape.member.business.MemberService
import roomescape.member.infrastructure.persistence.Member
import roomescape.auth.infrastructure.jwt.JwtHandler import roomescape.auth.infrastructure.jwt.JwtHandler
import roomescape.common.exception.ErrorType import roomescape.common.exception.ErrorType
import roomescape.common.exception.RoomescapeException import roomescape.common.exception.RoomescapeException
import roomescape.member.business.MemberService
import roomescape.member.infrastructure.persistence.Member
private fun Any.isIrrelevantWith(annotationType: Class<out Annotation>): Boolean { private fun Any.isIrrelevantWith(annotationType: Class<out Annotation>): Boolean {
if (this !is HandlerMethod) { if (this !is HandlerMethod) {
@ -40,7 +40,7 @@ class LoginInterceptor(
val memberId: Long = jwtHandler.getMemberIdFromToken(token) val memberId: Long = jwtHandler.getMemberIdFromToken(token)
return memberService.existsById(memberId) return memberService.existsById(memberId)
} catch (e: RoomescapeException) { } catch (_: RoomescapeException) {
response.sendRedirect("/login") response.sendRedirect("/login")
throw RoomescapeException(ErrorType.LOGIN_REQUIRED, HttpStatus.FORBIDDEN) throw RoomescapeException(ErrorType.LOGIN_REQUIRED, HttpStatus.FORBIDDEN)
} }

29
src/main/java/roomescape/auth/web/support/CookieUtils.kt
View File

@ -2,26 +2,25 @@ package roomescape.auth.web.support
import jakarta.servlet.http.Cookie import jakarta.servlet.http.Cookie
import jakarta.servlet.http.HttpServletRequest import jakarta.servlet.http.HttpServletRequest
import jakarta.servlet.http.HttpServletResponse import org.springframework.http.ResponseCookie
import roomescape.auth.web.TokenResponse import roomescape.auth.web.TokenResponse
const val ACCESS_TOKEN_COOKIE_NAME = "accessToken" const val ACCESS_TOKEN_COOKIE_NAME = "accessToken"
fun Cookie.expire(): Unit {
this.value = ""
this.maxAge = 0
}
fun TokenResponse.toCookie(): Cookie = Cookie(ACCESS_TOKEN_COOKIE_NAME, this.accessToken)
.also { it.maxAge = 1800000 }
fun HttpServletRequest.accessTokenCookie(): Cookie = this.cookies fun HttpServletRequest.accessTokenCookie(): Cookie = this.cookies
?.firstOrNull { it.name == ACCESS_TOKEN_COOKIE_NAME } ?.firstOrNull { it.name == ACCESS_TOKEN_COOKIE_NAME }
?: Cookie(ACCESS_TOKEN_COOKIE_NAME, "") ?: Cookie(ACCESS_TOKEN_COOKIE_NAME, "")
fun HttpServletResponse.addAccessTokenCookie(cookie: Cookie) { fun TokenResponse.toResponseCookie(): String = accessTokenCookie(this.accessToken, 1800)
cookie.isHttpOnly = true .toString()
cookie.secure = true
cookie.path = "/" fun expiredAccessTokenCookie(): String = accessTokenCookie("", 0)
this.addCookie(cookie) .toString()
}
private fun accessTokenCookie(token: String, maxAgeSecond: Long): ResponseCookie =
ResponseCookie.from(ACCESS_TOKEN_COOKIE_NAME, token)
.httpOnly(true)
.secure(true)
.path("/")
.maxAge(maxAgeSecond)
.build()

14
src/main/java/roomescape/common/dto/response/CommonApiResponse.kt Normal file
View File

@ -0,0 +1,14 @@
package roomescape.common.dto.response
import com.fasterxml.jackson.annotation.JsonInclude
import roomescape.common.exception.ErrorType
@JsonInclude(JsonInclude.Include.NON_NULL)
data class CommonApiResponse<T>(
val data: T? = null,
)
data class CommonErrorResponse(
val errorType: ErrorType,
val message: String? = errorType.description
)

21
src/main/java/roomescape/common/dto/response/ErrorResponse.kt
View File

@ -1,21 +0,0 @@
package roomescape.common.dto.response
import io.swagger.v3.oas.annotations.media.Schema
import roomescape.common.exception.ErrorType
@Schema(name = "예외 응답", description = "예외 발생 시 응답에 사용됩니다.")
@JvmRecord
data class ErrorResponse(
@field:Schema(description = "발생한 예외의 종류", example = "INVALID_REQUEST_DATA")
val errorType: ErrorType,
@field:Schema(description = "예외 메시지", example = "요청 데이터 값이 올바르지 않습니다.")
val message: String
) {
companion object {
@JvmStatic
fun of(errorType: ErrorType, message: String): ErrorResponse {
return ErrorResponse(errorType, message)
}
}
}

27
src/main/java/roomescape/common/dto/response/RoomEscapeApiResponse.kt
View File

@ -1,27 +0,0 @@
package roomescape.common.dto.response
import io.swagger.v3.oas.annotations.media.Schema
@Schema(description = "API 응답 시에 사용합니다.")
@JvmRecord
data class RoomEscapeApiResponse<T>(
@field:Schema(description = "응답 메시지", defaultValue = SUCCESS_MESSAGE)
val message: String,
@field:Schema(description = "응답 바디")
val data: T? = null
) {
companion object {
private const val SUCCESS_MESSAGE = "요청이 성공적으로 수행되었습니다."
@JvmStatic
fun <T> success(data: T): RoomEscapeApiResponse<T> {
return RoomEscapeApiResponse(SUCCESS_MESSAGE, data)
}
@JvmStatic
fun success(): RoomEscapeApiResponse<Void> {
return RoomEscapeApiResponse(SUCCESS_MESSAGE, null)
}
}
}

17
src/main/java/roomescape/common/dto/response/RoomescapeApiResponse.kt Normal file
View File

@ -0,0 +1,17 @@
package roomescape.common.dto.response
import io.swagger.v3.oas.annotations.media.Schema
@Schema(name = "API 성공 응답")
@JvmRecord
data class RoomescapeApiResponse<T>(
val data: T? = null
) {
companion object {
@JvmStatic
fun <T> success(data: T): RoomescapeApiResponse<T> = RoomescapeApiResponse(data)
@JvmStatic
fun success(): RoomescapeApiResponse<Void> = RoomescapeApiResponse(null)
}
}

33
src/main/java/roomescape/common/dto/response/RoomescapeApiResponseKT.kt
View File

@ -1,33 +0,0 @@
package roomescape.common.dto.response
import com.fasterxml.jackson.annotation.JsonInclude
import roomescape.common.exception.ErrorType
@JsonInclude(JsonInclude.Include.NON_NULL)
data class RoomescapeApiResponseKT<T>(
val success: Boolean,
val data: T? = null,
val errorType: ErrorType? = null,
val message: String? = null,
) {
companion object {
@JvmStatic
fun <T> success(data: T? = null): RoomescapeApiResponseKT<T> {
return RoomescapeApiResponseKT(
success = true,
data = data,
)
}
@JvmStatic
fun <T> fail(errorType: ErrorType, message: String? = null): RoomescapeApiResponseKT<T> {
return RoomescapeApiResponseKT(
success = false,
errorType = errorType,
message = message ?: errorType.description
)
}
}
}

18
src/main/java/roomescape/common/dto/response/RoomescapeErrorResponse.kt Normal file
View File

@ -0,0 +1,18 @@
package roomescape.common.dto.response
import io.swagger.v3.oas.annotations.media.Schema
import roomescape.common.exception.ErrorType
@Schema(name = "API 에러 응답")
@JvmRecord
data class RoomescapeErrorResponse(
val errorType: ErrorType,
val message: String
) {
companion object {
@JvmStatic
fun of(errorType: ErrorType, message: String? = null): RoomescapeErrorResponse =
RoomescapeErrorResponse(errorType, message ?: errorType.description)
}
}

51
src/main/java/roomescape/common/exception/ExceptionControllerAdvice.kt
View File

@ -2,16 +2,15 @@ package roomescape.common.exception
import io.github.oshai.kotlinlogging.KLogger import io.github.oshai.kotlinlogging.KLogger
import io.github.oshai.kotlinlogging.KotlinLogging import io.github.oshai.kotlinlogging.KotlinLogging
import jakarta.servlet.http.HttpServletResponse
import org.springframework.http.HttpStatus import org.springframework.http.HttpStatus
import org.springframework.http.ResponseEntity
import org.springframework.http.converter.HttpMessageNotReadableException import org.springframework.http.converter.HttpMessageNotReadableException
import org.springframework.web.HttpRequestMethodNotSupportedException import org.springframework.web.HttpRequestMethodNotSupportedException
import org.springframework.web.bind.MethodArgumentNotValidException import org.springframework.web.bind.MethodArgumentNotValidException
import org.springframework.web.bind.annotation.ExceptionHandler import org.springframework.web.bind.annotation.ExceptionHandler
import org.springframework.web.bind.annotation.ResponseStatus
import org.springframework.web.bind.annotation.RestControllerAdvice import org.springframework.web.bind.annotation.RestControllerAdvice
import org.springframework.web.client.ResourceAccessException import org.springframework.web.client.ResourceAccessException
import roomescape.common.dto.response.ErrorResponse import roomescape.common.dto.response.CommonErrorResponse
@RestControllerAdvice @RestControllerAdvice
class ExceptionControllerAdvice( class ExceptionControllerAdvice(
@ -19,57 +18,59 @@ class ExceptionControllerAdvice(
) { ) {
@ExceptionHandler(value = [RoomescapeException::class]) @ExceptionHandler(value = [RoomescapeException::class])
fun handleRoomEscapeException( fun handleRoomEscapeException(e: RoomescapeException): ResponseEntity<CommonErrorResponse> {
e: RoomescapeException,
response: HttpServletResponse
): ErrorResponse {
logger.error(e) { "message: ${e.message}, invalidValue: ${e.invalidValue}" } logger.error(e) { "message: ${e.message}, invalidValue: ${e.invalidValue}" }
response.status = e.httpStatus.value()
return ErrorResponse.of(e.errorType, e.message!!) return ResponseEntity
.status(e.httpStatus)
.body(CommonErrorResponse(e.errorType))
} }
@ExceptionHandler(ResourceAccessException::class) @ExceptionHandler(ResourceAccessException::class)
@ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR) fun handleResourceAccessException(e: ResourceAccessException): ResponseEntity<CommonErrorResponse> {
fun handleResourceAccessException(e: ResourceAccessException): ErrorResponse {
logger.error(e) { "message: ${e.message}" } logger.error(e) { "message: ${e.message}" }
return ErrorResponse.of(ErrorType.PAYMENT_SERVER_ERROR, ErrorType.PAYMENT_SERVER_ERROR.description) return ResponseEntity
.status(HttpStatus.INTERNAL_SERVER_ERROR)
.body(CommonErrorResponse(ErrorType.PAYMENT_SERVER_ERROR))
} }
@ExceptionHandler(value = [HttpMessageNotReadableException::class]) @ExceptionHandler(value = [HttpMessageNotReadableException::class])
@ResponseStatus(HttpStatus.BAD_REQUEST) fun handleHttpMessageNotReadableException(e: HttpMessageNotReadableException): ResponseEntity<CommonErrorResponse> {
fun handleHttpMessageNotReadableException(e: HttpMessageNotReadableException): ErrorResponse {
logger.error(e) { "message: ${e.message}" } logger.error(e) { "message: ${e.message}" }
return ErrorResponse.of(ErrorType.INVALID_REQUEST_DATA_TYPE, return ResponseEntity
ErrorType.INVALID_REQUEST_DATA_TYPE.description) .status(HttpStatus.BAD_REQUEST)
.body(CommonErrorResponse(ErrorType.INVALID_REQUEST_DATA_TYPE))
} }
@ExceptionHandler(value = [MethodArgumentNotValidException::class]) @ExceptionHandler(value = [MethodArgumentNotValidException::class])
@ResponseStatus(HttpStatus.BAD_REQUEST) fun handleMethodArgumentNotValidException(e: MethodArgumentNotValidException): ResponseEntity<CommonErrorResponse> {
fun handleMethodArgumentNotValidException(e: MethodArgumentNotValidException): ErrorResponse {
val messages: String = e.bindingResult.allErrors val messages: String = e.bindingResult.allErrors
.mapNotNull { it.defaultMessage } .mapNotNull { it.defaultMessage }
.joinToString(", ") .joinToString(", ")
logger.error(e) { "message: $messages" } logger.error(e) { "message: $messages" }
return ErrorResponse.of(ErrorType.INVALID_REQUEST_DATA, messages) return ResponseEntity
.status(HttpStatus.BAD_REQUEST)
.body(CommonErrorResponse(ErrorType.INVALID_REQUEST_DATA, messages))
} }
@ExceptionHandler(value = [HttpRequestMethodNotSupportedException::class]) @ExceptionHandler(value = [HttpRequestMethodNotSupportedException::class])
@ResponseStatus(HttpStatus.METHOD_NOT_ALLOWED) fun handleHttpRequestMethodNotSupportedException(e: HttpRequestMethodNotSupportedException): ResponseEntity<CommonErrorResponse> {
fun handleHttpRequestMethodNotSupportedException(e: HttpRequestMethodNotSupportedException): ErrorResponse {
logger.error(e) { "message: ${e.message}" } logger.error(e) { "message: ${e.message}" }
return ErrorResponse.of(ErrorType.METHOD_NOT_ALLOWED, ErrorType.METHOD_NOT_ALLOWED.description) return ResponseEntity
.status(HttpStatus.METHOD_NOT_ALLOWED)
.body(CommonErrorResponse(ErrorType.METHOD_NOT_ALLOWED))
} }
@ExceptionHandler(value = [Exception::class]) @ExceptionHandler(value = [Exception::class])
@ResponseStatus(HttpStatus.INTERNAL_SERVER_ERROR) fun handleException(e: Exception): ResponseEntity<CommonErrorResponse> {
fun handleException(e: Exception): ErrorResponse {
logger.error(e) { "message: ${e.message}" } logger.error(e) { "message: ${e.message}" }
return ErrorResponse.of(ErrorType.UNEXPECTED_ERROR, ErrorType.UNEXPECTED_ERROR.description) return ResponseEntity
.status(HttpStatus.INTERNAL_SERVER_ERROR)
.body(CommonErrorResponse(ErrorType.UNEXPECTED_ERROR))
} }
} }

4
src/main/java/roomescape/member/business/MemberService.kt
View File

@ -4,12 +4,12 @@ import org.springframework.data.repository.findByIdOrNull
import org.springframework.http.HttpStatus import org.springframework.http.HttpStatus
import org.springframework.stereotype.Service import org.springframework.stereotype.Service
import org.springframework.transaction.annotation.Transactional import org.springframework.transaction.annotation.Transactional
import roomescape.common.exception.ErrorType
import roomescape.common.exception.RoomescapeException
import roomescape.member.infrastructure.persistence.Member import roomescape.member.infrastructure.persistence.Member
import roomescape.member.infrastructure.persistence.MemberRepository import roomescape.member.infrastructure.persistence.MemberRepository
import roomescape.member.web.MembersResponse import roomescape.member.web.MembersResponse
import roomescape.member.web.toResponse import roomescape.member.web.toResponse
import roomescape.common.exception.ErrorType
import roomescape.common.exception.RoomescapeException
@Service @Service
@Transactional(readOnly = true) @Transactional(readOnly = true)

21
src/main/java/roomescape/member/web/MemberAPI.kt → src/main/java/roomescape/member/docs/MemberAPI.kt
View File

@ -1,21 +1,24 @@
package roomescape.member.web package roomescape.member.docs
import io.swagger.v3.oas.annotations.Operation import io.swagger.v3.oas.annotations.Operation
import io.swagger.v3.oas.annotations.responses.ApiResponse import io.swagger.v3.oas.annotations.responses.ApiResponse
import io.swagger.v3.oas.annotations.responses.ApiResponses import io.swagger.v3.oas.annotations.responses.ApiResponses
import io.swagger.v3.oas.annotations.tags.Tag import io.swagger.v3.oas.annotations.tags.Tag
import org.springframework.http.HttpStatus import org.springframework.http.ResponseEntity
import org.springframework.web.bind.annotation.ResponseStatus
import roomescape.auth.web.support.Admin import roomescape.auth.web.support.Admin
import roomescape.common.dto.response.RoomEscapeApiResponse import roomescape.common.dto.response.CommonApiResponse
import roomescape.member.web.MembersResponse
@Tag(name = "2. 회원 API", description = "회원 정보를 관리할 때 사용합니다.") @Tag(name = "2. 회원 API", description = "회원 정보를 관리할 때 사용합니다.")
interface MemberAPI { interface MemberAPI {
@Admin @Admin
@Operation(summary = "모든 회원 조회", tags = ["관리자 로그인이 필요한 API"]) @Operation(summary = "모든 회원 조회", tags = ["관리자 로그인이 필요한 API"])
@ApiResponses(ApiResponse(responseCode = "200", description = "성공", useReturnTypeSchema = true)) @ApiResponses(
@ResponseStatus(HttpStatus.OK) ApiResponse(
fun readAllMembers(): RoomEscapeApiResponse<MembersResponse> responseCode = "200",
description = "성공",
useReturnTypeSchema = true
)
)
fun readAllMembers(): ResponseEntity<CommonApiResponse<MembersResponse>>
} }

39
src/main/java/roomescape/member/web/MemberController.kt
View File

@ -1,11 +1,11 @@
package roomescape.member.web package roomescape.member.web
import io.swagger.v3.oas.annotations.media.Schema import org.springframework.http.ResponseEntity
import org.springframework.web.bind.annotation.GetMapping import org.springframework.web.bind.annotation.GetMapping
import org.springframework.web.bind.annotation.RestController import org.springframework.web.bind.annotation.RestController
import roomescape.common.dto.response.CommonApiResponse
import roomescape.member.business.MemberService import roomescape.member.business.MemberService
import roomescape.member.infrastructure.persistence.Member import roomescape.member.docs.MemberAPI
import roomescape.common.dto.response.RoomEscapeApiResponse
@RestController @RestController
class MemberController( class MemberController(
@ -13,36 +13,9 @@ class MemberController(
) : MemberAPI { ) : MemberAPI {
@GetMapping("/members") @GetMapping("/members")
override fun readAllMembers(): RoomEscapeApiResponse<MembersResponse> { override fun readAllMembers(): ResponseEntity<CommonApiResponse<MembersResponse>> {
val result: MembersResponse = memberService.readAllMembers() val response: MembersResponse = memberService.readAllMembers()
return RoomEscapeApiResponse.success(result) return ResponseEntity.ok(CommonApiResponse(response))
} }
} }
@Schema(name = "회원 조회 응답", description = "회원 정보 조회 응답시 사용됩니다.")
data class MemberResponse(
@field:Schema(description = "회원의 고유 번호")
val id: Long,
@field:Schema(description = "회원의 이름")
val name: String
) {
companion object {
@JvmStatic
fun fromEntity(member: Member): MemberResponse {
return MemberResponse(member.id!!, member.name)
}
}
}
fun Member.toResponse(): MemberResponse = MemberResponse(
id = id!!,
name = name
)
@Schema(name = "회원 목록 조회 응답", description = "모든 회원의 정보 조회 응답시 사용됩니다.")
data class MembersResponse(
@field:Schema(description = "모든 회원의 ID 및 이름")
val members: List<MemberResponse>
)

31
src/main/java/roomescape/member/web/MemberDTO.kt Normal file
View File

@ -0,0 +1,31 @@
package roomescape.member.web
import io.swagger.v3.oas.annotations.media.Schema
import roomescape.member.infrastructure.persistence.Member
fun Member.toResponse(): MemberResponse = MemberResponse(
id = id!!,
name = name
)
@Schema(name = "회원 조회 응답", description = "회원 정보 조회 응답시 사용됩니다.")
data class MemberResponse(
@field:Schema(description = "회원의 고유 번호")
val id: Long,
@field:Schema(description = "회원의 이름")
val name: String
) {
companion object {
@JvmStatic
fun fromEntity(member: Member): MemberResponse {
return MemberResponse(member.id!!, member.name)
}
}
}
@Schema(name = "회원 목록 조회 응답", description = "모든 회원의 정보 조회 응답시 사용됩니다.")
data class MembersResponse(
@field:Schema(description = "모든 회원의 ID 및 이름")
val members: List<MemberResponse>
)

4
src/main/java/roomescape/payment/client/TossPaymentClient.java
View File

@ -14,13 +14,13 @@ import org.springframework.web.client.RestClient;
import com.fasterxml.jackson.databind.ObjectMapper; import com.fasterxml.jackson.databind.ObjectMapper;
import roomescape.common.exception.ErrorType;
import roomescape.common.exception.RoomescapeException;
import roomescape.payment.dto.request.PaymentCancelRequest; import roomescape.payment.dto.request.PaymentCancelRequest;
import roomescape.payment.dto.request.PaymentRequest; import roomescape.payment.dto.request.PaymentRequest;
import roomescape.payment.dto.response.PaymentCancelResponse; import roomescape.payment.dto.response.PaymentCancelResponse;
import roomescape.payment.dto.response.PaymentResponse; import roomescape.payment.dto.response.PaymentResponse;
import roomescape.payment.dto.response.TossPaymentErrorResponse; import roomescape.payment.dto.response.TossPaymentErrorResponse;
import roomescape.common.exception.ErrorType;
import roomescape.common.exception.RoomescapeException;
@Component @Component
public class TossPaymentClient { public class TossPaymentClient {

2
src/main/java/roomescape/payment/domain/Payment.java
View File

@ -12,9 +12,9 @@ import jakarta.persistence.GenerationType;
import jakarta.persistence.Id; import jakarta.persistence.Id;
import jakarta.persistence.JoinColumn; import jakarta.persistence.JoinColumn;
import jakarta.persistence.OneToOne; import jakarta.persistence.OneToOne;
import roomescape.reservation.domain.Reservation;
import roomescape.common.exception.ErrorType; import roomescape.common.exception.ErrorType;
import roomescape.common.exception.RoomescapeException; import roomescape.common.exception.RoomescapeException;
import roomescape.reservation.domain.Reservation;
@Entity @Entity
public class Payment { public class Payment {

4
src/main/java/roomescape/payment/service/PaymentService.java
View File

@ -7,6 +7,8 @@ import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional; import org.springframework.transaction.annotation.Transactional;
import roomescape.common.exception.ErrorType;
import roomescape.common.exception.RoomescapeException;
import roomescape.payment.domain.CanceledPayment; import roomescape.payment.domain.CanceledPayment;
import roomescape.payment.domain.Payment; import roomescape.payment.domain.Payment;
import roomescape.payment.domain.repository.CanceledPaymentRepository; import roomescape.payment.domain.repository.CanceledPaymentRepository;
@ -16,8 +18,6 @@ import roomescape.payment.dto.response.PaymentCancelResponse;
import roomescape.payment.dto.response.PaymentResponse; import roomescape.payment.dto.response.PaymentResponse;
import roomescape.payment.dto.response.ReservationPaymentResponse; import roomescape.payment.dto.response.ReservationPaymentResponse;
import roomescape.reservation.domain.Reservation; import roomescape.reservation.domain.Reservation;
import roomescape.common.exception.ErrorType;
import roomescape.common.exception.RoomescapeException;
@Service @Service
@Transactional @Transactional

70
src/main/java/roomescape/reservation/controller/ReservationController.java
View File

@ -24,6 +24,12 @@ import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.servlet.http.HttpServletResponse; import jakarta.servlet.http.HttpServletResponse;
import jakarta.validation.Valid; import jakarta.validation.Valid;
import jakarta.validation.constraints.NotNull; import jakarta.validation.constraints.NotNull;
import roomescape.auth.web.support.Admin;
import roomescape.auth.web.support.LoginRequired;
import roomescape.auth.web.support.MemberId;
import roomescape.common.dto.response.RoomescapeApiResponse;
import roomescape.common.dto.response.RoomescapeErrorResponse;
import roomescape.common.exception.RoomescapeException;
import roomescape.payment.client.TossPaymentClient; import roomescape.payment.client.TossPaymentClient;
import roomescape.payment.dto.request.PaymentCancelRequest; import roomescape.payment.dto.request.PaymentCancelRequest;
import roomescape.payment.dto.request.PaymentRequest; import roomescape.payment.dto.request.PaymentRequest;
@ -37,12 +43,6 @@ import roomescape.reservation.dto.response.ReservationResponse;
import roomescape.reservation.dto.response.ReservationsResponse; import roomescape.reservation.dto.response.ReservationsResponse;
import roomescape.reservation.service.ReservationService; import roomescape.reservation.service.ReservationService;
import roomescape.reservation.service.ReservationWithPaymentService; import roomescape.reservation.service.ReservationWithPaymentService;
import roomescape.auth.web.support.Admin;
import roomescape.auth.web.support.LoginRequired;
import roomescape.auth.web.support.MemberId;
import roomescape.common.dto.response.ErrorResponse;
import roomescape.common.dto.response.RoomEscapeApiResponse;
import roomescape.common.exception.RoomescapeException;
@RestController @RestController
@Tag(name = "3. 예약 API", description = "예약 및 대기 정보를 추가 / 조회 / 삭제할 때 사용합니다.") @Tag(name = "3. 예약 API", description = "예약 및 대기 정보를 추가 / 조회 / 삭제할 때 사용합니다.")
@ -66,8 +66,8 @@ public class ReservationController {
@ApiResponses({ @ApiResponses({
@ApiResponse(responseCode = "200", description = "성공", useReturnTypeSchema = true) @ApiResponse(responseCode = "200", description = "성공", useReturnTypeSchema = true)
}) })
public RoomEscapeApiResponse<ReservationsResponse> getAllReservations() { public RoomescapeApiResponse<ReservationsResponse> getAllReservations() {
return RoomEscapeApiResponse.success(reservationService.findAllReservations()); return RoomescapeApiResponse.success(reservationService.findAllReservations());
} }
@LoginRequired @LoginRequired
@ -77,9 +77,9 @@ public class ReservationController {
@ApiResponses({ @ApiResponses({
@ApiResponse(responseCode = "200", description = "성공", useReturnTypeSchema = true) @ApiResponse(responseCode = "200", description = "성공", useReturnTypeSchema = true)
}) })
public RoomEscapeApiResponse<MyReservationsResponse> getMemberReservations( public RoomescapeApiResponse<MyReservationsResponse> getMemberReservations(
@MemberId @Parameter(hidden = true) Long memberId) { @MemberId @Parameter(hidden = true) Long memberId) {
return RoomEscapeApiResponse.success(reservationService.findMemberReservations(memberId)); return RoomescapeApiResponse.success(reservationService.findMemberReservations(memberId));
} }
@Admin @Admin
@ -89,15 +89,15 @@ public class ReservationController {
@ApiResponses({ @ApiResponses({
@ApiResponse(responseCode = "200", description = "성공", useReturnTypeSchema = true), @ApiResponse(responseCode = "200", description = "성공", useReturnTypeSchema = true),
@ApiResponse(responseCode = "400", description = "날짜 범위를 지정할 때, 종료 날짜는 시작 날짜 이전일 수 없습니다.", @ApiResponse(responseCode = "400", description = "날짜 범위를 지정할 때, 종료 날짜는 시작 날짜 이전일 수 없습니다.",
content = @Content(schema = @Schema(implementation = ErrorResponse.class))) content = @Content(schema = @Schema(implementation = RoomescapeErrorResponse.class)))
}) })
public RoomEscapeApiResponse<ReservationsResponse> getReservationBySearching( public RoomescapeApiResponse<ReservationsResponse> getReservationBySearching(
@RequestParam(required = false) @Parameter(description = "테마 ID") Long themeId, @RequestParam(required = false) @Parameter(description = "테마 ID") Long themeId,
@RequestParam(required = false) @Parameter(description = "회원 ID") Long memberId, @RequestParam(required = false) @Parameter(description = "회원 ID") Long memberId,
@RequestParam(required = false) @Parameter(description = "yyyy-MM-dd 형식으로 입력해주세요", example = "2024-06-10") LocalDate dateFrom, @RequestParam(required = false) @Parameter(description = "yyyy-MM-dd 형식으로 입력해주세요", example = "2024-06-10") LocalDate dateFrom,
@RequestParam(required = false) @Parameter(description = "yyyy-MM-dd 형식으로 입력해주세요", example = "2024-06-10") LocalDate dateTo @RequestParam(required = false) @Parameter(description = "yyyy-MM-dd 형식으로 입력해주세요", example = "2024-06-10") LocalDate dateTo
) { ) {
return RoomEscapeApiResponse.success( return RoomescapeApiResponse.success(
reservationService.findFilteredReservations(themeId, memberId, dateFrom, dateTo)); reservationService.findFilteredReservations(themeId, memberId, dateFrom, dateTo));
} }
@ -108,16 +108,16 @@ public class ReservationController {
@ApiResponses({ @ApiResponses({
@ApiResponse(responseCode = "204", description = "성공"), @ApiResponse(responseCode = "204", description = "성공"),
@ApiResponse(responseCode = "404", description = "예약 또는 결제 정보를 찾을 수 없습니다.", @ApiResponse(responseCode = "404", description = "예약 또는 결제 정보를 찾을 수 없습니다.",
content = @Content(schema = @Schema(implementation = ErrorResponse.class))), content = @Content(schema = @Schema(implementation = RoomescapeErrorResponse.class))),
}) })
public RoomEscapeApiResponse<Void> removeReservation( public RoomescapeApiResponse<Void> removeReservation(
@MemberId @Parameter(hidden = true) Long memberId, @MemberId @Parameter(hidden = true) Long memberId,
@NotNull(message = "reservationId는 null일 수 없습니다.") @PathVariable("id") @Parameter(description = "예약 ID") Long reservationId @NotNull(message = "reservationId는 null일 수 없습니다.") @PathVariable("id") @Parameter(description = "예약 ID") Long reservationId
) { ) {
if (reservationWithPaymentService.isNotPaidReservation(reservationId)) { if (reservationWithPaymentService.isNotPaidReservation(reservationId)) {
reservationService.removeReservationById(reservationId, memberId); reservationService.removeReservationById(reservationId, memberId);
return RoomEscapeApiResponse.success(); return RoomescapeApiResponse.success();
} }
PaymentCancelRequest paymentCancelRequest = reservationWithPaymentService.removeReservationWithPayment( PaymentCancelRequest paymentCancelRequest = reservationWithPaymentService.removeReservationWithPayment(
@ -128,7 +128,7 @@ public class ReservationController {
reservationWithPaymentService.updateCanceledTime(paymentCancelRequest.paymentKey(), reservationWithPaymentService.updateCanceledTime(paymentCancelRequest.paymentKey(),
paymentCancelResponse.canceledAt()); paymentCancelResponse.canceledAt());
return RoomEscapeApiResponse.success(); return RoomescapeApiResponse.success();
} }
@LoginRequired @LoginRequired
@ -139,7 +139,7 @@ public class ReservationController {
@ApiResponse(responseCode = "201", description = "성공", useReturnTypeSchema = true, @ApiResponse(responseCode = "201", description = "성공", useReturnTypeSchema = true,
headers = @Header(name = HttpHeaders.LOCATION, description = "생성된 예약 정보 URL", schema = @Schema(example = "/reservations/1"))) headers = @Header(name = HttpHeaders.LOCATION, description = "생성된 예약 정보 URL", schema = @Schema(example = "/reservations/1")))
}) })
public RoomEscapeApiResponse<ReservationResponse> saveReservation( public RoomescapeApiResponse<ReservationResponse> saveReservation(
@Valid @RequestBody ReservationRequest reservationRequest, @Valid @RequestBody ReservationRequest reservationRequest,
@MemberId @Parameter(hidden = true) Long memberId, @MemberId @Parameter(hidden = true) Long memberId,
HttpServletResponse response HttpServletResponse response
@ -170,9 +170,9 @@ public class ReservationController {
@ApiResponses({ @ApiResponses({
@ApiResponse(responseCode = "201", description = "성공", useReturnTypeSchema = true, @ApiResponse(responseCode = "201", description = "성공", useReturnTypeSchema = true,
headers = @Header(name = HttpHeaders.LOCATION, description = "생성된 예약 정보 URL", schema = @Schema(example = "/reservations/1"))), headers = @Header(name = HttpHeaders.LOCATION, description = "생성된 예약 정보 URL", schema = @Schema(example = "/reservations/1"))),
@ApiResponse(responseCode = "409", description = "예약이 이미 존재합니다.", content = @Content(schema = @Schema(implementation = ErrorResponse.class))) @ApiResponse(responseCode = "409", description = "예약이 이미 존재합니다.", content = @Content(schema = @Schema(implementation = RoomescapeErrorResponse.class)))
}) })
public RoomEscapeApiResponse<ReservationResponse> saveReservationByAdmin( public RoomescapeApiResponse<ReservationResponse> saveReservationByAdmin(
@Valid @RequestBody AdminReservationRequest adminReservationRequest, @Valid @RequestBody AdminReservationRequest adminReservationRequest,
HttpServletResponse response HttpServletResponse response
) { ) {
@ -187,8 +187,8 @@ public class ReservationController {
@ApiResponses({ @ApiResponses({
@ApiResponse(responseCode = "200", description = "성공", useReturnTypeSchema = true) @ApiResponse(responseCode = "200", description = "성공", useReturnTypeSchema = true)
}) })
public RoomEscapeApiResponse<ReservationsResponse> getAllWaiting() { public RoomescapeApiResponse<ReservationsResponse> getAllWaiting() {
return RoomEscapeApiResponse.success(reservationService.findAllWaiting()); return RoomescapeApiResponse.success(reservationService.findAllWaiting());
} }
@LoginRequired @LoginRequired
@ -199,7 +199,7 @@ public class ReservationController {
@ApiResponse(responseCode = "201", description = "성공", useReturnTypeSchema = true, @ApiResponse(responseCode = "201", description = "성공", useReturnTypeSchema = true,
headers = @Header(name = HttpHeaders.LOCATION, description = "생성된 예약 정보 URL", schema = @Schema(example = "/reservations/1"))) headers = @Header(name = HttpHeaders.LOCATION, description = "생성된 예약 정보 URL", schema = @Schema(example = "/reservations/1")))
}) })
public RoomEscapeApiResponse<ReservationResponse> saveWaiting( public RoomescapeApiResponse<ReservationResponse> saveWaiting(
@Valid @RequestBody WaitingRequest waitingRequest, @Valid @RequestBody WaitingRequest waitingRequest,
@MemberId @Parameter(hidden = true) Long memberId, @MemberId @Parameter(hidden = true) Long memberId,
HttpServletResponse response HttpServletResponse response
@ -215,14 +215,14 @@ public class ReservationController {
@ApiResponses({ @ApiResponses({
@ApiResponse(responseCode = "204", description = "성공"), @ApiResponse(responseCode = "204", description = "성공"),
@ApiResponse(responseCode = "404", description = "회원의 예약 대기 정보를 찾을 수 없습니다.", @ApiResponse(responseCode = "404", description = "회원의 예약 대기 정보를 찾을 수 없습니다.",
content = @Content(schema = @Schema(implementation = ErrorResponse.class))) content = @Content(schema = @Schema(implementation = RoomescapeErrorResponse.class)))
}) })
public RoomEscapeApiResponse<Void> deleteWaiting( public RoomescapeApiResponse<Void> deleteWaiting(
@MemberId @Parameter(hidden = true) Long memberId, @MemberId @Parameter(hidden = true) Long memberId,
@NotNull(message = "reservationId는 null 또는 공백일 수 없습니다.") @PathVariable("id") @Parameter(description = "예약 ID") Long reservationId @NotNull(message = "reservationId는 null 또는 공백일 수 없습니다.") @PathVariable("id") @Parameter(description = "예약 ID") Long reservationId
) { ) {
reservationService.cancelWaiting(reservationId, memberId); reservationService.cancelWaiting(reservationId, memberId);
return RoomEscapeApiResponse.success(); return RoomescapeApiResponse.success();
} }
@Admin @Admin
@ -232,17 +232,17 @@ public class ReservationController {
@ApiResponses({ @ApiResponses({
@ApiResponse(responseCode = "200", description = "성공"), @ApiResponse(responseCode = "200", description = "성공"),
@ApiResponse(responseCode = "404", description = "예약 대기 정보를 찾을 수 없습니다.", @ApiResponse(responseCode = "404", description = "예약 대기 정보를 찾을 수 없습니다.",
content = @Content(schema = @Schema(implementation = ErrorResponse.class))), content = @Content(schema = @Schema(implementation = RoomescapeErrorResponse.class))),
@ApiResponse(responseCode = "409", description = "확정된 예약이 존재하여 대기 중인 예약을 승인할 수 없습니다.", @ApiResponse(responseCode = "409", description = "확정된 예약이 존재하여 대기 중인 예약을 승인할 수 없습니다.",
content = @Content(schema = @Schema(implementation = ErrorResponse.class))) content = @Content(schema = @Schema(implementation = RoomescapeErrorResponse.class)))
}) })
public RoomEscapeApiResponse<Void> approveWaiting( public RoomescapeApiResponse<Void> approveWaiting(
@MemberId @Parameter(hidden = true) Long memberId, @MemberId @Parameter(hidden = true) Long memberId,
@NotNull(message = "reservationId는 null 또는 공백일 수 없습니다.") @PathVariable("id") @Parameter(description = "예약 ID") Long reservationId @NotNull(message = "reservationId는 null 또는 공백일 수 없습니다.") @PathVariable("id") @Parameter(description = "예약 ID") Long reservationId
) { ) {
reservationService.approveWaiting(reservationId, memberId); reservationService.approveWaiting(reservationId, memberId);
return RoomEscapeApiResponse.success(); return RoomescapeApiResponse.success();
} }
@Admin @Admin
@ -252,22 +252,22 @@ public class ReservationController {
@ApiResponses({ @ApiResponses({
@ApiResponse(responseCode = "204", description = "대기 중인 예약 거절 성공"), @ApiResponse(responseCode = "204", description = "대기 중인 예약 거절 성공"),
@ApiResponse(responseCode = "404", description = "예약 대기 정보를 찾을 수 없습니다.", @ApiResponse(responseCode = "404", description = "예약 대기 정보를 찾을 수 없습니다.",
content = @Content(schema = @Schema(implementation = ErrorResponse.class))) content = @Content(schema = @Schema(implementation = RoomescapeErrorResponse.class)))
}) })
public RoomEscapeApiResponse<Void> denyWaiting( public RoomescapeApiResponse<Void> denyWaiting(
@MemberId @Parameter(hidden = true) Long memberId, @MemberId @Parameter(hidden = true) Long memberId,
@NotNull(message = "reservationId는 null 또는 공백일 수 없습니다.") @PathVariable("id") @Parameter(description = "예약 ID") Long reservationId @NotNull(message = "reservationId는 null 또는 공백일 수 없습니다.") @PathVariable("id") @Parameter(description = "예약 ID") Long reservationId
) { ) {
reservationService.denyWaiting(reservationId, memberId); reservationService.denyWaiting(reservationId, memberId);
return RoomEscapeApiResponse.success(); return RoomescapeApiResponse.success();
} }
private RoomEscapeApiResponse<ReservationResponse> getCreatedReservationResponse( private RoomescapeApiResponse<ReservationResponse> getCreatedReservationResponse(
ReservationResponse reservationResponse, ReservationResponse reservationResponse,
HttpServletResponse response HttpServletResponse response
) { ) {
response.setHeader(HttpHeaders.LOCATION, "/reservations/" + reservationResponse.id()); response.setHeader(HttpHeaders.LOCATION, "/reservations/" + reservationResponse.id());
return RoomEscapeApiResponse.success(reservationResponse); return RoomescapeApiResponse.success(reservationResponse);
} }
} }

28
src/main/java/roomescape/reservation/controller/ReservationTimeController.java
View File

@ -23,15 +23,15 @@ import io.swagger.v3.oas.annotations.tags.Tag;
import jakarta.servlet.http.HttpServletResponse; import jakarta.servlet.http.HttpServletResponse;
import jakarta.validation.Valid; import jakarta.validation.Valid;
import jakarta.validation.constraints.NotNull; import jakarta.validation.constraints.NotNull;
import roomescape.auth.web.support.Admin;
import roomescape.auth.web.support.LoginRequired;
import roomescape.common.dto.response.RoomescapeApiResponse;
import roomescape.common.dto.response.RoomescapeErrorResponse;
import roomescape.reservation.dto.request.ReservationTimeRequest; import roomescape.reservation.dto.request.ReservationTimeRequest;
import roomescape.reservation.dto.response.ReservationTimeInfosResponse; import roomescape.reservation.dto.response.ReservationTimeInfosResponse;
import roomescape.reservation.dto.response.ReservationTimeResponse; import roomescape.reservation.dto.response.ReservationTimeResponse;
import roomescape.reservation.dto.response.ReservationTimesResponse; import roomescape.reservation.dto.response.ReservationTimesResponse;
import roomescape.reservation.service.ReservationTimeService; import roomescape.reservation.service.ReservationTimeService;
import roomescape.auth.web.support.Admin;
import roomescape.auth.web.support.LoginRequired;
import roomescape.common.dto.response.ErrorResponse;
import roomescape.common.dto.response.RoomEscapeApiResponse;
@RestController @RestController
@Tag(name = "4. 예약 시간 API", description = "예약 시간을 조회 / 추가 / 삭제할 때 사용합니다.") @Tag(name = "4. 예약 시간 API", description = "예약 시간을 조회 / 추가 / 삭제할 때 사용합니다.")
@ -50,8 +50,8 @@ public class ReservationTimeController {
@ApiResponses({ @ApiResponses({
@ApiResponse(responseCode = "200", description = "성공", useReturnTypeSchema = true) @ApiResponse(responseCode = "200", description = "성공", useReturnTypeSchema = true)
}) })
public RoomEscapeApiResponse<ReservationTimesResponse> getAllTimes() { public RoomescapeApiResponse<ReservationTimesResponse> getAllTimes() {
return RoomEscapeApiResponse.success(reservationTimeService.findAllTimes()); return RoomescapeApiResponse.success(reservationTimeService.findAllTimes());
} }
@Admin @Admin
@ -61,16 +61,16 @@ public class ReservationTimeController {
@ApiResponses({ @ApiResponses({
@ApiResponse(responseCode = "201", description = "성공", useReturnTypeSchema = true), @ApiResponse(responseCode = "201", description = "성공", useReturnTypeSchema = true),
@ApiResponse(responseCode = "409", description = "같은 시간을 추가할 수 없습니다.", @ApiResponse(responseCode = "409", description = "같은 시간을 추가할 수 없습니다.",
content = @Content(schema = @Schema(implementation = ErrorResponse.class))) content = @Content(schema = @Schema(implementation = RoomescapeErrorResponse.class)))
}) })
public RoomEscapeApiResponse<ReservationTimeResponse> saveTime( public RoomescapeApiResponse<ReservationTimeResponse> saveTime(
@Valid @RequestBody ReservationTimeRequest reservationTimeRequest, @Valid @RequestBody ReservationTimeRequest reservationTimeRequest,
HttpServletResponse response HttpServletResponse response
) { ) {
ReservationTimeResponse reservationTimeResponse = reservationTimeService.addTime(reservationTimeRequest); ReservationTimeResponse reservationTimeResponse = reservationTimeService.addTime(reservationTimeRequest);
response.setHeader(HttpHeaders.LOCATION, "/times/" + reservationTimeResponse.id()); response.setHeader(HttpHeaders.LOCATION, "/times/" + reservationTimeResponse.id());
return RoomEscapeApiResponse.success(reservationTimeResponse); return RoomescapeApiResponse.success(reservationTimeResponse);
} }
@Admin @Admin
@ -80,14 +80,14 @@ public class ReservationTimeController {
@ApiResponses({ @ApiResponses({
@ApiResponse(responseCode = "204", description = "성공", useReturnTypeSchema = true), @ApiResponse(responseCode = "204", description = "성공", useReturnTypeSchema = true),
@ApiResponse(responseCode = "409", description = "예약된 시간은 삭제할 수 없습니다.", @ApiResponse(responseCode = "409", description = "예약된 시간은 삭제할 수 없습니다.",
content = @Content(schema = @Schema(implementation = ErrorResponse.class))) content = @Content(schema = @Schema(implementation = RoomescapeErrorResponse.class)))
}) })
public RoomEscapeApiResponse<Void> removeTime( public RoomescapeApiResponse<Void> removeTime(
@NotNull(message = "timeId는 null 또는 공백일 수 없습니다.") @PathVariable @Parameter(description = "삭제하고자 하는 시간의 ID값") Long id @NotNull(message = "timeId는 null 또는 공백일 수 없습니다.") @PathVariable @Parameter(description = "삭제하고자 하는 시간의 ID값") Long id
) { ) {
reservationTimeService.removeTimeById(id); reservationTimeService.removeTimeById(id);
return RoomEscapeApiResponse.success(); return RoomescapeApiResponse.success();
} }
@LoginRequired @LoginRequired
@ -97,7 +97,7 @@ public class ReservationTimeController {
@ApiResponses({ @ApiResponses({
@ApiResponse(responseCode = "200", description = "성공", useReturnTypeSchema = true) @ApiResponse(responseCode = "200", description = "성공", useReturnTypeSchema = true)
}) })
public RoomEscapeApiResponse<ReservationTimeInfosResponse> findAllAvailableReservationTimes( public RoomescapeApiResponse<ReservationTimeInfosResponse> findAllAvailableReservationTimes(
@NotNull(message = "날짜는 null일 수 없습니다.") @NotNull(message = "날짜는 null일 수 없습니다.")
@RequestParam @RequestParam
@Parameter(description = "yyyy-MM-dd 형식으로 입력해주세요.", example = "2024-06-10") @Parameter(description = "yyyy-MM-dd 형식으로 입력해주세요.", example = "2024-06-10")
@ -107,6 +107,6 @@ public class ReservationTimeController {
@Parameter(description = "조회할 테마의 ID를 입력해주세요.", example = "1") @Parameter(description = "조회할 테마의 ID를 입력해주세요.", example = "1")
Long themeId Long themeId
) { ) {
return RoomEscapeApiResponse.success(reservationTimeService.findAllAvailableTimesByDateAndTheme(date, themeId)); return RoomescapeApiResponse.success(reservationTimeService.findAllAvailableTimesByDateAndTheme(date, themeId));
} }
} }

2
src/main/java/roomescape/reservation/domain/Reservation.java
View File

@ -15,9 +15,9 @@ import jakarta.persistence.GenerationType;
import jakarta.persistence.Id; import jakarta.persistence.Id;
import jakarta.persistence.JoinColumn; import jakarta.persistence.JoinColumn;
import jakarta.persistence.ManyToOne; import jakarta.persistence.ManyToOne;
import roomescape.member.infrastructure.persistence.Member;
import roomescape.common.exception.ErrorType; import roomescape.common.exception.ErrorType;
import roomescape.common.exception.RoomescapeException; import roomescape.common.exception.RoomescapeException;
import roomescape.member.infrastructure.persistence.Member;
import roomescape.theme.domain.Theme; import roomescape.theme.domain.Theme;
@Entity @Entity

2
src/main/java/roomescape/reservation/dto/request/ReservationTimeRequest.java
View File

@ -7,9 +7,9 @@ import org.springframework.http.HttpStatus;
import io.micrometer.common.util.StringUtils; import io.micrometer.common.util.StringUtils;
import io.swagger.v3.oas.annotations.media.Schema; import io.swagger.v3.oas.annotations.media.Schema;
import jakarta.validation.constraints.NotNull; import jakarta.validation.constraints.NotNull;
import roomescape.reservation.domain.ReservationTime;
import roomescape.common.exception.ErrorType; import roomescape.common.exception.ErrorType;
import roomescape.common.exception.RoomescapeException; import roomescape.common.exception.RoomescapeException;
import roomescape.reservation.domain.ReservationTime;
@Schema(name = "예약 시간 저장 요청", description = "예약 시간 저장 요청시 사용됩니다.") @Schema(name = "예약 시간 저장 요청", description = "예약 시간 저장 요청시 사용됩니다.")
public record ReservationTimeRequest( public record ReservationTimeRequest(

4
src/main/java/roomescape/reservation/service/ReservationService.java
View File

@ -9,6 +9,8 @@ import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional; import org.springframework.transaction.annotation.Transactional;
import roomescape.common.exception.ErrorType;
import roomescape.common.exception.RoomescapeException;
import roomescape.member.business.MemberService; import roomescape.member.business.MemberService;
import roomescape.member.infrastructure.persistence.Member; import roomescape.member.infrastructure.persistence.Member;
import roomescape.reservation.domain.Reservation; import roomescape.reservation.domain.Reservation;
@ -22,8 +24,6 @@ import roomescape.reservation.dto.request.WaitingRequest;
import roomescape.reservation.dto.response.MyReservationsResponse; import roomescape.reservation.dto.response.MyReservationsResponse;
import roomescape.reservation.dto.response.ReservationResponse; import roomescape.reservation.dto.response.ReservationResponse;
import roomescape.reservation.dto.response.ReservationsResponse; import roomescape.reservation.dto.response.ReservationsResponse;
import roomescape.common.exception.ErrorType;
import roomescape.common.exception.RoomescapeException;
import roomescape.theme.domain.Theme; import roomescape.theme.domain.Theme;
import roomescape.theme.service.ThemeService; import roomescape.theme.service.ThemeService;

4
src/main/java/roomescape/reservation/service/ReservationTimeService.java
View File

@ -7,6 +7,8 @@ import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional; import org.springframework.transaction.annotation.Transactional;
import roomescape.common.exception.ErrorType;
import roomescape.common.exception.RoomescapeException;
import roomescape.reservation.domain.Reservation; import roomescape.reservation.domain.Reservation;
import roomescape.reservation.domain.ReservationTime; import roomescape.reservation.domain.ReservationTime;
import roomescape.reservation.domain.repository.ReservationRepository; import roomescape.reservation.domain.repository.ReservationRepository;
@ -16,8 +18,6 @@ import roomescape.reservation.dto.response.ReservationTimeInfoResponse;
import roomescape.reservation.dto.response.ReservationTimeInfosResponse; import roomescape.reservation.dto.response.ReservationTimeInfosResponse;
import roomescape.reservation.dto.response.ReservationTimeResponse; import roomescape.reservation.dto.response.ReservationTimeResponse;
import roomescape.reservation.dto.response.ReservationTimesResponse; import roomescape.reservation.dto.response.ReservationTimesResponse;
import roomescape.common.exception.ErrorType;
import roomescape.common.exception.RoomescapeException;
@Service @Service
@Transactional @Transactional

24
src/main/java/roomescape/theme/controller/ThemeController.java
View File

@ -23,8 +23,8 @@ import jakarta.validation.Valid;
import jakarta.validation.constraints.NotNull; import jakarta.validation.constraints.NotNull;
import roomescape.auth.web.support.Admin; import roomescape.auth.web.support.Admin;
import roomescape.auth.web.support.LoginRequired; import roomescape.auth.web.support.LoginRequired;
import roomescape.common.dto.response.ErrorResponse; import roomescape.common.dto.response.RoomescapeApiResponse;
import roomescape.common.dto.response.RoomEscapeApiResponse; import roomescape.common.dto.response.RoomescapeErrorResponse;
import roomescape.theme.dto.ThemeRequest; import roomescape.theme.dto.ThemeRequest;
import roomescape.theme.dto.ThemeResponse; import roomescape.theme.dto.ThemeResponse;
import roomescape.theme.dto.ThemesResponse; import roomescape.theme.dto.ThemesResponse;
@ -47,8 +47,8 @@ public class ThemeController {
@ApiResponses({ @ApiResponses({
@ApiResponse(responseCode = "200", description = "성공", useReturnTypeSchema = true) @ApiResponse(responseCode = "200", description = "성공", useReturnTypeSchema = true)
}) })
public RoomEscapeApiResponse<ThemesResponse> getAllThemes() { public RoomescapeApiResponse<ThemesResponse> getAllThemes() {
return RoomEscapeApiResponse.success(themeService.findAllThemes()); return RoomescapeApiResponse.success(themeService.findAllThemes());
} }
@GetMapping("/themes/most-reserved-last-week") @GetMapping("/themes/most-reserved-last-week")
@ -57,10 +57,10 @@ public class ThemeController {
@ApiResponses({ @ApiResponses({
@ApiResponse(responseCode = "200", description = "성공", useReturnTypeSchema = true) @ApiResponse(responseCode = "200", description = "성공", useReturnTypeSchema = true)
}) })
public RoomEscapeApiResponse<ThemesResponse> getMostReservedThemes( public RoomescapeApiResponse<ThemesResponse> getMostReservedThemes(
@RequestParam(defaultValue = "10") @Parameter(description = "최대로 조회할 테마 갯수") int count @RequestParam(defaultValue = "10") @Parameter(description = "최대로 조회할 테마 갯수") int count
) { ) {
return RoomEscapeApiResponse.success(themeService.getMostReservedThemesByCount(count)); return RoomescapeApiResponse.success(themeService.getMostReservedThemesByCount(count));
} }
@Admin @Admin
@ -70,16 +70,16 @@ public class ThemeController {
@ApiResponses({ @ApiResponses({
@ApiResponse(responseCode = "201", description = "성공", useReturnTypeSchema = true), @ApiResponse(responseCode = "201", description = "성공", useReturnTypeSchema = true),
@ApiResponse(responseCode = "409", description = "같은 이름의 테마를 추가할 수 없습니다.", @ApiResponse(responseCode = "409", description = "같은 이름의 테마를 추가할 수 없습니다.",
content = @Content(schema = @Schema(implementation = ErrorResponse.class))) content = @Content(schema = @Schema(implementation = RoomescapeErrorResponse.class)))
}) })
public RoomEscapeApiResponse<ThemeResponse> saveTheme( public RoomescapeApiResponse<ThemeResponse> saveTheme(
@Valid @RequestBody ThemeRequest request, @Valid @RequestBody ThemeRequest request,
HttpServletResponse response HttpServletResponse response
) { ) {
ThemeResponse themeResponse = themeService.addTheme(request); ThemeResponse themeResponse = themeService.addTheme(request);
response.setHeader(HttpHeaders.LOCATION, "/themes/" + themeResponse.id()); response.setHeader(HttpHeaders.LOCATION, "/themes/" + themeResponse.id());
return RoomEscapeApiResponse.success(themeResponse); return RoomescapeApiResponse.success(themeResponse);
} }
@Admin @Admin
@ -89,13 +89,13 @@ public class ThemeController {
@ApiResponses({ @ApiResponses({
@ApiResponse(responseCode = "204", description = "성공", useReturnTypeSchema = true), @ApiResponse(responseCode = "204", description = "성공", useReturnTypeSchema = true),
@ApiResponse(responseCode = "409", description = "예약된 테마는 삭제할 수 없습니다.", @ApiResponse(responseCode = "409", description = "예약된 테마는 삭제할 수 없습니다.",
content = @Content(schema = @Schema(implementation = ErrorResponse.class))) content = @Content(schema = @Schema(implementation = RoomescapeErrorResponse.class)))
}) })
public RoomEscapeApiResponse<Void> removeTheme( public RoomescapeApiResponse<Void> removeTheme(
@NotNull(message = "themeId는 null일 수 없습니다.") @PathVariable Long id @NotNull(message = "themeId는 null일 수 없습니다.") @PathVariable Long id
) { ) {
themeService.removeThemeById(id); themeService.removeThemeById(id);
return RoomEscapeApiResponse.success(); return RoomescapeApiResponse.success();
} }
} }

6
src/main/java/roomescape/theme/service/ThemeService.java
View File

@ -7,9 +7,9 @@ import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Service; import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional; import org.springframework.transaction.annotation.Transactional;
import roomescape.reservation.domain.repository.ReservationRepository;
import roomescape.common.exception.ErrorType; import roomescape.common.exception.ErrorType;
import roomescape.common.exception.RoomescapeException; import roomescape.common.exception.RoomescapeException;
import roomescape.reservation.domain.repository.ReservationRepository;
import roomescape.theme.domain.Theme; import roomescape.theme.domain.Theme;
import roomescape.theme.domain.repository.ThemeRepository; import roomescape.theme.domain.repository.ThemeRepository;
import roomescape.theme.dto.ThemeRequest; import roomescape.theme.dto.ThemeRequest;
@ -21,11 +21,9 @@ import roomescape.theme.dto.ThemesResponse;
public class ThemeService { public class ThemeService {
private final ThemeRepository themeRepository; private final ThemeRepository themeRepository;
private final ReservationRepository reservationRepository;
public ThemeService(ThemeRepository themeRepository, ReservationRepository reservationRepository) { public ThemeService(ThemeRepository themeRepository) {
this.themeRepository = themeRepository; this.themeRepository = themeRepository;
this.reservationRepository = reservationRepository;
} }
@Transactional(readOnly = true) @Transactional(readOnly = true)

5
src/test/java/roomescape/auth/web/AuthControllerTest.kt
View File

@ -4,10 +4,9 @@ import io.mockk.every
import org.hamcrest.Matchers.containsString import org.hamcrest.Matchers.containsString
import org.hamcrest.Matchers.`is` import org.hamcrest.Matchers.`is`
import org.springframework.data.repository.findByIdOrNull import org.springframework.data.repository.findByIdOrNull
import roomescape.auth.web.LoginRequest import roomescape.common.exception.ErrorType
import roomescape.util.MemberFixture import roomescape.util.MemberFixture
import roomescape.util.RoomescapeApiTest import roomescape.util.RoomescapeApiTest
import roomescape.common.exception.ErrorType
class AuthControllerTest : RoomescapeApiTest() { class AuthControllerTest : RoomescapeApiTest() {
@ -32,7 +31,7 @@ class AuthControllerTest : RoomescapeApiTest() {
runPostTest(endpoint, body = MemberFixture.userLoginRequest()) { runPostTest(endpoint, body = MemberFixture.userLoginRequest()) {
statusCode(200) statusCode(200)
cookie("accessToken", expectedToken) cookie("accessToken", expectedToken)
header("Set-Cookie", containsString("Max-Age=1800000")) header("Set-Cookie", containsString("Max-Age=1800"))
header("Set-Cookie", containsString("HttpOnly")) header("Set-Cookie", containsString("HttpOnly"))
header("Set-Cookie", containsString("Secure")) header("Set-Cookie", containsString("Secure"))
} }

72
src/test/java/roomescape/auth/web/support/CookieUtilsTest.kt Normal file
View File

@ -0,0 +1,72 @@
package roomescape.auth.web.support
import io.kotest.assertions.assertSoftly
import io.kotest.core.spec.style.FunSpec
import io.kotest.matchers.collections.shouldContainAll
import io.kotest.matchers.shouldBe
import io.mockk.every
import io.mockk.mockk
import jakarta.servlet.http.Cookie
import jakarta.servlet.http.HttpServletRequest
import roomescape.auth.web.TokenResponse
class CookieUtilsTest : FunSpec({
context("HttpServletRequest에서 accessToken 쿠키를 가져온다.") {
val httpServletRequest: HttpServletRequest = mockk()
test("accessToken이 있으면 해당 쿠키를 반환한다.") {
val token = "test-token"
val cookie = Cookie(ACCESS_TOKEN_COOKIE_NAME, token)
every { httpServletRequest.cookies } returns arrayOf(cookie)
assertSoftly(httpServletRequest.accessTokenCookie()) {
this.name shouldBe ACCESS_TOKEN_COOKIE_NAME
this.value shouldBe token
}
}
test("accessToken이 없으면 accessToken에 빈 값을 담은 쿠키를 반환한다.") {
every { httpServletRequest.cookies } returns arrayOf()
assertSoftly(httpServletRequest.accessTokenCookie()) {
this.name shouldBe ACCESS_TOKEN_COOKIE_NAME
this.value shouldBe ""
}
}
test("httpServletRequest.cookies가 null이면 accessToken에 빈 값을 담은 쿠키를 반환한다.") {
every { httpServletRequest.cookies } returns null
assertSoftly(httpServletRequest.accessTokenCookie()) {
this.name shouldBe ACCESS_TOKEN_COOKIE_NAME
this.value shouldBe ""
}
}
}
context("TokenResponse를 쿠키로 반환한다.") {
val tokenResponse = TokenResponse("test-token")
val result: String = tokenResponse.toResponseCookie()
result.split("; ") shouldContainAll listOf(
"accessToken=test-token",
"HttpOnly",
"Secure",
"Path=/",
"Max-Age=1800"
)
}
context("만료된 accessToken 쿠키를 반환한다.") {
val result: String = expiredAccessTokenCookie()
result.split("; ") shouldContainAll listOf(
"accessToken=",
"HttpOnly",
"Secure",
"Path=/",
"Max-Age=0"
)
}
})

316
src/test/java/roomescape/common/dto/response/RoomescapeApiResponseKTTest.kt
View File

@ -1,158 +1,158 @@
package roomescape.common.dto.response //package roomescape.common.dto.response
//
import com.fasterxml.jackson.databind.ObjectMapper //import com.fasterxml.jackson.databind.ObjectMapper
import com.ninjasquad.springmockk.MockkBean //import com.ninjasquad.springmockk.MockkBean
import com.ninjasquad.springmockk.SpykBean //import com.ninjasquad.springmockk.SpykBean
import io.kotest.core.spec.style.BehaviorSpec //import io.kotest.core.spec.style.BehaviorSpec
import org.hamcrest.CoreMatchers.equalTo //import org.hamcrest.CoreMatchers.equalTo
import org.springframework.beans.factory.annotation.Autowired //import org.springframework.beans.factory.annotation.Autowired
import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest //import org.springframework.boot.test.autoconfigure.web.servlet.WebMvcTest
import org.springframework.http.MediaType //import org.springframework.http.MediaType
import org.springframework.test.web.servlet.MockMvc //import org.springframework.test.web.servlet.MockMvc
import org.springframework.test.web.servlet.get //import org.springframework.test.web.servlet.get
import org.springframework.test.web.servlet.post //import org.springframework.test.web.servlet.post
import org.springframework.web.bind.annotation.* //import org.springframework.web.bind.annotation.*
import roomescape.auth.infrastructure.jwt.JwtHandler //import roomescape.auth.infrastructure.jwt.JwtHandler
import roomescape.auth.web.support.AdminInterceptor //import roomescape.auth.web.support.AdminInterceptor
import roomescape.auth.web.support.LoginInterceptor //import roomescape.auth.web.support.LoginInterceptor
import roomescape.auth.web.support.MemberIdResolver //import roomescape.auth.web.support.MemberIdResolver
import roomescape.common.exception.ErrorType //import roomescape.common.exception.ErrorType
import roomescape.member.business.MemberService //import roomescape.member.business.MemberService
import roomescape.member.infrastructure.persistence.MemberRepository //import roomescape.member.infrastructure.persistence.MemberRepository
//
@WebMvcTest(ApiResponseTestController::class) //@WebMvcTest(ApiResponseTestController::class)
class RoomescapeApiResponseKTTest( //class RoomescapeApiResponseKTTest(
@Autowired private val mockMvc: MockMvc // @Autowired private val mockMvc: MockMvc
) : BehaviorSpec() { //) : BehaviorSpec() {
@Autowired // @Autowired
private lateinit var AdminInterceptor: AdminInterceptor // private lateinit var AdminInterceptor: AdminInterceptor
//
@Autowired // @Autowired
private lateinit var loginInterceptor: LoginInterceptor // private lateinit var loginInterceptor: LoginInterceptor
//
@Autowired // @Autowired
private lateinit var memberIdResolver: MemberIdResolver // private lateinit var memberIdResolver: MemberIdResolver
//
@SpykBean // @SpykBean
private lateinit var memberService: MemberService // private lateinit var memberService: MemberService
//
@MockkBean // @MockkBean
private lateinit var memberRepository: MemberRepository // private lateinit var memberRepository: MemberRepository
//
@MockkBean // @MockkBean
private lateinit var jwtHandler: JwtHandler // private lateinit var jwtHandler: JwtHandler
//
init { // init {
Given("성공 응답에") { // Given("성공 응답에") {
val endpoint = "/success" // val endpoint = "/success"
When("객체 데이터를 담으면") { // When("객체 데이터를 담으면") {
val id: Long = 1L // val id: Long = 1L
val name = "name" // val name = "name"
Then("success=true, data={객체} 형태로 응답한다.") { // Then("success=true, data={객체} 형태로 응답한다.") {
mockMvc.post("$endpoint/$id/$name") { // mockMvc.post("$endpoint/$id/$name") {
contentType = MediaType.APPLICATION_JSON // contentType = MediaType.APPLICATION_JSON
}.andDo { // }.andDo {
print() // print()
}.andExpect { // }.andExpect {
status { isOk() } // status { isOk() }
jsonPath("$.success", equalTo(true)) // jsonPath("$.success", equalTo(true))
jsonPath("$.data.id", equalTo(id.toInt())) // jsonPath("$.data.id", equalTo(id.toInt()))
jsonPath("$.data.name", equalTo(name)) // jsonPath("$.data.name", equalTo(name))
} // }
} // }
} // }
//
When("문자열 데이터를 담으면") { // When("문자열 데이터를 담으면") {
val message: String = "Hello, World!" // val message: String = "Hello, World!"
//
Then("success=true, data={문자열} 형태로 응답한다.") { // Then("success=true, data={문자열} 형태로 응답한다.") {
mockMvc.get("/success/$message") { // mockMvc.get("/success/$message") {
contentType = MediaType.APPLICATION_JSON // contentType = MediaType.APPLICATION_JSON
}.andDo { // }.andDo {
print() // print()
}.andExpect { // }.andExpect {
status { isOk() } // status { isOk() }
jsonPath("$.success", equalTo(true)) // jsonPath("$.success", equalTo(true))
jsonPath("$.data", equalTo(message)) // jsonPath("$.data", equalTo(message))
} // }
} // }
} // }
} // }
//
Given("실패 응답에") { // Given("실패 응답에") {
val endpoint = "/fail" // val endpoint = "/fail"
val objectMapper = ObjectMapper() // val objectMapper = ObjectMapper()
//
When("errorType만 담으면") { // When("errorType만 담으면") {
Then("success=false, errorType={errorType}, message={errorType.description} 형태로 응답한다.") { // Then("success=false, errorType={errorType}, message={errorType.description} 형태로 응답한다.") {
mockMvc.post(endpoint) { // mockMvc.post(endpoint) {
contentType = MediaType.APPLICATION_JSON // contentType = MediaType.APPLICATION_JSON
content = objectMapper.writeValueAsString(FailRequest(errorType = ErrorType.INTERNAL_SERVER_ERROR)) // content = objectMapper.writeValueAsString(FailRequest(errorType = ErrorType.INTERNAL_SERVER_ERROR))
}.andDo { // }.andDo {
print() // print()
}.andExpect { // }.andExpect {
status { isOk() } // status { isOk() }
jsonPath("$.success", equalTo(false)) // jsonPath("$.success", equalTo(false))
jsonPath("$.errorType", equalTo(ErrorType.INTERNAL_SERVER_ERROR.name)) // jsonPath("$.errorType", equalTo(ErrorType.INTERNAL_SERVER_ERROR.name))
jsonPath("$.message", equalTo(ErrorType.INTERNAL_SERVER_ERROR.description)) // jsonPath("$.message", equalTo(ErrorType.INTERNAL_SERVER_ERROR.description))
} // }
} // }
} // }
//
When("errorType과 message를 담으면") { // When("errorType과 message를 담으면") {
val message: String = "An error occurred" // val message: String = "An error occurred"
//
Then("success=false, errorType={errorType}, message={message} 형태로 응답한다.") { // Then("success=false, errorType={errorType}, message={message} 형태로 응답한다.") {
mockMvc.post(endpoint) { // mockMvc.post(endpoint) {
contentType = MediaType.APPLICATION_JSON // contentType = MediaType.APPLICATION_JSON
content = objectMapper.writeValueAsString(FailRequest(errorType = ErrorType.INTERNAL_SERVER_ERROR, message = message)) // content = objectMapper.writeValueAsString(FailRequest(errorType = ErrorType.INTERNAL_SERVER_ERROR, message = message))
}.andDo { // }.andDo {
print() // print()
}.andExpect { // }.andExpect {
status { isOk() } // status { isOk() }
jsonPath("$.success", equalTo(false)) // jsonPath("$.success", equalTo(false))
jsonPath("$.errorType", equalTo(ErrorType.INTERNAL_SERVER_ERROR.name)) // jsonPath("$.errorType", equalTo(ErrorType.INTERNAL_SERVER_ERROR.name))
jsonPath("$.message", equalTo(message)) // jsonPath("$.message", equalTo(message))
} // }
} // }
} // }
} // }
} // }
} //}
//
data class SuccessResponse( //data class SuccessResponse(
val id: Long, // val id: Long,
val name: String // val name: String
) //)
//
data class FailRequest( //data class FailRequest(
val errorType: ErrorType, // val errorType: ErrorType,
val message: String? = null // val message: String? = null
) //)
//
@RestController //@RestController
class ApiResponseTestController { //class ApiResponseTestController {
//
@GetMapping("/success/{message}") // @GetMapping("/success/{message}")
fun succeedToGet( // fun succeedToGet(
@PathVariable message: String, // @PathVariable message: String,
): RoomescapeApiResponseKT<String> = // ): RoomescapeApiResponseKT<String> =
RoomescapeApiResponseKT.success(message) // RoomescapeApiResponseKT.success(message)
//
//
@PostMapping("/success/{id}/{name}") // @PostMapping("/success/{id}/{name}")
fun succeedToPost( // fun succeedToPost(
@PathVariable id: Long, // @PathVariable id: Long,
@PathVariable name: String, // @PathVariable name: String,
): RoomescapeApiResponseKT<SuccessResponse> = // ): RoomescapeApiResponseKT<SuccessResponse> =
RoomescapeApiResponseKT.success(SuccessResponse(id, name)) // RoomescapeApiResponseKT.success(SuccessResponse(id, name))
//
//
@PostMapping("/fail") // @PostMapping("/fail")
fun fail( // fun fail(
@RequestBody request: FailRequest // @RequestBody request: FailRequest
): RoomescapeApiResponseKT<Unit> = // ): RoomescapeApiResponseKT<Unit> =
request.message?.let { // request.message?.let {
RoomescapeApiResponseKT.fail(request.errorType, it) // RoomescapeApiResponseKT.fail(request.errorType, it)
} ?: RoomescapeApiResponseKT.fail(request.errorType) // } ?: RoomescapeApiResponseKT.fail(request.errorType)
} //}