Spring Boot와 AWS로 혼자 구현하는 웹 서비스 4 - Spring Security, OAuth 2.0으로 로그인 구현(Ch.05)

December 3, 2022

Authentication : 인증, 로그인
Authorization : 권한 부여
Spring MVC request lifecycle
- Spring Interceptor : DispatcherServlet에서 Handler로 가기 전에 정보를 처리
  - Spring에서 자체 제공하는 기능
  - 인증, 권한같은 작업을 주로 담당
- Filter : DispatcherServlet의 앞단에서 정보를 처리
  - J2EE 표준에 정의되어 있는 기능
  - 인코딩, 보안과 같이 web app 전역적으로 처리해야 하는 작업 담당
Spring에서는 Spring Security를 통해 보안 기능을 구현하는 것을 권장함
OAuth(Open Authorization) : 접근 위임을 위한 open standard
- 사용자들이 비밀번호를 제공하지 않고, 다른 웹사이트 상의 자신의 정보에 대해 앱의 접근 권한을 부여하기 위한 수단
  e.g. 구글 계정에 대한 접근 권한을 부여해줌

Spring Security와 Spring Security Oauth2 클라이언트

인증이 매우 복잡한 과정이기 때문에 대부분은 소셜 로그인 기능을 사용함
- OAuth를 사용할 경우 로그인 보안, 본인 인증, pw 찾기/변경, 회원정보 변경 등의 기능을 직접 개발하지 않아도 됨
Spring Boot 1.5, 2.0에서의 OAuth2 연동 방법이 바뀌었지만, spring-security-oauth2-autocnfigure 라이브러리를 사용해서 1.5에서 사용하던 설정을 2.0에서도 그대로 사용 가능
예제에서는 spring-security-oauth2-client 라이브러리를 사용할 예정
- 1.5에서 사용하던 spring-security-oauth는 maintenance mode로 바뀌어, 신규 기능은 추가되지 않음
- spring-security-oauth2-client는 springboot용 starter 라이브러리가 존재함
Spring Boot 1.5, 2.0 설정 차이
- client 정보가 google-client에 바로 존재하면 1.5, google-security-oauth2-client에 존재하면 2.0
- 1.5에서는 url을 모두 명시해야 하지만, 2.0에서는 client 인증 정보만 입력하면 됨
- 2.0에서는 CommonOAuth2Provider라는 enum을 통해 구글, 깃헙, 페이스북 등의 기본 설정값을 제공함(다른 사이트들은 직접 추가해줘야 함)

구글 서비스 등록

google cloud console에서 프로젝트 생성 후 API 및 서비스 - 사용자 인증 정보 - 사용자 인증 정보 만들기 - OAuth 클라이언트 ID 만들기 - 동의 화면 구성
- 범위 : 외부
- 테스트 사용자 등록
다시 OAuth 클라이언트 ID 만들기 - 웹앱 - 승인된 리디렉션 URI : http://localhost:8080/login/oauth2/code/google으로 설정
- 서비스에서 준 인증 정보로 인증이 성공하면 구글에서 redirect할 URL
- spring boot 2의 security에서는 기본적으로 {domain}/login/oauth2/code/{socialservice}로 redirect URL을 지원함
- redirect URL에 대한 controller는 security에서 이미 구현함
- AWS에 배포하면 localhost 이외의 주소를 추가해야 함

src/main/resources에 application-oauth.properties 생성 후 clientId, clientSecret 등록

spring.security.oauth2.client.registration.google.client-id= // CLIENTID
spring.security.oauth2.client.registration.google.client-secret= // CLIENTSECRET
spring.security.oauth2.client.registration.google.scope=profile,email

scope 설정의 경우 기본값이 openid,profile,email임
- openid scope가 있으면 Open Id Provider로 인식하고, OpenId Provider 서비스(구글)과 나머지(네이버, 카카오 등) 각각에 대해 OAuth2Service를 만들어야 함
- 예제에서는 하나만 만들기 위해 저렇게 범위를 지정해줌
스프링 부트에서는 application-prop.properties 파일을 생성해서 profile=prop과 같이 호출하면 해당 프로퍼티의 설정들을 가져올 수 있음

