round1: 리뷰 적용

포인트 1:1로 관계 수정
도메인 분리(User.currentPoint 제거)

Author: JVHE

apps/commerce-api/src/main/java/com/loopers/application/point/PointFacade.java

@@ -1,24 +1,32 @@
 package com.loopers.application.point;
 
 import com.loopers.domain.point.PointService;
+import com.loopers.domain.user.User;
 import com.loopers.domain.user.UserService;
 import com.loopers.support.error.CoreException;
 import com.loopers.support.error.ErrorType;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
 
 @RequiredArgsConstructor
 @Component
 public class PointFacade {
-    private final UserService userService;
     private final PointService pointService;
+    private final UserService userService;
 
+    @Transactional(readOnly = true)
     public Long getCurrentPoint(String userId) {
-        return userService.getCurrentPoint(userId)
+        User user = userService.findByUserId(userId).orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "사용자를 찾을 수 없습니다."));
+
+        return pointService.getCurrentPoint(user.getId())
                 .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "사용자를 찾을 수 없습니다."));
     }
 
-    public Long chargePoints(String userId, int amount) {
-        return pointService.chargePoint(userId, amount);
+    @Transactional
+    public Long chargePoint(String userId, int amount) {
+        User user = userService.findByUserIdForUpdate(userId).orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "사용자를 찾을 수 없습니다."));
+
+        return pointService.chargePoint(user.getId(), amount);
     }
 }

apps/commerce-api/src/main/java/com/loopers/application/user/UserFacade.java

@@ -1,21 +1,26 @@
 package com.loopers.application.user;
 
+import com.loopers.domain.point.PointService;
 import com.loopers.domain.user.User;
 import com.loopers.domain.user.UserService;
 import com.loopers.support.error.CoreException;
 import com.loopers.support.error.ErrorType;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Component;
