스프링부트 게시판 API 만들기 (4) - JSON 로그인 (3) - 시큐리티 JSON 로그인 커스텀하기

 

 

 

 

이번에는 저번 포스팅에 이어서 시큐리티 필터를 커스텀하여 로그인을 진행해보도록 하겠습니다.

 

 

• 시큐리티를 이용한 JSON 데이터로 로그인 (진행 중)
• JWT를 이용한 인증
• 도메인, 테이블 설계, 엔티티 생성
• 댓글 삭제 로직 구현
• 회원가입 + 정보수정 등 회원 서비스 구현
• 게시판 서비스 구현
• 댓글 서비스 구현 (1댓글 -> *(무한) 대댓글 구조)
• 예외 처리
• 예외 메세지 국제화
• 카테고리별 게시판 분류
• 게시글 페이징
• 동적인 검색 조건을 사용한 검색
• 사용자 간 쪽지 기능
• 무한 쪽지 스크롤
• 게시물 & 댓글에 대한 알람
• 쪽지에 대한 알람
• 접속한 사용자 간 실시간 채팅
• 회원가입 시 검증(예: XX대학교 XX과가 아니면 가입할 수 없게)
• Swagger를 사용한 API 문서 만들기
• 신고 & 블랙리스트 기능
• AOP를 통한 로그
• 어드민 페이지
• 캐시
• 배포 (+ 무중단 배포)
• 배포 자동화
• 포트와 어댑터 설계를 따르는 패키지 구조 설계하기
• ...

 

 

 

 

 

 

 

 

 

시큐리티 필터 커스텀하기

 

 

 

 

AbstractAuthenticationProcessingFilter 구현

formLogin에는 AbstractAuthenticationProcessingFilter에는 인증 성공과 실패에 대한 대부분의 로직이 들어있습니다.

 

따라서 우리는 formLogin 방식과 비슷하게, 데이터를 처리하는 방식만 json으로 바꾸어서 처리하도록 만들겠습니다.

 

filter 아래에 생성합니다.

 

 

 

 

이름은 JsonUsernamePasswordAuthenticationFilter로 정하겠습니다.

public class JsonUsernamePasswordAuthenticationFilter extends AbstractAuthenticationProcessingFilter {

    private static final String DEFAULT_LOGIN_REQUEST_URL = "/login";  // /login/oauth2/ + ????? 로 오는 요청을 처리할 것이다

    private static final String HTTP_METHOD = "POST";    //HTTP 메서드의 방식은 POST 이다.

    private static final String CONTENT_TYPE = "application/json";//json 타입의 데이터로만 로그인을 진행한다.

    private final ObjectMapper objectMapper;
    
    private static final String USERNAME_KEY="username";
    private static final String PASSWORD_KEY="password";


    private static final AntPathRequestMatcher DEFAULT_LOGIN_PATH_REQUEST_MATCHER =
            new AntPathRequestMatcher(DEFAULT_LOGIN_REQUEST_URL, HTTP_METHOD); //=>   /login 의 요청에, POST로 온 요청에 매칭된다.

    public JsonUsernamePasswordAuthenticationFilter(ObjectMapper objectMapper) {

        super(DEFAULT_LOGIN_PATH_REQUEST_MATCHER);   // 위에서 설정한  /oauth2/login/* 의 요청에, GET으로 온 요청을 처리하기 위해 설정한다.

        this.objectMapper = objectMapper;
    }

    @Override
    public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException, IOException, ServletException {
        if(request.getContentType() == null || !request.getContentType().equals(CONTENT_TYPE)  ) {
            throw new AuthenticationServiceException("Authentication Content-Type not supported: " + request.getContentType());
        }

        String messageBody = StreamUtils.copyToString(request.getInputStream(), StandardCharsets.UTF_8);

        Map<String, String> usernamePasswordMap = objectMapper.readValue(messageBody, Map.class);
        
        String username = usernamePasswordMap.get(USERNAME_KEY);
        String password = usernamePasswordMap.get(PASSWORD_KEY);

        UsernamePasswordAuthenticationToken authRequest = new UsernamePasswordAuthenticationToken(username, password);//principal 과 credentials 전달

        return this.getAuthenticationManager().authenticate(authRequest);
    }
}

 

 

설명

