[Spring] 로그인/회원가입 뽀개기(2) - JWT

본 글을 아래 도서를 보고 공부한 내용을 바탕으로 정리한 글입니다.

1. https://github.com/shinsunyoung/springboot-developer-2rd

GitHub - shinsunyoung/springboot-developer-2rd: 📚 <스프링부트 3 백엔드 개발자 되기 2판> 예제코드

https://product.kyobobook.co.kr/detail/S000201766024

스프링 부트 3 백엔드 개발자 되기: 자바 편 | 신선영 - 교보문고

이전 글에서는 Spring Security를 이용한 로그인/회원가입을 구현하였습니다. 이번 글에서는 JWT를 도입하여 로그인/회원가입을 구현해보도록 하겠습니다.

[Spring] 로그인/회원가입 뽀개기(1) - Spring Security

 

1. 토큰 기반 인증

1) 토큰 기반 인증과 세션 기반 인증의 차이점

사용자가 서버에 접근할 때, 이 사용자가 인증된 사용자인지 확인하는 대표적인 인증 확인 방법으로는 크게 세션 기반 인증과 토큰 기반 인증이 있습니다.  앞에서 했던 스프링 시큐리티로 구현한 로그인/회원가입이 세션기반 인증을 사용한 방법이었습니다. 

코딩애플님이 설명해주는 세션인증과 토큰인증 차이점이 간결하게 알아듣기 좋아서 참고하여 작성해보겠습니다. 

참고한 영상: https://www.youtube.com/watch?v=XXseiON9CV0

사이트가 접속한 사용자가 인증된 사용자임을 확인하기 위해 유저가 로그인을 하면 서버가 유저에게 입장권을 발급해줍니다. 그리고 서버는 사용자가 정보를 요청할 때마다 입장권을 요구하게됩니다. 

이때 세션기반 인증방식에서는 입장권에 발급번호만 쓰여져있어서 사용자가 입장권을 제시하면 서버는 디비에서 입장권 발급내역을 찾아서 정상적인 입장권인지 확인해야합니다. 토큰 기반 인증방식에서는 입장권에 유저의 이름, 이메일, 입장권 발급일시, 입장권 유효기간 등이 쓰여있습니다. 따라서 서버는 입장권만 보고 유효기간 등이 별 문제가 없으면 통과시켜줍니다. 이것이 세션과 토큰기반의 가장 큰 차이점입니다. 따라서 토큰 기반 인증 방식이 서버에 부담이 없기 때문에 대부분의 서버의 경우 토큰 기반 인증 방식을 이용합니다.

 

2) 토큰을 전달하고 인증받는 과정

1. 클라이언트가 아이디와 비밀번호를 가지고 서버에게 로그인(인증)을 요청합니다.

2. 서버는 아이디와 비밀번호를 확인해 유효한 사용자인지 검증합니다. 유효한 사용자이면 토큰을 생성하여 응답합니다. (입장권 발급)

3. 클라이언트는 서버에서 준 토큰을 저장합니다.

4. 인증이 필요한 API를 사용할 때마다 토큰과 함께 정보를 요청합니다. (입장권 제시)

5. 서버는 토큰의 유효기간 등을 보고 토큰이 유효한지 검증합니다. (입장권 검사)

6. 토큰이 유효하다면 클라이언트가 요청한 정보를 응답해줍니다.

 

3) 토큰의 유효기간과 리프레시 토큰

토큰 기반 인증은 토큰 자체만 보고 사용자의 접근을 허용하기 때문에 토큰이 탈취되면 이 접근을 막을 방법이 없습니다. 이것을 예방하기 위한 것이 토큰의 유효기간을 설정하는 것입니다. 토큰이 탈취되었더라도 토큰의 유효기간이 5분이라면 5분 후에는 탈취된 토큰을 사용할 수 없고 다시 로그인을 해서 새로운 토큰을 발급받아야하기 때문입니다. 

하지만 토큰의 유효기간을 짧게하는 것이 만사는 아닙니다. 정당한 사용자는 5분에 한번씩 로그인을 해야하므로 매우 불편할 것입니다. 이때 리프레시 토큰을 사용할 수 있습니다. 리스레시 토큰은 액세스 토큰과는 별개로 액세스 토큰이 만료되었을 때 새로운 액세스 토큰을 발급하기 위한 용도의 토큰입니다. 