+import org.springframework.transaction.annotation.Transactional;
 
 import java.util.Optional;
 
 @RequiredArgsConstructor
 @Component
 public class UserFacade {
     private final UserService userService;
+    private final PointService pointService;
 
+    @Transactional
     public UserInfo registerUser(String userId, String email, String birthday, String gender) {
         User registeredUser = userService.registerUser(userId, email, birthday, gender);
+        pointService.createPoint(registeredUser.getId());
         return UserInfo.from(registeredUser);
     }
 

apps/commerce-api/src/main/java/com/loopers/domain/point/Point.java

@@ -1,37 +1,38 @@
 package com.loopers.domain.point;
 
 import com.loopers.domain.BaseEntity;
-import com.loopers.domain.user.User;
 import com.loopers.support.error.CoreException;
 import com.loopers.support.error.ErrorType;
+import jakarta.persistence.Column;
 import jakarta.persistence.Entity;
-import jakarta.persistence.JoinColumn;
-import jakarta.persistence.ManyToOne;
 import jakarta.persistence.Table;
 import lombok.Getter;
 
 @Entity
 @Table(name = "point")
 @Getter
 public class Point extends BaseEntity {
-    @ManyToOne
-    @JoinColumn(referencedColumnName = "id", nullable = false, updatable = false)
-    private User user;
+    @Column(name = "user_id", nullable = false, updatable = false, unique = true)
+    private Long userId;
     private Long amount;
 
     protected Point() {
     }
 
-    private Point(User user, Long amount) {
-        this.user = user;
+    private Point(Long userId, Long amount) {
+        this.userId = userId;
         this.amount = amount;
     }
 
-    public static Point create(User user, int amount) {
+    public static Point create(Long userId) {
+        return new Point(userId, 0L);
+    }
+
+    public void charge(int amount) {
         if (amount <= 0) {
             throw new CoreException(ErrorType.BAD_REQUEST, "충전 포인트는 0보다 커야 합니다.");
         }
 
-        return new Point(user, (long) amount);
+        this.amount += amount;
     }
 }

apps/commerce-api/src/main/java/com/loopers/domain/point/PointJpaRepository.java

@@ -3,7 +3,10 @@
 import org.springframework.data.jpa.repository.JpaRepository;
 import org.springframework.stereotype.Repository;
 
+import java.util.Optional;
+
 @Repository
 public interface PointJpaRepository extends JpaRepository<Point, Long> {
 
+    Optional<Point> findByUserId(Long userId);
 }

apps/commerce-api/src/main/java/com/loopers/domain/point/PointService.java

@@ -1,28 +1,35 @@
 package com.loopers.domain.point;
 
-import com.loopers.domain.user.User;
-import com.loopers.domain.user.UserService;
 import com.loopers.support.error.CoreException;
 import com.loopers.support.error.ErrorType;
 import lombok.RequiredArgsConstructor;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
+import java.util.Optional;
+
 @RequiredArgsConstructor
 @Service
 public class PointService {
     private final PointJpaRepository pointJpaRepository;
-    private final UserService userService;
 
     @Transactional
-    public Long chargePoint(String userId, int amount) {
-        User user = userService.findByUserIdForUpdate(userId).orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "사용자를 찾을 수 없습니다."));
-
-        Point point = Point.create(user, amount);
+    public void createPoint(Long userId) {
+        Point point = Point.create(userId);
+        pointJpaRepository.save(point);
+    }
 
-        user.setCurrentPoint(user.getCurrentPoint() + amount);
+    @Transactional
+    public Long chargePoint(Long userId, int amount) {
+        Point point = pointJpaRepository.findByUserId(userId)
+                .orElseThrow(() -> new CoreException(ErrorType.NOT_FOUND, "포인트 정보를 찾을 수 없습니다."));
+        point.charge(amount);
         pointJpaRepository.save(point);
+        return point.getAmount();
+    }
 
-        return user.getCurrentPoint();
+    @Transactional(readOnly = true)
+    public Optional<Long> getCurrentPoint(Long userId) {
+        return pointJpaRepository.findByUserId(userId).map(Point::getAmount);
     }
 }

apps/commerce-api/src/main/java/com/loopers/domain/user/User.java

@@ -7,7 +7,6 @@
 import jakarta.persistence.Entity;
 import jakarta.persistence.Table;
 import lombok.Getter;
-import lombok.Setter;
 import org.apache.commons.lang3.StringUtils;
 
 @Entity
@@ -22,8 +21,6 @@ protected User() {
     private String email;
     private String birthday;
     private String gender;
-    @Setter
-    private Long currentPoint = 0L;
 
     private User(String userId, String email, String birthday, String gender) {
         this.userId = userId;

apps/commerce-api/src/main/java/com/loopers/domain/user/UserService.java

@@ -33,8 +33,5 @@ public Optional<User> findByUserId(String userId) {
     public Optional<User> findByUserIdForUpdate(String userId) {
         return userJpaRepository.findByUserIdForUpdate(userId);
     }
-    @Transactional(readOnly = true)
-    public Optional<Long> getCurrentPoint(String userId) {
-        return findByUserId(userId).map(User::getCurrentPoint);
-    }
+
 }

apps/commerce-api/src/main/java/com/loopers/interfaces/api/point/PointV1Controller.java

@@ -34,7 +34,7 @@ public ApiResponse<PointV1Dto.PointResponse> chargeUserPoints(
         if (StringUtils.isBlank(userId)) {
             throw new CoreException(ErrorType.BAD_REQUEST);
         }
-        Long chargedPoint = pointFacade.chargePoints(userId, request.amount());
+        Long chargedPoint = pointFacade.chargePoint(userId, request.amount());
         PointV1Dto.PointResponse response = PointV1Dto.PointResponse.from(chargedPoint);
         return ApiResponse.success(response);
     }

apps/commerce-api/src/test/java/com/loopers/domain/point/PointModelTest.java

@@ -1,6 +1,5 @@
 package com.loopers.domain.point;
 
-import com.loopers.domain.user.User;
 import com.loopers.support.error.CoreException;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Nested;
@@ -20,15 +19,9 @@ class Create {
         @ValueSource(ints = {0, -10, -100})
         void throwsException_whenPointIsZeroOrNegative(int invalidPoint) {
             // arrange
-            String validId = "user123";
-            String validEmail = "xx@yy.zz";
-            String validBirthday = "1993-03-13";
-            String validGender = "male";
-
-            User user = User.create(validId, validEmail, validBirthday, validGender);
-
+            Point point = Point.create(0L);
             // act
-            CoreException result = assertThrows(CoreException.class, () -> Point.create(user, invalidPoint));
+            CoreException result = assertThrows(CoreException.class, () -> point.charge(invalidPoint));
 
             // assert
             assertThat(result.getMessage()).isEqualTo("충전 포인트는 0보다 커야 합니다.");

apps/commerce-api/src/test/java/com/loopers/domain/point/PointServiceIntegrationTest.java

@@ -1,19 +1,68 @@
 package com.loopers.domain.point;
 
+import com.loopers.application.point.PointFacade;
+import com.loopers.domain.user.User;
+import com.loopers.domain.user.UserService;
 import com.loopers.support.error.CoreException;
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.boot.test.context.SpringBootTest;
 import org.springframework.transaction.annotation.Transactional;
 
+import java.util.Optional;
+
+import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
 @SpringBootTest
 @Transactional
 public class PointServiceIntegrationTest {
+    @Autowired
+    private PointFacade pointFacade;
     @Autowired
     private PointService pointService;
+    @Autowired
+    private UserService userService;
+
+    @BeforeEach
+    void setUp() {
+        String validId = "user123";
+        String validEmail = "xx@yy.zz";
+        String validBirthday = "1993-03-13";
+        String validGender = "male";
+        // 유저 등록
+        User registeredUser = userService.registerUser(validId, validEmail, validBirthday, validGender);
+        pointService.createPoint(registeredUser.getId());
+    }
+
+    @DisplayName("해당 ID 의 회원이 존재할 경우, 보유 포인트가 반환된다.")
+    @Test
+    void returnsUserPoints_whenUserExists() {
+        // arrange: setUp() 메서드에서 이미 유저 등록
+        String existingUserId = "user123";
+        Long userId = userService.findByUserId(existingUserId).get().getId();
+
+        // act
+        Optional<Long> currentPoint = pointService.getCurrentPoint(userId);
+
+        // assert
+        assertThat(currentPoint.orElse(null)).isEqualTo(0L);
+    }
+
+    @DisplayName("해당 ID 의 회원이 존재하지 않을 경우, null 이 반환된다.")
+    @Test
+    void returnsNullPoints_whenUserDoesNotExist() {
+        // arrange: setUp() 메서드에서 등록되지 않은 유저 ID 사용
+        Long nonExistingUserId = -1L;
+
+        // act
+        Optional<Long> currentPoint = pointService.getCurrentPoint(nonExistingUserId);
+
+        // assert
+        assertThat(currentPoint).isNotPresent();
+    }
 
     //존재하지 않는 유저 ID 로 충전을 시도한 경우, 실패한다.
     @DisplayName("존재하지 않는 유저 ID 로 충전을 시도한 경우, 실패한다.")
@@ -24,7 +73,6 @@ void throwsExceptionWhenChargePointWithNonExistingUserId() {
         int chargeAmount = 1000;
 
         // act & assert
-        assertThrows(CoreException.class, () -> pointService.chargePoint(nonExistingUserId, chargeAmount));
+        assertThrows(CoreException.class, () -> pointFacade.chargePoint(nonExistingUserId, chargeAmount));
     }
-
 }