• DEFAULT_LOGIN_REQUEST_URL 를 통해 "/login"으로 들어오는 요청에 대해서만 작동하도록 설정했습니다.
• HTTP_METHOD,  CONTENT_TYPE : POST에, json 타입으로 오는 데이터만 처리하도록 설정했습니다.
• attemptAuthentication 메서드를 구현하였습니다.
  • username과 password를 받아와 FormLogin과 동일하게 UsernamePasswordAuthenticationToken을 사용했습니다. JSON으로 로그인하는 방식만 달라졌을 뿐이지 username과 password를 사용하여 로그인하는 전략을 똑같기 때문에 굳이 따로 구현하지 않고 있는걸 가져다 사용하였습니다.
  • return은 authenticationManager의 authenticate 메서드를 실행했습니다. 여기서 사용되는 AuthenticationManager는 ProviderManager이고, 이 또한 이후 SecurityConfig 파일에서 설정해 주겠습니다.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

SecurityConfig 설정

 

(추가 - WebSecurityConfigurerAdapter가 Deprecate 되었습니다. 아래 사이트에 어떻게 수정해야 하는지 나와있습니다.

https://www.codejava.net/frameworks/spring-boot/fix-websecurityconfigureradapter-deprecated )

 

기존에 작성한 코드에 추가하였습니다.

@Configuration
@RequiredArgsConstructor
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    //private final LoginService loginService;
    private final ObjectMapper objectMapper;



    @Override
    protected void configure(HttpSecurity http) throws Exception {

        http
                .formLogin().disable()//formLogin 인증방법 비활성화
                .httpBasic().disable()//httpBasic 인증방법 비활성화(특정 리소스에 접근할 때 username과 password 물어봄)
                .csrf().disable()
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)

                .and()
                .authorizeRequests()
                .antMatchers("/login", "/signUp","/").permitAll()
                .anyRequest().authenticated();

        http.addFilterAfter(jsonUsernamePasswordLoginFilter(), LogoutFilter.class);

    }

    @Bean
    public PasswordEncoder passwordEncoder(){//1 - PasswordEncoder 등록
        return PasswordEncoderFactories.createDelegatingPasswordEncoder();
    }

    @Bean
    public AuthenticationManager authenticationManager() {//2 - AuthenticationManager 등록
        DaoAuthenticationProvider provider = new DaoAuthenticationProvider();//DaoAuthenticationProvider 사용
        provider.setPasswordEncoder(passwordEncoder());//PasswordEncoder로는 PasswordEncoderFactories.createDelegatingPasswordEncoder() 사용
        //provider.setUserDetailsService(loginService); //이후 작성할 코드입니다.
        return new ProviderManager(provider);
    }

    /*@Bean
    public LoginSuccessJWTProvideHandler loginSuccessJWTProvideHandler(){
        return new LoginSuccessJWTProvideHandler();
    }

    @Bean
    public LoginFailureHandler loginFailureHandler(){
        return new LoginFailureHandler();
    }*/

    @Bean
    public JsonUsernamePasswordAuthenticationFilter jsonUsernamePasswordLoginFilter(){
        JsonUsernamePasswordAuthenticationFilter jsonUsernamePasswordLoginFilter = new JsonUsernamePasswordAuthenticationFilter(objectMapper);
        jsonUsernamePasswordLoginFilter.setAuthenticationManager(authenticationManager());
        //jsonUsernamePasswordLoginFilter.setAuthenticationSuccessHandler(loginSuccessJWTProvideHandler());
        //jsonUsernamePasswordLoginFilter.setAuthenticationFailureHandler(loginFailureHandler());
        return jsonUsernamePasswordLoginFilter;
    }
}

 

(주석 처리한 코드는 이후 작성할 코드들입니다.)

 

설명

1. PasswordEncoder로 PasswordEncoderFactories.createDelegatingPasswordEncoder()를 사용합니다.
2. 해당 PasswordEncoder를 사용하는 AuthenticationProvider를 지정해준다. FormLogin에서와 동일하게 DaoAuthenticationProvider를 사용합니다.
3. AuthemticationManager로는 FormLogin에서와 동일하게 ProviderManager를 사용합니다.
4. 바로 위에서 생성한 JsonUsernamePasswordAuthenticationFilter를 빈으로 등록합니다. 이때 AuthenticationManager를 등록해 주어야 하고, 등록하지 않으면 다음의 오류가 발생합니다.

