인증 & 인가 관련 테스트 코드 리펙토링

backend/ddang/src/test/java/com/ddang/ddang/authentication/application/AuthenticationUserServiceTest.java

@@ -1,62 +1,35 @@
 package com.ddang.ddang.authentication.application;
 
+import static org.assertj.core.api.Assertions.assertThat;
+
+import com.ddang.ddang.authentication.application.fixture.AuthenticationUserServiceFixture;
 import com.ddang.ddang.configuration.IsolateDatabase;
-import com.ddang.ddang.image.domain.ProfileImage;
-import com.ddang.ddang.user.domain.User;
-import com.ddang.ddang.user.infrastructure.persistence.JpaUserRepository;
 import org.junit.jupiter.api.DisplayNameGeneration;
 import org.junit.jupiter.api.DisplayNameGenerator;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
 
-import static org.assertj.core.api.Assertions.assertThat;
-
 @IsolateDatabase
 @DisplayNameGeneration(DisplayNameGenerator.ReplaceUnderscores.class)
 @SuppressWarnings("NonAsciiCharacters")
-class AuthenticationUserServiceTest {
-
-    @Autowired
-    JpaUserRepository userRepository;
-
+class AuthenticationUserServiceTest extends AuthenticationUserServiceFixture {
 
     @Autowired
     AuthenticationUserService authenticationUserService;
 
     @Test
     void 회원탈퇴한_회원의_id를_전달하면_참을_반환한다() {
-        // given
-        final User user = User.builder()
-                              .name("회원")
-                              .profileImage(new ProfileImage("upload.png", "store.png"))
-                              .reliability(4.7d)
-                              .oauthId("12345")
-                              .build();
-
-        user.withdrawal();
-        userRepository.save(user);
-
         // when
-        final boolean actual = authenticationUserService.isWithdrawal(user.getId());
+        final boolean actual = authenticationUserService.isWithdrawal(탈퇴한_사용자.getId());
 
         // then
         assertThat(actual).isTrue();
     }
 
     @Test
     void 회원탈퇴하지_않거나_회원가입하지_않은_회원의_id를_전달하면_거짓을_반환한다() {
-        // given
-        final User user = User.builder()
-                              .name("회원")
-                              .profileImage(new ProfileImage("upload.png", "store.png"))
-                              .reliability(4.7d)
-                              .oauthId("12345")
-                              .build();
-
-        userRepository.save(user);
-
         // when
-        final boolean actual = authenticationUserService.isWithdrawal(user.getId());
+        final boolean actual = authenticationUserService.isWithdrawal(사용자.getId());
 
         // then
         assertThat(actual).isFalse();

backend/ddang/src/test/java/com/ddang/ddang/authentication/application/fixture/AuthenticationServiceFixture.java

@@ -0,0 +1,161 @@
+package com.ddang.ddang.authentication.application.fixture;
+
+import com.ddang.ddang.authentication.application.AuthenticationService;
+import com.ddang.ddang.authentication.application.BlackListTokenService;
+import com.ddang.ddang.authentication.domain.Oauth2UserInformationProviderComposite;
+import com.ddang.ddang.authentication.domain.TokenDecoder;
+import com.ddang.ddang.authentication.domain.TokenEncoder;
+import com.ddang.ddang.authentication.domain.TokenType;
+import com.ddang.ddang.authentication.domain.dto.UserInformationDto;
+import com.ddang.ddang.authentication.infrastructure.oauth2.OAuth2UserInformationProvider;
+import com.ddang.ddang.authentication.infrastructure.oauth2.Oauth2Type;
+import com.ddang.ddang.configuration.IsolateDatabase;
+import com.ddang.ddang.device.application.DeviceTokenService;
+import com.ddang.ddang.device.domain.DeviceToken;
+import com.ddang.ddang.device.infrastructure.persistence.JpaDeviceTokenRepository;
+import com.ddang.ddang.image.domain.ProfileImage;
+import com.ddang.ddang.image.infrastructure.persistence.JpaProfileImageRepository;
+import com.ddang.ddang.user.domain.User;
+import com.ddang.ddang.user.infrastructure.persistence.JpaUserRepository;
+import java.time.Instant;
+import java.time.LocalDateTime;
+import java.time.ZoneId;
+import java.util.Map;
+import org.junit.jupiter.api.BeforeEach;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.mock.mockito.MockBean;
+
+@SuppressWarnings("NonAsciiCharacters")
+public class AuthenticationServiceFixture {
+
+    @MockBean
+    protected Oauth2UserInformationProviderComposite 소셜_회원_정보_제공자_묶음;
+
+    @MockBean
+    protected OAuth2UserInformationProvider 소셜_회원_정보_제공자;
+
+    protected AuthenticationService authenticationService;
+
+    protected Oauth2Type 지원하는_소셜_로그인 = Oauth2Type.KAKAO;
+    protected Oauth2Type 지원하지_않는_소셜_로그인 = Oauth2Type.KAKAO;
+
+    protected String 유효한_소셜_로그인_토큰 = "Bearer accessToken";
+    protected String 유효하지_않은_소셜_로그인_토큰 = "accessToken";
+    protected String 만료된_소셜_로그인_토큰;
+
+    protected String 디바이스_토큰 = "deviceToken";
+
+    protected User 사용자;
+    protected User 탈퇴한_사용자;
+
+    protected UserInformationDto 사용자_회원_정보 = new UserInformationDto(12345L);
+    protected UserInformationDto 탈퇴한_사용자_회원_정보 = new UserInformationDto(54321L);
+    protected UserInformationDto 가입하지_않은_사용자_회원_정보 = new UserInformationDto(-99999L);
+
+    protected String 유효한_액세스_토큰;
+    protected String 탈퇴한_사용자_액세스_토큰;
+    protected String 이미지가_없는_사용자_액세스_토큰;
+    protected String 존재하지_않는_사용자_액세스_토큰;
+    protected String 유효한_리프레시_토큰;
+    protected String 만료된_리프레시_토큰;
+    protected String 유효하지_않은_타입의_리프레시_토큰 = "invalidRefreshToken";
+
+    @MockBean
+    private DeviceTokenService deviceTokenService;
+
+    @Autowired
+    private JpaUserRepository userRepository;
+
+    @Autowired
+    private JpaProfileImageRepository profileImageRepository;
+
+    @Autowired
+    private TokenEncoder tokenEncoder;
+
+    @Autowired
+    private TokenDecoder tokenDecoder;
+
+    @Autowired
+    private BlackListTokenService blackListTokenService;
+
+    @Autowired
+    private JpaDeviceTokenRepository deviceTokenRepository;
+
+    @BeforeEach
+    void setUp() {
+        authenticationService = new AuthenticationService(
+                deviceTokenService,
+                소셜_회원_정보_제공자_묶음,
+                userRepository,
+                profileImageRepository,
+                tokenEncoder,
+                tokenDecoder,
+                blackListTokenService,
+                deviceTokenRepository
+        );
+
+        사용자 = User.builder()
+                  .name("kakao12345")
+                  .profileImage(new ProfileImage("upload.png", "store.png"))
+                  .reliability(0.0d)
+                  .oauthId("12345")
+                  .build();
+
+        탈퇴한_사용자 = User.builder()
+                  .name("kakao12346")
+                  .profileImage(new ProfileImage("upload.png", "store.png"))
+                  .reliability(0.0d)
+                  .oauthId("12346")
+                  .build();
+
+        userRepository.save(사용자);
+        userRepository.save(탈퇴한_사용자);
+
+        탈퇴한_사용자.withdrawal();
+
+        final DeviceToken deviceToken = new DeviceToken(사용자, 디바이스_토큰);
+        deviceTokenRepository.save(deviceToken);
+
+        유효한_리프레시_토큰 = tokenEncoder.encode(
+                LocalDateTime.now(),
+                TokenType.REFRESH,
+                Map.of("userId", 1L)
+        );
+
+        만료된_리프레시_토큰 = tokenEncoder.encode(
+                LocalDateTime.ofInstant(Instant.parse("2023-01-01T22:21:20Z"),  ZoneId.of("UTC")),
+                TokenType.REFRESH,
+                Map.of("userId", 1L)
+        );
+
+        만료된_소셜_로그인_토큰 = tokenEncoder.encode(
+                Instant.parse("2000-08-10T15:30:00Z").atZone(ZoneId.of("UTC")).toLocalDateTime(),
+                TokenType.ACCESS,
+                Map.of("userId", 1L)
+        );
+
+        유효한_액세스_토큰 = tokenEncoder.encode(
+                LocalDateTime.now(),
+                TokenType.ACCESS,
+                Map.of("userId", 1L)
+        );
+
+        탈퇴한_사용자_액세스_토큰 = tokenEncoder.encode(
+                LocalDateTime.now(),
+                TokenType.ACCESS,
+                Map.of("userId", 탈퇴한_사용자.getId())
+        );
+
+        이미지가_없는_사용자_액세스_토큰 = tokenEncoder.encode(
+                LocalDateTime.now(),
+                TokenType.ACCESS,
+                Map.of("userId", 가입하지_않은_사용자_회원_정보.id())
+        );
+
+        존재하지_않는_사용자_액세스_토큰 = tokenEncoder.encode(
+                LocalDateTime.now(),
+                TokenType.ACCESS,
+                Map.of("userId", -99999L)
+        );
+    }
+}

backend/ddang/src/test/java/com/ddang/ddang/authentication/application/fixture/AuthenticationUserServiceFixture.java

@@ -0,0 +1,39 @@
+package com.ddang.ddang.authentication.application.fixture;
+
+import com.ddang.ddang.image.domain.ProfileImage;
+import com.ddang.ddang.user.domain.User;
+import com.ddang.ddang.user.infrastructure.persistence.JpaUserRepository;
+import org.junit.jupiter.api.BeforeEach;
+import org.springframework.beans.factory.annotation.Autowired;
+
+@SuppressWarnings("NonAsciiCharacters")
+public class AuthenticationUserServiceFixture {
+
+    @Autowired
+    private JpaUserRepository userRepository;
+
+    protected User 사용자;
+    protected User 탈퇴한_사용자;
+
+    @BeforeEach
+    void setUp() {
+        사용자 = User.builder()
+                  .name("kakao12345")
+                  .profileImage(new ProfileImage("upload.png", "store.png"))
+                  .reliability(0.0d)
+                  .oauthId("12345")
+                  .build();
+
+        탈퇴한_사용자 = User.builder()
+                      .name("kakao12346")
+                      .profileImage(new ProfileImage("upload.png", "store.png"))
+                      .reliability(0.0d)
+                      .oauthId("12346")
+                      .build();
+
+        userRepository.save(사용자);
+        userRepository.save(탈퇴한_사용자);
+
+        탈퇴한_사용자.withdrawal();
+    }
+}

backend/ddang/src/test/java/com/ddang/ddang/authentication/infrastructure/jwt/JwtDecoderTest.java

@@ -3,67 +3,48 @@
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
-import com.ddang.ddang.authentication.configuration.JwtConfigurationProperties;
 import com.ddang.ddang.authentication.domain.TokenType;
 import com.ddang.ddang.authentication.domain.exception.InvalidTokenException;
-import java.time.LocalDateTime;
-import java.util.Map;
+import com.ddang.ddang.authentication.infrastructure.jwt.fixture.JwtDecoderFixture;
 import java.util.Optional;
-import org.junit.jupiter.api.BeforeEach;
+import org.assertj.core.api.SoftAssertions;
 import org.junit.jupiter.api.DisplayNameGeneration;
 import org.junit.jupiter.api.DisplayNameGenerator;
 import org.junit.jupiter.api.Test;
 
 @DisplayNameGeneration(DisplayNameGenerator.ReplaceUnderscores.class)
 @SuppressWarnings("NonAsciiCharacters")
-class JwtDecoderTest {
-
-    JwtDecoder jwtDecoder;
-
-    JwtEncoder jwtEncoder;
-
-    @BeforeEach
-    void setUp() {
-        final JwtConfigurationProperties jwtConfigurationProperties = new JwtConfigurationProperties(
-                "thisistoolargeaccesstokenkeyfordummykeydataforlocal",
-                "thisistoolargerefreshtokenkeyfordummykeydataforlocal",
-                12L,
-                1460L
-        );
-
-        jwtDecoder = new JwtDecoder(jwtConfigurationProperties);
-        jwtEncoder = new JwtEncoder(jwtConfigurationProperties);
-    }
+class JwtDecoderTest extends JwtDecoderFixture {
 
     @Test
     void 토큰의_길이가_유효하지_않다면_예외가_발생한다() {
         // given
-        final String invalidLengthToken = "abcde";
+        final JwtDecoder jwtDecoder = new JwtDecoder(토큰_설정);
 
         // when & then
-        assertThatThrownBy(() -> jwtDecoder.decode(TokenType.ACCESS, invalidLengthToken))
+        assertThatThrownBy(() -> jwtDecoder.decode(TokenType.ACCESS, 유효하지_않은_길이의_토큰))
                 .isInstanceOf(InvalidTokenException.class)
                 .hasMessage("Bearer 타입이 아니거나 유효한 토큰이 아닙니다.");
     }
 
     @Test
     void 토큰의_타입이_유효하지_않다면_예외가_발생한다() {
         // given
-        final String invalidTypeToken = "Basic12 abcde";
+        final JwtDecoder jwtDecoder = new JwtDecoder(토큰_설정);
 
         // when & then
-        assertThatThrownBy(() -> jwtDecoder.decode(TokenType.ACCESS, invalidTypeToken))
+        assertThatThrownBy(() -> jwtDecoder.decode(TokenType.ACCESS, 유효하지_않은_타입의_토큰))
                 .isInstanceOf(InvalidTokenException.class)
                 .hasMessage("Bearer 타입이 아닙니다.");
     }
 
     @Test
     void 토큰이_유효하지_않다면_빈_Optional을_반환한다() {
         // given
-        final String invalidToken = "Bearer adf";
+        final JwtDecoder jwtDecoder = new JwtDecoder(토큰_설정);
 
         // when
-        final Optional<PrivateClaims> actual = jwtDecoder.decode(TokenType.ACCESS, invalidToken);
+        final Optional<PrivateClaims> actual = jwtDecoder.decode(TokenType.ACCESS, 유효하지_않은_토큰);
 
         // then
         assertThat(actual).isEmpty();
@@ -72,13 +53,15 @@ void setUp() {
     @Test
     void 유효한_토큰이면_해당_토큰의_본문을_반환한다() {
         // given
-        final Map<String, Object> privateClaims = Map.of("userId", 1L);
-        final String accessToken = jwtEncoder.encode(LocalDateTime.now(), TokenType.ACCESS, privateClaims);
+        final JwtDecoder jwtDecoder = new JwtDecoder(토큰_설정);
 
         // when
-        final Optional<PrivateClaims> actual = jwtDecoder.decode(TokenType.ACCESS, accessToken);
+        final Optional<PrivateClaims> actual = jwtDecoder.decode(TokenType.ACCESS, 유효한_토큰);
 
         // then
-        assertThat(actual).isPresent();
+        SoftAssertions.assertSoftly(softAssertions -> {
+            softAssertions.assertThat(actual).isPresent();
+            softAssertions.assertThat(actual.get().userId()).isEqualTo(토큰_내용.get(회원_아이디_키));
+        });
     }
 }