refactor: set ddl-auto: validate

* test: 유저 통합테스트 추가

* test: JwtFilter 테스트케이스 추가

* refactor: 매직넘버 제거

* refactor: 회원탈퇴 / 패스워드 변경 검증 로직 수정

README.md

@@ -91,7 +91,7 @@ erDiagram
         bigint seat_id FK "좌석 ID"
         bigint movie_time_id FK "상영시간표 ID"
         bigint payment_id "결제 ID"
-        varchar status "상태 - 구매가능/예약진행중/판매완료"
+        varchar status "상태 - 판매가능/예약/"
         int ticket_price "가격"
         datetime deleted_at "삭제일시"
         datetime created_at "등록일시"
@@ -101,10 +101,11 @@ erDiagram
     PAYMENT {
         bigint id PK "결제 ID"
         bigint user_alternate_id "유저 대체ID"
+        varchar tid "카카오페이 결제고유번호"
         varchar movie_title "영화제목"
         varchar type "결제 타입 - 예) 네이버페이, 카카오페이"
-        varchar status "상태 - 완료/환불/실패"
+        varchar status "상태 - 완료/환불"
-        varchar failed_message "실패사유 - 컬럼명을 알아보기 쉬운가?"
+        varchar failed_message "실패사유"
         varchar payment_number "예매번호"
         int total_price "결제 금액"
         datetime deleted_at "삭제일시"

server/Dockerfile

@@ -0,0 +1,12 @@
+FROM openjdk:11-jre-slim
+
+ENV APP_HOME=/usr/app/
+
+WORKDIR $APP_HOME
+
+COPY build/libs/server-0.0.1-SNAPSHOT.jar application.jar
+
+EXPOSE 8443
+EXPOSE 8080
+
+CMD ["java", "-jar", "application.jar"]

server/src/intTest/java/com/ticketing/server/global/config/WithAuthUser.java

@@ -0,0 +1,15 @@
+package com.ticketing.server.global.config;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import org.springframework.security.test.context.support.WithSecurityContext;
+
+@Retention(RetentionPolicy.RUNTIME)
+@WithSecurityContext(factory = WithAuthUserSecurityContextFactory.class)
+public @interface WithAuthUser {
+
+	String email();
+
+	String role();
+
+}

server/src/intTest/java/com/ticketing/server/global/config/WithAuthUserSecurityContextFactory.java

@@ -0,0 +1,27 @@
+package com.ticketing.server.global.config;
+
+import java.util.List;
+import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
+import org.springframework.security.core.authority.SimpleGrantedAuthority;
+import org.springframework.security.core.context.SecurityContext;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.security.core.userdetails.User;
+import org.springframework.security.test.context.support.WithSecurityContextFactory;
+
+public class WithAuthUserSecurityContextFactory implements WithSecurityContextFactory<WithAuthUser> {
+
+	@Override
+	public SecurityContext createSecurityContext(WithAuthUser annotation) {
+		String email = annotation.email();
+		String role = annotation.role();
+		List<SimpleGrantedAuthority> authorities = List.of(new SimpleGrantedAuthority(role));
+
+		User authUser = new User(email, "", authorities);
+		UsernamePasswordAuthenticationToken token =
+			new UsernamePasswordAuthenticationToken(authUser, "", authorities);
+		SecurityContext context = SecurityContextHolder.getContext();
+		context.setAuthentication(token);
+		return context;
+	}
+
+}

server/src/intTest/java/com/ticketing/server/user/application/UserControllerTest.java

@@ -1,7 +1,242 @@
 package com.ticketing.server.user.application;
 
-import static org.junit.jupiter.api.Assertions.*;
+import static org.springframework.http.MediaType.APPLICATION_JSON;
+import static org.springframework.security.test.web.servlet.setup.SecurityMockMvcConfigurers.springSecurity;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.delete;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
+import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.put;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
+import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
 
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.ticketing.server.global.config.WithAuthUser;
+import com.ticketing.server.user.application.request.LoginRequest;
+import com.ticketing.server.user.application.request.SignUpRequest;
+import com.ticketing.server.user.application.request.UserChangeGradeRequest;
+import com.ticketing.server.user.application.request.UserChangePasswordRequest;
+import com.ticketing.server.user.application.request.UserDeleteRequest;
+import com.ticketing.server.user.domain.UserGrade;
+import com.ticketing.server.user.domain.UserGrade.ROLES;
+import com.ticketing.server.user.domain.repository.UserRepository;
+import org.junit.jupiter.api.BeforeEach;
+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.boot.test.context.SpringBootTest.WebEnvironment;
+import org.springframework.http.MediaType;
+import org.springframework.test.web.servlet.MockMvc;
+import org.springframework.test.web.servlet.ResultActions;
+import org.springframework.test.web.servlet.setup.MockMvcBuilders;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.web.context.WebApplicationContext;
+
+@SpringBootTest(webEnvironment = WebEnvironment.RANDOM_PORT)
+@Transactional
 class UserControllerTest {
 
+	private static final String LOGIN_URL = "/api/auth/token";
+
+	private static final String BASICS_URL = "/api/users";
+	private static final String DETAILS_URL = "/api/users/details";
+	private static final String CHANGE_PASSWORD_URL = "/api/users/password";
+	private static final String CHANGE_GRADE_URL = "/api/users/grade";
+
+	private static final String NAME = "$.name";
+	private static final String EMAIL = "$.email";
+	private static final String GRADE = "$.grade";
+	private static final String PHONE = "$.phone";
+	private static final String BEFORE_GRADE = "$.beforeGrade";
+	private static final String AFTER_GRADE = "$.afterGrade";
+
+	private static final String USER_EMAIL = "testemail@ticketing.com";
+	private static final String USER_PW = "qwe123";
+	private static final String USER_NAME = "김철수";
+	private static final String USER_PHONE = "010-1234-5678";
+
+	@Autowired
+	UserRepository userRepository;
+
+	@Autowired
+	ObjectMapper mapper;
+
+	@Autowired
+	WebApplicationContext context;
+
+	MockMvc mvc;
+
+	SignUpRequest signUpRequest;
+
+
+	@Test
+	@DisplayName("회원가입 성공")
+	void registerSuccess() throws Exception {
+		// given
+		// when
+		ResultActions resultActions = mvc.perform(
+			post(BASICS_URL)
+				.content(mapper.writeValueAsString(signUpRequest))
+				.contentType(APPLICATION_JSON)
+		);
+
+		// then
+		resultActions
+			.andExpect(status().isCreated())
+			.andExpect(content().contentType(APPLICATION_JSON))
+			.andExpect(jsonPath(NAME).value(USER_NAME))
+			.andExpect(jsonPath(EMAIL).value(USER_EMAIL));
+	}
+
+	@Test
+	@DisplayName("유저 정보 조회")
+	@WithAuthUser(email = USER_EMAIL, role = ROLES.USER)
+	void detailsSuccess() throws Exception {
+		// given
+		mvc.perform(
+			post(BASICS_URL)
+				.content(mapper.writeValueAsString(signUpRequest))
+				.contentType(APPLICATION_JSON)
+		);
+
+		// when
+		ResultActions resultActions = mvc.perform(
+			get(DETAILS_URL)
+				.content(mapper.writeValueAsString(signUpRequest))
+				.contentType(APPLICATION_JSON)
+		);
+
+		// then
+		resultActions
+			.andExpect(status().isOk())
+			.andExpect(content().contentType(APPLICATION_JSON))
+			.andExpect(jsonPath(NAME).value(USER_NAME))
+			.andExpect(jsonPath(EMAIL).value(USER_EMAIL))
+			.andExpect(jsonPath(GRADE).value(UserGrade.USER.name()))
+			.andExpect(jsonPath(PHONE).value(USER_PHONE));
+	}
+
+	@Test
+	@DisplayName("유저 탈퇴 성공")
+	@WithAuthUser(email = USER_EMAIL, role = ROLES.USER)
+	void deleteUserSuccess() throws Exception {
+		// given
+		UserDeleteRequest deleteRequest = new UserDeleteRequest(USER_EMAIL, USER_PW);
+		LoginRequest loginRequest = new LoginRequest(USER_EMAIL, USER_PW);
+		mvc.perform(
+			post(BASICS_URL)
+				.content(mapper.writeValueAsString(signUpRequest))
+				.contentType(APPLICATION_JSON)
+		);
+
+		// when
+
+		// 1. 회원 탈퇴 진행
+		mvc.perform(
+			delete(BASICS_URL)
+				.content(mapper.writeValueAsString(deleteRequest))
+				.contentType(APPLICATION_JSON)
+		);
+
+		// 2. 탈퇴된 계정 로그인
+		ResultActions resultActions = mvc.perform(post(LOGIN_URL)
+			.content(mapper.writeValueAsString(loginRequest))
+			.contentType(MediaType.APPLICATION_JSON));
+
+		// then
+		resultActions
+			.andExpect(status().isUnauthorized());
+	}
+
+	@Test
+	@DisplayName("비밀번호 변경 성공")
+	@WithAuthUser(email = USER_EMAIL, role = ROLES.USER)
+	void changePasswordSuccess() throws Exception {
+		// given
+		UserChangePasswordRequest changePasswordRequest = new UserChangePasswordRequest(USER_PW, "qwe1234");
+		LoginRequest loginRequest = new LoginRequest(USER_EMAIL, USER_PW);
+		mvc.perform(
+			post(BASICS_URL)
+				.content(mapper.writeValueAsString(this.signUpRequest))
+				.contentType(APPLICATION_JSON)
+		);
+
+		// when
+
+		// 1. 패스워드 변경
+		mvc.perform(
+				put(CHANGE_PASSWORD_URL)
+					.content(mapper.writeValueAsString(changePasswordRequest))
+					.contentType(APPLICATION_JSON)
+			)
+			.andExpect(status().isOk());
+
+		// 2. 변경 전 계정으로 로그인
+		ResultActions resultActions = mvc.perform(post(LOGIN_URL)
+			.content(mapper.writeValueAsString(loginRequest))
+			.contentType(MediaType.APPLICATION_JSON));
+
+		// then
+		resultActions
+			.andExpect(status().isUnauthorized());
+	}
+
+	@Test
+	@DisplayName("유저 등급 변경")
+	@WithAuthUser(email = "admin@ticketing.com", role = ROLES.ADMIN)
+	void changeGradeSuccess() throws Exception {
+		// given
+		UserChangeGradeRequest changeGradeRequest = new UserChangeGradeRequest(USER_EMAIL, UserGrade.STAFF);
+		mvc.perform(
+			post(BASICS_URL)
+				.content(mapper.writeValueAsString(signUpRequest))
+				.contentType(APPLICATION_JSON)
+		);
+
+		// when
+		ResultActions resultActions = mvc.perform(
+			post(CHANGE_GRADE_URL)
+				.content(mapper.writeValueAsString(changeGradeRequest))
+				.contentType(APPLICATION_JSON)
+		);
+
+		// then
+		resultActions
+			.andExpect(status().isOk())
+			.andExpect(content().contentType(APPLICATION_JSON))
+			.andExpect(jsonPath(EMAIL).value(USER_EMAIL))
+			.andExpect(jsonPath(BEFORE_GRADE).value(UserGrade.USER.name()))
+			.andExpect(jsonPath(AFTER_GRADE).value(UserGrade.STAFF.name()));
+	}
+
+	@Test
+	@DisplayName("유저 등급 변경 실패 - 권한 등급이 낮을 경우")
+	@WithAuthUser(email = "staff@ticketing.com", role = ROLES.STAFF)
+	void changeGradeFail() throws Exception {
+		// given
+		UserChangeGradeRequest changeGradeRequest = new UserChangeGradeRequest(USER_EMAIL, UserGrade.STAFF);
+
+		// when
+		ResultActions resultActions = mvc.perform(
+			post(CHANGE_GRADE_URL)
+				.content(mapper.writeValueAsString(changeGradeRequest))
+				.contentType(APPLICATION_JSON)
+		);
+
+		// then
+		resultActions
+			.andExpect(status().isForbidden());
+	}
+
+	@BeforeEach
+	void init() {
+		mvc = MockMvcBuilders
+			.webAppContextSetup(context)
+			.apply(springSecurity())
+			.build();
+
+		signUpRequest = new SignUpRequest(USER_NAME, USER_EMAIL, USER_PW, USER_PHONE);
+	}
+
 }

server/src/intTest/resources/application.yml

@@ -20,6 +20,9 @@ spring:
     pathmatch:
       matching-strategy: ant_path_matcher
 
+  config:
+    import: "optional:configserver:"
+
 jasypt:
   encryptor:
     bean: jasyptStringEncryptor

server/src/main/java/com/ticketing/server/global/exception/ErrorCode.java

@@ -24,6 +24,8 @@ public enum ErrorCode {
 	BAD_REQUEST_PAYMENT_COMPLETE(BAD_REQUEST, "처리할 결제 정보가 존재하지 않습니다."),
 	BAD_REQUEST_PAYMENT_READY(BAD_REQUEST, "이미 진행 중인 결제가 존재합니다."),
 	BAD_REQUEST_PAYMENT_CANCEL(BAD_REQUEST, "취소할 티켓이 존재하지 않습니다."),
+	NOT_REFUNDABLE_TIME(BAD_REQUEST, "환불이 가능한 시간이 지났습니다."),
+	NOT_REFUNDABLE_SEAT(BAD_REQUEST, "환불할 수 있는 좌석이 아닙니다."),
 
 	/* 403 FORBIDDEN : 접근 권한 제한 */
 	VALID_USER_ID(FORBIDDEN, "해당 정보에 접근 권한이 존재하지 않습니다."),
@@ -32,6 +34,7 @@ public enum ErrorCode {
 	USER_NOT_FOUND(NOT_FOUND, "해당 유저 정보를 찾을 수 없습니다."),
 	EMAIL_NOT_FOUND(NOT_FOUND, "해당 이메일을 찾을 수 없습니다."),
 	MOVIE_NOT_FOUND(NOT_FOUND, "해당 제목의 영화를 찾을 수 없습니다."),
+	MOVIE_TIME_NOT_FOUND(NOT_FOUND, "해당 영화 시간표 정보를 찾을 수 없습니다"),
 	REFRESH_TOKEN_NOT_FOUND(NOT_FOUND, "리프레쉬 토큰을 찾을 수 없습니다."),
 	PAYMENT_ID_NOT_FOUND(NOT_FOUND, "결제정보를 찾을 수 없습니다."),
 	THEATER_NOT_FOUND(NOT_FOUND, "상영관 정보를 찾을 수 없습니다."),
@@ -84,6 +87,14 @@ public enum ErrorCode {
 		throw new TicketingException(BAD_REQUEST_PAYMENT_CANCEL);
 	}
 
+	public static TicketingException throwNotRefundableTime() {
+		throw new TicketingException(NOT_REFUNDABLE_TIME);
+	}
+
+	public static TicketingException throwNotRefundableSeat() {
+		throw new TicketingException(NOT_REFUNDABLE_SEAT);
+	}
+
 	/* 403 FORBIDDEN : 접근 권한 제한 */
 	public static TicketingException throwValidUserId() {
 		throw new TicketingException(VALID_USER_ID);
@@ -102,6 +113,10 @@ public enum ErrorCode {
 		throw new TicketingException(MOVIE_NOT_FOUND);
 	}
 
+	public static TicketingException throwMovieTimeNotFound() {
+		throw new TicketingException(MOVIE_TIME_NOT_FOUND);
+	}
+
 	public static TicketingException throwRefreshTokenNotFound() {
 		throw new TicketingException(REFRESH_TOKEN_NOT_FOUND);
 	}

server/src/main/java/com/ticketing/server/global/exception/GlobalExceptionHandler.java

@@ -21,6 +21,7 @@ import org.springframework.http.HttpMethod;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
 import org.springframework.security.access.AccessDeniedException;
+import org.springframework.security.authentication.BadCredentialsException;
 import org.springframework.security.core.AuthenticationException;
 import org.springframework.validation.BindException;
 import org.springframework.validation.ObjectError;
@@ -211,6 +212,17 @@ public class GlobalExceptionHandler extends ResponseEntityExceptionHandler {
 		return ResponseEntity.status(response.getStatus()).headers(new HttpHeaders()).body(response);
 	}
 
+	/**
+	 * 이메일이 존재하지 않을 경우
+	 */
+	@ExceptionHandler(value = BadCredentialsException.class)
+	protected ResponseEntity<ErrorResponse> handleBadCredentialsException(BadCredentialsException ex) {
+		log.error("BadCredentialsException :: ", ex);
+
+		ErrorResponse response = new ErrorResponse(UNAUTHORIZED, ex.getLocalizedMessage(), "아이디 혹은 패스워드가 일치하지 않습니다.");
+		return ResponseEntity.status(response.getStatus()).headers(new HttpHeaders()).body(response);
+	}
+
 	/**
 	 * 인증 정보가 없을 때
 	 */

server/src/main/java/com/ticketing/server/global/redis/PaymentCache.java

@@ -33,12 +33,15 @@ public class PaymentCache {
 
 	private Long paymentNumber;
 
-	public PaymentCache(String email, String movieTitle, String tid, List<Long> ticketIds, Long userAlternateId, Long paymentNumber) {
+	private Integer totalAmount;
+
+	public PaymentCache(String email, String movieTitle, String tid, List<Long> ticketIds, Long userAlternateId, Long paymentNumber, Integer totalAmount) {
 		this.email = email;
 		this.movieTitle = movieTitle;
 		this.tid = tid;
 		this.ticketIds = ticketIds;
 		this.userAlternateId = userAlternateId;
 		this.paymentNumber = paymentNumber;
+		this.totalAmount = totalAmount;
 	}
 }

server/src/main/java/com/ticketing/server/movie/application/MovieController.java

@@ -8,11 +8,12 @@ import com.ticketing.server.movie.application.response.MovieDeleteResponse;
 import com.ticketing.server.movie.application.response.MovieListResponse;
 import com.ticketing.server.movie.application.response.MovieInfoResponse;
 import com.ticketing.server.movie.service.dto.DeletedMovieDTO;
-import com.ticketing.server.movie.service.dto.MovieListDTO;
+import com.ticketing.server.movie.service.dto.MovieDTO;
 import com.ticketing.server.movie.service.dto.RegisteredMovieDTO;
 import com.ticketing.server.movie.service.interfaces.MovieService;
 import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiOperation;
+import java.util.List;
 import javax.validation.Valid;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
@@ -51,11 +52,11 @@ public class MovieController {
 	@GetMapping()
 	@ApiOperation(value = "영화 목록 조회")
 	public ResponseEntity<MovieListResponse> getMovies() {
-		MovieListDTO movieListDto = movieService.getMovies();
+		List<MovieDTO> movieDtos = movieService.getMovies();
 
 		return ResponseEntity.status(HttpStatus.OK)
 			.body(
-				movieListDto.toResponse()
+				new MovieListResponse(movieDtos)
 			);
 	}
 

server/src/main/java/com/ticketing/server/movie/application/MovieTimeController.java

@@ -5,13 +5,14 @@ import static com.ticketing.server.user.domain.UserGrade.ROLES.STAFF;
 import com.ticketing.server.movie.application.request.MovieTimeRegisterRequest;
 import com.ticketing.server.movie.application.response.MovieTimeInfoResponse;
 import com.ticketing.server.movie.application.response.MovieTimeListResponse;
-import com.ticketing.server.movie.service.dto.MovieTimeListDTO;
+import com.ticketing.server.movie.service.dto.MovieTimeDTO;
 import com.ticketing.server.movie.service.dto.RegisteredMovieTimeDTO;
 import com.ticketing.server.movie.service.interfaces.MovieTimeService;
 import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiOperation;
 import io.swagger.annotations.ApiParam;
 import java.time.LocalDate;
+import java.util.List;
 import javax.validation.Valid;
 import javax.validation.constraints.NotNull;
 import lombok.RequiredArgsConstructor;
@@ -58,11 +59,11 @@ public class MovieTimeController {
 	public ResponseEntity<MovieTimeListResponse> getMovieTimes(
 		@ApiParam(value = "영화 ID", required = true) @RequestParam @NotNull Long movieId,
 		@ApiParam(value = "상영 날짜", required = true) @RequestParam @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate runningDate) {
-		MovieTimeListDTO movieTimeListDto = movieTimeService.getMovieTimes(movieId, runningDate);
+		List<MovieTimeDTO> movieTimeDtos = movieTimeService.getMovieTimes(movieId, runningDate);
 
 		return ResponseEntity.status(HttpStatus.OK)
 			.body(
-				movieTimeListDto.toResponse()
+				new MovieTimeListResponse(movieTimeDtos)
 			);
 	}
 

server/src/main/java/com/ticketing/server/movie/application/TicketController.java

@@ -1,16 +1,24 @@
 package com.ticketing.server.movie.application;
 
+import static com.ticketing.server.user.domain.UserGrade.ROLES.USER;
+
 import com.ticketing.server.movie.application.response.TicketDetailsResponse;
-import com.ticketing.server.movie.service.dto.TicketDetailsDTO;
+import com.ticketing.server.movie.application.response.TicketListResponse;
+import com.ticketing.server.movie.service.dto.TicketDTO;
 import com.ticketing.server.movie.service.interfaces.TicketService;
+import com.ticketing.server.payment.service.dto.TicketDetailDTO;
+import io.swagger.annotations.ApiParam;
+import java.util.List;
 import javax.validation.constraints.NotNull;
 import lombok.RequiredArgsConstructor;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.ResponseEntity;
+import org.springframework.security.access.annotation.Secured;
 import org.springframework.validation.annotation.Validated;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.PathVariable;
 import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RestController;
 
 @RestController
@@ -21,12 +29,28 @@ public class TicketController {
 
 	private final TicketService ticketService;
 
-	@GetMapping("/payments/{paymentId}")
+	@GetMapping
-	public ResponseEntity<TicketDetailsResponse> findTicketsByPaymentId(@PathVariable("paymentId") @NotNull Long paymentId) {
+	@Secured(USER)
-		TicketDetailsDTO tickets = ticketService.findTicketsByPaymentId(paymentId);
+	public ResponseEntity<TicketListResponse> getTickets(
+		@ApiParam(value = "영화 시간표 ID", required = true) @RequestParam @NotNull Long movieTimeId) {
+		List<TicketDTO> tickets = ticketService.getTickets(movieTimeId);
 
 		return ResponseEntity.status(HttpStatus.OK)
-			.body(tickets.toResponse());
+			.body(
+				new TicketListResponse(tickets)
+			);
+	}
+
+	@GetMapping("/payments/{paymentId}")
+	@Secured(USER)
+	public ResponseEntity<TicketDetailsResponse> findTicketsByPaymentId(
+		@PathVariable("paymentId") @NotNull Long paymentId) {
+		List<TicketDetailDTO> tickets = ticketService.findTicketsByPaymentId(paymentId);
+
+		return ResponseEntity.status(HttpStatus.OK)
+			.body(
+				new TicketDetailsResponse(tickets)
+			);
 	}
 
 }

server/src/main/java/com/ticketing/server/movie/application/response/MovieListResponse.java

@@ -10,7 +10,7 @@ import lombok.Getter;
 @AllArgsConstructor
 public class MovieListResponse {
 
-    @ApiModelProperty(value = "영화 제목")
+    @ApiModelProperty(value = "영화 목록")
     private List<MovieDTO> movieDtos;
 
 }

server/src/main/java/com/ticketing/server/movie/application/response/MovieTimeListResponse.java

@@ -11,7 +11,7 @@ import lombok.Getter;
 @AllArgsConstructor
 public class MovieTimeListResponse {
 
-    @ApiModelProperty(value = "영화 시간표 정보")
+    @ApiModelProperty(value = "영화 시간표 목록")
     private List<MovieTimeDTO> movieTimeDtos;
 
 }

server/src/main/java/com/ticketing/server/movie/application/response/TicketListResponse.java

@@ -0,0 +1,16 @@
+package com.ticketing.server.movie.application.response;
+
+import com.ticketing.server.movie.service.dto.TicketDTO;
+import io.swagger.annotations.ApiModelProperty;
+import java.util.List;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class TicketListResponse {
+
+	@ApiModelProperty(value = "티켓 목록")
+	private List<TicketDTO> ticketDtos;
+
+}

server/src/main/java/com/ticketing/server/movie/domain/Ticket.java

@@ -3,6 +3,7 @@ package com.ticketing.server.movie.domain;
 import com.ticketing.server.global.dto.repository.AbstractEntity;
 import com.ticketing.server.global.exception.ErrorCode;
 import java.time.LocalDateTime;
+import java.time.temporal.ChronoUnit;
 import javax.persistence.Entity;
 import javax.persistence.EnumType;
 import javax.persistence.Enumerated;
@@ -26,7 +27,7 @@ public class Ticket extends AbstractEntity {
 
 	@NotNull
 	@ManyToOne(fetch = FetchType.LAZY)
-	@JoinColumn(name = "movie_times_id", referencedColumnName = "id", updatable = false)
+	@JoinColumn(name = "movie_time_id", referencedColumnName = "id", updatable = false)
 	private MovieTime movieTime;
 
 	private Long paymentId;
@@ -78,6 +79,26 @@ public class Ticket extends AbstractEntity {
 		}
 
 		status = TicketStatus.SALE;
+		paymentId = null;
+		return this;
+	}
+
+	public Ticket refund(LocalDateTime dateTime) {
+		long seconds = ChronoUnit.SECONDS.between(dateTime, getStartAt());
+		if (600L > seconds) {
+			throw ErrorCode.throwNotRefundableTime();
+		}
+
+		return refund();
+	}
+
+	public Ticket refund() {
+		if (!TicketStatus.SOLD.equals(status)) {
+			throw ErrorCode.throwNotRefundableSeat();
+		}
+
+		status = TicketStatus.SALE;
+		paymentId = null;
 		return this;
 	}
 

server/src/main/java/com/ticketing/server/movie/domain/repository/MovieRepository.java

@@ -1,7 +1,6 @@
 package com.ticketing.server.movie.domain.repository;
 
 import com.ticketing.server.movie.domain.Movie;
-import java.time.LocalDateTime;
 import java.util.List;
 import java.util.Optional;
 import org.springframework.data.jpa.repository.JpaRepository;
@@ -17,8 +16,8 @@ public interface MovieRepository extends JpaRepository<Movie, Long> {
 
 	@Query(value = "SELECT m "
 		+ "FROM Movie m "
-		+ "WHERE title = :title "
+		+ "WHERE m.title = :title "
-		+ "AND deleted_at IS NULL")
+		+ "AND m.deletedAt IS NULL")
 	Optional<Movie> findValidMovieWithTitle(String title);
 
     @Query(value = "SELECT * "

server/src/main/java/com/ticketing/server/movie/domain/repository/TicketRepository.java

@@ -1,5 +1,6 @@
 package com.ticketing.server.movie.domain.repository;
 
+import com.ticketing.server.movie.domain.MovieTime;
 import com.ticketing.server.movie.domain.Ticket;
 import java.util.List;
 import org.springframework.data.jpa.repository.JpaRepository;
@@ -11,8 +12,16 @@ import org.springframework.stereotype.Repository;
 public interface TicketRepository extends JpaRepository<Ticket, Long> {
 
 	@Query(
-		value =
+		value = "SELECT t "
-			"SELECT t "
+			+ "FROM Ticket t "
+			+ "JOIN FETCH t.seat s "
+			+ "WHERE t.movieTime = :movieTime "
+			+ "AND t.deletedAt IS NULL"
+	)
+	List<Ticket> findValidTickets(MovieTime movieTime);
+
+	@Query(
+		value = "SELECT t "
 			+ "FROM Ticket t "
 			+ "JOIN FETCH t.movieTime mt "
 			+ "JOIN FETCH t.seat s "
@@ -22,8 +31,7 @@ public interface TicketRepository extends JpaRepository<Ticket, Long> {
 	List<Ticket> findTicketFetchJoinByPaymentId(@Param("paymentId") Long paymentId);
 
 	@Query(
-		value =
+		value = "SELECT t "
-			"SELECT t "
 				+ "FROM Ticket t "
 				+ "JOIN FETCH t.movieTime mt "
 				+ "JOIN FETCH t.seat s "

server/src/main/java/com/ticketing/server/movie/service/MovieServiceImpl.java

@@ -5,7 +5,6 @@ import com.ticketing.server.movie.domain.Movie;
 import com.ticketing.server.movie.domain.repository.MovieRepository;
 import com.ticketing.server.movie.service.dto.DeletedMovieDTO;
 import com.ticketing.server.movie.service.dto.MovieDTO;
-import com.ticketing.server.movie.service.dto.MovieListDTO;
 import com.ticketing.server.movie.service.dto.RegisteredMovieDTO;
 import com.ticketing.server.movie.service.interfaces.MovieService;
 import java.util.List;
@@ -39,14 +38,12 @@ public class MovieServiceImpl implements MovieService {
 	}
 
 	@Override
-	public MovieListDTO getMovies() {
+	public List<MovieDTO> getMovies() {
 		List<Movie> movies = movieRepository.findValidMovies();
 
-		List<MovieDTO> movieDtos = movies.stream()
+		return movies.stream()
 			.map(movie -> movie.toMovieDTO())
 			.collect(Collectors.toList());
-
-		return new MovieListDTO(movieDtos);
 	}
 
 	@Override

server/src/main/java/com/ticketing/server/movie/service/MovieTimeServiceImpl.java

@@ -8,9 +8,7 @@ import com.ticketing.server.movie.domain.repository.MovieRepository;
 import com.ticketing.server.movie.domain.repository.MovieTimeRepository;
 import com.ticketing.server.movie.domain.repository.TheaterRepository;
 import com.ticketing.server.movie.service.dto.MovieTimeDTO;
-import com.ticketing.server.movie.service.dto.MovieTimeListDTO;
 import com.ticketing.server.movie.service.dto.MovieTimeRegisterDTO;
-import com.ticketing.server.movie.service.dto.RegisteredMovieDTO;
 import com.ticketing.server.movie.service.dto.RegisteredMovieTimeDTO;
 import com.ticketing.server.movie.service.interfaces.MovieTimeService;
 import java.time.LocalDate;
@@ -38,12 +36,13 @@ public class MovieTimeServiceImpl implements MovieTimeService {
 	public RegisteredMovieTimeDTO registerMovieTime(@Valid MovieTimeRegisterDTO movieTimeRegisterDto) {
 		Movie movie = findMovieById(movieTimeRegisterDto.getMovieId());
 		Theater theater = findTheaterByNumber(movieTimeRegisterDto.getTheaterNumber());
+
 		int round = movieTimeRegisterDto.getRound();
 
 		Optional<MovieTime> movieTime =
 			movieTimeRepository.findByMovieAndTheaterAndRoundAndDeletedAtNull(movie, theater, round);
 
-		if(movieTime.isEmpty()) {
+		if (movieTime.isEmpty()) {
 			MovieTime newMovieTime = movieTimeRepository.save(
 				new MovieTime(movie, theater, round, movieTimeRegisterDto.getStartAt())
 			);
@@ -55,7 +54,7 @@ public class MovieTimeServiceImpl implements MovieTimeService {
 	}
 
 	@Override
-	public MovieTimeListDTO getMovieTimes(Long movieId, LocalDate runningDate) {
+	public List<MovieTimeDTO> getMovieTimes(Long movieId, LocalDate runningDate) {
 		Movie movie = findMovieById(movieId);
 
 		LocalDateTime startOfDay = runningDate.atStartOfDay().plusHours(6);
@@ -63,11 +62,9 @@ public class MovieTimeServiceImpl implements MovieTimeService {
 
 		List<MovieTime> movieTimes = movieTimeRepository.findValidMovieTimes(movie, startOfDay, endOfDay);
 
-		List<MovieTimeDTO> movieTimeDtos = movieTimes.stream()
+		return movieTimes.stream()
 			.map(movieTime -> movieTime.toMovieTimeDTO())
 			.collect(Collectors.toList());
-
-		return new MovieTimeListDTO(movieTimeDtos);
 	}
 
 	@Override

server/src/main/java/com/ticketing/server/movie/service/TicketServiceImpl.java

@@ -2,9 +2,12 @@ package com.ticketing.server.movie.service;
 
 import com.ticketing.server.global.exception.ErrorCode;
 import com.ticketing.server.global.validator.constraints.NotEmptyCollection;
+import com.ticketing.server.movie.domain.MovieTime;
 import com.ticketing.server.movie.domain.Ticket;
+import com.ticketing.server.movie.domain.repository.MovieTimeRepository;
 import com.ticketing.server.movie.domain.repository.TicketRepository;
-import com.ticketing.server.movie.service.dto.TicketDetailsDTO;
+import com.ticketing.server.movie.service.dto.TicketDTO;
+import com.ticketing.server.movie.service.dto.TicketRefundDTO;
 import com.ticketing.server.movie.service.dto.TicketReservationDTO;
 import com.ticketing.server.movie.service.dto.TicketSoldDTO;
 import com.ticketing.server.movie.service.dto.TicketsCancelDTO;
@@ -13,6 +16,7 @@ import com.ticketing.server.movie.service.dto.TicketsSoldDTO;
 import com.ticketing.server.movie.service.interfaces.TicketService;
 import com.ticketing.server.payment.service.dto.TicketDetailDTO;
 import java.util.List;
+import java.util.function.UnaryOperator;
 import java.util.stream.Collectors;
 import javax.validation.constraints.NotNull;
 import lombok.RequiredArgsConstructor;
@@ -30,8 +34,21 @@ public class TicketServiceImpl implements TicketService {
 
 	private final TicketRepository ticketRepository;
 
+	private final MovieTimeRepository movieTimeRepository;
+
 	@Override
-	public TicketDetailsDTO findTicketsByPaymentId(@NotNull Long paymentId) {
+	public List<TicketDTO> getTickets(@NotNull Long movieTimeId) {
+		MovieTime movieTime = movieTimeRepository.findById(movieTimeId)
+			.orElseThrow(ErrorCode::throwMovieTimeNotFound);
+
+		return ticketRepository.findValidTickets(movieTime)
+			.stream()
+			.map(TicketDTO::new)
+			.collect(Collectors.toList());
+	}
+
+	@Override
+	public List<TicketDetailDTO> findTicketsByPaymentId(@NotNull Long paymentId) {
 		List<TicketDetailDTO> ticketDetails = ticketRepository.findTicketFetchJoinByPaymentId(paymentId)
 			.stream()
 			.map(TicketDetailDTO::new)
@@ -41,7 +58,7 @@ public class TicketServiceImpl implements TicketService {
 			throw ErrorCode.throwPaymentIdNotFound();
 		}
 
-		return new TicketDetailsDTO(ticketDetails);
+		return ticketDetails;
 	}
 
 	@Override
@@ -82,7 +99,18 @@ public class TicketServiceImpl implements TicketService {
 		List<Ticket> tickets = getTicketsByInTicketIds(ticketIds);
 		tickets.forEach(Ticket::cancel);
 
-		return new TicketsCancelDTO(ticketIds);
+		return new TicketsCancelDTO(tickets);
+	}
+
+	@Override
+	@Transactional
+	public List<TicketRefundDTO> ticketsRefund(@NotNull Long paymentId, UnaryOperator<Ticket> refund) {
+		List<Ticket> tickets = ticketRepository.findTicketFetchJoinByPaymentId(paymentId);
+
+		return tickets.stream()
+			.map(refund)
+			.map(TicketRefundDTO::new)
+			.collect(Collectors.toList());
 	}
 
 	private List<Ticket> getTicketsByInTicketIds(List<Long> ticketIds) {

server/src/main/java/com/ticketing/server/movie/service/dto/MovieListDTO.java

@@ -1,18 +0,0 @@
-package com.ticketing.server.movie.service.dto;
-
-import com.ticketing.server.movie.application.response.MovieListResponse;
-import java.util.List;
-import lombok.AllArgsConstructor;
-import lombok.Getter;
-
-@Getter
-@AllArgsConstructor
-public class MovieListDTO {
-
-	private final List<MovieDTO> movieDtos;
-
-	public MovieListResponse toResponse() {
-		return new MovieListResponse(movieDtos);
-	}
-
-}

server/src/main/java/com/ticketing/server/movie/service/dto/MovieTimeListDTO.java

@@ -1,18 +0,0 @@
-package com.ticketing.server.movie.service.dto;
-
-import com.ticketing.server.movie.application.response.MovieTimeListResponse;
-import java.util.List;
-import lombok.AllArgsConstructor;
-import lombok.Getter;
-
-@Getter
-@AllArgsConstructor
-public class MovieTimeListDTO {
-
-	private final List<MovieTimeDTO> movieTimeDtos;
-
-	public MovieTimeListResponse toResponse() {
-		return new MovieTimeListResponse(movieTimeDtos);
-	}
-
-}

server/src/main/java/com/ticketing/server/movie/service/dto/TicketDTO.java

@@ -0,0 +1,33 @@
+package com.ticketing.server.movie.service.dto;
+
+import com.ticketing.server.movie.domain.Ticket;
+import com.ticketing.server.movie.domain.TicketStatus;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+public class TicketDTO {
+
+	private Long ticketId;
+
+	private Integer ticketPrice;
+
+	private Integer seatRow;
+
+	private Integer seatColumn;
+
+	private TicketStatus status;
+
+	public TicketDTO(Ticket ticket) {
+		this(
+			ticket.getId(),
+			ticket.getTicketPrice(),
+			ticket.getRow(),
+			ticket.getColumn(),
+			ticket.getStatus()
+		);
+	}
+
+}

server/src/main/java/com/ticketing/server/movie/service/dto/TicketDetailsDTO.java

@@ -1,18 +0,0 @@
-package com.ticketing.server.movie.service.dto;
-
-import com.ticketing.server.movie.application.response.TicketDetailsResponse;
-import com.ticketing.server.payment.service.dto.TicketDetailDTO;
-import java.util.List;
-import lombok.AllArgsConstructor;
-import lombok.Getter;
-
-@Getter
-@AllArgsConstructor
-public class TicketDetailsDTO {
-
-	private final List<TicketDetailDTO> ticketDetails;
-
-	public TicketDetailsResponse toResponse() {
-		return new TicketDetailsResponse(ticketDetails);
-	}
-}

server/src/main/java/com/ticketing/server/movie/service/dto/TicketRefundDTO.java

@@ -0,0 +1,20 @@
+package com.ticketing.server.movie.service.dto;
+
+import com.ticketing.server.movie.domain.Ticket;
+import com.ticketing.server.movie.domain.TicketStatus;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+public class TicketRefundDTO {
+
+	private Long ticketId;
+	private TicketStatus ticketStatus;
+
+	public TicketRefundDTO(Ticket ticket) {
+		this(ticket.getId(), ticket.getStatus());
+	}
+
+}

server/src/main/java/com/ticketing/server/movie/service/dto/TicketsCancelDTO.java

@@ -1,16 +1,22 @@
 package com.ticketing.server.movie.service.dto;
 
 import com.ticketing.server.movie.application.response.TicketCancelResponse;
+import com.ticketing.server.movie.domain.Ticket;
 import java.util.List;
-import lombok.AllArgsConstructor;
+import java.util.stream.Collectors;
 import lombok.Getter;
 
 @Getter
-@AllArgsConstructor
 public class TicketsCancelDTO {
 
 	private final List<Long> ticketIds;
 
+	public TicketsCancelDTO(List<Ticket> tickets) {
+		ticketIds = tickets.stream()
+			.map(Ticket::getId)
+			.collect(Collectors.toList());
+	}
+
 	public TicketCancelResponse toResponse() {
 		return new TicketCancelResponse(ticketIds);
 	}

server/src/main/java/com/ticketing/server/movie/service/dto/TicketsRefundResponse.java

@@ -0,0 +1,21 @@
+package com.ticketing.server.movie.service.dto;
+
+import java.util.List;
+import java.util.stream.Collectors;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class TicketsRefundResponse {
+
+	private final List<TicketRefundDTO> tickets;
+
+	public List<Long> getTicketIds() {
+		return tickets.stream()
+			.mapToLong(TicketRefundDTO::getTicketId)
+			.boxed()
+			.collect(Collectors.toList());
+	}
+
+}

server/src/main/java/com/ticketing/server/movie/service/interfaces/MovieService.java

@@ -1,14 +1,15 @@
 package com.ticketing.server.movie.service.interfaces;
 
 import com.ticketing.server.movie.service.dto.DeletedMovieDTO;
-import com.ticketing.server.movie.service.dto.MovieListDTO;
+import com.ticketing.server.movie.service.dto.MovieDTO;
 import com.ticketing.server.movie.service.dto.RegisteredMovieDTO;
+import java.util.List;
 
 public interface MovieService {
 
 	RegisteredMovieDTO registerMovie(String title, Long runningTime);
 
-	MovieListDTO getMovies();
+	List<MovieDTO> getMovies();
 
 	DeletedMovieDTO deleteMovie(Long id);
 }

server/src/main/java/com/ticketing/server/movie/service/interfaces/MovieTimeService.java

@@ -2,17 +2,18 @@ package com.ticketing.server.movie.service.interfaces;
 
 import com.ticketing.server.movie.domain.Movie;
 import com.ticketing.server.movie.domain.Theater;
-import com.ticketing.server.movie.service.dto.MovieTimeListDTO;
+import com.ticketing.server.movie.service.dto.MovieTimeDTO;
 import com.ticketing.server.movie.service.dto.MovieTimeRegisterDTO;
 import com.ticketing.server.movie.service.dto.RegisteredMovieTimeDTO;
 import java.time.LocalDate;
+import java.util.List;
 import javax.validation.Valid;
 
 public interface MovieTimeService {
 
 	RegisteredMovieTimeDTO registerMovieTime(@Valid MovieTimeRegisterDTO movieTimeRegisterDto);
 
-	MovieTimeListDTO getMovieTimes(Long movieId, LocalDate runningDate);
+	List<MovieTimeDTO> getMovieTimes(Long movieId, LocalDate runningDate);
 
 	Movie findMovieById(Long movieId);
 

server/src/main/java/com/ticketing/server/movie/service/interfaces/TicketService.java

@@ -1,16 +1,22 @@
 package com.ticketing.server.movie.service.interfaces;
 
 import com.ticketing.server.global.validator.constraints.NotEmptyCollection;
-import com.ticketing.server.movie.service.dto.TicketDetailsDTO;
+import com.ticketing.server.movie.domain.Ticket;
+import com.ticketing.server.movie.service.dto.TicketDTO;
+import com.ticketing.server.movie.service.dto.TicketRefundDTO;
 import com.ticketing.server.movie.service.dto.TicketsCancelDTO;
 import com.ticketing.server.movie.service.dto.TicketsReservationDTO;
 import com.ticketing.server.movie.service.dto.TicketsSoldDTO;
+import com.ticketing.server.payment.service.dto.TicketDetailDTO;
 import java.util.List;
+import java.util.function.UnaryOperator;
 import javax.validation.constraints.NotNull;
 
 public interface TicketService {
 
-	TicketDetailsDTO findTicketsByPaymentId(@NotNull Long paymentId);
+	List<TicketDTO> getTickets(@NotNull Long movieTimeId);
+
+	List<TicketDetailDTO> findTicketsByPaymentId(@NotNull Long paymentId);
 
 	TicketsReservationDTO ticketReservation(@NotEmptyCollection List<Long> ticketIds);
 
@@ -18,4 +24,6 @@ public interface TicketService {
 
 	TicketsCancelDTO ticketCancel(@NotEmptyCollection List<Long> ticketIds);
 
+	List<TicketRefundDTO> ticketsRefund(@NotNull Long paymentId, UnaryOperator<Ticket> refund);
+
 }

server/src/main/java/com/ticketing/server/movie/setup/MovieSetupService.java

@@ -46,7 +46,7 @@ MovieSetupService {
 		initTheater();
 		initMovieTime();
 		initTicket();
-		initPayment();
+//		initPayment();
 	}
 
 	private void initMovie() {
@@ -125,7 +125,8 @@ MovieSetupService {
 			"T2d03c9130bf237a9700",
 			List.of(1L, 2L),
 			user.getAlternateId(),
-			124124231513245L
+			124124231513245L,
+			30_000
 		);
 
 		Payment payment = new Payment(paymentCache, PaymentType.KAKAO_PAY, PaymentStatus.SOLD, 30_000);

server/src/main/java/com/ticketing/server/payment/api/KakaoPayClient.java

@@ -3,8 +3,10 @@ package com.ticketing.server.payment.api;
 import static org.springframework.http.MediaType.APPLICATION_FORM_URLENCODED_VALUE;
 
 import com.ticketing.server.payment.api.dto.requset.KakaoPayApproveRequest;
+import com.ticketing.server.payment.api.dto.requset.KakaoPayCancelRequest;
 import com.ticketing.server.payment.api.dto.requset.KakaoPayReadyRequest;
 import com.ticketing.server.payment.api.dto.response.KakaoPayApproveResponse;
+import com.ticketing.server.payment.api.dto.response.KakaoPayCancelResponse;
 import com.ticketing.server.payment.api.dto.response.KakaoPayReadyResponse;
 import feign.Headers;
 import org.springframework.cloud.openfeign.FeignClient;
@@ -23,4 +25,8 @@ public interface KakaoPayClient {
 	@Headers("Content-Type: application/x-www-form-urlencoded;charset=utf-8")
 	KakaoPayApproveResponse approve(@RequestHeader(value = "Authorization") String authorization, KakaoPayApproveRequest request);
 
+	@PostMapping(value = "/cancel", consumes = APPLICATION_FORM_URLENCODED_VALUE)
+	@Headers("Content-Type: application/x-www-form-urlencoded;charset=utf-8")
+	KakaoPayCancelResponse cancel(@RequestHeader(value = "Authorization") String authorization, KakaoPayCancelRequest request);
+
 }

server/src/main/java/com/ticketing/server/payment/api/MovieClient.java

@@ -2,11 +2,14 @@ package com.ticketing.server.payment.api;
 
 import com.ticketing.server.movie.application.request.TicketCancelRequest;
 import com.ticketing.server.movie.application.request.TicketReservationRequest;
+import com.ticketing.server.movie.application.request.TicketSoldRequest;
 import com.ticketing.server.movie.application.response.TicketCancelResponse;
 import com.ticketing.server.movie.application.response.TicketDetailsResponse;
 import com.ticketing.server.movie.application.response.TicketReservationResponse;
-import com.ticketing.server.movie.application.request.TicketSoldRequest;
 import com.ticketing.server.movie.application.response.TicketSoldResponse;
+import com.ticketing.server.movie.service.dto.TicketsRefundResponse;
+import com.ticketing.server.payment.api.impl.TicketsRefundRequest;
+import java.time.LocalDateTime;
 import javax.validation.constraints.NotNull;
 
 public interface MovieClient {
@@ -18,4 +21,8 @@ public interface MovieClient {
 	TicketSoldResponse ticketSold(@NotNull TicketSoldRequest request);
 
 	TicketCancelResponse ticketCancel(@NotNull TicketCancelRequest request);
+
+	TicketsRefundResponse ticketRefundByDateTime(TicketsRefundRequest request, LocalDateTime dateTime);
+
+	TicketsRefundResponse ticketRefund(TicketsRefundRequest request);
 }

server/src/main/java/com/ticketing/server/payment/api/dto/requset/KakaoPayCancelRequest.java

@@ -0,0 +1,47 @@
+package com.ticketing.server.payment.api.dto.requset;
+
+import com.fasterxml.jackson.annotation.JsonInclude;
+import com.fasterxml.jackson.annotation.JsonInclude.Include;
+import javax.validation.constraints.NotEmpty;
+import lombok.Getter;
+
+@Getter
+@JsonInclude(Include.NON_NULL)
+public class KakaoPayCancelRequest {
+
+	@NotEmpty
+	private String cid = "TC0ONETIME";
+
+	@feign.form.FormProperty("cid_secret")
+	private String cidSecret;
+
+	@NotEmpty
+	private String tid;
+
+	@NotEmpty
+	@feign.form.FormProperty("cancel_amount")
+	private Integer cancelAmount;
+
+	@NotEmpty
+	@feign.form.FormProperty("cancel_tax_free_amount")
+	private Integer cancelTaxFreeAmount;
+
+	@feign.form.FormProperty("cancel_vat_amount")
+	private Integer cancelVatAmount;
+
+	@feign.form.FormProperty("cancel_available_amount")
+	private Integer cancelAvailableAmount;
+
+	private String payload;
+
+	public KakaoPayCancelRequest(String tid, Integer cancelAmount) {
+		this(tid, cancelAmount, 0);
+	}
+
+	public KakaoPayCancelRequest(String tid, Integer cancelAmount, int cancelTaxFreeAmount) {
+		this.tid = tid;
+		this.cancelAmount = cancelAmount;
+		this.cancelTaxFreeAmount = cancelTaxFreeAmount;
+	}
+
+}

server/src/main/java/com/ticketing/server/payment/api/dto/response/ApprovedCancelAmount.java

@@ -0,0 +1,16 @@
+package com.ticketing.server.payment.api.dto.response;
+
+import com.ticketing.server.payment.api.dto.SnakeCaseStrategy;
+import lombok.Getter;
+
+@Getter
+public class ApprovedCancelAmount extends SnakeCaseStrategy {
+
+	private Integer total;
+	private Integer taxFree;
+	private Integer vat;
+	private Integer point;
+	private Integer discount;
+	private Integer greenDeposit;
+
+}

server/src/main/java/com/ticketing/server/payment/api/dto/response/CancelAvailableAmount.java

@@ -0,0 +1,16 @@
+package com.ticketing.server.payment.api.dto.response;
+
+import com.ticketing.server.payment.api.dto.SnakeCaseStrategy;
+import lombok.Getter;
+
+@Getter
+public class CancelAvailableAmount extends SnakeCaseStrategy {
+
+	private Integer total;
+	private Integer taxFree;
+	private Integer vat;
+	private Integer point;
+	private Integer discount;
+	private Integer greenDeposit;
+
+}

server/src/main/java/com/ticketing/server/payment/api/dto/response/CanceledAmount.java

@@ -0,0 +1,16 @@
+package com.ticketing.server.payment.api.dto.response;
+
+import com.ticketing.server.payment.api.dto.SnakeCaseStrategy;
+import lombok.Getter;
+
+@Getter
+public class CanceledAmount extends SnakeCaseStrategy {
+
+	private Integer total;
+	private Integer taxFree;
+	private Integer vat;
+	private Integer point;
+	private Integer discount;
+	private Integer greenDeposit;
+
+}

server/src/main/java/com/ticketing/server/payment/api/dto/response/KakaoPayCancelResponse.java

@@ -0,0 +1,50 @@
+package com.ticketing.server.payment.api.dto.response;
+
+import com.ticketing.server.payment.api.dto.SnakeCaseStrategy;
+import java.time.LocalDateTime;
+import lombok.Getter;
+
+@Getter
+public class KakaoPayCancelResponse extends SnakeCaseStrategy {
+
+	private String aid;
+
+	private String tid;
+
+	private String cid;
+
+	private String status;
+
+	private String partnerOrderId;
+
+	private String partnerUserId;
+
+	private String paymentMethodType;
+
+	private Amount amount;
+
+	private ApprovedCancelAmount approvedCancelAmount;
+
+	private CanceledAmount canceledAmount;
+
+	private CancelAvailableAmount cancelAvailableAmount;
+
+	private String itemName;
+
+	private String itemCode;
+
+	private Integer quantity;
+
+	private LocalDateTime createdAt;
+
+	private LocalDateTime approvedAt;
+
+	private LocalDateTime canceledAt;
+
+	private String payload;
+
+	public Integer getTotalAmount() {
+		return amount.getTotal();
+	}
+
+}

server/src/main/java/com/ticketing/server/payment/api/impl/MovieClientImpl.java

@@ -7,12 +7,17 @@ import com.ticketing.server.movie.application.response.TicketCancelResponse;
 import com.ticketing.server.movie.application.response.TicketDetailsResponse;
 import com.ticketing.server.movie.application.response.TicketReservationResponse;
 import com.ticketing.server.movie.application.response.TicketSoldResponse;
-import com.ticketing.server.movie.service.dto.TicketDetailsDTO;
+import com.ticketing.server.movie.domain.Ticket;
+import com.ticketing.server.movie.service.dto.TicketRefundDTO;
 import com.ticketing.server.movie.service.dto.TicketsCancelDTO;
+import com.ticketing.server.movie.service.dto.TicketsRefundResponse;
 import com.ticketing.server.movie.service.dto.TicketsReservationDTO;
 import com.ticketing.server.movie.service.dto.TicketsSoldDTO;
 import com.ticketing.server.movie.service.interfaces.TicketService;
 import com.ticketing.server.payment.api.MovieClient;
+import com.ticketing.server.payment.service.dto.TicketDetailDTO;
+import java.time.LocalDateTime;
+import java.util.List;
 import javax.validation.constraints.NotNull;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
@@ -27,8 +32,8 @@ public class MovieClientImpl implements MovieClient {
 
 	@Override
 	public TicketDetailsResponse getTicketsByPaymentId(@NotNull Long paymentId) {
-		TicketDetailsDTO ticketDetails = ticketService.findTicketsByPaymentId(paymentId);
+		List<TicketDetailDTO> ticketDetails = ticketService.findTicketsByPaymentId(paymentId);
-		return ticketDetails.toResponse();
+		return new TicketDetailsResponse(ticketDetails);
 	}
 
 	@Override
@@ -49,4 +54,16 @@ public class MovieClientImpl implements MovieClient {
 		return ticketsCancelDto.toResponse();
 	}
 
+	@Override
+	public TicketsRefundResponse ticketRefundByDateTime(TicketsRefundRequest request, LocalDateTime dateTime) {
+		List<TicketRefundDTO> ticketRefundDTOS = ticketService.ticketsRefund(request.getPaymentId(), ticket -> ticket.refund(dateTime));
+		return new TicketsRefundResponse(ticketRefundDTOS);
+	}
+
+	@Override
+	public TicketsRefundResponse ticketRefund(TicketsRefundRequest request) {
+		List<TicketRefundDTO> ticketRefundDtos = ticketService.ticketsRefund(request.getPaymentId(), Ticket::refund);
+		return new TicketsRefundResponse(ticketRefundDtos);
+	}
+
 }

server/src/main/java/com/ticketing/server/payment/api/impl/TicketsRefundRequest.java

@@ -0,0 +1,12 @@
+package com.ticketing.server.payment.api.impl;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class TicketsRefundRequest {
+
+	private final Long paymentId;
+
+}

server/src/main/java/com/ticketing/server/payment/application/PaymentController.java

@@ -1,18 +1,25 @@
 package com.ticketing.server.payment.application;
 
+import static com.ticketing.server.user.domain.UserGrade.ROLES.STAFF;
+import static com.ticketing.server.user.domain.UserGrade.ROLES.USER;
+
 import com.ticketing.server.payment.application.request.PaymentReadyRequest;
-import com.ticketing.server.payment.application.response.PaymentDetailResponse;
+import com.ticketing.server.payment.application.request.PaymentRefundRequest;
-import com.ticketing.server.payment.application.response.SimplePaymentsResponse;
-import com.ticketing.server.payment.service.dto.PaymentCancelDTO;
 import com.ticketing.server.payment.application.response.PaymentCancelResponse;
-import com.ticketing.server.payment.service.dto.PaymentCompleteDTO;
 import com.ticketing.server.payment.application.response.PaymentCompleteResponse;
+import com.ticketing.server.payment.application.response.PaymentDetailResponse;
+import com.ticketing.server.payment.application.response.PaymentRefundResponse;
+import com.ticketing.server.payment.application.response.SimplePaymentsResponse;
+import com.ticketing.server.payment.service.AdminKakaoPayRefundService;
+import com.ticketing.server.payment.service.MyKakaoPayRefundService;
+import com.ticketing.server.payment.service.dto.PaymentCancelDTO;
+import com.ticketing.server.payment.service.dto.PaymentCompleteDTO;
 import com.ticketing.server.payment.service.dto.PaymentDetailDTO;
 import com.ticketing.server.payment.service.dto.PaymentReadyDTO;
+import com.ticketing.server.payment.service.dto.PaymentRefundDTO;
 import com.ticketing.server.payment.service.dto.SimplePaymentsDTO;
 import com.ticketing.server.payment.service.interfaces.PaymentApisService;
 import com.ticketing.server.payment.service.interfaces.PaymentService;
-import com.ticketing.server.user.domain.UserGrade;
 import javax.validation.Valid;
 import javax.validation.constraints.NotNull;
 import lombok.RequiredArgsConstructor;
@@ -37,9 +44,11 @@ public class PaymentController {
 
 	private final PaymentApisService paymentApisService;
 	private final PaymentService paymentService;
+	private final AdminKakaoPayRefundService adminKakaoPayRefundService;
+	private final MyKakaoPayRefundService myKakaoPayRefundService;
 
 	@GetMapping
-	@Secured(UserGrade.ROLES.USER)
+	@Secured(USER)
 	public ResponseEntity<SimplePaymentsResponse> simplePayments(@NotNull Long userAlternateId) {
 		SimplePaymentsDTO simplePayments = paymentService.findSimplePayments(userAlternateId);
 
@@ -48,7 +57,7 @@ public class PaymentController {
 	}
 
 	@GetMapping("/detail")
-	@Secured(UserGrade.ROLES.USER)
+	@Secured(USER)
 	public ResponseEntity<PaymentDetailResponse> detail(@NotNull Long paymentId) {
 		PaymentDetailDTO paymentDetail = paymentApisService.findPaymentDetail(paymentId);
 
@@ -57,7 +66,7 @@ public class PaymentController {
 	}
 
 	@PostMapping("/ready")
-	@Secured(UserGrade.ROLES.USER)
+	@Secured(USER)
 	public ResponseEntity<PaymentReadyDTO> ready(@RequestBody @Valid PaymentReadyRequest request) {
 		PaymentReadyDTO paymentReadyDto = paymentApisService.ready(request.getTicketIds());
 
@@ -66,7 +75,7 @@ public class PaymentController {
 	}
 
 	@GetMapping("/complete")
-	@Secured(UserGrade.ROLES.USER)
+	@Secured(USER)
 	public ResponseEntity<PaymentCompleteResponse> complete(
 		@AuthenticationPrincipal UserDetails userRequest,
 		@RequestParam("pg_token") String pgToken) {
@@ -77,7 +86,7 @@ public class PaymentController {
 	}
 
 	@GetMapping("/cancel")
-	@Secured(UserGrade.ROLES.USER)
+	@Secured(USER)
 	public ResponseEntity<PaymentCancelResponse> cancel(@AuthenticationPrincipal UserDetails userRequest) {
 		PaymentCancelDTO paymentCancelDto = paymentApisService.cancel(userRequest.getUsername());
 
@@ -85,4 +94,22 @@ public class PaymentController {
 			.body(paymentCancelDto.toResponse());
 	}
 
+	@PostMapping("/refund")
+	@Secured(USER)
+	public ResponseEntity<PaymentRefundResponse> refund(@RequestBody @Valid PaymentRefundRequest request) {
+		PaymentRefundDTO paymentRefundDto = myKakaoPayRefundService.refund(request.getPaymentId());
+
+		return ResponseEntity.status(HttpStatus.OK)
+			.body(paymentRefundDto.toResponse());
+	}
+
+	@PostMapping("/staff/refund")
+	@Secured(STAFF)
+	public ResponseEntity<PaymentRefundResponse> adminRefund(@RequestBody @Valid PaymentRefundRequest request) {
+		PaymentRefundDTO paymentRefundDto = adminKakaoPayRefundService.refund(request.getPaymentId());
+
+		return ResponseEntity.status(HttpStatus.OK)
+			.body(paymentRefundDto.toResponse());
+	}
+
 }

server/src/main/java/com/ticketing/server/payment/application/request/PaymentRefundRequest.java

@@ -0,0 +1,12 @@
+package com.ticketing.server.payment.application.request;
+
+import javax.validation.constraints.NotNull;
+import lombok.Getter;
+
+@Getter
+public class PaymentRefundRequest {
+
+	@NotNull
+	private Long paymentId;
+
+}

server/src/main/java/com/ticketing/server/payment/application/response/PaymentRefundResponse.java

@@ -0,0 +1,18 @@
+package com.ticketing.server.payment.application.response;
+
+import java.time.LocalDateTime;
+import java.util.List;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class PaymentRefundResponse {
+
+	private Long paymentId;
+	private List<Long> ticketIds;
+	private String movieTitle;
+	private Integer cancelAmount;
+	private LocalDateTime canceledAt;
+
+}

server/src/main/java/com/ticketing/server/payment/domain/Payment.java

@@ -82,4 +82,7 @@ public class Payment extends AbstractEntity {
 		this.totalPrice = totalPrice;
 	}
 
+	public void refund() {
+		status = PaymentStatus.REFUNDED;
+	}
 }

server/src/main/java/com/ticketing/server/payment/service/AdminKakaoPayRefundService.java

@@ -0,0 +1,40 @@
+package com.ticketing.server.payment.service;
+
+import com.ticketing.server.global.exception.ErrorCode;
+import com.ticketing.server.movie.service.dto.TicketsRefundResponse;
+import com.ticketing.server.payment.api.KakaoPayClient;
+import com.ticketing.server.payment.api.KakaoPayProperties;
+import com.ticketing.server.payment.api.MovieClient;
+import com.ticketing.server.payment.api.impl.TicketsRefundRequest;
+import com.ticketing.server.payment.domain.Payment;
+import com.ticketing.server.payment.domain.repository.PaymentRepository;
+import com.ticketing.server.payment.service.interfaces.AbstractKakaoPayRefund;
+import org.springframework.stereotype.Service;
+
+@Service
+public class AdminKakaoPayRefundService extends AbstractKakaoPayRefund {
+
+	private final PaymentRepository paymentRepository;
+	private final MovieClient movieClient;
+
+	public AdminKakaoPayRefundService(KakaoPayClient kakaoPayClient, KakaoPayProperties kakaoPayProperties, PaymentRepository paymentRepository, MovieClient movieClient) {
+		super(kakaoPayClient, kakaoPayProperties);
+		this.paymentRepository = paymentRepository;
+		this.movieClient = movieClient;
+	}
+
+	@Override
+	protected Payment getPayment(Long paymentId) {
+		return paymentRepository.findById(paymentId)
+			.orElseThrow(ErrorCode::throwPaymentIdNotFound);
+	}
+
+	@Override
+	protected TicketsRefundResponse movieAndPaymentRefund(Payment payment) {
+		TicketsRefundResponse refundResponse = movieClient.ticketRefund(new TicketsRefundRequest(payment.getId()));
+		payment.refund();
+
+		return refundResponse;
+	}
+
+}

server/src/main/java/com/ticketing/server/payment/service/MyKakaoPayRefundService.java

@@ -0,0 +1,54 @@
+package com.ticketing.server.payment.service;
+
+import com.ticketing.server.global.exception.ErrorCode;
+import com.ticketing.server.movie.service.dto.TicketsRefundResponse;
+import com.ticketing.server.payment.api.KakaoPayClient;
+import com.ticketing.server.payment.api.KakaoPayProperties;
+import com.ticketing.server.payment.api.MovieClient;
+import com.ticketing.server.payment.api.UserClient;
+import com.ticketing.server.payment.api.dto.response.UserDetailResponse;
+import com.ticketing.server.payment.api.impl.TicketsRefundRequest;
+import com.ticketing.server.payment.domain.Payment;
+import com.ticketing.server.payment.domain.repository.PaymentRepository;
+import com.ticketing.server.payment.service.interfaces.AbstractKakaoPayRefund;
+import java.time.LocalDateTime;
+import org.springframework.stereotype.Service;
+
+@Service
+public class MyKakaoPayRefundService extends AbstractKakaoPayRefund {
+
+	private final PaymentRepository paymentRepository;
+	private final MovieClient movieClient;
+	private final UserClient userClient;
+
+	public MyKakaoPayRefundService(KakaoPayClient kakaoPayClient, KakaoPayProperties kakaoPayProperties, PaymentRepository paymentRepository,
+		MovieClient movieClient, UserClient userClient) {
+		super(kakaoPayClient, kakaoPayProperties);
+		this.paymentRepository = paymentRepository;
+		this.movieClient = movieClient;
+		this.userClient = userClient;
+	}
+
+	@Override
+	protected Payment getPayment(Long paymentId) {
+		UserDetailResponse userDetail = userClient.detail();
+		Payment payment = paymentRepository.findById(paymentId)
+			.orElseThrow(ErrorCode::throwPaymentIdNotFound);
+
+		if (userDetail.hasUserAlternateId(payment)) {
+			throw ErrorCode.throwValidUserId();
+		}
+
+		return payment;
+	}
+
+	@Override
+	protected TicketsRefundResponse movieAndPaymentRefund(Payment payment) {
+		LocalDateTime now = LocalDateTime.now();
+		TicketsRefundResponse refundResponse = movieClient.ticketRefundByDateTime(new TicketsRefundRequest(payment.getId()), now);
+		payment.refund();
+
+		return refundResponse;
+	}
+
+}

server/src/main/java/com/ticketing/server/payment/service/PaymentApisServiceImpl.java

@@ -76,6 +76,10 @@ public class PaymentApisServiceImpl implements PaymentApisService {
 		UserDetailResponse userResponse = userClient.detail();
 		Long userAlternateId = userResponse.getUserAlternateId();
 
+		// 다른 결제중인 데이터가 있다면, 예외처리
+		paymentCacheRepository.findByEmail(userResponse.getEmail())
+			.ifPresent(paymentCache -> ErrorCode.throwBadRequestPaymentReady());
+
 		// Ticket 정보 조회 - 영화제목, 티켓가격이 필요함.
 		TicketReservationResponse ticketResponse = movieClient.ticketReservation(new TicketReservationRequest(ticketIds));
 		String movieTitle = ticketResponse.getMovieTitle();
@@ -95,21 +99,18 @@ public class PaymentApisServiceImpl implements PaymentApisService {
 		);
 		KakaoPayReadyResponse response = kakaoPayClient.ready(kakaoPayProperties.getAuthorization(), request);
 
-		PaymentCache paymentReady = new PaymentCache(
+		paymentCacheRepository.save(
-			userResponse.getEmail(),
+			new PaymentCache(
-			movieTitle,
+				userResponse.getEmail(),
-			response.getTid(),
+				movieTitle,
-			ticketIds,
+				response.getTid(),
-			userAlternateId,
+				ticketIds,
-			paymentNumber
+				userAlternateId,
+				paymentNumber,
+				request.getTotalAmount()
+			)
 		);
 
-		paymentCacheRepository.findByEmail(userResponse.getEmail())
-			.ifPresentOrElse(
-				paymentCache -> ErrorCode.throwBadRequestPaymentReady()
-				, () -> paymentCacheRepository.save(paymentReady)
-			);
-
 		return new PaymentReadyDTO(response);
 	}
 
@@ -119,6 +120,13 @@ public class PaymentApisServiceImpl implements PaymentApisService {
 		PaymentCache paymentCache = paymentCacheRepository.findByEmail(email)
 			.orElseThrow(ErrorCode::throwBadRequestPaymentComplete);
 
+		Payment payment = new Payment(paymentCache, PaymentType.KAKAO_PAY, PaymentStatus.SOLD, paymentCache.getTotalAmount());
+		payment = paymentRepository.save(payment);
+
+		movieClient.ticketSold(new TicketSoldRequest(payment.getId(), paymentCache.getTicketIds()));
+		paymentCacheRepository.delete(paymentCache);
+
+		// 카카오페이 결제완료
 		String paymentNumberToString = paymentCache.getPaymentNumber().toString();
 		String userAlternateIdToString = paymentCache.getUserAlternateId().toString();
 		KakaoPayApproveRequest kakaoPayApproveRequest = new KakaoPayApproveRequest(
@@ -132,12 +140,6 @@ public class PaymentApisServiceImpl implements PaymentApisService {
 			kakaoPayApproveRequest
 		);
 
-		Payment payment = new Payment(paymentCache, PaymentType.KAKAO_PAY, PaymentStatus.SOLD, kakaoPayApproveResponse.getTotalAmount());
-		payment = paymentRepository.save(payment);
-
-		movieClient.ticketSold(new TicketSoldRequest(payment.getId(), paymentCache.getTicketIds()));
-		paymentCacheRepository.delete(paymentCache);
-
 		return new PaymentCompleteDTO(email, kakaoPayApproveResponse);
 	}
 

server/src/main/java/com/ticketing/server/payment/service/dto/PaymentRefundDTO.java

@@ -0,0 +1,41 @@
+package com.ticketing.server.payment.service.dto;
+
+import com.ticketing.server.movie.service.dto.TicketsRefundResponse;
+import com.ticketing.server.payment.api.dto.response.KakaoPayCancelResponse;
+import com.ticketing.server.payment.application.response.PaymentRefundResponse;
+import com.ticketing.server.payment.domain.Payment;
+import java.time.LocalDateTime;
+import java.util.List;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public class PaymentRefundDTO {
+
+	private Long paymentId;
+	private List<Long> ticketIds;
+	private String movieTitle;
+	private Integer cancelAmount;
+	private LocalDateTime canceledAt;
+
+	public PaymentRefundDTO(Payment payment, KakaoPayCancelResponse kakaoPayCancelResponse, TicketsRefundResponse refundResponse) {
+		this(
+			payment.getId(),
+			refundResponse.getTicketIds(),
+			kakaoPayCancelResponse.getItemName(),
+			kakaoPayCancelResponse.getTotalAmount(),
+			kakaoPayCancelResponse.getCanceledAt()
+		);
+	}
+
+	public PaymentRefundResponse toResponse() {
+		return new PaymentRefundResponse(
+			paymentId,
+			ticketIds,
+			movieTitle,
+			cancelAmount,
+			canceledAt
+		);
+	}
+}

server/src/main/java/com/ticketing/server/payment/service/interfaces/AbstractKakaoPayRefund.java

@@ -0,0 +1,42 @@
+package com.ticketing.server.payment.service.interfaces;
+
+import com.ticketing.server.movie.service.dto.TicketsRefundResponse;
+import com.ticketing.server.payment.api.KakaoPayClient;
+import com.ticketing.server.payment.api.KakaoPayProperties;
+import com.ticketing.server.payment.api.dto.requset.KakaoPayCancelRequest;
+import com.ticketing.server.payment.api.dto.response.KakaoPayCancelResponse;
+import com.ticketing.server.payment.domain.Payment;
+import com.ticketing.server.payment.service.dto.PaymentRefundDTO;
+import javax.validation.constraints.NotNull;
+import lombok.RequiredArgsConstructor;
+import org.springframework.transaction.annotation.Transactional;
+import org.springframework.validation.annotation.Validated;
+
+@RequiredArgsConstructor
+@Validated
+public abstract class AbstractKakaoPayRefund {
+
+	private final KakaoPayClient kakaoPayClient;
+	private final KakaoPayProperties kakaoPayProperties;
+
+	@Transactional
+	public PaymentRefundDTO refund(@NotNull Long paymentId) {
+		Payment payment = getPayment(paymentId);
+
+		// 내부 환불
+		TicketsRefundResponse refundResponse = movieAndPaymentRefund(payment);
+
+		// 카카오페이 환불
+		KakaoPayCancelResponse kakaoPayCancelResponse = kakaoPayClient.cancel(
+			kakaoPayProperties.getAuthorization(),
+			new KakaoPayCancelRequest(payment.getTid(), payment.getTotalPrice())
+		);
+
+		return new PaymentRefundDTO(payment, kakaoPayCancelResponse, refundResponse);
+	}
+
+	protected abstract Payment getPayment(Long paymentId);
+
+	protected abstract TicketsRefundResponse movieAndPaymentRefund(Payment payment);
+
+}

server/src/main/java/com/ticketing/server/user/application/request/UserChangeGradeRequest.java

@@ -4,9 +4,13 @@ import com.ticketing.server.user.domain.UserGrade;
 import javax.validation.constraints.Email;
 import javax.validation.constraints.NotEmpty;
 import javax.validation.constraints.NotNull;
+import lombok.AllArgsConstructor;
 import lombok.Getter;
+import lombok.NoArgsConstructor;
 
 @Getter
+@NoArgsConstructor
+@AllArgsConstructor
 public class UserChangeGradeRequest {
 
 	@NotEmpty(message = "{validation.not.empty.email}")

server/src/main/java/com/ticketing/server/user/application/response/UserDetailResponse.java

@@ -1,8 +1,6 @@
 package com.ticketing.server.user.application.response;
 
 import com.ticketing.server.user.domain.UserGrade;
-import com.ticketing.server.user.service.dto.UserDetailDTO;
-import lombok.AccessLevel;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
 

server/src/main/java/com/ticketing/server/user/service/CustomUserDetailsService.java

@@ -1,6 +1,5 @@
 package com.ticketing.server.user.service;
 
-import com.ticketing.server.global.exception.ErrorCode;
 import com.ticketing.server.user.domain.User;
 import com.ticketing.server.user.domain.repository.UserRepository;
 import java.util.Collections;
@@ -21,7 +20,7 @@ public class CustomUserDetailsService implements UserDetailsService {
 	public UserDetails loadUserByUsername(String email) throws UsernameNotFoundException {
 		return userRepository.findByEmailAndDeletedAtNull(email)
 			.map(this::createUserDetails)
-			.orElseThrow(ErrorCode::throwEmailNotFound);
+			.orElseThrow(() -> new UsernameNotFoundException(email));
 	}
 
 	private UserDetails createUserDetails(User user) {

server/src/main/resources/application-prod.yml

@@ -0,0 +1,30 @@
+server:
+  port: 8443
+  address: 0.0.0.0
+
+  http:
+    port: 8080
+
+  ssl:
+    key-store: classpath:keystore/ticketing.p12
+    key-store-password: ENC(OMvGcpZLpggFTiGNkqNe66Zq/SmJXF6o)
+    key-store-type: PKCS12
+
+spring:
+  datasource:
+    url: jdbc:mysql://ticketing-db/ticketing?serverTimezone=Asia/Seoul&characterEncoding=UTF-8
+    username: ENC(LowN1n4w0Ep/DqLD8+q5Bq6AXM4b8e3V)
+    password: ENC(OMvGcpZLpggFTiGNkqNe66Zq/SmJXF6o)
+    driver-class-name: com.mysql.cj.jdbc.Driver
+
+  jpa:
+    properties:
+      hibernate:
+        show_sql: true
+        format_sql: true
+    hibernate:
+      ddl-auto: validate
+
+  redis:
+    host: 172.18.0.3
+    port: 6379

server/src/test/java/com/ticketing/server/global/security/jwt/JwtFilterTest.java

@@ -0,0 +1,120 @@
+package com.ticketing.server.global.security.jwt;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.jupiter.api.Assertions.assertAll;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+import com.ticketing.server.global.factory.YamlPropertySourceFactory;
+import com.ticketing.server.user.domain.UserGrade;
+import com.ticketing.server.user.domain.UserGrade.ROLES;
+import com.ticketing.server.user.service.dto.TokenDTO;
+import java.io.IOException;
+import java.util.Collection;
+import java.util.Collections;
+import javax.servlet.ServletException;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
+import org.springframework.context.annotation.PropertySource;
+import org.springframework.mock.web.MockFilterChain;
+import org.springframework.mock.web.MockHttpServletRequest;
+import org.springframework.mock.web.MockHttpServletResponse;
+import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
+import org.springframework.security.core.Authentication;
+import org.springframework.security.core.GrantedAuthority;
+import org.springframework.security.core.authority.SimpleGrantedAuthority;
+import org.springframework.security.core.context.SecurityContextHolder;
+import org.springframework.security.core.userdetails.User;
+import org.springframework.test.context.junit.jupiter.SpringExtension;
+
+@ExtendWith(SpringExtension.class)
+@EnableConfigurationProperties(value = JwtProperties.class)
+@PropertySource(value = "classpath:application.yml", factory = YamlPropertySourceFactory.class)
+class JwtFilterTest {
+
+	@Autowired
+	private JwtProperties jwtProperties;
+
+	private MockHttpServletRequest mockRequest;
+	private MockHttpServletResponse mockResponse;
+	private MockFilterChain mockFilterChain;
+
+	private JwtFilter jwtFilter;
+
+	@BeforeEach
+	void init() {
+		mockRequest = new MockHttpServletRequest();
+		mockResponse = new MockHttpServletResponse();
+		mockFilterChain = new MockFilterChain();
+
+		JwtProvider jwtProvider = new JwtProvider(jwtProperties);
+		jwtFilter = new JwtFilter(jwtProperties, jwtProvider);
+
+		SimpleGrantedAuthority grantedAuthority = new SimpleGrantedAuthority(UserGrade.USER.name());
+		Collection<SimpleGrantedAuthority> authorities = Collections.singleton(grantedAuthority);
+		User user = new User(
+			"kdhyo98@gmail.com",
+			"",
+			authorities
+		);
+		TokenDTO tokenDto = jwtProvider.generateTokenDto(new UsernamePasswordAuthenticationToken(user, null, authorities));
+		mockRequest.addHeader("Authorization", "Bearer " + tokenDto.getAccessToken());
+
+		SecurityContextHolder.clearContext();
+	}
+
+	@ParameterizedTest
+	@DisplayName("Header 정보가 올바르지 않을 경우")
+	@ValueSource(strings = {"Bearer tokenTest", "Bearer", "BearertokenTest"})
+	void validateToken(String authorization) {
+		// given
+		mockRequest.removeHeader("Authorization");
+		mockRequest.addHeader("Authorization", authorization);
+
+		// when
+		// then
+		assertThatThrownBy(() -> jwtFilter.doFilterInternal(mockRequest, mockResponse, mockFilterChain))
+			.isInstanceOf(RuntimeException.class);
+	}
+
+	@Test
+	@DisplayName("다음 필터 실행")
+	void continuesToNextFilter() throws ServletException, IOException {
+		// given
+		MockFilterChain mockFilterChainSpy = spy(this.mockFilterChain);
+
+		// when
+		jwtFilter.doFilter(mockRequest, mockResponse, mockFilterChainSpy);
+
+		// then
+		verify(mockFilterChainSpy, times(1)).doFilter(mockRequest, mockResponse);
+	}
+
+	@Test
+	@DisplayName("setAuthentication 데이터 확인")
+	void setsAuthenticationInSecurityContext() throws ServletException, IOException {
+		// given
+		SimpleGrantedAuthority grantedAuthority = new SimpleGrantedAuthority(ROLES.USER);
+		Collection<GrantedAuthority> authorities = Collections.singleton(grantedAuthority);
+
+		// when
+		jwtFilter.doFilter(mockRequest, mockResponse, mockFilterChain);
+
+		// then
+		Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
+		User principal = (User) authentication.getPrincipal();
+		assertAll(
+			() -> assertThat(principal.getUsername()).isEqualTo("kdhyo98@gmail.com"),
+			() -> assertThat(principal.getAuthorities()).isEqualTo(authorities)
+		);
+	}
+
+}

server/src/test/java/com/ticketing/server/movie/domain/TicketTest.java

@@ -8,6 +8,7 @@ import static org.junit.jupiter.api.Assertions.assertAll;
 
 import com.ticketing.server.global.exception.ErrorCode;
 import com.ticketing.server.global.exception.TicketingException;
+import java.time.LocalDateTime;
 import java.util.ArrayList;
 import java.util.List;
 import org.junit.jupiter.api.BeforeEach;
@@ -165,10 +166,94 @@ public class TicketTest {
 		ticket.makeSold(123L);
 
 		// then
-		assertThatThrownBy(() -> ticket.cancel())
+		assertThatThrownBy(ticket::cancel)
 			.isInstanceOf(TicketingException.class)
 			.extracting("errorCode")
 			.isEqualTo(ErrorCode.BAD_REQUEST_PAYMENT_CANCEL);
 	}
 
+	@Test
+	@DisplayName("시간 비교 환불 성공")
+	void refundByDateTimeSuccess() {
+		// given
+		LocalDateTime now = LocalDateTime.now();
+		LocalDateTime dateTime = LocalDateTime.of(now.getYear(), now.getMonthValue(), now.getDayOfMonth(), 7, 50);
+		Ticket ticket = tickets.get(0);
+
+		// when
+		ticket.makeSold(123L);
+		ticket.refund(dateTime);
+
+		// then
+		assertAll(
+			() -> assertThat(ticket.getStatus()).isEqualTo(TicketStatus.SALE),
+			() -> assertThat(ticket.getPaymentId()).isNull()
+		);
+	}
+
+	@Test
+	@DisplayName("시간 비교 환불 실패 - 상영시작 시간 10분보다 작을경우")
+	void refundByDateTimeFail() {
+		// given
+		LocalDateTime now = LocalDateTime.now();
+		LocalDateTime dateTime = LocalDateTime.of(now.getYear(), now.getMonthValue(), now.getDayOfMonth(), 7, 51);
+		Ticket ticket = tickets.get(0);
+
+		// when
+		ticket.makeSold(123L);
+
+		// then
+		assertThatThrownBy(() -> ticket.refund(dateTime))
+			.isInstanceOf(TicketingException.class)
+			.extracting("errorCode")
+			.isEqualTo(ErrorCode.NOT_REFUNDABLE_TIME);
+	}
+
+	@Test
+	@DisplayName("관리자 환불 성공")
+	void refundSuccess() {
+		// given
+		Ticket ticket = tickets.get(0);
+
+		// when
+		ticket.makeSold(123L);
+		ticket.refund();
+
+		// then
+		assertAll(
+			() -> assertThat(ticket.getStatus()).isEqualTo(TicketStatus.SALE),
+			() -> assertThat(ticket.getPaymentId()).isNull()
+		);
+	}
+
+	@Test
+	@DisplayName("관리자 환불 실패 - 상태 SALE")
+	void refundFail_SALE() {
+		// given
+		Ticket ticket = tickets.get(0);
+
+		// when
+		// then
+		assertThatThrownBy(ticket::refund)
+			.isInstanceOf(TicketingException.class)
+			.extracting("errorCode")
+			.isEqualTo(ErrorCode.NOT_REFUNDABLE_SEAT);
+	}
+
+	@Test
+	@DisplayName("관리자 환불 실패 - 상태 RESERVATION")
+	void refundFail_RESERVATION() {
+		// given
+		Ticket ticket = tickets.get(0);
+
+		// when
+		ticket.makeReservation();
+
+		// then
+		assertThatThrownBy(ticket::refund)
+			.isInstanceOf(TicketingException.class)
+			.extracting("errorCode")
+			.isEqualTo(ErrorCode.NOT_REFUNDABLE_SEAT);
+	}
+
 }

server/src/test/java/com/ticketing/server/movie/service/MovieServiceImplTest.java

@@ -1,15 +1,22 @@
 package com.ticketing.server.movie.service;
 
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.when;
 
+import com.ticketing.server.global.exception.TicketingException;
 import com.ticketing.server.movie.domain.Movie;
 import com.ticketing.server.movie.domain.repository.MovieRepository;
+import com.ticketing.server.movie.service.dto.DeletedMovieDTO;
 import com.ticketing.server.movie.service.dto.MovieDTO;
-import com.ticketing.server.movie.service.dto.MovieListDTO;
+import com.ticketing.server.movie.service.dto.RegisteredMovieDTO;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
+import java.util.Optional;
+import org.hibernate.sql.Delete;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
@@ -21,9 +28,7 @@ import org.mockito.junit.jupiter.MockitoExtension;
 public class MovieServiceImplTest {
 
     Movie movie;
-    MovieDTO movieDto;
     List<Movie> movies = new ArrayList<>();
-    List<MovieDTO> movieDTOS = new ArrayList<>();
 
     @Mock
     MovieRepository movieRepository;
@@ -39,10 +44,10 @@ public class MovieServiceImplTest {
             .thenReturn(Collections.emptyList());
 
         // when
-        MovieListDTO movieListDto = movieService.getMovies();
+        List<MovieDTO> movieDtos = movieService.getMovies();
 
         // then
-        assertTrue(movieListDto.getMovieDtos().isEmpty());
+        assertTrue(movieDtos.isEmpty());
     }
 
     @Test
@@ -55,11 +60,80 @@ public class MovieServiceImplTest {
         when(movieRepository.findValidMovies())
             .thenReturn(movies);
 
-        // when
+	    // when
-	    MovieListDTO movieListDto = movieService.getMovies();
+	    List<MovieDTO> movieDtos = movieService.getMovies();
 
-        // then
+	    // then
-        assertTrue(!movieListDto.getMovieDtos().isEmpty());
+	    assertTrue(!movieDtos.isEmpty());
     }
 
+	@Test
+	@DisplayName("Movie Service Test - register movie")
+	void shouldAbleToRegisterMovie() {
+		// given
+		String title = "추가할 영화 제목";
+		movie = new Movie(title, 100L);
+
+		when(movieRepository.findValidMovieWithTitle(title))
+			.thenReturn(Optional.empty());
+		when(movieRepository.save(any()))
+			.thenReturn(movie);
+
+		// when
+		RegisteredMovieDTO registeredMovieDto =
+			movieService.registerMovie(title, movie.getRunningTime());
+
+		// then
+		assertThat(registeredMovieDto).isNotNull();
+		assertTrue(registeredMovieDto.getTitle().equals(title));
+	}
+
+	@Test
+	@DisplayName("Movie Service Test - register movie when there is same movie already")
+	void shouldThrowExceptionWhenRegistering() {
+		// given
+		String title = "이미 중복된 영화 제목";
+
+		Movie movie = new Movie(title, 100L);
+
+		when(movieRepository.findValidMovieWithTitle(title))
+			.thenReturn(Optional.of(movie));
+
+		// when
+		// then
+		assertThatThrownBy(() -> movieService.registerMovie(title, 100L))
+			.isInstanceOf(TicketingException.class);
+
+	}
+
+	@Test
+	@DisplayName("Movie Service Test - delete movie")
+	void shouldAbleToDeleteMovie() {
+		// given
+		Movie movie = new Movie("삭제할 영화 제목", 100L);
+
+		when(movieRepository.findByIdAndDeletedAtNull(1L))
+			.thenReturn(Optional.of(movie));
+
+		// when
+		DeletedMovieDTO deletedMovieDto =
+			movieService.deleteMovie(1L);
+
+		// then
+		assertTrue(deletedMovieDto.getTitle().equals("삭제할 영화 제목"));
+		assertThat(deletedMovieDto.getDeletedAt()).isNotNull();
+	}
+
+	@Test
+	@DisplayName("Movie Service Test - delete movie when there is no such movie")
+	void shouldThrowExceptionWhenDeleting() {
+		// given
+		when(movieRepository.findByIdAndDeletedAtNull(1L))
+			.thenReturn(Optional.empty());
+
+		// when
+		// then
+		assertThatThrownBy(() -> movieService.deleteMovie(1L))
+			.isInstanceOf(TicketingException.class);
+	}
 }

server/src/test/java/com/ticketing/server/movie/service/MovieTimeServiceImplTest.java

@@ -1,15 +1,23 @@
 package com.ticketing.server.movie.service;
 
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyLong;
 import static org.mockito.Mockito.when;
 import static org.mockito.ArgumentMatchers.any;
 
+import com.ticketing.server.global.exception.TicketingException;
 import com.ticketing.server.movie.domain.Movie;
 import com.ticketing.server.movie.domain.MovieTime;
 import com.ticketing.server.movie.domain.Theater;
 import com.ticketing.server.movie.domain.repository.MovieRepository;
 import com.ticketing.server.movie.domain.repository.MovieTimeRepository;
-import com.ticketing.server.movie.service.dto.MovieTimeListDTO;
+import com.ticketing.server.movie.domain.repository.TheaterRepository;
+import com.ticketing.server.movie.service.dto.MovieTimeDTO;
+import com.ticketing.server.movie.service.dto.MovieTimeRegisterDTO;
+import com.ticketing.server.movie.service.dto.RegisteredMovieTimeDTO;
 import java.time.LocalDate;
 import java.time.LocalDateTime;
 import java.util.ArrayList;
@@ -27,11 +35,15 @@ import org.mockito.junit.jupiter.MockitoExtension;
 public class MovieTimeServiceImplTest {
 
     String title = "범죄도시2";
+	LocalDateTime startAt = LocalDateTime.now();
     List<MovieTime> movieTimes = new ArrayList<>();
 
     @Mock
     MovieRepository movieRepository;
 
+	@Mock
+	TheaterRepository theaterRepository;
+
     @Mock
     MovieTimeRepository movieTimeRepository;
 
@@ -39,7 +51,7 @@ public class MovieTimeServiceImplTest {
     MovieTimeServiceImpl movieTimeService;
 
     @Test
-    @DisplayName("MovieTime Service Test - get empty list when there are no valid movie times")
+    @DisplayName("MovieTime Service Test - get empty list when there is no valid movie time")
     void shouldGetEmptyList() {
         // given
         Movie movie = new Movie(title, 106L);
@@ -51,10 +63,10 @@ public class MovieTimeServiceImplTest {
             .thenReturn(Collections.emptyList());
 
         // when
-        MovieTimeListDTO movieTimeListDto = movieTimeService.getMovieTimes(any(), LocalDate.now());
+        List<MovieTimeDTO> movieTimeDtos = movieTimeService.getMovieTimes(any(), LocalDate.now());
 
         // then
-        assertTrue(movieTimeListDto.getMovieTimeDtos().isEmpty());
+        assertTrue(movieTimeDtos.isEmpty());
     }
 
     @Test
@@ -76,10 +88,82 @@ public class MovieTimeServiceImplTest {
             .thenReturn(movieTimes);
 
         // when
-	    MovieTimeListDTO movieTimeListDto = movieTimeService.getMovieTimes(any(), LocalDate.of(2022, 07, 01));
+	    List<MovieTimeDTO> movieTimeDtos = movieTimeService.getMovieTimes(any(), LocalDate.of(2022, 07, 01));
 
         // then
-        assertTrue(!movieTimeListDto.getMovieTimeDtos().isEmpty());
+        assertTrue(!movieTimeDtos.isEmpty());
     }
 
+	@Test
+	@DisplayName("MovieTime Service Test - register movie time")
+	void shouldAbleToRegisterMovieTime() {
+		// given
+		Movie movie = new Movie(title, 100L);
+		Theater theater = new Theater(1);
+		MovieTime movieTime = new MovieTime(movie, theater, 1, startAt);
+
+		when(movieRepository.findByIdAndDeletedAtNull(anyLong()))
+			.thenReturn(Optional.of(movie));
+
+		when(theaterRepository.findByTheaterNumber(anyInt()))
+			.thenReturn(Optional.of(theater));
+
+		when(movieTimeRepository.findByMovieAndTheaterAndRoundAndDeletedAtNull(any(), any(), anyInt()))
+			.thenReturn(Optional.empty());
+
+		when(movieTimeRepository.save(any()))
+			.thenReturn(movieTime);
+
+		// when
+		RegisteredMovieTimeDTO registeredMovieTimeDto =
+			movieTimeService.registerMovieTime(
+				new MovieTimeRegisterDTO(1L, 1, 1, startAt)
+			);
+
+		// then
+		assertThat(registeredMovieTimeDto).isNotNull();
+		assertTrue(registeredMovieTimeDto.getTheaterNumber() == 1);
+		assertTrue(registeredMovieTimeDto.getStartAt() == startAt);
+		assertTrue(registeredMovieTimeDto.getRound() == 1);
+	}
+
+	@Test
+	@DisplayName("MovieTime Service Test - register movie time when there is same movie time already")
+	void shouldThrowExceptionWhenRegisteringDuplicateMovieTime() {
+		// given
+		Movie movie = new Movie(title, 100L);
+		Theater theater = new Theater(1);
+		MovieTime movieTime = new MovieTime(movie, theater, 1, startAt);
+		MovieTimeRegisterDTO movieTimeRegisterDto = new MovieTimeRegisterDTO(1L, 1, 1, startAt);
+
+		when(movieRepository.findByIdAndDeletedAtNull(anyLong()))
+			.thenReturn(Optional.of(movie));
+
+		when(theaterRepository.findByTheaterNumber(anyInt()))
+			.thenReturn(Optional.of(theater));
+
+		when(movieTimeRepository.findByMovieAndTheaterAndRoundAndDeletedAtNull(any(), any(), anyInt()))
+			.thenReturn(Optional.of(movieTime));
+
+		// when
+		// then
+		assertThatThrownBy(() -> movieTimeService.registerMovieTime(movieTimeRegisterDto))
+			.isInstanceOf(TicketingException.class);
+	}
+
+	@Test
+	@DisplayName("MovieTime Service Test - register movie time when there is no such movie")
+	void shouldThrowExceptionWhenRegisteringMovieTimeWithNoSuchMovie() {
+		// given
+		Theater theater = new Theater(1);
+		MovieTimeRegisterDTO movieTimeRegisterDto = new MovieTimeRegisterDTO(1L, 1, 1, startAt);
+
+		when(movieRepository.findByIdAndDeletedAtNull(1L))
+			.thenReturn(Optional.empty());
+
+		// when
+		// then
+		assertThatThrownBy(() -> movieTimeService.registerMovieTime(movieTimeRegisterDto))
+			.isInstanceOf(TicketingException.class);
+	}
 }

server/src/test/java/com/ticketing/server/movie/service/TicketServiceImplTest.java

@@ -10,7 +10,6 @@ import com.ticketing.server.global.exception.ErrorCode;
 import com.ticketing.server.global.exception.TicketingException;
 import com.ticketing.server.movie.domain.Ticket;
 import com.ticketing.server.movie.domain.repository.TicketRepository;
-import com.ticketing.server.movie.service.dto.TicketDetailsDTO;
 import com.ticketing.server.movie.service.dto.TicketsReservationDTO;
 import com.ticketing.server.payment.service.dto.TicketDetailDTO;
 import java.util.Collections;
@@ -53,8 +52,7 @@ class TicketServiceImplTest {
 		when(ticketRepository.findTicketFetchJoinByPaymentId(1L)).thenReturn(List.of(tickets.get(0)));
 
 		// when
-		TicketDetailsDTO ticketDetailDto = ticketService.findTicketsByPaymentId(1L);
+		List<TicketDetailDTO> ticketDetails = ticketService.findTicketsByPaymentId(1L);
-		List<TicketDetailDTO> ticketDetails = ticketDetailDto.getTicketDetails();
 
 		// then
 		assertAll(
@@ -66,14 +64,14 @@ class TicketServiceImplTest {
 	@Test
 	@DisplayName("티켓목록 예약으로 변경 시 조회된 갯수랑 다른 경우")
 	void ticketReservationFail() {
-	    // given
+		// given
 		List<Ticket> tickets = setupTickets();
 		List<Ticket> list = List.of(tickets.get(0), tickets.get(1), tickets.get(2));
 		List<Long> ids = List.of(0L, 1L, 2L, 10000L);
 
 		when(ticketRepository.findTicketFetchJoinByTicketIds(ids)).thenReturn(list);
 
-	    // when
+		// when
 		// then
 		assertThatThrownBy(() -> ticketService.ticketReservation(ids))
 			.isInstanceOf(TicketingException.class)
@@ -84,14 +82,14 @@ class TicketServiceImplTest {
 	@Test
 	@DisplayName("티켓목록 예약으로 변경 완료")
 	void ticketReservationSuccess() {
-	    // given
+		// given
 		List<Ticket> tickets = setupTickets();
 		List<Ticket> list = List.of(tickets.get(0), tickets.get(1), tickets.get(2));
 		List<Long> ids = List.of(0L, 1L, 2L);
 
 		when(ticketRepository.findTicketFetchJoinByTicketIds(ids)).thenReturn(list);
 
-	    // when
+		// when
 		TicketsReservationDTO ticketReservationsDto = ticketService.ticketReservation(ids);
 
 		// then

server/src/test/java/com/ticketing/server/payment/service/PaymentServiceImplTest.java

@@ -57,7 +57,8 @@ class PaymentServiceImplTest {
 					"T2d03c9130bf237a97001",
 					List.of(3L),
 					userAlternateId,
-					1241242343245L
+					1241242343245L,
+					15_000
 				),
 				KAKAO_PAY,
 				SOLD,
@@ -70,7 +71,8 @@ class PaymentServiceImplTest {
 					"T2d03c9130bf237a97002",
 					List.of(3L),
 					userAlternateId,
-					12412343212445L
+					12412343212445L,
+					30_000
 				),
 				KAKAO_PAY,
 				SOLD,

server/src/test/java/com/ticketing/server/user/service/UserApisServiceImplTest.java

@@ -76,7 +76,8 @@ class UserApisServiceImplTest {
 						"T2d03c9130bf237a9700",
 						List.of(1L, 2L),
 						user.getAlternateId(),
-						124124231513245L
+						124124231513245L,
+						15_000
 					),
 					KAKAO_PAY,
 					SOLD,
@@ -91,7 +92,8 @@ class UserApisServiceImplTest {
 						"T2d03c9130bf237a97001",
 						List.of(3L),
 						user.getAlternateId(),
-						1241242343245L
+						1241242343245L,
+						15_000
 					),
 					KAKAO_PAY,
 					SOLD,