authenticationManager must be specified

authenticationManager must be specified => authenticationManager를 지정해 주어야 한다는 오류입니다.

 

 

 

 

 

 

 

 

이제 UserDetailsService를 상속받아 UserDetails를 반환하는 클래스를 만들어보겠습니다. 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

LoginService 생성

 

 

@Service
@RequiredArgsConstructor
public class LoginService implements UserDetailsService {

    private final MemberRepository memberRepository;


    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        Member member = memberRepository.findByUsername(username).orElseThrow(() -> new UsernameNotFoundException("아이디가 없습니다"));

        return User.builder().username(member.getUsername())
                .password(member.getPassword())
                .roles(member.getRole().name())
                .build();
    }

}

DB에서 username에 해당하는 값을 찾아 반환해주면 됩니다.

 

 

 

 

 

비밀번호 검증은 DaoAuthenticationProvider 에서 해줍니다.

더 정확히는 AbstractUserDetailsAuthenticationProvider에서 해주는데, 코드를 통해 살펴보겠습니다.

retriveUser와 마찬가지로 additionalAuthenticationChecks도 추상 메서드로 구현 클래스에게 처리를 맡깁니다.

 

 

 

 

 

DaoAuthenticationProvider는 이를 구현해야 하고 그 코드는 다음과 같습니다.

비밀번호(여기서는 Credentials)의 일치여부를 판단합니다.

 

 

UserDetails는 우리가 UserDetailsService에서 만들어준 User 객체이고,

이것의 password 와

JsonUsernamePasswordAuthenticationFilter (정확히는 AbstractAuthenticationProcessingFilter)에서

Request의 정보를 통해 인자로 전달해준 Authentication 객체(여기서는 UsernamePasswordAuthenticationToken)의  Credentials (우리는 password를 넣어주었다)를 비교합니다.

 

 

 

 

따라서 저희는 DB에서 User정보를 찾아서 반환만 해주면 됩니다.

 

 

이제 성공 처리와 실패 처리를 할 Handler를 구현해보겠습니다.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

LoginSuccessJWTProvideHandler 생성

 

 

SimpleUrlAuthenticationSuccessHandler를 상속받아 구현합니다.

@Slf4j
public class LoginSuccessJWTProvideHandler extends SimpleUrlAuthenticationSuccessHandler {

    @Override
    public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
        UserDetails userDetails = (UserDetails) authentication.getPrincipal();
        log.info( "로그인에 성공합니다 JWT를 발급합니다. username: {}" ,userDetails.getUsername());


      response.getWriter().write("success");
    }
}

(아직 JWT를 발급하는 코드는 작성하지 않았습니다.)

 

 

 

 

 

 

 

 

 

 

 

 

LoginFailureHandler 생성

SimpleUrlAuthenticationFailureHandler를 상속받아 구현했습니다.

@Slf4j
public class LoginFailureHandler extends SimpleUrlAuthenticationFailureHandler {

    @Override
    public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException exception) throws IOException, ServletException {
        response.setStatus(HttpServletResponse.SC_OK);//보안을 위해 로그인 오류지만 200 반환
        response.getWriter().write("fail");
        log.info("로그인에 실패했습니다");
    }
}

(상태코드를 200으로 설정하는 이유는 서버 보안을 위해 모든 요청에 대해 상태코드를 200으로 반환하고 커스텀한 상태코드를 같이 제공한다는 이야기를 들어서 이번에는 그렇게 작성하려고 만들었습니다.

이후 변경될 수 있으며, fail을 반환하는 것은 이후 변경하도록 하겠습니다.

우선은 실패 여부를 판단하기 위해 작성했습니다)

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

SecurityConfig 설정 추가

@Configuration
@RequiredArgsConstructor
public class SecurityConfig extends WebSecurityConfigurerAdapter {

    private final LoginService loginService;
    private final ObjectMapper objectMapper;



    @Override
    protected void configure(HttpSecurity http) throws Exception {

        http
                .formLogin().disable()// formLogin 인증방법 비활성화
                .httpBasic().disable()// httpBasic 인증방법 비활성화(특정 리소스에 접근할 때 username과 password 물어봄)
                .csrf().disable()
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS)

