Feat(Auth): reissue, logout 구현

jabiseo-api/src/main/java/com/jabiseo/auth/application/JwtHandler.java

@@ -3,6 +3,7 @@
 import com.jabiseo.auth.exception.AuthenticationBusinessException;
 import com.jabiseo.auth.exception.AuthenticationErrorCode;
 import com.jabiseo.member.domain.Member;
+import io.jsonwebtoken.ClaimJwtException;
 import io.jsonwebtoken.Claims;
 import io.jsonwebtoken.ExpiredJwtException;
 import io.jsonwebtoken.Jwts;
@@ -21,7 +22,7 @@ public class JwtHandler {
     private final Key refreshKey;
     private final Integer accessExpiredMin;
     private final Integer refreshExpiredDay;
-    private final String APP_ISSUER = "jabiseo";
+    private static final String APP_ISSUER = "jabiseo";
 
     public JwtHandler(JwtProperty jwtProperty) {
         byte[] accessEncodeByte = Base64.getEncoder().encode((jwtProperty.getAccessKey().getBytes()));
@@ -36,7 +37,6 @@ public JwtHandler(JwtProperty jwtProperty) {
     public String createAccessToken(Member member) {
         Instant accessExpiredTime = Instant.now()
                 .plus(this.accessExpiredMin, ChronoUnit.MINUTES);
-
         Map<String, Object> payload = new HashMap<>();
 
         return Jwts.builder()
@@ -57,21 +57,35 @@ public String createRefreshToken() {
                 .compact();
     }
 
-
-    public boolean validateAccessToken(String token) {
+    public void validateAccessToken(String accessToken){
         try {
             Jwts.parserBuilder()
                     .setSigningKey(accessKey)
                     .build()
-                    .parseClaimsJws(token);
-            return true;
+                    .parseClaimsJws(accessToken)
+                    .getBody();
         } catch (ExpiredJwtException e) {
             throw new AuthenticationBusinessException(AuthenticationErrorCode.EXPIRED_APP_JWT);
         } catch (Exception e) {
             throw new AuthenticationBusinessException(AuthenticationErrorCode.INVALID_APP_JWT);
         }
     }
 
+    public void validateAccessTokenNotCheckExpired(String accessToken){
+        try {
+            Jwts.parserBuilder()
+                    .setSigningKey(accessKey)
+                    .build()
+                    .parseClaimsJws(accessToken)
+                    .getBody();
+        } catch (ExpiredJwtException e) {
+            return;
+        } catch (Exception e) {
+            throw new AuthenticationBusinessException(AuthenticationErrorCode.INVALID_APP_JWT);
+        }
+    }
+
+
     public void validateRefreshToken(String refreshToken) {
         try {
             Jwts.parserBuilder()
@@ -86,26 +100,19 @@ public void validateRefreshToken(String refreshToken) {
     }
 
 
-    public Claims getClaimFromExpiredAccessToken(String accessToken) {
+    public Claims getClaimsFromAccessToken(String token) {
         try {
-            return Jwts.parserBuilder()
+            return Jwts
+                    .parserBuilder()
                     .setSigningKey(accessKey)
                     .build()
-                    .parseClaimsJws(accessToken)
+                    .parseClaimsJws(token)
                     .getBody();
-        } catch (ExpiredJwtException e) {
+        } catch (ClaimJwtException e) {
+            // 기존 검증에서 처리후 가져오는 동작
             return e.getClaims();
         } catch (Exception e) {
             throw new AuthenticationBusinessException(AuthenticationErrorCode.INVALID_APP_JWT);
         }
     }
-
-    public Claims getClaimsFromAccessToken(String token) {
-        return Jwts
-                .parserBuilder()
-                .setSigningKey(accessKey)
-                .build()
-                .parseClaimsJws(token)
-                .getBody();
-    }
 }

jabiseo-api/src/main/java/com/jabiseo/auth/application/usecase/LogoutUseCase.java

@@ -1,10 +1,17 @@
 package com.jabiseo.auth.application.usecase;
 
+import com.jabiseo.cache.RedisCacheRepository;
+import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 
 @Service
+@RequiredArgsConstructor
 public class LogoutUseCase {
-    public void execute() {
+
+    private final RedisCacheRepository redisCacheRepository;
+
+    public void execute(String memberId) {
+        redisCacheRepository.deleteToken(memberId);
     }
 
 }

jabiseo-api/src/main/java/com/jabiseo/auth/application/usecase/ReissueUseCase.java

@@ -1,13 +1,42 @@
 package com.jabiseo.auth.application.usecase;
 
+import com.jabiseo.auth.application.JwtHandler;
 import com.jabiseo.auth.dto.LoginResponse;
+import com.jabiseo.auth.dto.ReissueRequest;
+import com.jabiseo.auth.dto.ReissueResponse;
+import com.jabiseo.auth.exception.AuthenticationBusinessException;
+import com.jabiseo.auth.exception.AuthenticationErrorCode;
+import com.jabiseo.cache.RedisCacheRepository;
+import com.jabiseo.member.domain.Member;
+import com.jabiseo.member.domain.MemberRepository;
+import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
 
 @Service
+@RequiredArgsConstructor
+@Transactional(readOnly = true)
 public class ReissueUseCase {
 
-    public LoginResponse reissue(String refreshToken) {
-        return new LoginResponse("access_token", "refresh_token");
+    private final MemberRepository memberRepository;
+    private final RedisCacheRepository redisCacheRepository;
+    private final JwtHandler jwtHandler;
+
+    public ReissueResponse execute(ReissueRequest request, String memberId) {
+        Member member = memberRepository.getReferenceById(memberId);
+
+        jwtHandler.validateRefreshToken(request.refreshToken());
+
+        String savedToken = redisCacheRepository.findToken(memberId)
+                .orElseThrow(() -> new AuthenticationBusinessException(AuthenticationErrorCode.REQUIRE_LOGIN));
+
+        if (!savedToken.equals(request.refreshToken())) {
+            throw new AuthenticationBusinessException(AuthenticationErrorCode.NOT_MATCH_REFRESH);
+        }
+
+        String accessToken = jwtHandler.createAccessToken(member);
+        return new ReissueResponse(accessToken);
     }
 
+
 }

jabiseo-api/src/main/java/com/jabiseo/auth/controller/AuthController.java

@@ -6,6 +6,10 @@
 import com.jabiseo.auth.application.usecase.LogoutUseCase;
 import com.jabiseo.auth.application.usecase.ReissueUseCase;
 import com.jabiseo.auth.application.usecase.WithdrawUseCase;
+import com.jabiseo.auth.dto.ReissueRequest;
+import com.jabiseo.auth.dto.ReissueResponse;
+import com.jabiseo.config.auth.AuthMember;
+import com.jabiseo.config.auth.AuthenticatedMember;
 import jakarta.validation.Valid;
 import lombok.RequiredArgsConstructor;
 import org.springframework.http.ResponseEntity;
@@ -34,14 +38,14 @@ public ResponseEntity<LoginResponse> login(@Valid @RequestBody LoginRequest logi
     }
 
     @PostMapping("/reissue")
-    public ResponseEntity<LoginResponse> reissue(String refreshToken) {
-        LoginResponse result = reissueUseCase.reissue(refreshToken);
+    public ResponseEntity<ReissueResponse> reissue(@Valid @RequestBody ReissueRequest request, @AuthenticatedMember AuthMember member) {
+        ReissueResponse result = reissueUseCase.execute(request, member.getMemberId());
         return ResponseEntity.ok(result);
     }
 
     @PostMapping("/logout")
-    public ResponseEntity<Void> logout() {
-        logoutUseCase.execute();
+    public ResponseEntity<Void> logout(@AuthenticatedMember AuthMember member) {
+        logoutUseCase.execute(member.getMemberId());
         return ResponseEntity.noContent().build();
     }
 

jabiseo-api/src/main/java/com/jabiseo/auth/dto/ReissueRequest.java

@@ -0,0 +1,6 @@
+package com.jabiseo.auth.dto;
+
+import jakarta.validation.constraints.NotBlank;
+
+public record ReissueRequest(@NotBlank String refreshToken) {
+}

jabiseo-api/src/main/java/com/jabiseo/auth/dto/ReissueResponse.java

@@ -0,0 +1,5 @@
+package com.jabiseo.auth.dto;
+
+public record ReissueResponse(String accessToken) {
+
+}

jabiseo-api/src/main/java/com/jabiseo/common/security/JwtAuthenticationFilter.java

@@ -24,22 +24,31 @@
 public class JwtAuthenticationFilter extends OncePerRequestFilter {
 
     private final JwtHandler jwtHandler;
-    private static final  String AUTHORIZATION_HEADER = "Authorization";
+    private static final String AUTHORIZATION_HEADER = "Authorization";
     private static final String HEADER_PREFIX = "Bearer ";
-
+    private static final String REISSUE_REQUEST = "/api/auth/reissue";
 
     @Override
     protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {
         String token = extractTokenFromRequest(request);
 
-        if (StringUtils.hasText(token) && jwtHandler.validateAccessToken(token)) {
-            Claims claims = jwtHandler.getClaimsFromAccessToken(token);
+        if (StringUtils.hasText(token)) {
+            Claims claims = getClaimsFromToken(token, request);
             setAuthenticationToContext(claims);
         }
 
         filterChain.doFilter(request, response);
     }
 
+    private Claims getClaimsFromToken(String token, HttpServletRequest request) {
+        if (request.getRequestURI().equals(REISSUE_REQUEST)) {
+            jwtHandler.validateAccessTokenNotCheckExpired(token);
+        } else {
+            jwtHandler.validateAccessToken(token);
+        }
+        return jwtHandler.getClaimsFromAccessToken(token);
+    }
+
     private void setAuthenticationToContext(Claims jwtClaim) {
         String memberId = jwtClaim.getSubject();
         Set<GrantedAuthority> authorities = new HashSet<>();

jabiseo-api/src/main/resources/api.yml

@@ -38,7 +38,7 @@ management:
         include: "*"
 
 jwt:
-  access-expired-min: 6000
+  access-expired-min: 1
 
 ---
 spring:

jabiseo-api/src/test/java/com/jabiseo/auth/application/usecase/ReissueUseCaseTest.java

@@ -0,0 +1,95 @@
+package com.jabiseo.auth.application.usecase;
+
+import com.jabiseo.auth.application.JwtHandler;
+import com.jabiseo.auth.dto.ReissueRequest;
+import com.jabiseo.auth.dto.ReissueResponse;
+import com.jabiseo.auth.exception.AuthenticationBusinessException;
+import com.jabiseo.auth.exception.AuthenticationErrorCode;
+import com.jabiseo.cache.RedisCacheRepository;
+import com.jabiseo.member.domain.Member;
+import com.jabiseo.member.domain.MemberRepository;
+import fixture.MemberFixture;
+import org.assertj.core.api.Assertions;
+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;
+
+import java.util.Optional;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.BDDMockito.given;
+
+@ExtendWith(MockitoExtension.class)
+class ReissueUseCaseTest {
+
+    @InjectMocks
+    ReissueUseCase reissueUseCase;
+
+    @Mock
+    MemberRepository memberRepository;
+
+    @Mock
+    RedisCacheRepository redisCacheRepository;
+
+    @Mock
+    JwtHandler jwtHandler;
+
+    ReissueRequest request;
+
+    @BeforeEach
+    void setUp() {
+        request = new ReissueRequest("refresh");
+    }
+
+    @Test
+    @DisplayName("저장된 토큰이 없는 경우 예외를 반환한다")
+    void savedTokenIsNullThrownException() {
+        //given
+        String memberId = "id";
+        given(memberRepository.getReferenceById(memberId)).willReturn(MemberFixture.createMember(memberId));
+        given(redisCacheRepository.findToken(memberId)).willReturn(Optional.empty());
+
+        //when then
+        assertThatThrownBy(() -> reissueUseCase.execute(request, memberId))
+                .isInstanceOf(AuthenticationBusinessException.class);
+    }
+
+    @Test
+    @DisplayName("다른 refreshToken으로 요청하면 예외를 반환한다")
+    void otherTokenRequestThrownException() {
+        //given
+        String memberId = "id";
+        String otherToken = "tokens";
+        given(memberRepository.getReferenceById(memberId)).willReturn(MemberFixture.createMember(memberId));
+        given(redisCacheRepository.findToken(memberId)).willReturn(Optional.of(otherToken));
+
+        //when then
+        assertThatThrownBy(() -> reissueUseCase.execute(request, memberId))
+                .isInstanceOf(AuthenticationBusinessException.class)
+                .hasMessage(AuthenticationErrorCode.NOT_MATCH_REFRESH.getMessage());
+    }
+
+    @Test
+    @DisplayName("정상 요청의 경우 새로운 access Token을 발급한다.")
+    void requestSuccessReturnNewAccessToken(){
+        //given
+        String memberId = "id";
+        Member member = MemberFixture.createMember(memberId);
+        String newAccessToken = "accessToken";
+        given(memberRepository.getReferenceById(memberId)).willReturn(member);
+        given(redisCacheRepository.findToken(memberId)).willReturn(Optional.of(request.refreshToken()));
+        given(jwtHandler.createAccessToken(member)).willReturn(newAccessToken);
+
+        //when
+        ReissueResponse execute = reissueUseCase.execute(request, memberId);
+
+        //then
+        assertThat(execute.accessToken()).isEqualTo(newAccessToken);
+    }
+}