Ignore: 🔧 Seperate Business Logic From DeviceTokenRegisterService

pennyway-domain/domain-service/src/main/java/kr/co/pennyway/domain/context/account/collection/DeviceTokenRegisterCollection.java

@@ -0,0 +1,112 @@
+package kr.co.pennyway.domain.context.account.collection;
+
+import kr.co.pennyway.domain.domains.device.domain.DeviceToken;
+import kr.co.pennyway.domain.domains.device.exception.DeviceTokenErrorCode;
+import kr.co.pennyway.domain.domains.device.exception.DeviceTokenErrorException;
+import kr.co.pennyway.domain.domains.user.domain.User;
+import kr.co.pennyway.domain.domains.user.exception.UserErrorCode;
+import kr.co.pennyway.domain.domains.user.exception.UserErrorException;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.lang.NonNull;
+
+import java.util.List;
+
+@Slf4j
+public class DeviceTokenRegisterCollection {
+    private final List<DeviceToken> userDeviceTokens;
+    private DeviceToken deviceToken;
+
+    public DeviceTokenRegisterCollection() {
+        this.deviceToken = null;
+        this.userDeviceTokens = List.of();
+    }
+
+    public DeviceTokenRegisterCollection(DeviceToken deviceToken) {
+        this.deviceToken = deviceToken;
+        this.userDeviceTokens = List.of();
+    }
+
+    /**
+     * @param userDeviceTokens :
+     */
+    public DeviceTokenRegisterCollection(DeviceToken deviceToken, List<DeviceToken> userDeviceTokens) {
+        this.deviceToken = deviceToken;
+        this.userDeviceTokens = userDeviceTokens;
+    }
+
+    /**
+     * 사용자의 디바이스 토큰을 생성하거나 갱신한다.
+     *
+     * <pre>
+     * [비즈니스 규칙]
+     * - 같은 {userId, deviceId}에 대해 새로운 토큰이 발급될 수 있지만, 활성화된 토큰은 하나여야 합니다.
+     * - {deviceId, token} 조합은 시스템 전체에서 유일해야 합니다.
+     * - device token이 이미 등록된 경우, 소유자 정보를 갱신하고 마지막 로그인 시간을 갱신한다.
+     * - device token이 등록되지 않은 경우, 새로운 device token을 생성한다.
+     * </pre>
+     *
+     * @param owner      User :   사용자 정보
+     * @param deviceId   String: 디바이스 식별자
+     * @param deviceName String: 디바이스 이름
+     * @param token      String: 디바이스 토큰
+     * @return {@link DeviceToken} 사용자의 기기로 등록된 Device 정보
+     * @throws UserErrorException        {@link UserErrorCode#NOT_FOUND} : 사용자 파라미터가 null인 경우
+     * @throws DeviceTokenErrorException {@link DeviceTokenErrorCode#DUPLICATED_DEVICE_TOKEN} : 이미 등록된 활성화 디바이스 토큰의 deviceId와 다른 deviceId가 들어온 경우
+     */
+    public DeviceToken register(User owner, @NonNull String deviceId, @NonNull String deviceName, @NonNull String token) {
+        if (owner == null) {
+            log.error("디바이스 토큰을 등록할 사용자 정보가 없습니다.");
+            throw new UserErrorException(UserErrorCode.NOT_FOUND);
+        }
+
+        DeviceToken existingDeviceToken = this.getDeviceTokenByToken(token);
+
+        return (existingDeviceToken != null)
+                ? this.updateDevice(owner, deviceId, existingDeviceToken)
+                : this.createDevice(owner, deviceId, deviceName, token);
+    }
+
+    private DeviceToken getDeviceTokenByToken(String token) {
+        if (this.deviceToken != null && this.deviceToken.getToken().equals(token)) {
+            return this.deviceToken;
+        }
+
+        return null;
+    }
+
+    private DeviceToken updateDevice(User user, String deviceId, DeviceToken originalDeviceToken) {
+        if (isDuplicatedDeviceToken(deviceId, originalDeviceToken)) {
+            log.error("활성화된 토큰을 다른 디바이스에서 사용 중입니다.");
+            throw new DeviceTokenErrorException(DeviceTokenErrorCode.DUPLICATED_DEVICE_TOKEN);
+        }
+
+        originalDeviceToken.handleOwner(user, deviceId);
+        log.info("디바이스 토큰이 갱신되었습니다. deviceId: {}, token: {}", deviceId, originalDeviceToken.getToken());
+
+        return originalDeviceToken;
+    }
+
+    private boolean isDuplicatedDeviceToken(String deviceId, DeviceToken originalDeviceToken) {
+        return !originalDeviceToken.getDeviceId().equals(deviceId) && originalDeviceToken.isActivated();
+    }
+
+    private DeviceToken createDevice(User user, String deviceId, String deviceName, String token) {
+        this.deviceToken = DeviceToken.of(token, deviceId, deviceName, user);
+        log.info("새로운 디바이스 토큰이 생성되었습니다. deviceId: {}, token: {}", deviceId, token);
+
+        deactivateExistingTokens();
+
+        return this.deviceToken;
+    }
+
+    /**
+     * 특정 사용자의 디바이스에 대한 기존 활성 토큰들을 비활성화합니다.
+     * 새로운 토큰 등록 시 호출되어 하나의 디바이스에 하나의 활성 토큰만 존재하도록 보장합니다.
+     */
+    private void deactivateExistingTokens() {
+        userDeviceTokens.stream()
+                .filter(token -> token.getDeviceId().equals(deviceToken.getDeviceId()))
+                .filter(DeviceToken::isActivated)
+                .forEach(DeviceToken::deactivate);
+    }
+}