                .and()
                .authorizeRequests()
                .antMatchers("/login", "/signUp","/").permitAll()
                .anyRequest().authenticated();

        http.addFilterAfter(jsonUsernamePasswordLoginFilter(), LogoutFilter.class);

    }

    @Bean
    public PasswordEncoder passwordEncoder(){
        return PasswordEncoderFactories.createDelegatingPasswordEncoder();
    }

    @Bean
    public AuthenticationManager authenticationManager() {
        DaoAuthenticationProvider provider = new DaoAuthenticationProvider();
        provider.setPasswordEncoder(passwordEncoder());
        provider.setUserDetailsService(loginService);
        return new ProviderManager(provider);
    }

    @Bean
    public LoginSuccessJWTProvideHandler loginSuccessJWTProvideHandler(){
        return new LoginSuccessJWTProvideHandler();
    }

    @Bean
    public LoginFailureHandler loginFailureHandler(){
        return new LoginFailureHandler();
    }

    @Bean
    public JsonUsernamePasswordAuthenticationFilter jsonUsernamePasswordLoginFilter(){
        JsonUsernamePasswordAuthenticationFilter jsonUsernamePasswordLoginFilter = new JsonUsernamePasswordAuthenticationFilter(objectMapper);
        jsonUsernamePasswordLoginFilter.setAuthenticationManager(authenticationManager());
        jsonUsernamePasswordLoginFilter.setAuthenticationSuccessHandler(loginSuccessJWTProvideHandler());
        jsonUsernamePasswordLoginFilter.setAuthenticationFailureHandler(loginFailureHandler());
        return jsonUsernamePasswordLoginFilter;
    }
}

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

테스트코드 작성

 

 

• 로그인 성공 - 200에 성공 메세지 반환
• 로그인 실패 - 아이디 틀림 - 200에 실패 메세지
• 로그인 실패 - 비밀번호 틀림 -200에 실패 메세지
• 로그인 주소가 틀리면 403 Forbidden
• 로그인 데이터형식이 Json이 아니면 200에 실패 메세지 (로그인 실패와 동일)
• 로그인 Http Method가 Post가 아니면 404 NotFound

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

기본 로그인 테스트 형식

@Transactional
@SpringBootTest
@AutoConfigureMockMvc
public class LoginTest {

    @Autowired MockMvc mockMvc;

    @Autowired MemberRepository memberRepository;

    @Autowired EntityManager em;

    PasswordEncoder delegatingPasswordEncoder = PasswordEncoderFactories.createDelegatingPasswordEncoder();

    ObjectMapper objectMapper = new ObjectMapper();

    private static String KEY_USERNAME = "username";
    private static String KEY_PASSWORD = "password";
    private static String USERNAME = "username";
    private static String PASSWORD = "123456789";

    private static String LOGIN_RUL = "/login";


    private void clear(){
        em.flush();
        em.clear();
    }


    @BeforeEach
    private void init(){
            memberRepository.save(Member.builder()
                    .username(USERNAME)
                    .password(delegatingPasswordEncoder.encode(PASSWORD))
                    .name("Member1")
                    .nickName("NickName1")
                    .role(Role.USER)
                    .age(22)
                    .build());
            clear();
    }

    private Map getUsernamePasswordMap(String username, String password){
        Map<String, String> map = new HashMap<>();
        map.put(KEY_USERNAME, username);
        map.put(KEY_PASSWORD, password);
        return map;
    }


    private ResultActions perform(String url, MediaType mediaType, Map usernamePasswordMap) throws Exception {
        return mockMvc.perform(MockMvcRequestBuilders
                .post(url)
                .contentType(mediaType)
                .content(objectMapper.writeValueAsString(usernamePasswordMap)));

    }

 

 

 

 

 

 

 

 

 

 

 

 

로그인 성공

    @Test
    public void 로그인_성공() throws Exception {
        //given
        Map<String, String> map = getUsernamePasswordMap(USERNAME, PASSWORD);


        //when, then
        MvcResult result = perform(LOGIN_RUL, APPLICATION_JSON, map)
                .andDo(print())
                .andExpect(status().isOk())
                .andReturn();

    }

 

 

 

 

 

 

 

 

 

 

 

로그인 실패 - 아이디 오류

