refactor: MovieDto 필드에 @JsonProperty 추가

server/build.gradle.kts

@@ -33,7 +33,7 @@ dependencies {
 	implementation("org.springframework.boot:spring-boot-starter-actuator")
 	implementation("org.springframework.boot:spring-boot-starter-log4j2")
 	implementation("org.projectlombok:lombok:1.18.20")
-	implementation("io.springfox:springfox-swagger2:3.0.0")
+    implementation("io.springfox:springfox-boot-starter:3.0.0")
 	implementation("io.springfox:springfox-swagger-ui:3.0.0")
 	implementation("com.github.ulisesbocchio:jasypt-spring-boot-starter:3.0.4")
 	implementation("com.lmax:disruptor:3.4.2")

server/src/main/java/com/ticketing/server/global/config/SwaggerConfig.java

@@ -1,14 +1,28 @@
 package com.ticketing.server.global.config;
 
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.List;
 import lombok.RequiredArgsConstructor;
+import org.springframework.boot.actuate.autoconfigure.endpoint.web.CorsEndpointProperties;
+import org.springframework.boot.actuate.autoconfigure.endpoint.web.WebEndpointProperties;
+import org.springframework.boot.actuate.autoconfigure.web.server.ManagementPortType;
+import org.springframework.boot.actuate.endpoint.ExposableEndpoint;
+import org.springframework.boot.actuate.endpoint.web.EndpointLinksResolver;
+import org.springframework.boot.actuate.endpoint.web.EndpointMapping;
+import org.springframework.boot.actuate.endpoint.web.EndpointMediaTypes;
+import org.springframework.boot.actuate.endpoint.web.ExposableWebEndpoint;
+import org.springframework.boot.actuate.endpoint.web.WebEndpointsSupplier;
+import org.springframework.boot.actuate.endpoint.web.annotation.ControllerEndpointsSupplier;
+import org.springframework.boot.actuate.endpoint.web.annotation.ServletEndpointsSupplier;
+import org.springframework.boot.actuate.endpoint.web.servlet.WebMvcEndpointHandlerMapping;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
-import springfox.documentation.builders.ApiInfoBuilder;
+import org.springframework.core.env.Environment;
+import org.springframework.util.StringUtils;
 import springfox.documentation.builders.PathSelectors;
 import springfox.documentation.builders.RequestHandlerSelectors;
-import springfox.documentation.service.ApiInfo;
 import springfox.documentation.service.ApiKey;
 import springfox.documentation.service.AuthorizationScope;
 import springfox.documentation.service.SecurityReference;
@@ -22,27 +36,29 @@ import springfox.documentation.swagger.web.UiConfigurationBuilder;
 @RequiredArgsConstructor
 public class SwaggerConfig {
 
-    public static final String SECURITY_SCHEMA_NAME = "Authorization";
-    public static final String AUTHORIZATION_SCOPE_GLOBAL = "global";
-    public static final String AUTHORIZATION_SCOPE_GLOBAL_DESC = "accessEverything";
-
     @Bean
     public Docket api() {
-        return new Docket(DocumentationType.OAS_30)
-            .useDefaultResponseMessages(false)
-            .select()
-            .apis(RequestHandlerSelectors.any())
-            .paths(PathSelectors.ant("/api/**")).build()
-            .apiInfo(apiInfo())
+        return new Docket(DocumentationType.OAS_30).useDefaultResponseMessages(false).select()
+            .apis(RequestHandlerSelectors.any()).paths(PathSelectors.ant("/api/**")).build()
             .securityContexts(Arrays.asList(securityContext()))
             .securitySchemes(Arrays.asList(apiKey()));
     }
 
-    private ApiInfo apiInfo() {
-        return new ApiInfoBuilder()
-            .title("Ticketing REST API Document")
-            .version("v1")
-            .description("Ticketing REST API 문서").build();
+    @Bean
+    public WebMvcEndpointHandlerMapping webEndpointServletHandlerMapping(WebEndpointsSupplier webEndpointsSupplier, ServletEndpointsSupplier servletEndpointsSupplier, ControllerEndpointsSupplier controllerEndpointsSupplier, EndpointMediaTypes endpointMediaTypes, CorsEndpointProperties corsProperties, WebEndpointProperties webEndpointProperties, Environment environment) {
+        List<ExposableEndpoint<?>> allEndpoints = new ArrayList<>();
+        Collection<ExposableWebEndpoint> webEndpoints = webEndpointsSupplier.getEndpoints();
+        allEndpoints.addAll(webEndpoints);
+        allEndpoints.addAll(servletEndpointsSupplier.getEndpoints());
+        allEndpoints.addAll(controllerEndpointsSupplier.getEndpoints());
+        String basePath = webEndpointProperties.getBasePath();
+        EndpointMapping endpointMapping = new EndpointMapping(basePath);
+        boolean shouldRegisterLinksMapping = this.shouldRegisterLinksMapping(webEndpointProperties, environment, basePath);
+        return new WebMvcEndpointHandlerMapping(endpointMapping, webEndpoints, endpointMediaTypes, corsProperties.toCorsConfiguration(), new EndpointLinksResolver(allEndpoints, basePath), shouldRegisterLinksMapping, null);
+    }
+
+    private boolean shouldRegisterLinksMapping(WebEndpointProperties webEndpointProperties, Environment environment, String basePath) {
+        return webEndpointProperties.getDiscovery().isEnabled() && (StringUtils.hasText(basePath) || ManagementPortType.get(environment).equals(ManagementPortType.DIFFERENT));
     }
 
     private ApiKey apiKey() {
@@ -53,6 +69,10 @@ public class SwaggerConfig {
         return SecurityContext.builder().securityReferences(defaultAuth()).build();
     }
 
+    public static final String SECURITY_SCHEMA_NAME = "Authorization";
+    public static final String AUTHORIZATION_SCOPE_GLOBAL = "global";
+    public static final String AUTHORIZATION_SCOPE_GLOBAL_DESC = "accessEverything";
+
     private List<SecurityReference> defaultAuth() {
         AuthorizationScope authorizationScope = new AuthorizationScope(AUTHORIZATION_SCOPE_GLOBAL,
             AUTHORIZATION_SCOPE_GLOBAL_DESC);

server/src/main/java/com/ticketing/server/global/dto/repository/AbstractEntity.java

@@ -28,4 +28,6 @@ public abstract class AbstractEntity {
 	@LastModifiedDate
 	private LocalDateTime updatedAt;
 
+	private LocalDateTime deletedAt;
+
 }

server/src/main/java/com/ticketing/server/global/security/RoleConfig.java

@@ -1,56 +0,0 @@
-package com.ticketing.server.global.security;
-
-import com.ticketing.server.user.domain.UserGrade;
-import java.util.ArrayList;
-import java.util.List;
-import org.springframework.context.annotation.Bean;
-import org.springframework.context.annotation.Configuration;
-import org.springframework.security.access.AccessDecisionManager;
-import org.springframework.security.access.AccessDecisionVoter;
-import org.springframework.security.access.annotation.Jsr250Voter;
-import org.springframework.security.access.expression.method.ExpressionBasedPreInvocationAdvice;
-import org.springframework.security.access.hierarchicalroles.RoleHierarchy;
-import org.springframework.security.access.hierarchicalroles.RoleHierarchyImpl;
-import org.springframework.security.access.prepost.PreInvocationAuthorizationAdviceVoter;
-import org.springframework.security.access.vote.AffirmativeBased;
-import org.springframework.security.access.vote.AuthenticatedVoter;
-import org.springframework.security.access.vote.RoleHierarchyVoter;
-import org.springframework.security.access.vote.RoleVoter;
-import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
-import org.springframework.security.config.annotation.method.configuration.GlobalMethodSecurityConfiguration;
-
-@EnableGlobalMethodSecurity(
-	securedEnabled = true,
-	jsr250Enabled = true,
-	prePostEnabled = true
-)
-@Configuration
-public class RoleConfig extends GlobalMethodSecurityConfiguration {
-
-	@Override
-	protected AccessDecisionManager accessDecisionManager() {
-		List<AccessDecisionVoter<?>> decisionVoters = new ArrayList<>();
-		ExpressionBasedPreInvocationAdvice expressionAdvice = new ExpressionBasedPreInvocationAdvice();
-		expressionAdvice.setExpressionHandler(getExpressionHandler());
-		decisionVoters.add(new PreInvocationAuthorizationAdviceVoter(expressionAdvice));
-		decisionVoters.add(new Jsr250Voter());
-
-		decisionVoters.add(new RoleVoter());
-		decisionVoters.add(roleHierarchyVoter());
-		decisionVoters.add(new AuthenticatedVoter());
-		return new AffirmativeBased(decisionVoters);
-	}
-
-	@Bean
-	public RoleHierarchyVoter roleHierarchyVoter() {
-		return new RoleHierarchyVoter(roleHierarchy());
-	}
-
-	@Bean
-	public RoleHierarchy roleHierarchy() {
-		RoleHierarchyImpl roleHierarchy = new RoleHierarchyImpl();
-		roleHierarchy.setHierarchy(UserGrade.getRoleHierarchy());
-		return roleHierarchy;
-	}
-
-}

server/src/main/java/com/ticketing/server/global/security/WebSecurityConfig.java

@@ -8,7 +8,9 @@ import lombok.RequiredArgsConstructor;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.http.HttpMethod;
+import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
 import org.springframework.security.config.annotation.web.builders.HttpSecurity;
+import org.springframework.security.config.annotation.web.builders.WebSecurity;
 import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
 import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
 import org.springframework.security.config.http.SessionCreationPolicy;
@@ -17,6 +19,7 @@ import org.springframework.security.crypto.password.PasswordEncoder;
 
 @Configuration
 @EnableWebSecurity
+@EnableGlobalMethodSecurity(securedEnabled = true)
 @RequiredArgsConstructor
 public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
 
@@ -53,10 +56,11 @@ public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
 			.antMatchers(HttpMethod.POST, "/api/user/login").permitAll()
 			.antMatchers(HttpMethod.POST, "/api/user/refresh").permitAll()
 			.antMatchers(HttpMethod.POST, "/api/user").permitAll()
+			.antMatchers("/api/movies/**").permitAll()
 			.antMatchers("/l7check").permitAll()
-			.antMatchers("/actuator/health").permitAll()
+			.antMatchers("/actuator/**").permitAll()
+			.antMatchers("/api/v3/", "/swagger-ui/**", "/swagger/", "/swagger-resources/**", "/v3/api-docs").permitAll()
 			.anyRequest().authenticated()
-
 			.and()
 			.apply(new JwtSecurityConfig(jwtFilter));
 	}

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

@@ -1,8 +1,30 @@
 package com.ticketing.server.movie.application;
 
+import com.ticketing.server.movie.application.response.MovieListResponse;
+import com.ticketing.server.movie.service.interfaces.MovieService;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 
 @RestController
+@RequestMapping("/api/movies")
+@Api(value = "Movie API", tags = {"Movie"})
+@RequiredArgsConstructor
+@Slf4j
 public class MovieController {
 
+    private final MovieService movieService;
+
+    @GetMapping()
+    @ApiOperation(value = "영화 목록 조회")
+    public ResponseEntity<MovieListResponse> getMovies() {
+        return ResponseEntity.status(HttpStatus.OK).body(MovieListResponse.from(movieService.getMovies()));
+    }
+
 }

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

@@ -0,0 +1,23 @@
+package com.ticketing.server.movie.application.response;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import com.ticketing.server.movie.service.dto.MovieDto;
+import io.swagger.annotations.ApiModelProperty;
+import java.util.List;
+import lombok.AccessLevel;
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor(access = AccessLevel.PRIVATE)
+public class MovieListResponse {
+
+    @ApiModelProperty(value = "영화 제목")
+    @JsonProperty
+    private List<MovieDto> movieDtos;
+
+    public static MovieListResponse from(List<MovieDto> movieDtos) {
+        return new MovieListResponse(movieDtos);
+    }
+
+}

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

@@ -1,6 +1,7 @@
 package com.ticketing.server.movie.domain;
 
 import com.ticketing.server.global.dto.repository.AbstractEntity;
+import com.ticketing.server.movie.service.dto.MovieDto;
 import javax.persistence.Column;
 import javax.persistence.Entity;
 import javax.validation.constraints.NotNull;
@@ -21,4 +22,8 @@ public class Movie extends AbstractEntity {
     @NotNull
     private Integer runningTime;
 
+    public MovieDto toDto() {
+        return new MovieDto(this.title);
+    }
+
 }

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

@@ -1,8 +1,11 @@
 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;
+import org.springframework.data.jpa.repository.Query;
 import org.springframework.stereotype.Repository;
 
 @Repository
@@ -10,4 +13,9 @@ public interface MovieRepository extends JpaRepository<Movie, Long> {
 
     Optional<Movie> findByTitle(String title);
 
+    @Query(value = "SELECT * "
+        + "FROM movie "
+        + "WHERE deleted_at IS NULL", nativeQuery = true)
+    List<Movie> findValidMovies();
+
 }

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

@@ -1,9 +1,29 @@
 package com.ticketing.server.movie.service;
 
+import com.ticketing.server.movie.domain.Movie;
+import com.ticketing.server.movie.domain.repository.MovieRepository;
+import com.ticketing.server.movie.service.dto.MovieDto;
 import com.ticketing.server.movie.service.interfaces.MovieService;
+import java.util.List;
+import java.util.stream.Collectors;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
 
 @Service
+@RequiredArgsConstructor
+@Slf4j
 public class MovieServiceImpl implements MovieService {
 
+    private final MovieRepository movieRepository;
+
+    public List<MovieDto> getMovies() {
+        List<Movie> movies = movieRepository.findValidMovies();
+
+        return movies.stream()
+            .map(movie -> movie.toDto())
+            .collect(Collectors.toList());
+
+    }
+
 }

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

@@ -0,0 +1,12 @@
+package com.ticketing.server.movie.service.dto;
+
+import com.fasterxml.jackson.annotation.JsonProperty;
+import lombok.AllArgsConstructor;
+
+@AllArgsConstructor
+public class MovieDto {
+
+    @JsonProperty
+    private String title;
+
+}

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

@@ -1,5 +1,10 @@
 package com.ticketing.server.movie.service.interfaces;
 
+import com.ticketing.server.movie.service.dto.MovieDto;
+import java.util.List;
+
 public interface MovieService {
 
+    List<MovieDto> getMovies();
+
 }

server/src/main/java/com/ticketing/server/user/application/UserController.java

@@ -10,7 +10,6 @@ import com.ticketing.server.user.application.response.TokenDto;
 import com.ticketing.server.user.application.response.UserChangePasswordResponse;
 import com.ticketing.server.user.application.response.UserDeleteResponse;
 import com.ticketing.server.user.domain.User;
-import com.ticketing.server.user.domain.UserGrade;
 import com.ticketing.server.user.service.UserServiceImpl;
 import com.ticketing.server.user.service.interfaces.AuthenticationService;
 import javax.servlet.http.HttpServletResponse;
@@ -47,14 +46,14 @@ public class UserController {
 	}
 
 	@DeleteMapping
-	@Secured(UserGrade.ROLES.GUEST)
+	@Secured("ROLE_GUEST")
 	public ResponseEntity<UserDeleteResponse> deleteUser(@RequestBody @Valid UserDeleteRequest request) {
 		User user = userService.delete(request.toDeleteUserDto(passwordEncoder));
 		return ResponseEntity.status(HttpStatus.OK).body(UserDeleteResponse.from(user));
 	}
 
 	@PutMapping("/password")
-	@Secured(UserGrade.ROLES.GUEST)
+	@Secured("ROLE_GUEST")
 	public ResponseEntity<UserChangePasswordResponse> changePassword(@RequestBody @Valid UserModifyPasswordRequest request) {
 		if (request.oldEqualNew()) {
 			log.error("기존 패스워드와 동일한 패스워드로 변경할 수 없습니다.");

server/src/main/java/com/ticketing/server/user/domain/User.java

@@ -23,6 +23,14 @@ import lombok.NoArgsConstructor;
 @NoArgsConstructor
 public class User extends AbstractEntity {
 
+	public User(String name, String email, String password, UserGrade grade, String phone) {
+		this.name = name;
+		this.email = email;
+		this.password = password;
+		this.grade = grade;
+		this.phone = phone;
+	}
+
 	@Column(name = "name")
 	@NotEmpty(message = "{validation.not.empty.name}")
 	private String name;
@@ -50,14 +58,6 @@ public class User extends AbstractEntity {
 
 	private LocalDateTime deletedAt;
 
-	public User(String name, String email, String password, UserGrade grade, String phone) {
-		this.name = name;
-		this.email = email;
-		this.password = password;
-		this.grade = grade;
-		this.phone = phone;
-	}
-
 	public User delete(DeleteUserDTO deleteUser) {
 		if (isDeleted) {
 			throw new AlreadyDeletedException("이미 탈퇴된 회원 입니다.");

server/src/main/java/com/ticketing/server/user/domain/UserGrade.java

@@ -1,38 +1,5 @@
 package com.ticketing.server.user.domain;
 
-import lombok.RequiredArgsConstructor;
-
-@RequiredArgsConstructor
 public enum UserGrade {
-	ADMIN(ROLES.ADMIN, null),
-	STAFF(ROLES.STAFF, ROLES.ADMIN),
-	GUEST(ROLES.GUEST, ROLES.STAFF);
-
-	private final String roleName;
-	private final String parentName;
-
-	public static class ROLES {
-
-		public static final String ADMIN = "ROLE_ADMIN";
-		public static final String STAFF = "ROLE_STAFF";
-		public static final String GUEST = "ROLE_GUEST";
-
-		private ROLES() {
-		}
-	}
-
-	public static String getRoleHierarchy() {
-		StringBuilder sb = new StringBuilder();
-
-		for (UserGrade grade : UserGrade.values()) {
-			if (grade.parentName != null) {
-				sb.append(grade.parentName);
-				sb.append(" > ");
-				sb.append(grade.roleName);
-				sb.append("\n");
-			}
-		}
-
-		return sb.toString();
-	}
+	GUEST, STAFF
 }

server/src/main/resources/application.yml

@@ -18,6 +18,10 @@ spring:
       maximum-pool-size: 10 # default 10
       max-lifetime: 1800000 # default 30 minutes
 
+  mvc:
+    pathmatch:
+      matching-strategy: ant_path_matcher
+
 jasypt:
   encryptor:
     bean: jasyptStringEncryptor
@@ -29,3 +33,8 @@ jwt:
   secret-key: Zi1sYWItdGlja2V0aW5nLXByb2plY3Qtc3ByaW5nLWJvb3Qtc2VjdXJpdHktand0LXNlY3JldC1rZXktZi1sYWItdGlja2V0aW5nLXByb2plY3Qtc3ByaW5nLWJvb3Qtc2VjdXJpdHktand0LXNlY3JldC1rZXkK
   access-token-validity-in-seconds: 60 # 1분
   refresh-token-validity-in-seconds: 259200 # 3일
+
+springfox:
+  documentation:
+    swagger:
+      use-model-v3: false

server/src/test/java/com/ticketing/server/movie/domain/repository/MovieRepositoryTest.java

@@ -27,7 +27,7 @@ public class MovieRepositoryTest {
     @Order(1)
     @Test
     @Rollback(value = false)
-    @DisplayName("Movie Repository - test saving movie")
+    @DisplayName("Movie Repository Test - saving movie")
     void shouldAbleToSaveMovie() {
         // given
         Movie movie = new Movie("범죄도시 2", 106);

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

@@ -1,9 +1,66 @@
 package com.ticketing.server.movie.service;
 
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.when;
+
+import com.ticketing.server.movie.domain.Movie;
+import com.ticketing.server.movie.domain.repository.MovieRepository;
+import com.ticketing.server.movie.service.dto.MovieDto;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+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.mockito.InjectMocks;
+import org.mockito.Mock;
 import org.mockito.junit.jupiter.MockitoExtension;
 
 @ExtendWith(MockitoExtension.class)
 public class MovieServiceImplTest {
 
+    Movie movie;
+    MovieDto movieDto;
+    List<Movie> movies = new ArrayList<>();
+    List<MovieDto> movieDtos = new ArrayList<>();
+
+    @Mock
+    MovieRepository movieRepository;
+
+    @InjectMocks
+    MovieServiceImpl movieService;
+
+    @Test
+    @DisplayName("Movie Service Test - get movies when there is no movie")
+    void shouldGetEmptyList() {
+        // given
+        when(movieRepository.findValidMovies()).thenReturn(Collections.emptyList());
+
+        // when
+        List<MovieDto> movieDtoList = movieService.getMovies();
+
+        // then
+        assertTrue(movieDtoList.isEmpty());
+
+    }
+
+    @Test
+    @DisplayName("Movie Service Test - get movies")
+    void shouldAbleToGetMovies() {
+        // given
+        movie = new Movie("범죄도시2", 106);
+        movieDto = movie.toDto();
+        movies.add(movie);
+        movieDtos.add(movieDto);
+
+        when(movieRepository.findValidMovies()).thenReturn(movies);
+
+        // when
+        List<MovieDto> movieDtoList = movieService.getMovies();
+
+        // then
+        assertTrue(!movieDtoList.isEmpty());
+    }
+
 }