따라서 리프레시 토큰은 액세스 토큰과 함께 발급되지만, 더 긴 유효 기간을 가집니다. 액세스 토큰이 만료되었을 때, 사용자는 다시 로그인하지 않고 리프레시 토큰을 사용해 새로운 액세스 토큰을 요청할 수 있습니다.

리프레시 토큰을 사용할 때의 동작 방식

1. 사용자가 아이디와 비밀번호로 서버에게 로그인을 요청합니다.

2. 서버는 액세스 토큰과 리프레시 토큰을 생성하여 응답합니다.

3. 클라이언트는 액세스 토큰과 리프레시 토큰을 저장합니다.

4. 클라이언트는 액세스 토큰을 사용하여 서버에 인증된 요청을 보냅니다.

5. 서버는 액세스 토큰이 유효한지 검증합니다. 

6. 만약 액세스 토큰이 유효기간이 끝난 만료된 토큰이라면 액세스 토큰이 만료되었다는 응답을 클라이언트에게 보냅니다.

7. 클라이언트는 서버로부터 액세스 토큰이 만료되었다는 응답을 받으면 새로운 액세스 토큰을 발급받기 위해 액세스 토큰과 리프레시 토큰을 함께 보냅니다.

8. 서버는 클라이언트가 보내온 리프레시 토큰이 유효한지 검증하기 위해 DB에 저장해놓았던 리프레시 토큰 정보를 보고 해당 리프레시 토큰을 검사합니다.

9. 리프레시 토큰이 유효하다면 새로운 액세스 토큰을 클라이언트에게 발급해줍니다.

이렇게 리프레시 토큰을 사용하는 과정을 통해 사용자는 계속해서 인증된 상태를 유지하면서 서비스를 이용할 수 있습니다. 리프레시 토큰 덕분에 사용자는 자주 로그인을 다시 할 필요가 없고, 동시에 보안도 유지할 수 있습니다.

 

2. JWT 서비스 구현하기

1) 의존성 추가

// build.gradle
dependencies {
	...
    testAnnotationProcessor 'org.projectlombok:lombok'
    testImplementation 'org.projectlombok:lombok'
    implementation 'io.jsonwebtoken:jjwt:0.9.1'
    implementation 'javax.xml.bind:jaxb-api:2.3.1'
}

자바에서 JWT를 사용하기 위한 라이브러리를 추가하고 XML 문서와 자바 객체 간 매핑을 자동화하는 jax-api를 추가합니다.

 

2) 토큰 제공자 추가

//application.yml

jwt:
  issuer: eun61n@gmail.com
  secret_key: secretkey

JWT 토큰 헤더에 필수로 들어가야하는 발급자(issuer)와 비밀키(secret_key)를 설정파일(application.yml)에 설정해줍니다.

 

// config/jwt/JwtProperties.java

import lombok.Getter;
import lombok.Setter;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Getter
@Setter
@Component
@ConfigurationProperties("jwt")
public class JwtProperties {

    private String issuer;
    private String secretKey;

}

JwtProperties 클래스를 만들어서 위와 같이 작성하면 application.yml에서 설정한 jwt.issuer 값이 issuer에 매핑되고 jwt.secret_key값이 secretKey에 매핑됩니다.

 

이제 토큰을 생성하고 올바른 토큰인지 유효성 검사를 하고, 토큰에서 필요한 정보를 가져오는 클래스를 작성하겠습니다.

package com.eunbin.springbootblog.config.jwt;

import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;

@RequiredArgsConstructor
@Service
public class TokenProvider {
    
    private final JwtProperties jwtProperties;
    
}

우선 TokenProvider 클래스를 선언하고 JwtProperties를 주입받도록 설정해줍니다. 아래에서 메서드를 하나하나씩 추가해보도록 하겠습니다.

 

public class TokenProvider {

    private final JwtProperties jwtProperties;

    public String generateToken(User user, Duration expiredAt) {
        Date now = new Date();
        return makeToken(user, new Date(now.getTime() + expiredAt.toMillis()));
    }

