SCRUM-77 사용자 예약 API 리팩토링

api-user/src/main/java/com/wellmeet/reservation/ReservationService.java

@@ -29,7 +29,7 @@ public CreateReservationResponse reserve(Long memberId, CreateReservationRequest
                 request.getRestaurantId());
         reservationDomainService.alreadyReserved(memberId, request.getRestaurantId(), request.getAvailableDateId());
         Member member = memberDomainService.getById(memberId);
-        availableDate.reduceCapacity(request.getPartySize());
+        restaurantDomainService.decreaseAvailableDateCapacity(availableDate, request.getPartySize());
         Reservation reservation = request.toDomain(availableDate.getRestaurant(), availableDate, member);
 
         Reservation savedReservation = reservationDomainService.save(reservation);
@@ -60,8 +60,9 @@ public CreateReservationResponse updateReservation(
         AvailableDate availableDate = restaurantDomainService.getAvailableDate(request.getAvailableDateId(),
                 request.getRestaurantId());
         Reservation reservation = reservationDomainService.getByIdAndMemberId(reservationId, memberId);
-        availableDate.increaseCapacity(reservation.getPartySize());
-        availableDate.reduceCapacity(request.getPartySize());
+        restaurantDomainService.increaseAvailableDateCapacity(reservation.getAvailableDate(),
+                reservation.getPartySize());
+        restaurantDomainService.decreaseAvailableDateCapacity(availableDate, request.getPartySize());
         reservation.update(
                 availableDate,
                 request.getPartySize(),

api-user/src/test/java/com/wellmeet/BaseServiceTest.java

@@ -0,0 +1,89 @@
+package com.wellmeet;
+
+import com.wellmeet.domain.reservation.repository.ReservationRepository;
+import com.wellmeet.domain.restaurant.availabledate.repository.AvailableDateRepository;
+import com.wellmeet.fixture.AvailableDateGenerator;
+import com.wellmeet.fixture.MemberGenerator;
+import com.wellmeet.fixture.MenuGenerator;
+import com.wellmeet.fixture.OwnerGenerator;
+import com.wellmeet.fixture.ReservationGenerator;
+import com.wellmeet.fixture.RestaurantGenerator;
+import com.wellmeet.fixture.ReviewGenerator;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.boot.test.context.SpringBootTest;
+
+@ExtendWith(DataBaseCleaner.class)
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.NONE)
+public abstract class BaseServiceTest {
+
+    @Autowired
+    protected AvailableDateGenerator availableDateGenerator;
+
+    @Autowired
+    protected ReservationGenerator reservationGenerator;
+
+    @Autowired
+    protected MemberGenerator memberGenerator;
+
+    @Autowired
+    protected OwnerGenerator ownerGenerator;
+
+    @Autowired
+    protected RestaurantGenerator restaurantGenerator;
+
+    @Autowired
+    protected MenuGenerator menuGenerator;
+
+    @Autowired
+    protected ReviewGenerator reviewGenerator;
+
+    @Autowired
+    protected ReservationRepository reservationRepository;
+
+    @Autowired
+    protected AvailableDateRepository availableDateRepository;
+
+    protected void runAtSameTime(int count, Runnable task) throws InterruptedException {
+        ExecutorService executorService = Executors.newFixedThreadPool(count);
+        CountDownLatch latch = new CountDownLatch(count);
+        for (int i = 0; i < count; i++) {
+            executorService.submit(() -> {
+                try {
+                    task.run();
+                } catch (Exception e) {
+                    e.printStackTrace();
+                    throw new RuntimeException(e);
+                } finally {
+                    latch.countDown();
+                }
+            });
+        }
+        latch.await();
+        executorService.shutdown();
+    }
+
+    protected void runAtSameTime(List<Runnable> tasks) throws InterruptedException {
+        int size = tasks.size();
+        ExecutorService executorService = Executors.newFixedThreadPool(size);
+        CountDownLatch latch = new CountDownLatch(size);
+        for (Runnable task : tasks) {
+            executorService.submit(() -> {
+                try {
+                    task.run();
+                } catch (Exception e) {
+                    e.printStackTrace();
+                    throw new RuntimeException(e);
+                } finally {
+                    latch.countDown();
+                }
+            });
+        }
+        latch.await();
+        executorService.shutdown();
+    }
+}

api-user/src/test/java/com/wellmeet/reservation/ReservationServiceTest.java

@@ -0,0 +1,78 @@
+package com.wellmeet.reservation;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertAll;
+
+import com.wellmeet.BaseServiceTest;
+import com.wellmeet.domain.member.entity.Member;
+import com.wellmeet.domain.owner.entity.Owner;
+import com.wellmeet.domain.reservation.entity.Reservation;
+import com.wellmeet.domain.restaurant.availabledate.entity.AvailableDate;
+import com.wellmeet.domain.restaurant.entity.Restaurant;
+import com.wellmeet.reservation.dto.CreateReservationRequest;
+import java.time.LocalDateTime;
+import java.util.ArrayList;
+import java.util.List;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+
+class ReservationServiceTest extends BaseServiceTest {
+
+    @Autowired
+    private ReservationService reservationService;
+
+    @Nested
+    class Reserve {
+
+        @Test
+        void 한_사람이_같은_예약_요청을_동시에_여러번_신청해도_한_번만_처리된다() throws InterruptedException {
+            Owner owner1 = ownerGenerator.generate("owner1");
+            Restaurant restaurant1 = restaurantGenerator.generate("restaurant1", owner1);
+            int capacity = 100;
+            AvailableDate availableDate = availableDateGenerator.generate(LocalDateTime.now().plusDays(1), capacity,
+                    restaurant1);
+            int partySize = 4;
+            CreateReservationRequest request = new CreateReservationRequest(
+                    restaurant1.getId(), availableDate.getId(), partySize, "request"
+            );
+            Member member = memberGenerator.generate("test");
+
+            runAtSameTime(500, () -> reservationService.reserve(member.getId(), request));
+            List<Reservation> reservations = reservationRepository.findAll();
+            AvailableDate foundAvailableDate = availableDateRepository.findById(availableDate.getId()).get();
+
+            assertAll(
+                    () -> assertThat(reservations).hasSize(1),
+                    () -> assertThat(foundAvailableDate.getMaxCapacity()).isEqualTo(capacity - partySize)
+            );
+        }
+
+        @Test
+        void 여러_사람이_예약_요청을_동시에_신청해도_적절히_처리된다() throws InterruptedException {
+            Owner owner1 = ownerGenerator.generate("owner1");
+            Restaurant restaurant1 = restaurantGenerator.generate("restaurant1", owner1);
+            int capacity = 100;
+            AvailableDate availableDate = availableDateGenerator.generate(LocalDateTime.now().plusDays(1), capacity,
+                    restaurant1);
+            int partySize = 2;
+            CreateReservationRequest request = new CreateReservationRequest(
+                    restaurant1.getId(), availableDate.getId(), partySize, "request"
+            );
+            List<Runnable> tasks = new ArrayList<>();
+            for (int i = 0; i < 500; i++) {
+                Member member = memberGenerator.generate("member" + i);
+                tasks.add(() -> reservationService.reserve(member.getId(), request));
+            }
+
+            runAtSameTime(tasks);
+            List<Reservation> reservations = reservationRepository.findAll();
+            AvailableDate foundAvailableDate = availableDateRepository.findById(availableDate.getId()).get();
+
+            assertAll(
+                    () -> assertThat(reservations).hasSize(50),
+                    () -> assertThat(foundAvailableDate.getMaxCapacity()).isZero()
+            );
+        }
+    }
+}

api-user/src/test/resources/application.yml

@@ -14,13 +14,13 @@ spring:
     username: root
     password:
   jpa:
-    show-sql: true
+    #    show-sql: true
     properties:
       hibernate:
-        format_sql: true
+        #        format_sql: true
         dialect: org.hibernate.dialect.MySQLDialect
     hibernate:
-      ddl-auto: create-drop
+      ddl-auto: create
     defer-datasource-initialization: true
 
 cors:

domain/src/main/java/com/wellmeet/domain/restaurant/RestaurantDomainService.java

@@ -53,4 +53,15 @@ public List<Menu> getMenuByRestaurantId(String restaurantId) {
     public AvailableDate getAvailableDate(Long availableDateId, String restaurantId) {
         return availableDateDomainService.getByIdAndRestaurantId(availableDateId, restaurantId);
     }
+
+    public void decreaseAvailableDateCapacity(AvailableDate availableDate, int partySize) {
+        if (availableDate.canNotReserve(partySize)) {
+            throw new RestaurantException(RestaurantErrorCode.NOT_ENOUGH_CAPACITY);
+        }
+        availableDateDomainService.decreaseCapacity(availableDate, partySize);
+    }
+
+    public void increaseAvailableDateCapacity(AvailableDate availableDate, int partySize) {
+        availableDateDomainService.increaseCapacity(availableDate, partySize);
+    }
 }

domain/src/main/java/com/wellmeet/domain/restaurant/availabledate/AvailableDateDomainService.java

@@ -22,4 +22,15 @@ public AvailableDate getByIdAndRestaurantId(Long id, String restaurantId) {
         return availableDateRepository.findByIdAndRestaurantId(id, restaurantId)
                 .orElseThrow(() -> new RestaurantException(RestaurantErrorCode.AVAILABLE_DATE_NOT_FOUND));
     }
+
+    public void decreaseCapacity(AvailableDate availableDate, int partySize) {
+        int row = availableDateRepository.decreaseCapacity(availableDate.getId(), partySize);
+        if (row == 0) {
+            throw new RestaurantException(RestaurantErrorCode.NOT_ENOUGH_CAPACITY);
+        }
+    }
+
+    public void increaseCapacity(AvailableDate availableDate, int partySize) {
+        availableDateRepository.increaseCapacity(availableDate.getId(), partySize);
+    }
 }