pennyway-domain/domain-service/src/main/java/kr/co/pennyway/domain/context/account/service/DeviceTokenRegisterService.java

@@ -1,19 +1,17 @@
 package kr.co.pennyway.domain.context.account.service;
 
 import kr.co.pennyway.common.annotation.DomainService;
+import kr.co.pennyway.domain.context.account.collection.DeviceTokenRegisterCollection;
 import kr.co.pennyway.domain.domains.device.domain.DeviceToken;
-import kr.co.pennyway.domain.domains.device.exception.DeviceTokenErrorCode;
-import kr.co.pennyway.domain.domains.device.exception.DeviceTokenErrorException;
 import kr.co.pennyway.domain.domains.device.service.DeviceTokenRdbService;
 import kr.co.pennyway.domain.domains.user.domain.User;
-import kr.co.pennyway.domain.domains.user.exception.UserErrorCode;
-import kr.co.pennyway.domain.domains.user.exception.UserErrorException;
 import kr.co.pennyway.domain.domains.user.service.UserRdbService;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.transaction.annotation.Transactional;
 
 import java.util.List;
+import java.util.Optional;
 
 @Slf4j
 @DomainService
@@ -25,14 +23,6 @@ public class DeviceTokenRegisterService {
     /**
      * 사용자의 디바이스 토큰을 생성하거나 갱신한다.
      *
-     * <pre>
-     * [비즈니스 규칙]
-     * - 같은 {userId, deviceId}에 대해 새로운 토큰이 발급될 수 있지만, 활성화된 토큰은 하나여야 합니다.
-     * - {deviceId, token} 조합은 시스템 전체에서 유일해야 합니다.
-     * - device token이 이미 등록된 경우, 소유자 정보를 갱신하고 마지막 로그인 시간을 갱신한다.
-     * - device token이 등록되지 않은 경우, 새로운 device token을 생성한다.
-     * </pre>
-     *
      * @param userId      사용자 식별자
      * @param deviceId    디바이스 식별자
      * @param deviceName  디바이스 이름
@@ -41,47 +31,15 @@ public class DeviceTokenRegisterService {
      */
     @Transactional
     public DeviceToken execute(Long userId, String deviceId, String deviceName, String deviceToken) {
-        User user = userRdbService.readUser(userId).orElseThrow(() -> new UserErrorException(UserErrorCode.NOT_FOUND));
-
-        return getOrCreateDevice(user, deviceId, deviceName, deviceToken);
-    }
-
-    /**
-     * 사용자의 디바이스 토큰을 생성합니다.
-     * 만약, 이미 등록된 디바이스 토큰이 존재한다면, 해당 토큰을 갱신하고 반환합니다.
-     */
-    private DeviceToken getOrCreateDevice(User user, String deviceId, String deviceName, String deviceToken) {
-        return deviceTokenRdbService.readDeviceByToken(deviceToken)
-                .map(originalDeviceToken -> updateDevice(user, deviceId, originalDeviceToken))
-                .orElseGet(() -> createDevice(user, deviceId, deviceName, deviceToken));
-    }
-
-    private DeviceToken updateDevice(User user, String deviceId, DeviceToken originalDeviceToken) {
-        if (!originalDeviceToken.getDeviceId().equals(deviceId) && originalDeviceToken.isActivated()) {
-            throw new DeviceTokenErrorException(DeviceTokenErrorCode.DUPLICATED_DEVICE_TOKEN);
-        }
-
-        originalDeviceToken.handleOwner(user, deviceId);
-        return originalDeviceToken;
-    }
-
-    private DeviceToken createDevice(User user, String deviceId, String deviceName, String deviceToken) {
-        deactivateExistingTokens(user.getId(), deviceId);
+        Optional<User> user = userRdbService.readUser(userId);
+        Optional<DeviceToken> existingDeviceToken = deviceTokenRdbService.readDeviceByToken(deviceToken);
+        List<DeviceToken> userDeviceTokens = deviceTokenRdbService.readByUserIdAndDeviceId(userId, deviceId);
 
-        DeviceToken newDeviceToken = DeviceToken.of(deviceToken, deviceId, deviceName, user);
+        DeviceToken newDeviceToken = new DeviceTokenRegisterCollection(
+                existingDeviceToken.orElse(null),
+                userDeviceTokens
+        ).register(user.orElse(null), deviceId, deviceName, deviceToken);
 
         return deviceTokenRdbService.createDevice(newDeviceToken);
     }
-
-    /**
-     * 특정 사용자의 디바이스에 대한 기존 활성 토큰들을 비활성화합니다.
-     * 새로운 토큰 등록 시 호출되어 하나의 디바이스에 하나의 활성 토큰만 존재하도록 보장합니다.
-     */
-    private void deactivateExistingTokens(Long userId, String deviceId) {
-        List<DeviceToken> userDeviceTokens = deviceTokenRdbService.readByUserIdAndDeviceId(userId, deviceId);
-
-        userDeviceTokens.stream()
-                .filter(DeviceToken::isActivated)
-                .forEach(DeviceToken::deactivate);
-    }
 }