    private String makeToken(User user, Date expiry) {
        Date now = new Date();
        return Jwts.builder()
                .setHeaderParam(Header.TYPE, Header.JWT_TYPE)
                .setIssuer(jwtProperties.getIssuer())
                .setIssuedAt(now)
                .setExpiration(expiry)
                .setSubject(user.getEmail())
                .claim("id", user.getId())
                .signWith(SignatureAlgorithm.HS256, jwtProperties.getSecretKey())
                .compact();
    }

}

• 사용자 정보와 유효기간을 입력으로 받아 토큰을 생성해주는 generateToken() 메서드를 작성해줍니다.
• 메서드를 generateToken()과 makeToken() 두개로 분리한 이유는 secret key에 접근할 수 있는 메서드는 private으로 선언하기 위해서 입니다. 
• Jwts의 빌더 클래스로 토큰의 헤더, 내용, 클레임 정보 등을 세팅하여 리턴합니다.
• JWT는 크게 세 부분으로 구성되어있습니다.

JWT 구성

• 헤더에는 토큰의 타입과 해시 알고리즘을 정보를 담습니다. 다음은 헤더 예시입니다.

{
    "typ": "JWT",
    "alg": "HS256"
}

• 내용에는 토큰과 관련된 정보를 담습니다. 내용의 한 덩어리를 클레임(claim)이라고 하며 클레임은 등록된 클레임 / 공개 클레임 / 비공개 클레임으로 분류합니다.
• iss(토큰 발급자issuer), sub(토큰 제목), exp(토큰 만료시간) 등이 내용에 포함되는 등록된 클레임입니다.
• 마지막으로 서명에는 secret key를 암호화하여 넣습니다.

 

public class TokenProvider {

    private final JwtProperties jwtProperties;

	...

    public boolean validToken(String token) {
        try {
            Jwts.parser()
                    .setSigningKey(jwtProperties.getSecretKey())
                    .parseClaimsJws(token);

            return true;
        } catch (Exception e) {
            return false;
        }
    }

}

토큰을 인자로 받아 토큰의 유효성을 검증하는 validToken() 메서드를 작성합니다.

• Jwts 클래스의 parser() 메서드는 JWT를 파싱할 준비를 하는 객체를 생성합니다. 
• setSigningKey() 메서드는 JwtProperties.getSecretKey()로 비밀키를 가져와서 JWT의 서명(Signiture)을 검증하기 위해 사용될 secret key를 설정합니다.
• parseClaimsJws() 메서드에서 전달된 token을 파싱하고 서명을 검증합니다.
• token이 유효하면 JWT의 내용을 파싱하고 true를 리턴합니다.
• 토큰이 만료되었거나, 서명이 올바르지 않거나, 잘못된 형식의 토큰이라면 try 블록에서 예외가 발생하여 catch 블록이 실행되어 false가 반환됩니다.

 

public class TokenProvider {

    private final JwtProperties jwtProperties;
    
    ...

    public Authentication getAuthentication(String token) {
        Claims claims = getClaims(token);
        Set<SimpleGrantedAuthority> authorities = Collections.singleton(new SimpleGrantedAuthority("ROLE_USER"));
        return new UsernamePasswordAuthenticationToken(
                new org.springframework.security.core.userdetails.User(claims.getSubject(), "", authorities),
                token,
                authorities
        );
    }
    
    private Claims getClaims(String token) {
        return Jwts.parser()
                .setSigningKey(jwtProperties.getSecretKey())
                .parseClaimsJws(token)
                .getBody();
    }

}

JWT 토큰을 기반으로 스프링 시큐리티의 Authentication 객체를 생성하는 getAuthentication() 메서드를 작성하였습니다. JWT 토큰에서 사용자 정보를 추출하고, 이를 사용해 스프링 시큐리티에서 사용하는 Authentication 객체를 생성하여 반환합니다.