    @Test
    public void 로그인_실패_아이디틀림() throws Exception {
        //given
        Map<String, String> map = getUsernamePasswordMap(USERNAME+"123", PASSWORD);

        //when, then
        MvcResult result = perform(LOGIN_RUL, APPLICATION_JSON, map)
                .andDo(print())
                .andExpect(status().isOk())
                .andReturn();

    }

 

 

 

 

 

 

 

 

 

 

 

로그인 실패 - 비밀번호 오류

    @Test
    public void 로그인_실패_비밀번호틀림() throws Exception {
        //given
        Map<String, String> map = getUsernamePasswordMap(USERNAME, PASSWORD+"123");


        //when, then
        MvcResult result = perform(LOGIN_RUL, APPLICATION_JSON, map)
                .andDo(print())
                .andExpect(status().isOk())
                .andReturn();

    }

 

 

 

 

 

 

 

 

 

로그인 주소가 틀리면 Forbidden

    @Test
    public void 로그인_주소가_틀리면_FORBIDDEN() throws Exception {
        //given
        Map<String, String> map = getUsernamePasswordMap(USERNAME, PASSWORD);


        //when, then
        perform(LOGIN_RUL+"123", APPLICATION_JSON, map)
                .andDo(print())
                .andExpect(status().isForbidden());
        
    }

 

 

 

 

 

 

 

 

 

로그인 형식 JSON이 아니면 200

    @Test
    public void 로그인_데이터형식_JSON이_아니면_200() throws Exception {
        //given
        Map<String, String> map = getUsernamePasswordMap(USERNAME, PASSWORD);

        //when, then
        perform(LOGIN_RUL, APPLICATION_FORM_URLENCODED, map)
                .andDo(print())
                .andExpect(status().isOk())
                .andReturn();
    }

 

 

 

 

 

 

 

 

 

 

로그인 Http Method가 Post가 아니면 404 NotFound

    @Test
    public void 로그인_HTTP_METHOD_GET이면_NOTFOUND() throws Exception {
        //given
        Map<String, String> map = getUsernamePasswordMap(USERNAME, PASSWORD);


        //when
        mockMvc.perform(MockMvcRequestBuilders
                        .get(LOGIN_RUL)
                        .contentType(APPLICATION_FORM_URLENCODED)
                        .content(objectMapper.writeValueAsString(map)))
                .andDo(print())
                .andExpect(status().isNotFound());
    }



    @Test
    public void 오류_로그인_HTTP_METHOD_PUT이면_NOTFOUND() throws Exception {
        //given
        Map<String, String> map = getUsernamePasswordMap(USERNAME, PASSWORD);


        //when
        mockMvc.perform(MockMvcRequestBuilders
                        .put(LOGIN_RUL)
                        .contentType(APPLICATION_FORM_URLENCODED)
                        .content(objectMapper.writeValueAsString(map)))
                .andDo(print())
                .andExpect(status().isNotFound());
    }

 

 

 

 

 

 

 

 

 

 

전체 테스트코드

import static org.springframework.http.MediaType.*;
import static org.springframework.test.web.servlet.result.MockMvcResultHandlers.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;

import java.util.HashMap;
import java.util.Map;

import javax.persistence.EntityManager;

import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.security.crypto.factory.PasswordEncoderFactories;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.MvcResult;
import org.springframework.test.web.servlet.ResultActions;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
import org.springframework.transaction.annotation.Transactional;

import com.fasterxml.jackson.databind.ObjectMapper;

import boardexample.myboard.domain.member.Member;
import boardexample.myboard.domain.member.MemberRepository;
import boardexample.myboard.domain.member.Role;


@Transactional
@SpringBootTest
@AutoConfigureMockMvc
class LoginTest {

	@Autowired
	MockMvc mockMvc;

	@Autowired
	MemberRepository memberRepository;

	@Autowired
	EntityManager em;

	PasswordEncoder delegatingPasswordEncoder = PasswordEncoderFactories.createDelegatingPasswordEncoder();

	ObjectMapper objectMapper = new ObjectMapper();

	private static String KEY_USERNAME = "username";
	private static String KEY_PASSWORD = "password";
	private static String USERNAME = "username";
	private static String PASSWORD = "123456789";

	private static String LOGIN_RUL = "/login";