pennyway-domain/domain-service/src/test/java/kr/co/pennyway/domain/context/account/integration/DeviceTokenRegisterServiceIntegrationTest.java

@@ -27,6 +27,8 @@
 import org.springframework.test.context.ActiveProfiles;
 import org.springframework.transaction.annotation.Transactional;
 
+import java.util.List;
+
 import static org.junit.jupiter.api.Assertions.*;
 
 @Slf4j
@@ -53,29 +55,62 @@ void setUp() {
         savedUser = userRepository.save(UserFixture.GENERAL_USER.toUser());
     }
 
+    @Test
+    @DisplayName("새로운 토큰 등록 요청 시 디바이스 토큰이 정상적으로 저장됩니다")
+    void when_registering_new_token_then_save_successfully() {
+        // given
+        String deviceId = "newDevice";
+        String token = "newToken";
+
+        // when
+        DeviceToken result = deviceTokenRegisterService.execute(savedUser.getId(), deviceId, "Android", token);
+
+        // then
+        // 1. 반환된 결과 검증
+        assertEquals(token, result.getToken());
+        assertEquals(deviceId, result.getDeviceId());
+        assertEquals(savedUser.getId(), result.getUser().getId());
+        assertTrue(result.isActivated());
+
+        // 2. 실제 DB 저장 여부 검증
+        DeviceToken savedToken = deviceTokenRepository.findById(result.getId())
+                .orElseThrow(() -> new IllegalStateException("저장된 토큰을 찾을 수 없습니다."));
+
+        assertEquals(token, savedToken.getToken());
+        assertEquals(deviceId, savedToken.getDeviceId());
+        assertEquals(savedUser.getId(), savedToken.getUser().getId());
+        assertTrue(savedToken.isActivated());
+    }
+
     @Test
     @Transactional