• getClaims(token) 메서드를 호출해서 토큰에서 클레임을 가져옵니다. 클레임에 접근할 수 있는 getClaims() 메서드를 private으로 선언하기 위해 메서드를 분리하였습니다. 
• SimpleGrantedAuthority는 스프링 시큐리티에서 사용자의 권한(역할)을 나타내는 클래스입니다. 여기서는 "ROLE_USER"라는 단일 권한을 가진 SimpleGrantedAuthority 객체를 생성합니다. Collections.singleton()을 사용해서 단일 요소를 가진 불변(Set) 컬렉션을 생성하여 사용자가 "ROLE_USER" 권한만 가질 수 있도록 설정하였습니다. 
• 반환 타입은 UsernamePasswordAuthenticationToken으로 스프링 시큐리티에서 사용자 인증 정보를 나타내는 객체(Authentication 객체)입니다. Authentication 객체는 아래 3개의 인자를 받습니다.
  • Principal: 사용자를 식별하는 인증 정보입니다. 사용자 이름과 비밀번호로 인증할 때 이 값은 대부분 UserDetails의 인스턴스입니다.
  • Credential: 주로 비밀번호를 의미합니다.  대부분 사용자가 인증된 후에 이 값은 유출되지 않도록 삭제됩니다. 여기서는 JWT 토큰을 그대로 전달하였습니다. 
  • Authorities: 사용자의 권한 목록입니다.

전체적으로 위의 코드가 동작하는 흐름은 다음과 같습니다. 

1.getAuthentication(String token) 메서드가 호출되면, 먼저 getClaims(token) 메서드를 사용해 토큰에서 클레임(Claims) 정보를 추출합니다.

2. 이 클레임에서 사용자의 ID(claims.getSubject())를 가져옵니다.

3. 단일 권한 “ROLE_USER”를 가진 SimpleGrantedAuthority 객체를 생성합니다.

4. UsernamePasswordAuthenticationToken 객체를 생성하는데, 여기에는 사용자 ID, JWT 토큰, 권한 정보가 포함됩니다.

5. 이 Authentication 객체를 반환함으로써, 스프링 시큐리티는 해당 사용자가 인증된 상태임을 인식하게 됩니다.

 

public class TokenProvider {

    private final JwtProperties jwtProperties;

    ...

    public Long getUserId(String token) {
        Claims claims =  getClaims(token);
        return claims.get("id", Long.class);
    }

    private Claims getClaims(String token) {
        return Jwts.parser()
                .setSigningKey(jwtProperties.getSecretKey())
                .parseClaimsJws(token)
                .getBody();
    }

}

token으로 사용자의 id를 반환하는 getUserId() 메서드도 추가로 작성합니다. 여기까지 작성하면 TokenProvider 클래스는 완성이 되었습니다.

 

3) 리프레시 토큰 도메인 구현하기

리프레시 토큰은 데이터베이스에 저장하는 정보이므로 엔티티와 리포지터리를 추가해야 합니다.

// domain/RefreshToken.java

@NoArgsConstructor(access = AccessLevel.PROTECTED)
@Getter
@Entity
public class RefreshToken {

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

    @Column(name = "user_id", nullable = false, unique = true)
    private Long userId;

    @Column(name = "refresh_token", nullable = false)
    private String refreshToken;

    public RefreshToken(Long userId, String refreshToken) {
        this.userId = userId;
        this.refreshToken = refreshToken;
    }

    public RefreshToken update(String refreshToken) {
        this.refreshToken = refreshToken;
        return this;
    }

}

 

// repository/RefreshTokenRepository.java

public interface RefreshTokenRepository extends JpaRepository<RefreshToken, Long> {
    Optional<RefreshToken> findByUserId(Long userId);
    Optional<RefreshToken> findByRefreshToken(String refreshToken);
}

 

4) 토큰 필터 구현하기

이제 토큰 필터를 만들 차례입니다. 토큰 필터는 요청이 오면 헤더값에서 토큰이 있는지 확인하고 유효 토큰이라면 시큐리티 콘텍스트 홀더(Security Context Holder)에 인증 정보를 저장합니다. 

https://docs.spring.io/spring-security/reference/servlet/authentication/architecture.html#servlet-authentication-securitycontext

SecurityContext는 스프링 시큐리티가 인증(authenticated)된 사용자의 정보를 저장하는 보관소입니다. 스프링 시큐리티는 SecurityContextHolder에 어떤 정보가 있는지는 고려하지 않고 그냥 값이 채워져있다면 인증된 사용자라고 판단합니다. SecurityContext 클래스는 스레드마다 공간을 할당하는 스레드 로컬(thread local)에 저장되므로 코드 아무 곳에서나 참조할 수 있고, 다른 스레드와 공유하지 않으므로 독립적으로 사용할 수 있습니다.

 

