fix[member]: 테스트 코드에 수정된 로직 반영 및 주석 수정, 환경변수 오타 수정

asowjdan · asowjdan · commit 2cf30d5eea19 · 2025-09-25T12:49:11.000+09:00
diff --git a/backend/.env.default b/backend/.env.default
@@ -7,7 +7,7 @@ SPRING__SECURITY__OAUTH2__CLIENT__REGISTRATION__KAKAO__CLIENT_SECRET=NEED_TO_SET
 SPRING__SECURITY__OAUTH2__CLIENT__REGISTRATION__NAVER__CLIENT_ID=NEED_TO_SET
 SPRING__SECURITY__OAUTH2__CLIENT__REGISTRATION__NAVER__CLIENT_SECRET=NEED_TO_SET
 
-CUSTOM__JWT__SECRET_KEY=NEED_TO_SET
+CUSTOM_JWT_SECRET_KEY=NEED_TO_SET
 CUSTOM_JWT_ACCESS_TOKEN_EXPIRATION_SECONDS=NEED_TO_SET
 
 PROD_DATASOURCE_URL=NEED_TO_SET
diff --git a/backend/src/main/java/com/ai/lawyer/domain/member/controller/MemberController.java b/backend/src/main/java/com/ai/lawyer/domain/member/controller/MemberController.java
@@ -67,9 +67,9 @@ public ResponseEntity<Void> logout(Authentication authentication, HttpServletRes
         if (authentication != null && authentication.getName() != null) {
             String loginId = authentication.getName();
             memberService.logout(loginId, response);
-            log.info("로그아웃 완료: email={}", loginId);
+            log.info("로그아웃 완료: memberId={}", loginId);
         } else {
-            // 인증 정보가 없어도 쿠키는 클리어
+            // 인증되지 않은 상태에서도 클라이언트 쿠키 클리어 처리
             memberService.logout("", response);
             log.info("인증 정보 없이 로그아웃 완료");
         }
@@ -87,7 +87,7 @@ public ResponseEntity<MemberResponse> refreshToken(HttpServletRequest request,
                                                      HttpServletResponse response) {
         log.info("토큰 재발급 요청");
 
-        // 쿠키에서 리프레시 토큰 추출 (간단한 방법)
+        // HTTP 쿠키에서 리프레시 토큰 추출
         String refreshToken = extractRefreshTokenFromCookies(request);
 
         if (refreshToken == null) {
@@ -116,7 +116,7 @@ public ResponseEntity<Void> withdraw(Authentication authentication, HttpServletR
         log.info("회원탈퇴 요청: memberId={}, email={}", memberId, loginId);
 
         memberService.withdraw(memberId);
-        memberService.logout(loginId, response); // 탈퇴 후 로그아웃 처리
+        memberService.logout(loginId, response); // 회원 탈퇴 후 세션 및 토큰 정리
         log.info("회원탈퇴 성공: memberId={}, email={}", memberId, loginId);
         return ResponseEntity.ok().build();
     }
@@ -140,6 +140,11 @@ public ResponseEntity<MemberResponse> getMyInfo(Authentication authentication) {
         return ResponseEntity.ok(response);
     }
 
+    /**
+     * HTTP 쿠키에서 리프레시 토큰을 추출합니다.
+     * @param request HTTP 요청 객체
+     * @return 리프레시 토큰 값 또는 null
+     */
     private String extractRefreshTokenFromCookies(HttpServletRequest request) {
         if (request.getCookies() != null) {
             for (jakarta.servlet.http.Cookie cookie : request.getCookies()) {
diff --git a/backend/src/main/java/com/ai/lawyer/domain/member/exception/MemberExceptionHandler.java b/backend/src/main/java/com/ai/lawyer/domain/member/exception/MemberExceptionHandler.java
@@ -12,17 +12,40 @@
 @Slf4j
 public class MemberExceptionHandler {
 
+    /**
+     * IllegalArgumentException 고도화 처리
+     * 메시지에 따라 HTTP 상태코드와 에러 메시지 다르게 반환
+     */
     @ExceptionHandler(IllegalArgumentException.class)
     public ResponseEntity<MemberErrorResponse> handleMemberIllegalArgumentException(IllegalArgumentException e) {
         log.warn("Member 도메인 IllegalArgumentException: {}", e.getMessage());
-        MemberErrorResponse errorResponse = MemberErrorResponse.of(
-                e.getMessage(),
-                HttpStatus.BAD_REQUEST.value(),
-                "잘못된 요청"
-        );
-        return ResponseEntity.badRequest().body(errorResponse);
+
+        String msg = e.getMessage();
+        HttpStatus status;
+        String error = switch (msg) {
+            case "이미 존재하는 이메일입니다.", "잘못된 입력입니다." -> {
+                status = HttpStatus.BAD_REQUEST;
+                yield "잘못된 요청";
+            }
+            case "존재하지 않는 회원입니다.", "비밀번호가 일치하지 않습니다." -> {
+                status = HttpStatus.UNAUTHORIZED;
+                yield "인증 실패";
+            }
+            default -> {
+                status = HttpStatus.BAD_REQUEST;
+                yield "오류 발생";
+            }
+        };
+
+        // 메시지 기반으로 상태코드 결정
+
+        MemberErrorResponse errorResponse = MemberErrorResponse.of(msg, status.value(), error);
+        return ResponseEntity.status(status).body(errorResponse);
     }
 
+    /**
+     * 인증 관련 예외 처리
+     */
     @ExceptionHandler(MemberAuthenticationException.class)
     public ResponseEntity<MemberErrorResponse> handleMemberAuthenticationException(MemberAuthenticationException e) {
         log.warn("Member 도메인 AuthenticationException: {}", e.getMessage());
@@ -34,6 +57,9 @@ public ResponseEntity<MemberErrorResponse> handleMemberAuthenticationException(M
         return ResponseEntity.status(HttpStatus.UNAUTHORIZED).body(errorResponse);
     }
 
+    /**
+     * 유효성 검증 실패 처리
+     */
     @ExceptionHandler(MethodArgumentNotValidException.class)
     public ResponseEntity<MemberErrorResponse> handleMemberValidationException(MethodArgumentNotValidException e) {
         String message = e.getBindingResult().getAllErrors().getFirst().getDefaultMessage();
@@ -45,4 +71,4 @@ public ResponseEntity<MemberErrorResponse> handleMemberValidationException(Metho
         );
         return ResponseEntity.badRequest().body(errorResponse);
     }
-}
+}
diff --git a/backend/src/main/java/com/ai/lawyer/domain/member/service/MemberService.java b/backend/src/main/java/com/ai/lawyer/domain/member/service/MemberService.java
@@ -46,34 +46,32 @@ public MemberResponse login(MemberLoginRequest request, HttpServletResponse resp
             throw new IllegalArgumentException("비밀번호가 일치하지 않습니다.");
         }
 
-        // 토큰 생성 및 쿠키 설정
+        // JWT 액세스 토큰과 리프레시 토큰 생성 후 HTTP 쿠키에 설정
         String accessToken = tokenProvider.generateAccessToken(member);
         String refreshToken = tokenProvider.generateRefreshToken(member);
         cookieUtil.setTokenCookies(response, accessToken, refreshToken);
 
-        // TODO: 추후 레디스에 토큰-회원 매핑 정보 저장
-
         return MemberResponse.from(member);
     }
 
     public void logout(String loginId, HttpServletResponse response) {
-        // loginId가 있는 경우에만 Redis에서 리프레시 토큰 삭제
+        // 로그인 ID가 존재할 경우 Redis에서 리프레시 토큰 삭제
         if (loginId != null && !loginId.trim().isEmpty()) {
             tokenProvider.deleteRefreshToken(loginId);
         }
 
-        // 쿠키는 항상 클리어 (인증 정보가 없어도 클라이언트의 쿠키는 삭제해야 함)
+        // 인증 상태와 관계없이 클라이언트 쿠키 클리어
         cookieUtil.clearTokenCookies(response);
     }
 
     public MemberResponse refreshToken(String refreshToken, HttpServletResponse response) {
-        // Redis에서 리프레시 토큰으로 사용자를 찾기 (Redis 키 패턴: refresh_token:loginId)
+        // Redis에서 리프레시 토큰으로 사용자 찾기
         String username = tokenProvider.findUsernameByRefreshToken(refreshToken);
         if (username == null) {
             throw new IllegalArgumentException("유효하지 않은 리프레시 토큰입니다.");
         }
 
-        // Redis에서 리프레시 토큰 유효성 검증
+        // 리프레시 토큰 유효성 검증
         if (!tokenProvider.validateRefreshToken(username, refreshToken)) {
             throw new IllegalArgumentException("유효하지 않은 리프레시 토큰입니다.");
         }
@@ -82,14 +80,14 @@ public MemberResponse refreshToken(String refreshToken, HttpServletResponse resp
         Member member = memberRepository.findByLoginId(username)
                 .orElseThrow(() -> new IllegalArgumentException("존재하지 않는 회원입니다."));
 
-        // 기존 리프레시 토큰 Redis에서 삭제 (RTR 패턴)
+        // RTR(Refresh Token Rotation) 패턴: 기존 리프레시 토큰 삭제
         tokenProvider.deleteRefreshToken(username);
 
         // 새로운 액세스 토큰과 리프레시 토큰 생성
         String newAccessToken = tokenProvider.generateAccessToken(member);
         String newRefreshToken = tokenProvider.generateRefreshToken(member);
 
-        // 새로운 토큰들을 쿠키로 설정
+        // 새로운 토큰들을 HTTP 쿠키에 설정
         cookieUtil.setTokenCookies(response, newAccessToken, newRefreshToken);
 
         return MemberResponse.from(member);
@@ -110,11 +108,11 @@ public MemberResponse getMemberById(Long memberId) {
         return MemberResponse.from(member);
     }
 
-    public Member findByLoginId(String loginId) {
-        return memberRepository.findByLoginId(loginId)
-                .orElseThrow(() -> new IllegalArgumentException("존재하지 않는 회원입니다."));
-    }
-
+    /**
+     * 로그인 ID 중복 검사
+     * @param loginId 검사할 로그인 ID
+     * @throws IllegalArgumentException 중복된 로그인 ID인 경우
+     */
     private void validateDuplicateLoginId(String loginId) {
         if (memberRepository.existsByLoginId(loginId)) {
             throw new IllegalArgumentException("이미 존재하는 이메일입니다.");
diff --git a/backend/src/main/java/com/ai/lawyer/global/jwt/JwtAuthenticationFilter.java b/backend/src/main/java/com/ai/lawyer/global/jwt/JwtAuthenticationFilter.java
@@ -31,9 +31,8 @@ protected void doFilterInternal(@Nullable HttpServletRequest request, @Nullable
         if (request != null) {
             String accessToken = cookieUtil.getAccessTokenFromCookies(request);
 
-            // 액세스 토큰이 있는 경우
+            // JWT 액세스 토큰 검증 및 인증 처리
             if (accessToken != null && tokenProvider.validateToken(accessToken)) {
-                // 유효한 토큰 - 인증 정보 설정
                 setAuthentication(accessToken);
             }
         }
@@ -43,9 +42,12 @@ protected void doFilterInternal(@Nullable HttpServletRequest request, @Nullable
         }
     }
 
+    /**
+     * JWT 토큰에서 사용자 정보를 추출하여 Spring Security 인증 객체를 설정합니다.
+     * @param token JWT 액세스 토큰
+     */
     private void setAuthentication(String token) {
         try {
-            // 토큰에서 사용자 정보 추출
             Long memberId = tokenProvider.getMemberIdFromToken(token);
             String role = tokenProvider.getRoleFromToken(token);
 
@@ -54,11 +56,11 @@ private void setAuthentication(String token) {
                 return;
             }
 
-            // 권한 설정 (토큰에서 추출한 role 사용)
+            // Spring Security 권한 형식으로 변환
             String authority = "ROLE_" + (role != null ? role : "USER");
             List<SimpleGrantedAuthority> authorities = List.of(new SimpleGrantedAuthority(authority));
 
-            // memberId를 principal로 사용하는 인증 객체 생성
+            // memberId를 principal로 하는 인증 객체 생성
             UsernamePasswordAuthenticationToken authentication =
                 new UsernamePasswordAuthenticationToken(memberId, null, authorities);
 
@@ -68,10 +70,14 @@ private void setAuthentication(String token) {
         }
     }
 
+    /**
+     * JWT 인증이 필요하지 않은 경로들을 필터링에서 제외합니다.
+     * @param request HTTP 요청
+     * @return true인 경우 필터 제외
+     */
     @Override
     protected boolean shouldNotFilter(HttpServletRequest request) {
         String path = request.getRequestURI();
-        // 인증이 필요없는 경로들 (구체적으로 명시)
         return path.equals("/api/auth/signup") ||
                path.equals("/api/auth/login") ||
                path.equals("/api/auth/refresh") ||
diff --git a/backend/src/main/java/com/ai/lawyer/global/jwt/TokenProvider.java b/backend/src/main/java/com/ai/lawyer/global/jwt/TokenProvider.java
@@ -47,7 +47,7 @@ public String generateAccessToken(Member member) {
     public String generateRefreshToken(Member member) {
         String refreshToken = UUID.randomUUID().toString();
 
-        // Redis에 리프레시 토큰 저장
+        // Redis에 리프레시 토큰 저장 (만료시간: 7일)
         String redisKey = REFRESH_TOKEN_PREFIX + member.getLoginId();
         redisTemplate.opsForValue().set(redisKey, refreshToken, Duration.ofSeconds(REFRESH_TOKEN_EXPIRE_TIME));
 
@@ -114,6 +114,12 @@ public void deleteRefreshToken(String loginId) {
         redisTemplate.delete(redisKey);
     }
 
+    /**
+     * 리프레시 토큰으로 사용자명을 찾습니다.
+     * Redis에서 모든 리프레시 토큰 키를 순회하며 일치하는 토큰을 찾습니다.
+     * @param refreshToken 찾을 리프레시 토큰
+     * @return 사용자명 또는 null
+     */
     public String findUsernameByRefreshToken(String refreshToken) {
         String pattern = REFRESH_TOKEN_PREFIX + "*";
         var keys = redisTemplate.keys(pattern);
diff --git a/backend/src/main/java/com/ai/lawyer/global/security/SecurityConfig.java b/backend/src/main/java/com/ai/lawyer/global/security/SecurityConfig.java
@@ -60,7 +60,7 @@ public PasswordEncoder passwordEncoder() {
     @Bean
     public CorsConfigurationSource corsConfigurationSource() {
         CorsConfiguration configuration = new CorsConfiguration();
-        configuration.setAllowedOrigins(List.of("http://localhost:3000")); // 프론트엔드 주소
+        configuration.setAllowedOrigins(List.of("http://localhost:3000"));
         configuration.setAllowedMethods(List.of("GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"));
         configuration.setAllowedHeaders(List.of("*"));
         configuration.setAllowCredentials(true);
diff --git a/backend/src/test/java/com/ai/lawyer/domain/member/controller/MemberControllerTest.java b/backend/src/test/java/com/ai/lawyer/domain/member/controller/MemberControllerTest.java