-    @DisplayName("디바이스 토큰 등록 시 기존 활성 토큰은 비활성화됩니다")
-    void shouldDeactivateExistingTokensWhenRegisteringNew() {
+    @DisplayName("사용자가 동일한 디바이스에 새로운 토큰을 등록하면 기존 토큰이 비활성화됩니다")
+    void when_registering_new_token_for_same_device_then_deactivate_existing_token() {
         // given
         String deviceId = "device1";
+        DeviceToken firstToken = deviceTokenRepository.save(DeviceToken.of("token1", deviceId, "Android", savedUser));
 
         // when
-        DeviceToken firstToken = deviceTokenRegisterService.execute(savedUser.getId(), deviceId, "Android", "token1");
         DeviceToken secondToken = deviceTokenRegisterService.execute(savedUser.getId(), deviceId, "Android", "token2");
 
         // then
         assertFalse(firstToken.isActivated());
         assertTrue(secondToken.isActivated());
+        assertEquals(deviceId, secondToken.getDeviceId());
+
+        // DB에 실제로 저장되었는지 확인
+        List<DeviceToken> savedTokens = deviceTokenRepository.findAllByUser_Id(savedUser.getId());
+        assertEquals(2, savedTokens.size());
+        assertEquals(1L, savedTokens.stream().filter(DeviceToken::isActivated).count(), "활성화된 토큰은 1개여야 합니다");
     }
 
     @Test
     @Transactional
-    @DisplayName("활성화된 토큰이 다른 디바이스에서 사용되면 예외가 발생합니다")
-    void shouldThrowExceptionWhenActiveTokenIsUsedOnDifferentDevice() {
+    @DisplayName("활성화된 토큰을 다른 디바이스에서 사용하려고 하면 예외가 발생합니다")
+    void when_using_active_token_on_different_device_then_throw_exception() {
         // given
         String token = "token1";
-        deviceTokenRegisterService.execute(savedUser.getId(), "device1", "Android", token);
+        deviceTokenRepository.save(DeviceToken.of(token, "device1", "iPhone", savedUser));
 
         // when & then
         DeviceTokenErrorException exception = assertThrowsExactly(
@@ -86,6 +121,7 @@ void shouldThrowExceptionWhenActiveTokenIsUsedOnDifferentDevice() {
     }
 
     @Test
+    @Transactional
     @DisplayName("같은 deviceId, token / 다른 사용자 갱신 요청이라면, 디바이스 토큰의 소유권이 다른 사용자에게 이전됩니다")
     void shouldTransferTokenOwnership() {
         // given
@@ -94,13 +130,45 @@ void shouldTransferTokenOwnership() {
         String deviceId = "device1";
         String token = "token1";
 
+        DeviceToken firstUserToken = deviceTokenRepository.save(DeviceToken.of(token, deviceId, "Android", savedUser));
+
         // when
-        DeviceToken firstUserToken = deviceTokenRegisterService.execute(savedUser.getId(), deviceId, "Android", token);
         DeviceToken secondUserToken = deviceTokenRegisterService.execute(anotherUser.getId(), deviceId, "Android", token);
 
         // then
         assertEquals(firstUserToken.getId(), secondUserToken.getId());
         assertEquals(anotherUser.getId(), secondUserToken.getUser().getId());
         assertTrue(secondUserToken.isActivated());
+
+        List<DeviceToken> firstUserTokens = deviceTokenRepository.findAllByUser_Id(savedUser.getId());
+        List<DeviceToken> secondUserTokens = deviceTokenRepository.findAllByUser_Id(anotherUser.getId());
+
+        assertTrue(firstUserTokens.isEmpty(), "첫 번째 사용자의 토큰이 없어야 합니다");
+        assertEquals(1, secondUserTokens.size(), "두 번째 사용자의 토큰이 1개 있어야 합니다");
+    }
+
+    @Test
+    @DisplayName("사용자는 여러 기기에 서로 다른 토큰을 등록할 수 있습니다")
+    void when_user_registers_multiple_devices_then_allow_different_tokens() {
+        // given
+        String device1Token = "token1";
+        String device2Token = "token2";
+
+        // when
+        DeviceToken result1 = deviceTokenRegisterService.execute(savedUser.getId(), "device1", "Android", device1Token);
+        DeviceToken result2 = deviceTokenRegisterService.execute(savedUser.getId(), "device2", "iPhone", device2Token);
+
+        // then
+        assertTrue(result1.isActivated());
+        assertTrue(result2.isActivated());
+        assertNotEquals(result1.getDeviceId(), result2.getDeviceId());
+        assertNotEquals(result1.getToken(), result2.getToken());
+
+        // DB에 실제로 저장되었는지 확인
+        List<DeviceToken> savedTokens = deviceTokenRepository.findAllByUser_Id(savedUser.getId());
+        assertEquals(2, savedTokens.size());
+        assertTrue(savedTokens.stream().allMatch(DeviceToken::isActivated));
+
+        deviceTokenRepository.deleteAll(savedTokens);
     }
 }