application.properties에 spring.profiles.include=oauth 추가
.gitignore에 application-oauth.properties 추가

구글 로그인 연동

domain.user 패키지 생성 후 User 클래스 생성

@Getter
@NoArgsConstructor
@Entity
public class User extends BaseTimeEntity {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false)
    private String name;

    @Column(nullable = false)
    private String email;

    @Column
    private String picture;

    @Enumerated(EnumType.STRING)
    @Column(nullable = false)
    private Role role;

    @Builder
    public User(String name, String email, String picture, Role role) {
        this.name = name;
        this.email = email;
        this.picture = picture;
        this.role = role;
    }

    public User update(String name, String picture) {
        this.name = name;
        this.picture = picture;

        return this;
    }

    public String getRoleKey() {
        return this.role.getKey();
    }
}

@Enumerated(EnumTypes.STRING) : enum의 타입 지정(역할의 의미를 담기 위해 문자열로 설정)

user 패키지 안에 enum Role 생성

@Getter
@RequiredArgsConstructor
public enum Role {

    GUEST("ROLE_GUEST", "guest"),
    USER("ROLE_USER", "user");

    private final String key;
    private  final String title;
}

Spring Security에는 권한 코드에 항상 ROLE_가 붙어야 함

user 패키지에 interface UserRepository 추가

public interface UserRepository extends JpaRepository<User, Long> {

    Optional<User> findByEmail(String email);
}

User의 CRUD을 정의
findByEmail : 이미 등록된 사용자인지 email으로 판단하기 위해 구현

Spring Security 설정

build.gradle에 compile org.springframework.boot:spring-boot-starter-oauth2-client' 의존성 추가
- client의 소셜 기능(소셜 로그인 등) 구현 시 필요함

springaws.config.auth 패키지 생성 후 SecurityConfig 클래스 생성

@RequiredArgsConstructor
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    private final CustomOAuth2UserService customOAuth2UserService;

    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http.csrf().disable()
                .headers().frameOptions().disable()
                    .and()
                        .authorizeRequests()
                        .antMatchers("/", "/css/**", "/images/**", "/js/**", "/h2-console/**").permitAll()
                        .antMatchers("/api/v1/**").hasRole(Role.USER.name())
                        .anyRequest().authenticated()
                .and()
                    .logout()
                    .logoutSuccessUrl("/")
                .and()
                    .oauth2Login()
                        .userInfoEndpoint()
                            .userService(customOAuth2UserService);
    }
}

@EnableWebSecurity : spring security 설정 활성화
csrf().disable().headers().frameOptions().disable() : h2-console 화면을 사용하기 위해 비활성화해줌
authorizeRequests : URL별 권한 관리를 설정의 진입점
- authorizeRequests를 선언 후 andMatchers 옵션 사용 가능
andMatchers : 권한 관리 대상을 지정하는 옵션
- URL, HTTP 메소드별로 관리 가능
- "/"와 같은 지정된 URL들은 permitAll()으로 전체 열람 권한 부여
- "/api/v1/**"과 같은 API는 USER 권한을 가진 사람만 열람 가능하도록 권한 부여
anyRequest().authenticated() : 설정된 값 이외의 나머지 URL은 인증된 사용자만 허용하도록 권한 부여
logout().logoutSuccessUrl("/") : 로그아웃 성공 시 / 주소로 이동
oauth2Login() : OAuth2 로그인 기능에 대한 설정의 진입점
- userInfoEndpoint : 로그인 성공 이후 사용자 정보를 가져올 때 설정 담당
userService() : 소셜 로그인 성공 이후의 작업들 위한 UserService interface이 구현체를 등록함
- 리소스 서버(소셜 서비스들)에서 유저 정보를 가져온 상태에서 추가로 진행할 기능을 명시할 수 있음

config.auth 패키지에 CustomOAuth2UserService 클래스 생성

@RequiredArgsConstructor
@Service
public class CustomOAuth2UserService implements OAuth2UserService<OAuth2UserRequest, OAuth2User> {
    private final UserRepository userRepository;
    private final HttpSession httpSession;