// config/TokenAuthenticationFilter.java

@RequiredArgsConstructor
public class TokenAuthenticationFilter extends OncePerRequestFilter {
    
    private final TokenProvider tokenProvider;
    private final static String HEADER_AUTHORIZATION = "Authorization";
    private final static String TOKEN_PREFIX = "Bearer";

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
        String authorizationHeader = request.getHeader(HEADER_AUTHORIZATION);
        String token = getAccessToken(authorizationHeader);
        if (tokenProvider.validToken(token)) {
            Authentication authenciation = tokenProvider.getAuthentication(token);
            SecurityContextHolder.getContext().setAuthentication(authenciation);
        }
        filterChain.doFilter(request, response);
    }

    private String getAccessToken(String authorizationHeader) {
        if (authorizationHeader != null && authorizationHeader.startsWith(TOKEN_PREFIX)) {
            return authorizationHeader.substring(TOKEN_PREFIX.length());
        }
        return null;
    }

}

config 디렉터리에 TokenAuthenticationFilter.java 파일을 만들겠습니다. 이 필터는 각 HTTP 요청에 대해 JWT 토큰을 검사하고, 유효한 토큰이 있을 경우 사용자를 인증하는 역할을 합니다. 필터는 스프링 시큐리티의 필터 체인에 추가되어, 모든 요청에 대해 한번씩 실행됩니다.

• TokenAuthenticationFilter 클래스는 OncePerRequestFilter를 상속받아, 요청마다 한번씩 실행되는 필터로 정의됩니다.
• request의 헤더를 가져오고 헤더에서 접두사 Bearer를 제외한 값(token)을 얻습니다.
• 얻은 token값이 유효한지 검사하고 유효하다면 인증 정보를 관리하는 시큐리티 컨텍스트에 인증 정보를 설정합니다. 위에서 작성한 코드가 실행되며 인증 정보가 설정된 이후에 컨텍스트 홀더에서 getAuthentication() 메서드를 사용해 인증 정보를 가져오면 유저 객체가 반환됩니다. 유저 객체에는 유저 이름(username)과 권한 목록(authorities)과 같은 인증 정보가 저장됩니다.
• filterChain.doFilter(request, response)가 호출되면 필터 체인의 다음 단계로 요청 처리가 이루어집니다.

 

3. 토큰 API 구현하기

1) 토큰 서비스 추가하기

먼저 토큰 서비스를 추가하겠습니다. 리프레시 토큰을 전달받아 새로운 액세스 토큰을 만드는 토큰 서비스 클래스를 생성하겠습니다.

// service/RefreshTokenService.java

@RequiredArgsConstructor
@Service
public class RefreshTokenService {

    private final RefreshTokenRepository refreshTokenRepository;

    public RefreshToken findByRefreshToken(String refreshToken) {
        return refreshTokenRepository.findByRefreshToken(refreshToken)
                .orElseThrow(() -> new IllegalArgumentException("Unexpected token"));
    }

}

전달받은 리프레시 토큰으로 DB에서 리프레시 토큰 객체를 검색해서 전달하는 findByRefreshToken() 메서드를 구현하였습니다. 

 

@RequiredArgsConstructor
@Service
public class TokenService {

    private final TokenProvider tokenProvider;
    private final RefreshTokenService refreshTokenService;
    private final UserService userService;

    public String createNewAccessToken(String refreshToken) throws IllegalAccessException {
        if (!tokenProvider.validToken(refreshToken)) {
            throw new IllegalAccessException("Unexpected token");
        }

        Long userId = refreshTokenService.findByRefreshToken(refreshToken).getUserId();
        User user = userService.findById(userId);

        return tokenProvider.generateToken(user, Duration.ofHours(2));
    }

}

리프레시 토큰을 받아서 새로운 액세스 토큰을 리턴하는 메서드를 작성해줍니다. 만약 리프레시 토큰이 유효하지 않다면 예외를 발생시킵니다.

 

토큰을 생성하고, 유효성을 검증하는 로직을 모두 작성하였으니 이제 실제로 토큰을 발급받는 API를 생성하겠습니다.

// dto/CreateAccessTokenRequest.java

@Getter
@Setter
public class CreateAccessTokenRequest {
    private String refreshToken;
}

// dto/CreateAccessTokenResponse.java