	private void clear() {
		em.flush();
		em.clear();
	}

	@BeforeEach
	private void init() {
		memberRepository.save(Member.builder()
			.username(USERNAME)
			.password(delegatingPasswordEncoder.encode(PASSWORD))
			.name("Member1")
			.nickName("NickName1")
			.role(Role.USER)
			.age(22)
			.build());
		clear();
	}

	private Map getUsernamePasswordMap(String username, String password) {
		Map<String, String> map = new HashMap<>();
		map.put(KEY_USERNAME, username);
		map.put(KEY_PASSWORD, password);
		return map;
	}

	private ResultActions perform(String url, MediaType mediaType, Map usernamePasswordMap) throws Exception {
		return mockMvc.perform(MockMvcRequestBuilders
			.post(url)
			.contentType(mediaType)
			.content(objectMapper.writeValueAsString(usernamePasswordMap)));

	}
	@Test
	public void 로그인_성공() throws Exception {
		//given
		Map<String, String> map = getUsernamePasswordMap(USERNAME, PASSWORD);


		//when
		MvcResult result = perform(LOGIN_RUL, APPLICATION_JSON, map)
			.andDo(print())
			.andExpect(status().isOk())
			.andReturn();
	}



	@Test
	public void 로그인_실패_아이디틀림() throws Exception {
		//given
		Map<String, String> map = getUsernamePasswordMap(USERNAME+"123", PASSWORD);

		//when
		MvcResult result = perform(LOGIN_RUL, APPLICATION_JSON, map)
			.andDo(print())
			.andExpect(status().isOk())
			.andReturn();
	}




	@Test
	public void 로그인_실패_비밀번호틀림() throws Exception {
		//given
		Map<String, String> map = getUsernamePasswordMap(USERNAME, PASSWORD+"123");


		//when
		MvcResult result = perform(LOGIN_RUL, APPLICATION_JSON, map)
			.andDo(print())
			.andExpect(status().isOk())
			.andReturn();
	}


	@Test
	public void 로그인_주소가_틀리면_FORBIDDEN() throws Exception {
		//given
		Map<String, String> map = getUsernamePasswordMap(USERNAME, PASSWORD);


		//when, then
		perform(LOGIN_RUL+"123", APPLICATION_JSON, map)
			.andDo(print())
			.andExpect(status().isForbidden());

	}


	@Test
	public void 로그인_데이터형식_JSON이_아니면_200() throws Exception {
		//given
		Map<String, String> map = getUsernamePasswordMap(USERNAME, PASSWORD);

		//when, then
		perform(LOGIN_RUL, APPLICATION_FORM_URLENCODED, map)
			.andDo(print())
			.andExpect(status().isOk())
			.andReturn();
	}

	@Test
	public void 로그인_HTTP_METHOD_GET이면_NOTFOUND() throws Exception {
		//given
		Map<String, String> map = getUsernamePasswordMap(USERNAME, PASSWORD);


		//when
		mockMvc.perform(MockMvcRequestBuilders
				.get(LOGIN_RUL)
				.contentType(APPLICATION_FORM_URLENCODED)
				.content(objectMapper.writeValueAsString(map)))
			.andDo(print())
			.andExpect(status().isNotFound());
	}



	@Test
	public void 오류_로그인_HTTP_METHOD_PUT이면_NOTFOUND() throws Exception {
		//given
		Map<String, String> map = getUsernamePasswordMap(USERNAME, PASSWORD);


		//when
		mockMvc.perform(MockMvcRequestBuilders
				.put(LOGIN_RUL)
				.contentType(APPLICATION_FORM_URLENCODED)
				.content(objectMapper.writeValueAsString(map)))
			.andDo(print())
			.andExpect(status().isNotFound());
	}
}

 

 

 

 

 

 

 

이렇게 로그인 처리까지 성공적으로 끝마쳤습니다.

이제 로그인 했을 경우 JWT를 발급하고, 인증이 필요한 요청에 대해서 AccessToken을 가지고 인증을 수행하는 코드를 작성하겠습니다.

 

 

 

 

 

 

 

 

전체 코드는 깃허브에서 확인하실 수 있습니다.

 

https://github.com/ShinDongHun1/SpringBoot-Board-API

GitHub - ShinDongHun1/SpringBoot-Board-API