    @Override
    public OAuth2User loadUser(OAuth2UserRequest userRequest) throws OAuth2AuthenticationException {
        OAuth2UserService<OAuth2UserRequest, OAuth2User> delegate = new DefaultOAuth2UserService();
        OAuth2User oAuth2User = delegate.loadUser(userRequest);

        String registrationId = userRequest.getClientRegistration().getRegistrationId();
        String userNameAttributeName = userRequest.getClientRegistration().getProviderDetails()
                .getUserInfoEndpoint().getUserNameAttributeName();

        OAuthAttributes attributes = OAuthAttributes.of(registrationId, userNameAttributeName, oAuth2User.getAttributes());

        User user = saveOrUpdate(attributes);

        httpSession.setAttribute("user", new SessionUser(user));

        return new DefaultOAuth2User(Collections.singleton(new SimpleGrantedAuthority(user.getRoleKey())),
                attributes.getAttributes(),
                attributes.getNameAttributeKey());
    }

    private User saveOrupdate(OAuthAttributes attributes) {
        User user = userRepository.findByEmail(attributes.getEmail())
                .map(entity -> entity.update(attributes.getName(), attributes.getPicture()))
                .orElse(attributes.toEntity());

        return userRepository.save(user);
    }
}

registrationId : 현재 로그인 진행 중인 서비스(구글, 네이버, …)를 구분
userNameAttributeName : OAuth2 로그인 진행할 때 키가 되는 필드값
- PK와 같은 의미임
- 구글의 기본코드 : "sub"
  네이버, 카카오는 기본으로 지원하지 않음
OAuthAttributes : OAuth2UserService를 통해 가져온 OAuth2User의 attribute를 담을 클래스
SessionUser : 세션에 사용자 정보를 저장하기 위한 Dto 클래스
- User 클래스의 직렬화(Serialization)을 구현하지 않았기 때문에 바로 http session에 저장하려고 하면 에러가 남
- User 클래스는 entity이기 때문에 자식 엔티티를 가지게 된다면, 자식들까지 직렬화 대상에 포함되면서 성능 이슈가 발생할 수 있음
  → 세션에 집어넣기 위해 직렬화 기능을 가진 세션 Dto를 따로 만드는게 나음

auth.dto 패키지 생성 후 OAuthAttributes 클래스 생성

@Getter
public class OAuthAttributes {
    private Map<String, Object> attributes;
    private String nameAttributeKey;
    private String name;
    private String email;
    private String picture;

    @Builder
    public OAuthAttributes(Map<String, Object> attributes,
                           String nameAttributeKey, String name,
                           String email, String picture) {
        this.attributes = attributes;
        this.nameAttributeKey = nameAttributeKey;
        this.name = name;
        this.email = email;
        this.picture = picture;
    }

    public static OAuthAttributes of(String registrationId,
                                     String userNameAttributeName,
                                     Map<String, Object> attributes) {
        return ofGoogle(userNameAttributeName, attributes);
    }

    private static OAuthAttributes ofGoogle(String userNameAttributeName, Map<String, Object> attributes) {
        return OAuthAttributes.builder()
                .name((String) attributes.get("name"))
                .email((String) attributes.get("email"))
                .picture((String) attributes.get("picture"))
                .attributes(attributes)
                .nameAttributeKey(userNameAttributeName)
                .build();
    }

    public User toEntity() {
        return User.builder()
                .name(name)
                .email(email)
                .picture(picture)
                .role(Role.GUEST)
                .build();
    }
}

of() : OAuth2User에서 반환하는 값은 Map이기 때문에 하나씩 변환해줘야 함
toEntity() : User entity 생성
- 처음 가입하는 시점에 OAuthAttributes에서 entity를 생성
- 가입할 때 기본 권한을 GUEST로 주기 위해 role의 빌더값으로 Role.GUEST 사용

config.auth.dto 패키지에 SessionUser 클래스 생성

@Getter
public class SessionUser implements Serializable {
    private String name;
    private String email;
    private String picture;