@AllArgsConstructor
@Getter
public class CreateAccessTokenResponse {

    private String accessToken;

}

토큰 생성 요청과 응답에 해당하는 DTO를 각각 만듭니다.

 

2) 컨트롤러 추가하기

@RequiredArgsConstructor
@RestController
public class TokenApiController {

    private final TokenService tokenService;

    @PostMapping("/api/token")
    public ResponseEntity<CreateAccessTokenResponse> createNewAccessToken(@RequestBody CreateAccessTokenRequest request) throws IllegalAccessException {
        String newAccessToken = tokenService.createNewAccessToken(request.getRefreshToken());
        return ResponseEntity.status(HttpStatus.CREATED)
                .body(new CreateAccessTokenResponse(newAccessToken));
    }

}

• 컨트롤러에는 /api/token 포스트 요청에 매핑되는 createNewAccessToken() 메서드를 작성합니다.
• 클라이언트가 request body에 JSON 형식으로 전송한 데이터를 CreateAccessTokenRequest 객체로 매핑합니다. 이 객체에는 클라이언트가 가지고 있는 리프레시 토큰이 포함되어 있습니다. 
• 새로운 액세스 토큰을 포함하고 있는 CreateAccessTokenResponse 객체를 body에 담은 ResponseEntity 객체로 응답합니다. 

 

4. 테스트 코드

package com.eunbin.springbootblog.controller;

import com.eunbin.springbootblog.config.jwt.JwtFactory;
import com.eunbin.springbootblog.config.jwt.JwtProperties;
import com.eunbin.springbootblog.domain.RefreshToken;
import com.eunbin.springbootblog.domain.User;
import com.eunbin.springbootblog.dto.CreateAccessTokenRequest;
import com.eunbin.springbootblog.repository.RefreshTokenRepository;
import com.eunbin.springbootblog.repository.UserRepository;
import com.fasterxml.jackson.databind.ObjectMapper;
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.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.ResultActions;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.context.WebApplicationContext;

import java.util.Map;

import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.post;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.jsonPath;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;

@SpringBootTest
@AutoConfigureMockMvc
public class TokenApiControllerTestPractice {

    @Autowired
    protected MockMvc mockMvc;

    @Autowired
    protected ObjectMapper objectMapper;

    @Autowired
    protected WebApplicationContext context;

    @Autowired
    JwtProperties jwtProperties;

    @Autowired
    RefreshTokenRepository refreshTokenRepository;

    @Autowired
    UserRepository userRepository;

    @BeforeEach
    public void setMockMvc() {
        this.mockMvc = MockMvcBuilders.webAppContextSetup(context).build();
        userRepository.deleteAll();
    }

    @Test
    public void createNewAccessToken() throws Exception{

        final String url = "/api/token";

        User testUser = userRepository.save(
                User.builder()
                .email("user@test.com")
                .password("p@ssw0rd")
                .build()
        );

        String refreshToken = JwtFactory.builder()
                .claims(Map.of("id", testUser.getId()))
                .build()
                .generateToken(jwtProperties);

        refreshTokenRepository.save(new RefreshToken(testUser.getId(), refreshToken));

        CreateAccessTokenRequest request = new CreateAccessTokenRequest();
        request.setRefreshToken(refreshToken);
        final String requestBody = objectMapper.writeValueAsString(request);
        System.out.println("requestBody: " + requestBody);

        ResultActions resultActions = mockMvc.perform(
                post(url)
                        .contentType(MediaType.APPLICATION_JSON)
                        .content(requestBody)
        );

        String responseBody = resultActions.andReturn().getResponse().getContentAsString();
        System.out.println("Response Body: " + responseBody);

        int status = resultActions.andReturn().getResponse().getStatus();
        System.out.println("HTTP Status: " + status);

        resultActions
                .andExpect(status().isCreated())
                .andExpect(jsonPath("$.accessToken").isNotEmpty());

    }

}

테스트 유저를 생성하고 리프레시 토큰을 만들어서 데이터베이스에 저장합니다. 아래와 같이 리프레시 토큰을 담은 요청 객체(CreateAccessTokenRequest)를 생성합니다.

 

토큰 생성 api 요청(POST /api/token)을 하면 아래와 같이 응답 코드를 확인할 수 있습니다.