domain/src/main/java/com/wellmeet/domain/restaurant/availabledate/entity/AvailableDate.java

@@ -2,8 +2,6 @@
 
 import com.wellmeet.domain.common.BaseEntity;
 import com.wellmeet.domain.restaurant.entity.Restaurant;
-import com.wellmeet.domain.restaurant.exception.RestaurantErrorCode;
-import com.wellmeet.domain.restaurant.exception.RestaurantException;
 import jakarta.persistence.Column;
 import jakarta.persistence.Entity;
 import jakarta.persistence.FetchType;
@@ -51,14 +49,8 @@ public AvailableDate(LocalDate date, LocalTime time, int maxCapacity, Restaurant
         this.restaurant = restaurant;
     }
 
-    public void reduceCapacity(int partySize) {
-        if (maxCapacity < partySize) {
-            throw new RestaurantException(RestaurantErrorCode.NOT_ENOUGH_CAPACITY);
-        }
-        maxCapacity -= partySize;
-        if (maxCapacity == 0) {
-            isAvailable = false;
-        }
+    public boolean canNotReserve(int partySize) {
+        return !isAvailable || maxCapacity < partySize;
     }
 
     public void increaseCapacity(int partySize) {

domain/src/main/java/com/wellmeet/domain/restaurant/availabledate/repository/AvailableDateRepository.java

@@ -4,6 +4,9 @@
 import java.util.List;
 import java.util.Optional;
 import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Modifying;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
 import org.springframework.stereotype.Repository;
 
 @Repository
@@ -12,4 +15,15 @@ public interface AvailableDateRepository extends JpaRepository<AvailableDate, Lo
     List<AvailableDate> findAllByRestaurantId(String restaurantId);
 
     Optional<AvailableDate> findByIdAndRestaurantId(Long id, String restaurantId);
+
+    @Modifying
+    @Query("update AvailableDate a "
+            + "set a.maxCapacity = a.maxCapacity - :partySize, "
+            + "a.isAvailable = case when (a.maxCapacity - :partySize) = 0 then false else a.isAvailable end "
+            + "where a.id = :id and a.maxCapacity >= :partySize")
+    int decreaseCapacity(@Param("id") Long id, @Param("partySize") int partySize);
+
+    @Modifying
+    @Query("update AvailableDate a set a.maxCapacity = a.maxCapacity + :partySize, a.isAvailable = true where a.id = :id")
+    void increaseCapacity(@Param("id") Long id, @Param("partySize") int partySize);
 }

domain/src/main/java/com/wellmeet/domain/restaurant/exception/RestaurantErrorCode.java

@@ -15,7 +15,7 @@ public enum RestaurantErrorCode {
     RESTAURANT_NOT_FOUND(404, "해당 레스토랑을 찾을 수 없습니다."),
 
     AVAILABLE_DATE_NOT_FOUND(404, "해당 예약 가능한 날짜를 찾을 수 없습니다."),
-    NOT_ENOUGH_CAPACITY(400, "예약 가능한 인원이 부족합니다."),
+    NOT_ENOUGH_CAPACITY(400, "해당 시간에 예약이 불가능합니다."),
     TIME_SEQUENCE_INVALID(400, "시간 순서가 잘못되었습니다."),
     INVALID_MENU_PRICE(400, "유효하지 않은 메뉴 가격입니다."),
     ;