    public SessionUser(User user) {
        this.name = user.getName();
        this.email = user.getEmail();
        this.picture = user.getPicture();
    }
}

인증된 사용자 정보만 필요하기 때문에 name, email, picture만 필드로 선언

로그인 테스트

index.mustache에 로그인 버튼 추가

...
<div class="col-md-6">
    <a href="/posts/save" role="button" class="btn btn-primary">Upload post</a>
    {{#userName}}
        Logged in as: <span id="user">{{userName}}</span>
        <a href="/logout" class="btn btn-info active" role="button">Logout</a>
    {{/userName}}
    {{^userName}}
        <a href="/oauth2/authorization/google" class="btn btn-success active" role="button">Google Login</a>
    {{/userName}}
</div>
...

{{#userName}} : userName이 존재할 경우의 템플릿
{{^userName}} : userName이 존재하지 않을 경우의 템플릿
a href="/logout" : Spring Security에서 기본으로 제공하는 로그아웃 URL(별도의 controller 필요하지 않음)
- SecurityConfig 클래스에서 URL 변경 가능
a href="/oauth2/authorization/google" : 기본으로 제공하는 로그인 URL

IndexController에서 userName을 model에 저장

@GetMapping("/")
public String index(Model model) {
    model.addAttribute("posts", postsService.findAllDesc());
    SessionUser user = (SessionUser) httpSession.getAttribute("user");
    if (user != null) {
        model.addAttribute("userName", user.getName());
    }
    return "index";
}

(SessionUser) httpSession.getAttribute("user"); : 로그인 성공 시 세션에 SessionUser가 들어가기 때문에, 로그인 성공 시 세션에서 "user"를 가져올 수 있음

User 클래스에 @Table(name = "users") 어노테이션 추가해야 함

아니면 아래와 같이 에러남(user가 reserved라서 테이블 명을 따로 지정해야 함)

caused by: org.h2.jdbc.jdbcsqlsyntaxerrorexception: syntax error in sql statement "drop table if exists [*]user"; expected "identifier"; sql statement:~

로그인 후 update users set role='USER';로 전체 권한 변경 → 로그아웃 후 다시 로그인하면 글쓰기가 정상적으로 작동함 - 처음 로그인했을 때 세션에는 권한이 GUEST인 채로 로드되었기 때문에 글쓰면 에러남

어노테이션 기반으로 개선하기

지금은 아래와 같은 세션값을 가져오는 부분의 중복이 많음
SessionUser user = (SessionUser) httpSession.getAttribute("user");

config.auth에 LoginUser annotation 추가해서 메소드 인자로 세션값을 바로 받을 수 있도록 수정

@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
public @interface LoginUser {
}

@Target(ElementType.PARAMETER) : annotation이 생성될 수 있는 위치 지정
@interface : annotation 클래스로 지정

config.auth에 LoginUserArgumentResolver 클래스 생성

@RequiredArgsConstructor
@Component
public class LoginUserArgumentResolver implements HandlerMethodArgumentResolver {
    public final HttpSession httpSession;

    @Override
    public boolean supportsParameter(MethodParameter parameter) {
        boolean isLoginUserAnnotation = parameter.getParameterAnnotation(LoginUser.class) != null;
        boolean isUserClass = SessionUser.class.equals(parameter.getParameterType());
        return isLoginUserAnnotation && isUserClass;
    }

    @Override
    public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
                                  NativeWebRequest webRequest,
                                  WebDataBinderFactory binderFactory) throws Exception {
        return httpSession.getAttribute("user");
    }
}

supportsParameter() : parameter를 지원하는지 판단하기 위한 메소드
- parameter에 @LoginUser annotation이 붙어있고, class Type이 SessionUser.class인 경우 true 반환하도록 오버라이딩
resolveArgument() : 파라미터에 전달할 객체를 생성
- 세션에서 "user"에 해당하는 객체를 가져오도록 오버라이딩

config 패키지에 WebConfig 클래스 생성

@RequiredArgsConstructor
@Configuration
public class WebConfig implements WebMvcConfigurer {

    private final LoginUserArgumentResolver loginUserArgumentResolver;

    @Override
    public void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {
        argumentResolvers.add(loginUserArgumentResolver);
    }
}

LoginUserArgumentResolver가 Spring에서 인식될 수 있도록 WebMvcConfigurer에 추가함
HandlerMethodArgumentResolver는 항상 WebMvcConfigurer의 addArgumentresolvers()를 통해 추가해야 함

IndexController에서 반복되는 부분을 @LoginUser로 대체

@GetMapping("/")
public String index(Model model, @LoginUser SessionUser user) {
    model.addAttribute("posts", postsService.findAllDesc());
    if (user != null) {
        model.addAttribute("userName", user.getName());
    }
    return "index";
}

SessionUser user = (SessionUser) httpSession.getAttribute("user");를 대체함
@LoginUser를 사용해서 세션 정보를 가져올 수 있음

세션 저장소로 데이터베이스 사용하기

현재는 내장 톰캣의 메모리에 세션 정보가 저장되기 때문에, 앱을 재실행하면 로그인이 풀림
- 즉, 배포할 때마다 톰캣이 재시작됨
- 2대 이상의 서버를 기용하면 톰캣마다 세션 동기화 설정을 해야 함
실제 현업에서는 아래와 같은 방법들로 세션 저장소를 운용함
1. 톰캣 세션을 사용
  - 기본적으로 선택
  - WAS에 세션이 저장되기 때문에 2대 이상의 WAS가 구동되는 경우 세션 공유를 위한 추가 설정이 필요
2. MySQL과 같은 DB를 세션 저장소로 사용
  - 여러 WAS 간의 공용 세션을 사용할 수 있는 편리함
  - 로그인 요청마다 DB IO가 발생하기 때문에 성능 이슈 발생 가능
  - 로그인 요청이 많이 없는 백오피스, 사내 시스템 등에서 사용
3. redis, Memcached와 같은 메모리 DB를 세션 저장소로 사용
  - B2C 서비스에서 가장 많이 사용함
  - Embedded Redis가 아닌, 외부 메모리 서버가 필요함
이 예제에서는 DB를 세션 저장소로 사용할 예정
- 설정이 간단, 사용자가 적고 비용 절감을 위함
- 3번은 redis에 별도로 비용을 지불해야 함
build.gradle에 implementation 'org.springframework.session:spring-session-jdbc' 추가해서 spring-session-jdbc 의존성 추가
application.properties에 spring.session.store-type=jdbc 추가해서 세션 저장소로 jdbc 선택
- SPRING_SESSION, SPRING_SESSION_ATTRIBUTES 테이블이 생성되었지만, 현재는 H2도 spring이 재시작될 때 같이 재시작되기 때문에 이전과 마찬가지로 배포할 때마다 세션이 초기화됨

네이버 로그인

네이버 open api에서 앱 등록
- 사용 api : 이름, 이메일, 프로필 사진
- 환경 : pc 웹
- 서비스 URL : http://localhost:8080
- Callback URL : http://localhost:8080/login/oauth2/code/naver

application-oauth.properties 수정

# Naver

# registration
spring.security.oauth2.client.registration.naver.client-id= // CLIENTID
spring.security.oauth2.client.registration.naver.client-secret= // CLIENTSECRET
spring.security.oauth2.client.registration.naver.redirect-uri={baseUrl}/{action}/oauth2/code/{registrationId}
spring.security.oauth2.client.registration.naver.authorization_grant_type=authorization_code
spring.security.oauth2.client.registration.naver.scope=name,email,profile_image

# provider
spring.security.oauth2.client.provider.naver.authorization_uri=https://nid.naver.com/oauth2.0/authorize
spring.security.oauth2.client.provider.naver.token_uri=https://nid.naver.com/oauth2.0/token
spring.security.oauth2.client.provider.naver.user-info-uri=https://openapi.naver.com/v1/nid/me
spring.security.oauth2.client.provider.naver.user_name_attribute=response

# Google

spring.security.oauth2.client.registration.google.client-id= // CLIENTID
spring.security.oauth2.client.registration.google.client-secret= // CLIENTSECRET
spring.security.oauth2.client.registration.google.scope=profile,email

user_name_attribute=response :네이버에서는 user_name의 이름을 response로 설정해야 함(회원 조회시 반환되는 json이 아래와 같기 때문)

{
	"resultcode": "00",
	"message": "success",
	"response": {
		"email": "openapi@naver.com",
		"nickname": "OpenAPI",
		...
	}
}

Spring Security에서는 하위 필드를 명시할 수 없고, 최상위 필드들만 user_name으로 지정 가능함

스프링 시큐리티 설정 등록

dto.OAuthAttributes에 네이버인지 판단하는 코드, 네이버 생성자 추가

...
public static OAuthAttributes of(String registrationId,
                                 String userNameAttributeName,
                                 Map<String, Object> attributes) {
    if ("naver".equals(registrationId)) {
        return ofNaver("id", attributes);
    }

    return ofGoogle(userNameAttributeName, attributes);
}
...
private static OAuthAttributes ofNaver(String userNameAttributeName, Map<String, Object> attributes) {
    Map<String, Object> response = (Map<String, Object>) attributes.get("response");

    return OAuthAttributes.builder()
            .name((String) attributes.get("name"))
            .email((String) attributes.get("email"))
            .picture((String) attributes.get("profile_image"))
            .attributes(attributes)
            .nameAttributeKey(userNameAttributeName)
            .build();
}
...

index.mustache에 네이버 로그인 버튼 추가

...
{{^userName}}
    <a href="/oauth2/authorization/google" class="btn btn-success active" role="button">Google Login</a>

    <a href="/oauth2/authorization/naver" class="btn btn-secondary active" role="button">Naver Login</a>
{{/userName}}
...

네이버 로그인 URL은 application-oauth.properties에 등록한 redirect-uri 값에 맞춰 자동으로 등록됨

한글 깨짐 이슈 해결
1. intelliJ 콘솔로 userName 출력하면 양효원 제대로 나옴
2. header.mustache에서 <meta> 태그 변경해봐도 브라우저에는 ???로 나옴(깨지는 형식이 ???로 일정함)
3. 템플릿 엔진 문제인것 같아 찾아보니 springboot 2.7에서 mustache에 한글 깨지는 이슈가 있었음
4. application.properties에 아래 설정 추가하니 제대로 나옴
```
1
2
server.servlet.encoding.charset=UTF-8
server.servlet.encoding.force=true
```

기존 테스트에 시큐리티 적용하기

Gradle 메뉴 - Tasks - verification - test 실행해서 전체 테스트 수행
- src와 test는 환경 구성이 별도임
- test에 application.properties가 없을 경우 main의 설정을 가져옴
- 하지만 application-oauth.properties와 같은 다른 설정파일들은 test에 없어도 가져오지 않음

test.resource에 application.properties 생성

spring.jpa.show_sql=true
spring.jpa.properties.hibernate.dialect=org.hibernate.dialect.MySQL57Dialect
spring.h2.console.enabled=true
spring.session.store-type=jdbc
spring.jpa.properties.hibernate.dialect.storage_engine=innodb
spring.datasource.hikari.jdbc-url=jdbc:h2:mem://localhost/~/testdb;MODE=MYSQL
server.servlet.encoding.charset=UTF-8
server.servlet.encoding.force=true

# Test OAuth
spring.security.oauth2.client.registration.google.client-id=test
spring.security.oauth2.client.registration.google.client-secret=test
spring.security.oauth2.client.registration.google.scope=profile,email

CustomOAuth2UserService 생성을 위한 소셜 로그인 관련 설정값 추가

build.gradle에 testImplementation 'org.springframework.security:spring-security-test' 추가
- Spring Security에서는 인증되지 않은 사용자의 요청은 이동시키기 때문에, spring-security-test를 넣고 인증된 사용자를 추가해서 API를 테스트해야 함

PostsApiControllerTest의 테스트 메소드에 임의 사용자 인증 추가

...
@Test
@WithMockUser(roles = "USER")
public void Create_Posts() throws Exception {
...
@Test
@WithMockUser(roles = "USER")
public void Update_Posts() throws Exception {
...

PostsApiControllerTest에 MockMvc 적용

public class PostsApiControllerTest {

		...
		@Autowired
    private WebApplicationContext context;

    private MockMvc mvc;

    @BeforeEach
    public void setup() {
        mvc = MockMvcBuilders
                .webAppContextSetup(context)
                .apply(springSecurity())
                .build();
    }

		...
    @Test
    @WithMockUser(roles = "USER")
    public void Create_Posts() throws Exception {
				...
        //when
//        ResponseEntity<Long> responseEntity = restTemplate.postForEntity(url, requestDto, Long.class);

        mvc.perform(post(url)
                .contentType(MediaType.APPLICATION_JSON_UTF8)
                .content(new ObjectMapper().writeValueAsString(requestDto)))
                .andExpect(status().isOk());

        //then
//        assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.OK);
//        assertThat(responseEntity.getBody()).isGreaterThan(0L);
				...
    }

    @Test
    @WithMockUser(roles = "USER")
    public void Update_Posts() throws Exception {
        ...
        //when
//        ResponseEntity<Long> responseEntity = restTemplate.exchange(url, HttpMethod.PUT, requestEntity, Long.class);

        mvc.perform(put(url)
                .contentType(MediaType.APPLICATION_JSON_UTF8)
                .content(new ObjectMapper().writeValueAsString(requestDto)))
                .andExpect(status().isOk());
        //then
//        assertThat(responseEntity.getStatusCode()).isEqualTo(HttpStatus.OK);
//        assertThat(responseEntity.getBody()).isGreaterThan(0L);
				...
    }
}

mvc.perform() : 생성된 MockMvc를 통해서 API 테스트
- body 영역은 문자열로 표현하기 위해 ObjectMapper를 통해 문자열 JSON으로 변환
return_hello(), return_helloDto() 테스트를 제외한 나머지는 모두 통과함

@WebMvcTest는 @Controller, @ControllerAdvice를 읽고 @Repository, @Service, @Component는 스캔하지 않기 때문에 SecurityConfig는 읽고 CustomOAuth2UserService는 읽히지 않음

HelloControllerTest의 스캔 대상에서 SecurityConfig를 제외함

@ExtendWith(SpringExtension.class)
@WebMvcTest(controllers = HelloController.class,
        excludeFilters = {
                @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE,
                        classes = SecurityConfig.class)

        })
public class HelloControllerTest {
...

HelloControllerTest에도 위와 마찬가지로 @WithMockUser를 사용해 가짜로 인증된 사용자 생성

@Test
@WithMockUser(roles = "USER")
public void return_hello() throws Exception {
...
@Test
@WithMockUser(roles = "USER")
public void return_helloDto() throws Exception {
...

JPA metamodel must not be empty! : @EnableJpaAuditing을 사용하기 위해선 최소 하나의 @Entity 클래스가 필요한데, @WebMvcTest를 사용하기 때문에 엔티티 클래스가 없기 때문
- 현재는 @EnableJpaAuditing이 @SpringBootApplication과 같이 있기 때문에 @WebMvcTest에서 같이 스캔함
- SpringawsApplication에서 @EnableJpaAuditing 제거
- config 패키지에 JpaConfig 생성
```
1
2
3
4
@Configuration
@EnableJpaAuditing
public class JpaConfig {
}
```

Share on

Twitter Facebook LinkedIn

양효원

Spring Boot와 AWS로 혼자 구현하는 웹 서비스 4 - Spring Security, OAuth 2.0으로 로그인 구현(Ch.05)

Spring Security와 Spring Security Oauth2 클라이언트

구글 서비스 등록

구글 로그인 연동

Spring Security 설정

로그인 테스트

어노테이션 기반으로 개선하기

세션 저장소로 데이터베이스 사용하기

네이버 로그인

스프링 시큐리티 설정 등록

기존 테스트에 시큐리티 적용하기

Share on

Leave a comment

You may also enjoy

BOJ 16236 - 아기 상어

BOJ 1918 - 후위 표기식

BOJ 1865 - 웜홀

BOJ 1238 - 파티