diff --git a/src/main/java/kitchenpos/eatinorders/tobe/domain/constant/EatInOrderStatus.java b/src/main/java/kitchenpos/eatinorders/tobe/domain/constant/EatInOrderStatus.java new file mode 100644 index 000000000..eb90217fb --- /dev/null +++ b/src/main/java/kitchenpos/eatinorders/tobe/domain/constant/EatInOrderStatus.java @@ -0,0 +1,5 @@ +package kitchenpos.eatinorders.tobe.domain.constant; + +public enum EatInOrderStatus { + WAITING, ACCEPTED, SERVED, COMPLETED +} diff --git a/src/main/java/kitchenpos/eatinorders/tobe/domain/constant/EatInOrderType.java b/src/main/java/kitchenpos/eatinorders/tobe/domain/constant/EatInOrderType.java new file mode 100644 index 000000000..e02c7fc34 --- /dev/null +++ b/src/main/java/kitchenpos/eatinorders/tobe/domain/constant/EatInOrderType.java @@ -0,0 +1,5 @@ +package kitchenpos.eatinorders.tobe.domain.constant; + +public enum EatInOrderType { + EAT_IN +} diff --git a/src/main/java/kitchenpos/eatinorders/tobe/domain/constant/OrderTableStatus.java b/src/main/java/kitchenpos/eatinorders/tobe/domain/constant/OrderTableStatus.java new file mode 100644 index 000000000..85f7d1f62 --- /dev/null +++ b/src/main/java/kitchenpos/eatinorders/tobe/domain/constant/OrderTableStatus.java @@ -0,0 +1,6 @@ +package kitchenpos.eatinorders.tobe.domain.constant; + +public enum OrderTableStatus { + EMPTY_TABLE, + SIT_TABLE +} diff --git a/src/main/java/kitchenpos/eatinorders/tobe/domain/entity/CompletedOrderEvent.java b/src/main/java/kitchenpos/eatinorders/tobe/domain/entity/CompletedOrderEvent.java new file mode 100644 index 000000000..4f8e89fb3 --- /dev/null +++ b/src/main/java/kitchenpos/eatinorders/tobe/domain/entity/CompletedOrderEvent.java @@ -0,0 +1,16 @@ +package kitchenpos.eatinorders.tobe.domain.entity; + +import java.util.UUID; + +public class CompletedOrderEvent { + private UUID orderTableId; + + public CompletedOrderEvent(UUID orderTableId) { + this.orderTableId = orderTableId; + } + + public UUID getOrderTableId() { + return orderTableId; + } + +} diff --git a/src/main/java/kitchenpos/eatinorders/tobe/domain/entity/EatInOrder.java b/src/main/java/kitchenpos/eatinorders/tobe/domain/entity/EatInOrder.java new file mode 100644 index 000000000..6aa0d38a7 --- /dev/null +++ b/src/main/java/kitchenpos/eatinorders/tobe/domain/entity/EatInOrder.java @@ -0,0 +1,103 @@ +package kitchenpos.eatinorders.tobe.domain.entity; + +import jakarta.persistence.*; +import kitchenpos.eatinorders.tobe.domain.constant.EatInOrderStatus; +import kitchenpos.eatinorders.tobe.domain.constant.EatInOrderType; + +import java.math.BigDecimal; +import java.time.LocalDateTime; +import java.util.Set; +import java.util.UUID; + +@Table(name = "orders2") +@Entity(name = "EatInOrder") +public class EatInOrder { + @Column(name = "id", columnDefinition = "binary(16)") + @Id + private UUID id; + + @Column(name = "type", nullable = false, columnDefinition = "varchar(255)") + @Enumerated(EnumType.STRING) + private EatInOrderType type; + + @Column(name = "status", nullable = false, columnDefinition = "varchar(255)") + @Enumerated(EnumType.STRING) + private EatInOrderStatus status; + + @Column(name = "order_date_time", nullable = false) + private LocalDateTime orderDateTime; + + @Embedded + private OrderLineItems orderLineItems; + + private UUID orderTableId; + + protected EatInOrder() {} + + public EatInOrder(UUID id, EatInOrderType type, EatInOrderStatus status, LocalDateTime orderDateTime, + OrderLineItems orderLineItems, UUID orderTableId) { + this.id = id; + this.type = type; + this.status = status; + this.orderDateTime = orderDateTime; + this.orderLineItems = orderLineItems; + this.orderTableId = orderTableId; + } + + public void accept() { + if (status != EatInOrderStatus.WAITING) { + throw new IllegalStateException(); + } + status = EatInOrderStatus.ACCEPTED; + } + + public void serve() { + if (status != EatInOrderStatus.ACCEPTED) { + throw new IllegalStateException(); + } + status = EatInOrderStatus.SERVED; + } + + public void complete() { + if (status != EatInOrderStatus.SERVED) { + throw new IllegalStateException(); + } + status = EatInOrderStatus.COMPLETED; + } + + public boolean isComplete() { + return status == EatInOrderStatus.COMPLETED; + } + + public void updateMenuInOrders(UUID menuId, BigDecimal price, boolean displayed) { + orderLineItems.updateMenuInOrders(menuId, price, displayed); + } + + public Set allMenuId() { + return orderLineItems.allMenuId(); + } + + public boolean hasMenuId(UUID inputMenuId) { + boolean hasMenuId = orderLineItems.allMenuId() + .stream() + .anyMatch(thisMenuId -> thisMenuId.equals(inputMenuId)); + + return hasMenuId; + } + + public UUID getId() { + return id; + } + + public EatInOrderType getType() { + return type; + } + + public EatInOrderStatus getStatus() { + return status; + } + + public UUID getOrderTableId() { + return orderTableId; + } +} diff --git a/src/main/java/kitchenpos/eatinorders/tobe/domain/entity/OrderLineItem.java b/src/main/java/kitchenpos/eatinorders/tobe/domain/entity/OrderLineItem.java new file mode 100644 index 000000000..4d532ab54 --- /dev/null +++ b/src/main/java/kitchenpos/eatinorders/tobe/domain/entity/OrderLineItem.java @@ -0,0 +1,71 @@ +package kitchenpos.eatinorders.tobe.domain.entity; + +import jakarta.persistence.*; +import kitchenpos.eatinorders.tobe.domain.vo.MenuInEatInOrders; +import kitchenpos.eatinorders.tobe.domain.vo.Price; + +import java.math.BigDecimal; +import java.util.UUID; + +@Table(name = "order_line_item2") +@Entity(name = "OrderLineItem2") +public class OrderLineItem { + @Column(name = "seq") + @GeneratedValue(strategy = GenerationType.IDENTITY) + @Id + private Long seq; + + @Column(name = "quantity", nullable = false) + private long quantity; + + @Embedded + private Price price; + + @Embedded + private MenuInEatInOrders menuInOrders; + + protected OrderLineItem() {} + + public OrderLineItem(Long seq, long quantity, BigDecimal price, + UUID menuId, BigDecimal menuPrice) { + this(seq, quantity, price, menuId, false, menuPrice); + } + + public OrderLineItem(Long seq, long quantity, BigDecimal price, + UUID menuId, boolean isDisplayedMenu, BigDecimal menuPrice) { + this.seq = seq; + this.quantity = quantity; + this.price = new Price(price); + menuInOrders = new MenuInEatInOrders(menuId, isDisplayedMenu, menuPrice); + checkIsEqualPrice(); + } + + private void checkIsEqualPrice() { + if (this.price.isNotSamePrice(menuInOrders.getPrice())) { + throw new IllegalArgumentException("주문 항목 금액과 메뉴 금액이 서로 다릅니다."); + } + } + + public void updateMenuInOrders(UUID menuId, BigDecimal price, boolean displayed) { + if (menuInOrders.isSameId(menuId)) { + menuInOrders.update(price, displayed); + checkIsEqualPrice(); + } + } + + public Long getSeq() { + return seq; + } + + public long getQuantity() { + return quantity; + } + + public Price getPrice() { + return price; + } + + public UUID getMenuId() { + return menuInOrders.getMenuId(); + } +} diff --git a/src/main/java/kitchenpos/eatinorders/tobe/domain/entity/OrderLineItems.java b/src/main/java/kitchenpos/eatinorders/tobe/domain/entity/OrderLineItems.java new file mode 100644 index 000000000..1f2edca47 --- /dev/null +++ b/src/main/java/kitchenpos/eatinorders/tobe/domain/entity/OrderLineItems.java @@ -0,0 +1,39 @@ +package kitchenpos.eatinorders.tobe.domain.entity; + +import jakarta.persistence.*; + +import java.math.BigDecimal; +import java.util.List; +import java.util.Set; +import java.util.UUID; +import java.util.stream.Collectors; + +@Embeddable +public class OrderLineItems { + @OneToMany(cascade = {CascadeType.PERSIST, CascadeType.MERGE}) + @JoinColumn( + name = "order_id", + nullable = false, + columnDefinition = "binary(16)", + foreignKey = @ForeignKey(name = "fk_order_line_item_to_orders") + ) + private List orderLineItems; + + protected OrderLineItems() {} + + public OrderLineItems(List orderLineItems) { + this.orderLineItems = orderLineItems; + } + + public void updateMenuInOrders(UUID menuId, BigDecimal price, boolean displayed) { + for (OrderLineItem orderLineItem : orderLineItems) { + orderLineItem.updateMenuInOrders(menuId, price, displayed); + } + } + + public Set allMenuId() { + return orderLineItems.stream() + .map(orderLineItem -> orderLineItem.getMenuId()) + .collect(Collectors.toSet()); + } +} diff --git a/src/main/java/kitchenpos/eatinorders/tobe/domain/entity/OrderTable.java b/src/main/java/kitchenpos/eatinorders/tobe/domain/entity/OrderTable.java new file mode 100644 index 000000000..e972e3457 --- /dev/null +++ b/src/main/java/kitchenpos/eatinorders/tobe/domain/entity/OrderTable.java @@ -0,0 +1,81 @@ +package kitchenpos.eatinorders.tobe.domain.entity; + +import jakarta.persistence.*; +import kitchenpos.eatinorders.tobe.domain.vo.NumberOfGuests; +import kitchenpos.eatinorders.tobe.domain.vo.OrderTableName; + +import java.util.UUID; + +@Table(name = "order_table2") +@Entity(name = "OrderTable2") +public class OrderTable { + @Column(name = "id", columnDefinition = "binary(16)") + @Id + private UUID id; + + @Embedded + private OrderTableName name; + + @Embedded + private NumberOfGuests numberOfGuests; + + @Column(name = "occupied", nullable = false) + private boolean occupied; + + protected OrderTable() {} + + public OrderTable(UUID id, String name, int numberOfGuests, boolean occupied) { + checkNumberOfGuests(numberOfGuests); + checkOccupied(occupied); + this.id = id; + this.name = new OrderTableName(name); + this.numberOfGuests = new NumberOfGuests(numberOfGuests); + this.occupied = occupied; + } + + private void checkNumberOfGuests(int numberOfGuests) { + if (numberOfGuests != 0) { + throw new IllegalArgumentException(); + } + } + + private void checkOccupied(boolean occupied) { + if (occupied) { + throw new IllegalArgumentException(); + } + } + + public void sit() { + occupied = true; + } + + public void clear() { + numberOfGuests = NumberOfGuests.zero(); + occupied = false; + } + + public void changeNumberOfGuests(int numberOfGuests) { + NumberOfGuests inputNumberOfGuests = new NumberOfGuests(numberOfGuests); + if (isNotOccupied()) { + throw new IllegalStateException(); + } + this.numberOfGuests = inputNumberOfGuests; + } + + public boolean isNotOccupied() { + return !occupied; + } + + public boolean isOccupied() { + return occupied; + } + + public UUID getId() { + return id; + } + + public int getNumberOfGuests() { + return numberOfGuests.getNumberOfGuests(); + } + +} diff --git a/src/main/java/kitchenpos/eatinorders/tobe/domain/repository/EatInOrderRepository.java b/src/main/java/kitchenpos/eatinorders/tobe/domain/repository/EatInOrderRepository.java new file mode 100644 index 000000000..a6d11f6a2 --- /dev/null +++ b/src/main/java/kitchenpos/eatinorders/tobe/domain/repository/EatInOrderRepository.java @@ -0,0 +1,18 @@ +package kitchenpos.eatinorders.tobe.domain.repository; + +import kitchenpos.eatinorders.tobe.domain.entity.EatInOrder; + +import java.util.List; +import java.util.Optional; +import java.util.UUID; + +public interface EatInOrderRepository { + + EatInOrder save(EatInOrder order); + + Optional findById(UUID id); + + List findAllByOrderTableId(UUID id); + + List findAllByMenuId(UUID menuId); +} diff --git a/src/main/java/kitchenpos/eatinorders/tobe/domain/repository/OrderTableRepository.java b/src/main/java/kitchenpos/eatinorders/tobe/domain/repository/OrderTableRepository.java new file mode 100644 index 000000000..8d59be31c --- /dev/null +++ b/src/main/java/kitchenpos/eatinorders/tobe/domain/repository/OrderTableRepository.java @@ -0,0 +1,12 @@ +package kitchenpos.eatinorders.tobe.domain.repository; + +import kitchenpos.eatinorders.tobe.domain.entity.OrderTable; +import java.util.Optional; +import java.util.UUID; + +public interface OrderTableRepository { + + OrderTable save(OrderTable orderTable); + + Optional findById(UUID id); +} diff --git a/src/main/java/kitchenpos/eatinorders/tobe/domain/service/EatInOrderAccept.java b/src/main/java/kitchenpos/eatinorders/tobe/domain/service/EatInOrderAccept.java new file mode 100644 index 000000000..36718c3c8 --- /dev/null +++ b/src/main/java/kitchenpos/eatinorders/tobe/domain/service/EatInOrderAccept.java @@ -0,0 +1,50 @@ +package kitchenpos.eatinorders.tobe.domain.service; + +import kitchenpos.eatinorders.tobe.domain.entity.EatInOrder; +import kitchenpos.eatinorders.tobe.domain.entity.OrderTable; +import kitchenpos.eatinorders.tobe.domain.repository.OrderTableRepository; +import kitchenpos.menus.tobe.domain.entity.Menu; +import kitchenpos.menus.tobe.domain.repository.MenuRepository; + +import java.util.NoSuchElementException; +import java.util.Set; +import java.util.UUID; + +public class EatInOrderAccept { + private OrderTableRepository tableRepository; + private MenuRepository menuRepository; + + public EatInOrderAccept(OrderTableRepository tableRepository, MenuRepository menuRepository) { + this.tableRepository = tableRepository; + this.menuRepository = menuRepository; + } + + public void checkRequiredList(EatInOrder order) { + checkOrderTableIsOccupied(order.getOrderTableId()); + checkAllMenuIsDisplayed(order.allMenuId()); + } + + private void checkOrderTableIsOccupied(UUID orderId) { + OrderTable table = tableRepository.findById(orderId) + .orElseThrow(() -> new NoSuchElementException()); + + if (table.isNotOccupied()) { + throw new IllegalStateException("빈 테이블입니다."); + } + } + + private void checkAllMenuIsDisplayed(Set allMenuId) { + boolean hasNotDisplayedMenu = allMenuId.stream() + .anyMatch(menuId -> isNotDisplayedMenu(menuId)); + + if (hasNotDisplayedMenu) { + throw new IllegalStateException("숨긴 메뉴가 존재합니다."); + } + } + + private boolean isNotDisplayedMenu(UUID menuId) { + Menu menu = menuRepository.findById(menuId) + .orElseThrow(() -> new NoSuchElementException()); + return menu.isNotDisplayed(); + } +} diff --git a/src/main/java/kitchenpos/eatinorders/tobe/domain/service/EatInOrderCompletePolicy.java b/src/main/java/kitchenpos/eatinorders/tobe/domain/service/EatInOrderCompletePolicy.java new file mode 100644 index 000000000..9ee73b582 --- /dev/null +++ b/src/main/java/kitchenpos/eatinorders/tobe/domain/service/EatInOrderCompletePolicy.java @@ -0,0 +1,30 @@ +package kitchenpos.eatinorders.tobe.domain.service; + +import kitchenpos.eatinorders.tobe.domain.entity.CompletedOrderEvent; +import kitchenpos.eatinorders.tobe.domain.entity.EatInOrder; +import kitchenpos.eatinorders.tobe.domain.repository.EatInOrderRepository; +import org.springframework.context.ApplicationEventPublisher; +import org.springframework.stereotype.Component; +import java.util.List; + +@Component +public class EatInOrderCompletePolicy { + private final EatInOrderRepository orderRepository; + private final ApplicationEventPublisher publisher; + + public EatInOrderCompletePolicy(EatInOrderRepository orderRepository, ApplicationEventPublisher publisher) { + this.orderRepository = orderRepository; + this.publisher = publisher; + } + + public void complete(EatInOrder order) { + order.complete(); + List orders = orderRepository.findAllByOrderTableId(order.getOrderTableId()); + boolean allOrderCompleted = orders.stream() + .allMatch(thisOrder -> thisOrder.isComplete()); + + if (allOrderCompleted) { + publisher.publishEvent(new CompletedOrderEvent(order.getOrderTableId())); + } + } +} diff --git a/src/main/java/kitchenpos/eatinorders/tobe/domain/service/OrderTableModification.java b/src/main/java/kitchenpos/eatinorders/tobe/domain/service/OrderTableModification.java new file mode 100644 index 000000000..ab3cd86ff --- /dev/null +++ b/src/main/java/kitchenpos/eatinorders/tobe/domain/service/OrderTableModification.java @@ -0,0 +1,28 @@ +package kitchenpos.eatinorders.tobe.domain.service; + +import kitchenpos.eatinorders.tobe.domain.entity.CompletedOrderEvent; +import kitchenpos.eatinorders.tobe.domain.entity.OrderTable; +import kitchenpos.eatinorders.tobe.domain.repository.OrderTableRepository; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.context.event.EventListener; +import org.springframework.stereotype.Component; +import java.util.NoSuchElementException; + +@Component +public class OrderTableModification { + private static final Logger LOGGER = LoggerFactory.getLogger(OrderTableModification.class); + private final OrderTableRepository tableRepository; + + public OrderTableModification(OrderTableRepository tableRepository) { + this.tableRepository = tableRepository; + } + + @EventListener + public void setEmptyTable(CompletedOrderEvent event) { + LOGGER.info("주문이 완료 되어 빈 테이블 설정을 진행합니다."); + OrderTable table = tableRepository.findById(event.getOrderTableId()) + .orElseThrow(() -> new NoSuchElementException()); + table.clear(); + } +} diff --git a/src/main/java/kitchenpos/eatinorders/tobe/domain/service/UpdateMenuInOrders.java b/src/main/java/kitchenpos/eatinorders/tobe/domain/service/UpdateMenuInOrders.java new file mode 100644 index 000000000..bdc2c006f --- /dev/null +++ b/src/main/java/kitchenpos/eatinorders/tobe/domain/service/UpdateMenuInOrders.java @@ -0,0 +1,32 @@ +package kitchenpos.eatinorders.tobe.domain.service; + +import kitchenpos.eatinorders.tobe.domain.entity.EatInOrder; +import kitchenpos.eatinorders.tobe.domain.repository.EatInOrderRepository; +import kitchenpos.menus.tobe.domain.entity.ChangedMenuEvent; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.context.event.EventListener; +import org.springframework.stereotype.Component; + +import java.util.List; + +@Component +public class UpdateMenuInOrders { + private static final Logger LOGGER = LoggerFactory.getLogger(UpdateMenuInOrders.class); + private final EatInOrderRepository orderRepository; + + public UpdateMenuInOrders(EatInOrderRepository orderRepository) { + this.orderRepository = orderRepository; + } + + @EventListener + public void updateMenu(ChangedMenuEvent menuEvent) { + LOGGER.info("메뉴가 변경되어 주문 항목을 확인합니다."); + + List orders = orderRepository.findAllByMenuId(menuEvent.getMenuId()); + + for (EatInOrder order : orders) { + order.updateMenuInOrders(menuEvent.getMenuId(), menuEvent.getPrice(), menuEvent.isDisplayed()); + } + } +} diff --git a/src/main/java/kitchenpos/eatinorders/tobe/domain/vo/MenuInEatInOrders.java b/src/main/java/kitchenpos/eatinorders/tobe/domain/vo/MenuInEatInOrders.java new file mode 100644 index 000000000..8dfa0d75f --- /dev/null +++ b/src/main/java/kitchenpos/eatinorders/tobe/domain/vo/MenuInEatInOrders.java @@ -0,0 +1,59 @@ +package kitchenpos.eatinorders.tobe.domain.vo; + +import jakarta.persistence.Column; +import jakarta.persistence.Embeddable; +import jakarta.persistence.Transient; + +import java.math.BigDecimal; +import java.util.Objects; +import java.util.UUID; + +@Embeddable +public class MenuInEatInOrders { + @Column(name = "menu_id", nullable = false) + private UUID menuId; + + @Transient + private boolean isDisplayedMenu; + + @Transient + private Price price; + + public MenuInEatInOrders(UUID menuId, boolean isDisplayedMenu, BigDecimal price) { + checkMenuId(menuId); + checkIsDisplayed(isDisplayedMenu); + this.menuId = menuId; + this.isDisplayedMenu = isDisplayedMenu; + this.price = new Price(price); + } + + private void checkMenuId(UUID menuId) { + if (Objects.isNull(menuId)) { + throw new IllegalArgumentException("메뉴 식별자가 존재하지 않습니다."); + } + } + + public void update(BigDecimal price, boolean displayed) { + checkIsDisplayed(displayed); + this.price = new Price(price); + this.isDisplayedMenu = displayed; + } + + private void checkIsDisplayed(boolean isDisplayedMenu) { + if (!isDisplayedMenu) { + throw new IllegalStateException("메뉴가 비공개입니다."); + } + } + + public boolean isSameId(UUID inputMenuId) { + return menuId.equals(inputMenuId); + } + + public UUID getMenuId() { + return menuId; + } + + public Price getPrice() { + return price; + } +} diff --git a/src/main/java/kitchenpos/eatinorders/tobe/domain/vo/NumberOfGuests.java b/src/main/java/kitchenpos/eatinorders/tobe/domain/vo/NumberOfGuests.java new file mode 100644 index 000000000..0ab410418 --- /dev/null +++ b/src/main/java/kitchenpos/eatinorders/tobe/domain/vo/NumberOfGuests.java @@ -0,0 +1,46 @@ +package kitchenpos.eatinorders.tobe.domain.vo; + +import jakarta.persistence.Column; +import jakarta.persistence.Embeddable; + +import java.util.Objects; + +@Embeddable +public class NumberOfGuests { + @Column(name = "number_of_guests", nullable = false) + private int numberOfGuests; + + protected NumberOfGuests() {} + + public static NumberOfGuests zero() { + return new NumberOfGuests(0); + } + + public NumberOfGuests(int numberOfGuests) { + checkValidatedNumber(numberOfGuests); + this.numberOfGuests = numberOfGuests; + } + + private void checkValidatedNumber(int numberOfGuests) { + if (numberOfGuests < 0) { + throw new IllegalArgumentException(); + } + } + + public int getNumberOfGuests() { + return numberOfGuests; + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + NumberOfGuests that = (NumberOfGuests) o; + return numberOfGuests == that.numberOfGuests; + } + + @Override + public int hashCode() { + return Objects.hash(numberOfGuests); + } +} diff --git a/src/main/java/kitchenpos/eatinorders/tobe/domain/vo/OrderTableName.java b/src/main/java/kitchenpos/eatinorders/tobe/domain/vo/OrderTableName.java new file mode 100644 index 000000000..13887c132 --- /dev/null +++ b/src/main/java/kitchenpos/eatinorders/tobe/domain/vo/OrderTableName.java @@ -0,0 +1,38 @@ +package kitchenpos.eatinorders.tobe.domain.vo; + +import jakarta.persistence.Column; +import jakarta.persistence.Embeddable; + +import java.util.Objects; + +@Embeddable +public class OrderTableName { + @Column(name = "name", nullable = false) + private String name; + + protected OrderTableName() {} + + public OrderTableName(String name) { + checkValidatedName(name); + this.name = name; + } + + private void checkValidatedName(String name) { + if (Objects.isNull(name) || name.isEmpty()) { + throw new IllegalArgumentException(); + } + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + OrderTableName that = (OrderTableName) o; + return Objects.equals(name, that.name); + } + + @Override + public int hashCode() { + return Objects.hash(name); + } +} diff --git a/src/main/java/kitchenpos/eatinorders/tobe/domain/vo/Price.java b/src/main/java/kitchenpos/eatinorders/tobe/domain/vo/Price.java new file mode 100644 index 000000000..1d9dff4c4 --- /dev/null +++ b/src/main/java/kitchenpos/eatinorders/tobe/domain/vo/Price.java @@ -0,0 +1,54 @@ +package kitchenpos.eatinorders.tobe.domain.vo; + +import jakarta.persistence.Column; +import jakarta.persistence.Embeddable; + +import java.math.BigDecimal; +import java.util.Objects; + +@Embeddable +public class Price { + @Column(name = "price", nullable = false) + private BigDecimal price; + + protected Price() {} + + public Price(BigDecimal price) { + checkPrice(price); + this.price = price; + } + + private void checkPrice(BigDecimal price) { + if (Objects.isNull(price)) { + throw new IllegalArgumentException("주문 항목 금액이 존재하지 않습니다."); + } + if (price.signum() == -1) { + throw new IllegalArgumentException("주문 항목 금액이 음수입니다."); + } + } + + public BigDecimal getPrice() { + return price; + } + + public boolean isNotSamePrice(Price price) { + return !isSamePrice(price); + } + + public boolean isSamePrice(Price price) { + return this.equals(price); + } + + @Override + public boolean equals(Object o) { + if (this == o) return true; + if (o == null || getClass() != o.getClass()) return false; + Price price1 = (Price) o; + return Objects.equals(price, price1.price); + } + + @Override + public int hashCode() { + return Objects.hash(price); + } +} diff --git a/src/main/java/kitchenpos/menus/tobe/domain/CleanName.java b/src/main/java/kitchenpos/menus/tobe/domain/common/CleanName.java similarity index 90% rename from src/main/java/kitchenpos/menus/tobe/domain/CleanName.java rename to src/main/java/kitchenpos/menus/tobe/domain/common/CleanName.java index c7e069682..e59c128d7 100644 --- a/src/main/java/kitchenpos/menus/tobe/domain/CleanName.java +++ b/src/main/java/kitchenpos/menus/tobe/domain/common/CleanName.java @@ -1,7 +1,8 @@ -package kitchenpos.menus.tobe.domain; +package kitchenpos.menus.tobe.domain.common; import jakarta.persistence.Column; import jakarta.persistence.Embeddable; +import kitchenpos.menus.tobe.domain.service.MenuNameValidationService; import java.util.Objects; diff --git a/src/main/java/kitchenpos/menus/tobe/domain/Price.java b/src/main/java/kitchenpos/menus/tobe/domain/common/Price.java similarity index 79% rename from src/main/java/kitchenpos/menus/tobe/domain/Price.java rename to src/main/java/kitchenpos/menus/tobe/domain/common/Price.java index 77cfeee5b..065c15fef 100644 --- a/src/main/java/kitchenpos/menus/tobe/domain/Price.java +++ b/src/main/java/kitchenpos/menus/tobe/domain/common/Price.java @@ -1,4 +1,4 @@ -package kitchenpos.menus.tobe.domain; +package kitchenpos.menus.tobe.domain.common; import jakarta.persistence.Column; import jakarta.persistence.Embeddable; @@ -13,6 +13,19 @@ public class Price { protected Price() {} + public Price multiplyBy(int value) { + return multiplyBy(BigDecimal.valueOf(value)); + } + + public Price multiplyBy(long value) { + return multiplyBy(BigDecimal.valueOf(value)); + } + + public Price multiplyBy(BigDecimal value) { + price = price.multiply(value); + return new Price(price); + } + public Price(BigDecimal price, long quantity) { checkValidatedPrice(price); BigDecimal result = price.multiply(BigDecimal.valueOf(quantity)); diff --git a/src/main/java/kitchenpos/menus/tobe/domain/entity/ChangedMenuEvent.java b/src/main/java/kitchenpos/menus/tobe/domain/entity/ChangedMenuEvent.java new file mode 100644 index 000000000..a9227cfb8 --- /dev/null +++ b/src/main/java/kitchenpos/menus/tobe/domain/entity/ChangedMenuEvent.java @@ -0,0 +1,28 @@ +package kitchenpos.menus.tobe.domain.entity; + +import java.math.BigDecimal; +import java.util.UUID; + +public class ChangedMenuEvent { + private final UUID menuId; + private final BigDecimal price; + private final boolean isDisplayed; + + public ChangedMenuEvent(UUID menuId, BigDecimal price, boolean isDisplayed) { + this.menuId = menuId; + this.price = price; + this.isDisplayed = isDisplayed; + } + + public UUID getMenuId() { + return menuId; + } + + public BigDecimal getPrice() { + return price; + } + + public boolean isDisplayed() { + return isDisplayed; + } +} diff --git a/src/main/java/kitchenpos/menus/tobe/domain/Menu.java b/src/main/java/kitchenpos/menus/tobe/domain/entity/Menu.java similarity index 90% rename from src/main/java/kitchenpos/menus/tobe/domain/Menu.java rename to src/main/java/kitchenpos/menus/tobe/domain/entity/Menu.java index 4f8d73330..ad006fba1 100644 --- a/src/main/java/kitchenpos/menus/tobe/domain/Menu.java +++ b/src/main/java/kitchenpos/menus/tobe/domain/entity/Menu.java @@ -1,14 +1,16 @@ -package kitchenpos.menus.tobe.domain; +package kitchenpos.menus.tobe.domain.entity; import jakarta.persistence.*; +import kitchenpos.menus.tobe.domain.service.MenuNameValidationService; +import kitchenpos.menus.tobe.domain.common.*; import java.math.BigDecimal; import java.util.List; import java.util.Objects; import java.util.UUID; -@Table(name = "menu") -@Entity +@Table(name = "menu2") +@Entity(name = "Menu2") public class Menu { @Column(name = "id", columnDefinition = "binary(16)") @Id @@ -98,6 +100,10 @@ public void hide() { displayed = false; } + public boolean isNotDisplayed() { + return !displayed; + } + public boolean isDisplayed() { return displayed; } diff --git a/src/main/java/kitchenpos/menus/tobe/domain/MenuGroup.java b/src/main/java/kitchenpos/menus/tobe/domain/entity/MenuGroup.java similarity index 73% rename from src/main/java/kitchenpos/menus/tobe/domain/MenuGroup.java rename to src/main/java/kitchenpos/menus/tobe/domain/entity/MenuGroup.java index 8183bf710..897d3240c 100644 --- a/src/main/java/kitchenpos/menus/tobe/domain/MenuGroup.java +++ b/src/main/java/kitchenpos/menus/tobe/domain/entity/MenuGroup.java @@ -1,11 +1,12 @@ -package kitchenpos.menus.tobe.domain; +package kitchenpos.menus.tobe.domain.entity; import jakarta.persistence.*; +import kitchenpos.menus.tobe.domain.common.*; import java.util.UUID; -@Table(name = "menu_group") -@Entity +@Table(name = "menu_group2") +@Entity(name = "MenuGroup2") public class MenuGroup { @Column(name = "id", columnDefinition = "binary(16)") @Id diff --git a/src/main/java/kitchenpos/menus/tobe/domain/MenuProduct.java b/src/main/java/kitchenpos/menus/tobe/domain/entity/MenuProduct.java similarity index 74% rename from src/main/java/kitchenpos/menus/tobe/domain/MenuProduct.java rename to src/main/java/kitchenpos/menus/tobe/domain/entity/MenuProduct.java index db17757dd..e2be5eb5a 100644 --- a/src/main/java/kitchenpos/menus/tobe/domain/MenuProduct.java +++ b/src/main/java/kitchenpos/menus/tobe/domain/entity/MenuProduct.java @@ -1,12 +1,14 @@ -package kitchenpos.menus.tobe.domain; +package kitchenpos.menus.tobe.domain.entity; import jakarta.persistence.*; +import kitchenpos.menus.tobe.domain.vo.Quantity; +import kitchenpos.menus.tobe.domain.common.*; import java.math.BigDecimal; import java.util.UUID; -@Table(name = "menu_product") -@Entity +@Table(name = "menu_product2") +@Entity(name = "MenuProduct2") public class MenuProduct { @Column(name = "seq") @GeneratedValue(strategy = GenerationType.IDENTITY) @@ -28,7 +30,7 @@ public MenuProduct(Long seq, long quantity, UUID productId, BigDecimal productPr this.seq = seq; this.quantity = new Quantity(quantity); this.productId = productId; - this.price = new Price(productPrice, quantity); + this.price = new Price(productPrice).multiplyBy(quantity); } public Long getSeq() { diff --git a/src/main/java/kitchenpos/menus/tobe/domain/MenuProducts.java b/src/main/java/kitchenpos/menus/tobe/domain/entity/MenuProducts.java similarity index 91% rename from src/main/java/kitchenpos/menus/tobe/domain/MenuProducts.java rename to src/main/java/kitchenpos/menus/tobe/domain/entity/MenuProducts.java index 7b877c36f..24798fbf2 100644 --- a/src/main/java/kitchenpos/menus/tobe/domain/MenuProducts.java +++ b/src/main/java/kitchenpos/menus/tobe/domain/entity/MenuProducts.java @@ -1,6 +1,7 @@ -package kitchenpos.menus.tobe.domain; +package kitchenpos.menus.tobe.domain.entity; import jakarta.persistence.*; +import kitchenpos.menus.tobe.domain.common.*; import java.math.BigDecimal; import java.util.List; diff --git a/src/main/java/kitchenpos/menus/tobe/domain/repository/MenuRepository.java b/src/main/java/kitchenpos/menus/tobe/domain/repository/MenuRepository.java new file mode 100644 index 000000000..92f298545 --- /dev/null +++ b/src/main/java/kitchenpos/menus/tobe/domain/repository/MenuRepository.java @@ -0,0 +1,16 @@ +package kitchenpos.menus.tobe.domain.repository; + + + +import kitchenpos.menus.tobe.domain.entity.Menu; + +import java.util.Optional; +import java.util.UUID; + +public interface MenuRepository { + + Menu save(Menu menu); + + Optional findById(UUID id); + +} diff --git a/src/main/java/kitchenpos/menus/tobe/domain/service/ChangedMenuSender.java b/src/main/java/kitchenpos/menus/tobe/domain/service/ChangedMenuSender.java new file mode 100644 index 000000000..f2df092de --- /dev/null +++ b/src/main/java/kitchenpos/menus/tobe/domain/service/ChangedMenuSender.java @@ -0,0 +1,21 @@ +package kitchenpos.menus.tobe.domain.service; + +import kitchenpos.menus.tobe.domain.entity.ChangedMenuEvent; +import kitchenpos.menus.tobe.domain.entity.Menu; +import org.springframework.context.ApplicationEventPublisher; +import org.springframework.stereotype.Component; + +@Component +public class ChangedMenuSender { + private final ApplicationEventPublisher publisher; + + public ChangedMenuSender(ApplicationEventPublisher publisher) { + this.publisher = publisher; + } + + public void sendAtChangedMenu(Menu menu) { + publisher.publishEvent(new ChangedMenuEvent( + menu.getId(), menu.getPrice(), menu.isDisplayed() + )); + } +} diff --git a/src/main/java/kitchenpos/menus/tobe/domain/MenuNameValidationService.java b/src/main/java/kitchenpos/menus/tobe/domain/service/MenuNameValidationService.java similarity index 89% rename from src/main/java/kitchenpos/menus/tobe/domain/MenuNameValidationService.java rename to src/main/java/kitchenpos/menus/tobe/domain/service/MenuNameValidationService.java index ccafdcb2a..932359dea 100644 --- a/src/main/java/kitchenpos/menus/tobe/domain/MenuNameValidationService.java +++ b/src/main/java/kitchenpos/menus/tobe/domain/service/MenuNameValidationService.java @@ -1,4 +1,4 @@ -package kitchenpos.menus.tobe.domain; +package kitchenpos.menus.tobe.domain.service; import kitchenpos.products.infra.PurgomalumClient; diff --git a/src/main/java/kitchenpos/menus/tobe/domain/Quantity.java b/src/main/java/kitchenpos/menus/tobe/domain/vo/Quantity.java similarity index 95% rename from src/main/java/kitchenpos/menus/tobe/domain/Quantity.java rename to src/main/java/kitchenpos/menus/tobe/domain/vo/Quantity.java index 39b598842..b54ca7ffe 100644 --- a/src/main/java/kitchenpos/menus/tobe/domain/Quantity.java +++ b/src/main/java/kitchenpos/menus/tobe/domain/vo/Quantity.java @@ -1,4 +1,4 @@ -package kitchenpos.menus.tobe.domain; +package kitchenpos.menus.tobe.domain.vo; import jakarta.persistence.Column; import jakarta.persistence.Embeddable; diff --git a/src/main/java/kitchenpos/products/tobe/domain/Product.java b/src/main/java/kitchenpos/products/tobe/domain/Product.java index d962d7b2c..25e29747b 100644 --- a/src/main/java/kitchenpos/products/tobe/domain/Product.java +++ b/src/main/java/kitchenpos/products/tobe/domain/Product.java @@ -5,8 +5,8 @@ import java.math.BigDecimal; import java.util.UUID; -@Entity -@Table(name = "product") +@Entity(name = "Product2") +@Table(name = "product2") public class Product { @Column(name = "id", columnDefinition = "binary(16)") @Id diff --git a/src/test/java/kitchenpos/ToBeFixtures.java b/src/test/java/kitchenpos/ToBeFixtures.java index bb2fc01a7..b089f66ed 100644 --- a/src/test/java/kitchenpos/ToBeFixtures.java +++ b/src/test/java/kitchenpos/ToBeFixtures.java @@ -1,9 +1,10 @@ package kitchenpos; -import kitchenpos.menus.tobe.domain.Menu; -import kitchenpos.menus.tobe.domain.MenuGroup; -import kitchenpos.menus.tobe.domain.MenuNameValidationService; -import kitchenpos.menus.tobe.domain.MenuProduct; +import kitchenpos.menus.application.FakeMenuPurgomalumClient; +import kitchenpos.menus.tobe.domain.entity.MenuGroup; +import kitchenpos.menus.tobe.domain.service.MenuNameValidationService; +import kitchenpos.menus.tobe.domain.entity.MenuProduct; +import kitchenpos.menus.tobe.domain.entity.Menu; import kitchenpos.products.application.FakePurgomalumClient; import kitchenpos.products.tobe.domain.Product; import kitchenpos.products.tobe.domain.ProductNameValidationService; @@ -14,6 +15,17 @@ import java.util.UUID; public class ToBeFixtures { + public Menu 메뉴_치킨 = new kitchenpos.menus.tobe.domain.entity.Menu( + UUID.randomUUID(), + "치킨", + new MenuNameValidationService(new FakeMenuPurgomalumClient()), + BigDecimal.valueOf(100_000), + true, + List.of(new MenuProduct(new Random().nextLong(),5, + UUID.randomUUID(), BigDecimal.valueOf(20_000))), + UUID.randomUUID() + ); + public MenuGroup 치킨 = new MenuGroup(UUID.randomUUID(), "치킨"); public Product 후라이드_20000 = new Product( UUID.randomUUID(), @@ -35,6 +47,20 @@ public static MenuProduct menuProductOf(long productQuantity, BigDecimal product return menuProduct; } + public static Menu menuCreateOf(UUID id, BigDecimal price, boolean displayed) { + Menu menu = new Menu( + id, + "메뉴", + new MenuNameValidationService(new FakeMenuPurgomalumClient()), + price, + displayed, + List.of(new MenuProduct(new Random().nextLong(),1, + UUID.randomUUID(), BigDecimal.valueOf(20_000))), + UUID.randomUUID() + ); + return menu; + } + public static Menu menuCreateOf(String name, MenuNameValidationService menuNameValidationService, BigDecimal price, boolean displayed, List menuProducts) { Menu menu = new Menu( diff --git a/src/test/java/kitchenpos/eatinorders/EatInOrderFixture.java b/src/test/java/kitchenpos/eatinorders/EatInOrderFixture.java new file mode 100644 index 000000000..8c66f3e73 --- /dev/null +++ b/src/test/java/kitchenpos/eatinorders/EatInOrderFixture.java @@ -0,0 +1,76 @@ +package kitchenpos.eatinorders; + +import kitchenpos.eatinorders.tobe.domain.constant.EatInOrderStatus; +import kitchenpos.eatinorders.tobe.domain.constant.EatInOrderType; +import kitchenpos.eatinorders.tobe.domain.entity.EatInOrder; +import kitchenpos.eatinorders.tobe.domain.entity.OrderLineItem; +import kitchenpos.eatinorders.tobe.domain.entity.OrderLineItems; +import kitchenpos.eatinorders.tobe.domain.entity.OrderTable; + +import java.math.BigDecimal; +import java.time.LocalDateTime; +import java.util.Random; +import java.util.UUID; + +public class EatInOrderFixture { + private static Random random = new Random(); + + public static OrderTable emptyOrderTableOf(String name) { + OrderTable orderTable = new OrderTable( + UUID.randomUUID(), + name, + 0, + false + ); + return orderTable; + } + + public static OrderTable sitOrderTableOf(String name) { + OrderTable orderTable = new OrderTable( + UUID.randomUUID(), + name, + 0, + false + ); + orderTable.sit(); + return orderTable; + } + + public static OrderLineItem orderLineItemOf(long quantity, BigDecimal price) { + OrderLineItem orderLineItem = new OrderLineItem( + random.nextLong(), quantity, price, UUID.randomUUID(), true, BigDecimal.ONE + ); + return orderLineItem; + } + + public static OrderLineItem orderLineItemOf(long quantity, BigDecimal price, UUID menuId) { + OrderLineItem orderLineItem = new OrderLineItem( + random.nextLong(), quantity, price, menuId, true, BigDecimal.ONE + ); + return orderLineItem; + } + + public static OrderLineItem orderLineItemOf(long quantity, BigDecimal price, UUID menuId, + boolean isDisplayedMenu, BigDecimal menuPrice) { + OrderLineItem orderLineItem = new OrderLineItem( + random.nextLong(), quantity, price, menuId, isDisplayedMenu, menuPrice + ); + return orderLineItem; + } + + public static EatInOrder eatInOrderOf(OrderLineItems orderLineItems, UUID orderTableId) { + EatInOrder eatInOrder = new EatInOrder( + UUID.randomUUID(), EatInOrderType.EAT_IN, EatInOrderStatus.WAITING, + LocalDateTime.now(), orderLineItems, orderTableId + ); + return eatInOrder; + } + + public static EatInOrder eatInOrderOf(EatInOrderStatus status, OrderLineItems orderLineItems, UUID orderTableId) { + EatInOrder eatInOrder = new EatInOrder( + UUID.randomUUID(), EatInOrderType.EAT_IN, status, + LocalDateTime.now(), orderLineItems, orderTableId + ); + return eatInOrder; + } +} diff --git a/src/test/java/kitchenpos/eatinorders/domain/EatInOrderAcceptTest.java b/src/test/java/kitchenpos/eatinorders/domain/EatInOrderAcceptTest.java new file mode 100644 index 000000000..1dc12ecf7 --- /dev/null +++ b/src/test/java/kitchenpos/eatinorders/domain/EatInOrderAcceptTest.java @@ -0,0 +1,111 @@ +package kitchenpos.eatinorders.domain; + +import kitchenpos.ToBeFixtures; +import kitchenpos.eatinorders.EatInOrderFixture; +import kitchenpos.eatinorders.tobe.domain.entity.EatInOrder; +import kitchenpos.eatinorders.tobe.domain.entity.OrderLineItem; +import kitchenpos.eatinorders.tobe.domain.entity.OrderLineItems; +import kitchenpos.eatinorders.tobe.domain.entity.OrderTable; +import kitchenpos.eatinorders.tobe.domain.repository.OrderTableRepository; +import kitchenpos.eatinorders.tobe.domain.service.EatInOrderAccept; +import kitchenpos.menus.domain.FakeMenuRepository; +import kitchenpos.menus.tobe.domain.entity.Menu; +import kitchenpos.menus.tobe.domain.repository.MenuRepository; +import org.assertj.core.api.Assertions; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import java.math.BigDecimal; +import java.util.List; +import java.util.NoSuchElementException; +import java.util.UUID; + +@DisplayName("매장 주문 접수 도메인 서비스 테스트") +public class EatInOrderAcceptTest { + private OrderTableRepository orderTableRepository; + private MenuRepository menuRepository; + private EatInOrderAccept orderAccept; + private ToBeFixtures toBeFixtures; + + @BeforeEach + void setUp() { + initializeRepository(); + orderAccept = new EatInOrderAccept(orderTableRepository, menuRepository); + toBeFixtures = new ToBeFixtures(); + } + + private void initializeRepository() { + orderTableRepository = new FakeOrderTableRepository(); + menuRepository = new FakeMenuRepository(); + } + + @Test + @DisplayName("주문을 생성한다.") + void create() { + OrderLineItems orderLineItems = createDefaultOrderLineItems(); + OrderTable 주문_테이블 = orderTableRepository.save(EatInOrderFixture.sitOrderTableOf("주문_테이블")); + EatInOrder 매장_식사 = EatInOrderFixture.eatInOrderOf(orderLineItems, 주문_테이블.getId()); + + orderAccept.checkRequiredList(매장_식사); + + Assertions.assertThat(매장_식사.getId()).isNotNull(); + } + + @Test + @DisplayName("메뉴가 없으면 등록할 수 없다.") + void create_exception_nonMenu() { + OrderLineItem 주문_항목 = EatInOrderFixture.orderLineItemOf(1, BigDecimal.ONE, UUID.randomUUID()); + OrderLineItems orderLineItems = new OrderLineItems(List.of(주문_항목)); + OrderTable 주문_테이블 = orderTableRepository.save(EatInOrderFixture.sitOrderTableOf("주문_테이블")); + EatInOrder 매장_식사 = EatInOrderFixture.eatInOrderOf(orderLineItems, 주문_테이블.getId()); + + Assertions.assertThatThrownBy( + () -> orderAccept.checkRequiredList(매장_식사) + ).isInstanceOf(NoSuchElementException.class); + } + + @Test + @DisplayName("숨겨진 메뉴는 주문할 수 없다.") + void create_exception_hide_menu() { + Menu 메뉴_튀김 = toBeFixtures.메뉴_치킨; + 메뉴_튀김.hide(); + menuRepository.save(메뉴_튀김); + OrderLineItem 주문_항목 = EatInOrderFixture.orderLineItemOf(1, BigDecimal.ONE, 메뉴_튀김.getId()); + OrderLineItems orderLineItems = new OrderLineItems(List.of(주문_항목)); + OrderTable 주문_테이블 = orderTableRepository.save(EatInOrderFixture.sitOrderTableOf("주문_테이블")); + EatInOrder 매장_식사 = EatInOrderFixture.eatInOrderOf(orderLineItems, 주문_테이블.getId()); + + Assertions.assertThatThrownBy( + () -> orderAccept.checkRequiredList(매장_식사) + ).hasMessage("숨긴 메뉴가 존재합니다."); + } + + @Test + @DisplayName("빈 테이블에는 매장 주문을 등록할 수 없다.") + void create_exception_emptyOrderTable() { + OrderTable 빈_테이블 = orderTableRepository.save(EatInOrderFixture.emptyOrderTableOf("주문_테이블")); + EatInOrder 매장_식사 = EatInOrderFixture.eatInOrderOf(createDefaultOrderLineItems(), 빈_테이블.getId()); + + Assertions.assertThatThrownBy( + () -> orderAccept.checkRequiredList(매장_식사) + ).hasMessage("빈 테이블입니다."); + } + + private OrderLineItems createDefaultOrderLineItems() { + Menu menu = saveMenuBeforeTest(toBeFixtures.메뉴_치킨); + + OrderLineItem orderLineItem1 = EatInOrderFixture.orderLineItemOf( + 1, BigDecimal.valueOf(100_000), menu.getId(), menu.isDisplayed(), menu.getPrice() + ); + OrderLineItem orderLineItem2 = EatInOrderFixture.orderLineItemOf( + 1, BigDecimal.valueOf(100_000), menu.getId(), menu.isDisplayed(), menu.getPrice() + ); + return new OrderLineItems(List.of(orderLineItem1, orderLineItem2)); + } + + private Menu saveMenuBeforeTest(Menu menu) { + menuRepository.save(menu); + return menu; + } +} diff --git a/src/test/java/kitchenpos/eatinorders/domain/EatInOrderCompletePolicyTest.java b/src/test/java/kitchenpos/eatinorders/domain/EatInOrderCompletePolicyTest.java new file mode 100644 index 000000000..f340ce0da --- /dev/null +++ b/src/test/java/kitchenpos/eatinorders/domain/EatInOrderCompletePolicyTest.java @@ -0,0 +1,98 @@ +package kitchenpos.eatinorders.domain; + +import kitchenpos.ToBeFixtures; +import kitchenpos.eatinorders.EatInOrderFixture; +import kitchenpos.eatinorders.tobe.domain.constant.EatInOrderStatus; +import kitchenpos.eatinorders.tobe.domain.entity.EatInOrder; +import kitchenpos.eatinorders.tobe.domain.entity.OrderLineItem; +import kitchenpos.eatinorders.tobe.domain.entity.OrderLineItems; +import kitchenpos.eatinorders.tobe.domain.entity.OrderTable; +import kitchenpos.eatinorders.tobe.domain.repository.EatInOrderRepository; +import kitchenpos.eatinorders.tobe.domain.repository.OrderTableRepository; +import kitchenpos.eatinorders.tobe.domain.service.EatInOrderCompletePolicy; +import kitchenpos.menus.domain.FakeMenuRepository; +import kitchenpos.menus.tobe.domain.entity.Menu; +import kitchenpos.menus.tobe.domain.repository.MenuRepository; +import org.assertj.core.api.Assertions; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.mockito.Mockito; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.boot.test.mock.mockito.MockBean; + +import java.math.BigDecimal; +import java.util.List; +import java.util.Optional; + +import static org.junit.jupiter.api.Assertions.assertAll; + +@SpringBootTest +@DisplayName("매장 주문 완료 도메인 서비스 테스트") +public class EatInOrderCompletePolicyTest { + @Autowired + private EatInOrderCompletePolicy completePolicy; + @MockBean + private EatInOrderRepository orderRepository; + @MockBean + private OrderTableRepository tableRepository; + + private MenuRepository menuRepository; + private ToBeFixtures toBeFixtures; + + @BeforeEach + void setUp() { + menuRepository = new FakeMenuRepository(); + toBeFixtures = new ToBeFixtures(); + } + + @Test + @DisplayName("주문 테이블에 있는 모든 주문이 완료되면 빈 테이블로 설정한다.") + void complete() { + OrderTable 주문_테이블 = EatInOrderFixture.sitOrderTableOf("주문_테이블"); + EatInOrder 매장_식사 = EatInOrderFixture.eatInOrderOf(EatInOrderStatus.SERVED, createDefaultOrderLineItems(), 주문_테이블.getId()); + + Mockito.when(orderRepository.findAllByOrderTableId(주문_테이블.getId())) + .thenReturn(List.of(매장_식사)); + Mockito.when(tableRepository.findById(매장_식사.getOrderTableId())) + .thenReturn(Optional.of(주문_테이블)); + completePolicy.complete(매장_식사); + + assertAll( + () -> Assertions.assertThat(주문_테이블.getNumberOfGuests()).isZero(), + () -> Assertions.assertThat(주문_테이블.isNotOccupied()).isTrue() + ); + } + + @Test + @DisplayName("주문 테이블에 있는 모든 주문이 완료되지 않으면 빈 테이블로 설정되지 않는다.") + void complete_not_emptyTable() { + OrderTable 주문_테이블 = EatInOrderFixture.sitOrderTableOf("주문_테이블"); + EatInOrder 매장_식사 = EatInOrderFixture.eatInOrderOf(EatInOrderStatus.SERVED, createDefaultOrderLineItems(), 주문_테이블.getId()); + EatInOrder 매장_식사2 = EatInOrderFixture.eatInOrderOf(createDefaultOrderLineItems(), 주문_테이블.getId()); + + Mockito.when(orderRepository.findAllByOrderTableId(주문_테이블.getId())) + .thenReturn(List.of(매장_식사, 매장_식사2)); + completePolicy.complete(매장_식사); + + Assertions.assertThat(주문_테이블.isOccupied()).isTrue(); + } + + private OrderLineItems createDefaultOrderLineItems() { + Menu menu = saveMenuBeforeTest(toBeFixtures.메뉴_치킨); + + kitchenpos.eatinorders.tobe.domain.entity.OrderLineItem orderLineItem1 = EatInOrderFixture.orderLineItemOf( + 1, BigDecimal.valueOf(100_000), menu.getId(), menu.isDisplayed(), menu.getPrice() + ); + OrderLineItem orderLineItem2 = EatInOrderFixture.orderLineItemOf( + 1, BigDecimal.valueOf(100_000), menu.getId(), menu.isDisplayed(), menu.getPrice() + ); + return new OrderLineItems(List.of(orderLineItem1, orderLineItem2)); + } + + private Menu saveMenuBeforeTest(Menu menu) { + menuRepository.save(menu); + return menu; + } +} diff --git a/src/test/java/kitchenpos/eatinorders/domain/FakeEatInOrderRepository.java b/src/test/java/kitchenpos/eatinorders/domain/FakeEatInOrderRepository.java new file mode 100644 index 000000000..fb17e225a --- /dev/null +++ b/src/test/java/kitchenpos/eatinorders/domain/FakeEatInOrderRepository.java @@ -0,0 +1,39 @@ +package kitchenpos.eatinorders.domain; + +import kitchenpos.eatinorders.tobe.domain.entity.EatInOrder; +import kitchenpos.eatinorders.tobe.domain.repository.EatInOrderRepository; + +import java.util.*; +import java.util.stream.Collectors; + +public class FakeEatInOrderRepository implements EatInOrderRepository { + + private Map repository = new HashMap<>(); + + @Override + public EatInOrder save(EatInOrder order) { + repository.put(order.getId(), order); + return order; + } + + @Override + public Optional findById(UUID id) { + return Optional.ofNullable(repository.get(id)); + } + + @Override + public List findAllByOrderTableId(UUID orderTableId) { + return repository.values() + .stream() + .filter(thisOrder -> thisOrder.getOrderTableId().equals(orderTableId)) + .collect(Collectors.toList()); + } + + @Override + public List findAllByMenuId(UUID menuId) { + return repository.values() + .stream() + .filter(thisOrder -> thisOrder.hasMenuId(menuId)) + .collect(Collectors.toList()); + } +} diff --git a/src/test/java/kitchenpos/eatinorders/domain/FakeOrderTableRepository.java b/src/test/java/kitchenpos/eatinorders/domain/FakeOrderTableRepository.java new file mode 100644 index 000000000..669899192 --- /dev/null +++ b/src/test/java/kitchenpos/eatinorders/domain/FakeOrderTableRepository.java @@ -0,0 +1,25 @@ +package kitchenpos.eatinorders.domain; + +import kitchenpos.eatinorders.tobe.domain.entity.OrderTable; +import kitchenpos.eatinorders.tobe.domain.repository.OrderTableRepository; + +import java.util.HashMap; +import java.util.Map; +import java.util.Optional; +import java.util.UUID; + +public class FakeOrderTableRepository implements OrderTableRepository { + + private final Map repository = new HashMap<>(); + + @Override + public OrderTable save(OrderTable orderTable) { + repository.put(orderTable.getId(), orderTable); + return repository.get(orderTable.getId()); + } + + @Override + public Optional findById(UUID id) { + return Optional.ofNullable(repository.get(id)); + } +} diff --git a/src/test/java/kitchenpos/eatinorders/domain/OrderLineItemTest.java b/src/test/java/kitchenpos/eatinorders/domain/OrderLineItemTest.java new file mode 100644 index 000000000..bb6f9661a --- /dev/null +++ b/src/test/java/kitchenpos/eatinorders/domain/OrderLineItemTest.java @@ -0,0 +1,81 @@ +package kitchenpos.eatinorders.domain; + +import kitchenpos.eatinorders.EatInOrderFixture; +import kitchenpos.eatinorders.tobe.domain.entity.OrderLineItem; + +import org.assertj.core.api.Assertions; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; +import org.junit.jupiter.api.Test; + +import java.math.BigDecimal; +import java.util.Random; +import java.util.UUID; + +import static org.junit.jupiter.api.Assertions.assertAll; + +@DisplayName("주문 항목 도메인 테스트") +public class OrderLineItemTest { + + @Test + @DisplayName("주문 항목을 생성한다.") + void create() { + OrderLineItem 주문_항목 = EatInOrderFixture.orderLineItemOf(1, BigDecimal.ONE); + + assertAll( + () -> Assertions.assertThat(주문_항목.getSeq()).isNotNull(), + () -> Assertions.assertThat(주문_항목.getQuantity()).isNotNull(), + () -> Assertions.assertThat(주문_항목.getPrice()).isNotNull() + ); + } + + @DisplayName("예외 테스트") + @Nested + class ExceptionTest { + @Test + @DisplayName("주문 항목 생성 시 금액이 null인 경우 예외가 발생한다.") + void create_checkPrice() { + Assertions.assertThatThrownBy( + () -> EatInOrderFixture.orderLineItemOf(1, null) + ).isInstanceOf(IllegalArgumentException.class); + } + + @Test + @DisplayName("주문 항목 생성 시 금액이 음수일 경우 예외가 발생한다.") + void create_checkPrice_negative() { + Assertions.assertThatThrownBy( + () -> EatInOrderFixture.orderLineItemOf(1, BigDecimal.valueOf(-1)) + ).isInstanceOf(IllegalArgumentException.class); + } + + @Test + @DisplayName("주문 항목 생성 시 메뉴 식별자가 존재하지 않을 경우 예외가 발생한다.") + void create_checkMenuId() { + Assertions.assertThatThrownBy( + () -> new OrderLineItem(new Random().nextLong(), 1, BigDecimal.ONE, null, null) + ).isInstanceOf(IllegalArgumentException.class); + } + + @Test + @DisplayName("메뉴가 비공개일 경우 예외가 발생한다.") + void create_menuIsHide() { + Assertions.assertThatThrownBy( + () -> new OrderLineItem( + new Random().nextLong(), 1, BigDecimal.ONE, + UUID.randomUUID(), BigDecimal.ONE + ) + ).isInstanceOf(IllegalStateException.class); + } + + @Test + @DisplayName("메뉴의 가격과 주문 항목의 가격이 다르면 예외가 발생한다.") + void create_priceIsNotMenuPrice() { + Assertions.assertThatThrownBy( + () -> new OrderLineItem( + new Random().nextLong(), 1, BigDecimal.ONE, + UUID.randomUUID(), true, BigDecimal.TWO + ) + ).isInstanceOf(IllegalArgumentException.class); + } + } +} diff --git a/src/test/java/kitchenpos/eatinorders/domain/OrderTableTest.java b/src/test/java/kitchenpos/eatinorders/domain/OrderTableTest.java new file mode 100644 index 000000000..0bd8f416b --- /dev/null +++ b/src/test/java/kitchenpos/eatinorders/domain/OrderTableTest.java @@ -0,0 +1,97 @@ +package kitchenpos.eatinorders.domain; + +import kitchenpos.eatinorders.EatInOrderFixture; +import kitchenpos.eatinorders.tobe.domain.entity.OrderTable; +import org.assertj.core.api.Assertions; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.NullAndEmptySource; + +import java.util.UUID; + +import static org.junit.jupiter.api.Assertions.assertAll; + +@DisplayName("주문 테이블 도메인 테스트") +public class OrderTableTest { + + @Test + @DisplayName("주문 테이블을 등록한다.") + void create() { + OrderTable 주문_테이블 = EatInOrderFixture.emptyOrderTableOf("주문_테이블"); + + Assertions.assertThat(주문_테이블.getId()).isNotNull(); + } + + @NullAndEmptySource + @ParameterizedTest + @DisplayName("주문 테이블의 이름은 null이거나 공백일 수 없다.") + void checkValidatedName(String name) { + Assertions.assertThatThrownBy( + () -> EatInOrderFixture.emptyOrderTableOf(name) + ).isInstanceOf(IllegalArgumentException.class); + } + + @Test + @DisplayName("주문 테이블이 등록될 때 방문한 손님의 수는 0으로 설정된다.") + void create_numberOfGuests() { + Assertions.assertThatThrownBy( + () -> new OrderTable(UUID.randomUUID(), "주문_테이블", -1, false) + ).isInstanceOf(IllegalArgumentException.class); + + Assertions.assertThatThrownBy( + () -> new OrderTable(UUID.randomUUID(), "주문_테이블", 1, false) + ).isInstanceOf(IllegalArgumentException.class); + } + + @Test + @DisplayName("주문 테이블 등록 시 빈 테이블이어야 한다.") + void create_occupied() { + Assertions.assertThatThrownBy( + () -> new OrderTable(UUID.randomUUID(), "주문_테이블", 0, true) + ).isInstanceOf(IllegalArgumentException.class); + } + + @Test + @DisplayName("빈 테이블을 해지할 수 있다.") + void sit() { + OrderTable 빈_주문_테이블 = EatInOrderFixture.emptyOrderTableOf("주문_테이블"); + 빈_주문_테이블.sit(); + + Assertions.assertThat(빈_주문_테이블.isOccupied()).isTrue(); + } + + @Test + @DisplayName("방문한 손님의 수를 변경할 수 있다.") + void changeNumberOfGuests() { + OrderTable 주문_테이블 = EatInOrderFixture.sitOrderTableOf("주문_테이블"); + int 변경_숫자 = 5; + 주문_테이블.changeNumberOfGuests(변경_숫자); + + Assertions.assertThat(주문_테이블.getNumberOfGuests()).isEqualTo(변경_숫자); + } + + @Test + @DisplayName("빈 테이블은 방문한 손님의 수를 변경할 수 없다.") + void changeNumberOfGuests_exception_emptyTable() { + OrderTable 빈_테이블 = EatInOrderFixture.emptyOrderTableOf("주문_테이블"); + + Assertions.assertThatThrownBy( + () -> 빈_테이블.changeNumberOfGuests(5) + ).isInstanceOf(IllegalStateException.class); + } + + @Test + @DisplayName("빈 테이블로 설정할 수 있다.") + void clear() { + OrderTable 주문_테이블 = EatInOrderFixture.sitOrderTableOf("주문_테이블"); + 주문_테이블.changeNumberOfGuests(5); + 주문_테이블.clear(); + + assertAll( + () -> Assertions.assertThat(주문_테이블.getNumberOfGuests()).isZero(), + () -> Assertions.assertThat(주문_테이블.isNotOccupied()).isTrue() + ); + } + +} diff --git a/src/test/java/kitchenpos/eatinorders/domain/OrderTest.java b/src/test/java/kitchenpos/eatinorders/domain/OrderTest.java new file mode 100644 index 000000000..dc0015e51 --- /dev/null +++ b/src/test/java/kitchenpos/eatinorders/domain/OrderTest.java @@ -0,0 +1,61 @@ +package kitchenpos.eatinorders.domain; + +import kitchenpos.eatinorders.EatInOrderFixture; +import kitchenpos.eatinorders.tobe.domain.constant.EatInOrderStatus; +import kitchenpos.eatinorders.tobe.domain.constant.EatInOrderType; +import kitchenpos.eatinorders.tobe.domain.entity.OrderLineItem; +import kitchenpos.eatinorders.tobe.domain.entity.EatInOrder; +import kitchenpos.eatinorders.tobe.domain.entity.OrderLineItems; +import org.assertj.core.api.Assertions; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import java.math.BigDecimal; +import java.util.List; +import java.util.UUID; + +import static org.junit.jupiter.api.Assertions.assertAll; + +@DisplayName("주문 도메인 테스트") +public class OrderTest { + + @Test + @DisplayName("매장 식사 주문을 생성한다.") + void create() { + EatInOrder eatInOrder = EatInOrderFixture.eatInOrderOf(createDefaultOrderLineItems(), UUID.randomUUID()); + + assertAll( + () -> Assertions.assertThat(eatInOrder.getId()).isNotNull(), + () -> Assertions.assertThat(eatInOrder.getType()).isEqualTo(EatInOrderType.EAT_IN), + () -> Assertions.assertThat(eatInOrder.getStatus()).isEqualTo(EatInOrderStatus.WAITING) + ); + } + + @Test + @DisplayName("주문을 접수한다.") + void accept() { + EatInOrder 매장_식사 = EatInOrderFixture.eatInOrderOf(createDefaultOrderLineItems(), UUID.randomUUID()); + + 매장_식사.accept(); + + Assertions.assertThat(매장_식사.getStatus() == EatInOrderStatus.ACCEPTED).isTrue(); + } + + @Test + @DisplayName("주문을 서빙한다.") + void serve() { + EatInOrder 매장_식사 = EatInOrderFixture.eatInOrderOf( + EatInOrderStatus.ACCEPTED, createDefaultOrderLineItems(), UUID.randomUUID() + ); + + 매장_식사.serve(); + + Assertions.assertThat(매장_식사.getStatus() == EatInOrderStatus.SERVED).isTrue(); + } + + private OrderLineItems createDefaultOrderLineItems() { + OrderLineItem orderLineItem1 = EatInOrderFixture.orderLineItemOf(1, BigDecimal.ONE); + OrderLineItem orderLineItem2 = EatInOrderFixture.orderLineItemOf(1, BigDecimal.ONE); + return new OrderLineItems(List.of(orderLineItem1, orderLineItem2)); + } +} diff --git a/src/test/java/kitchenpos/eatinorders/domain/UpdateMenuInOrdersTest.java b/src/test/java/kitchenpos/eatinorders/domain/UpdateMenuInOrdersTest.java new file mode 100644 index 000000000..979ad2145 --- /dev/null +++ b/src/test/java/kitchenpos/eatinorders/domain/UpdateMenuInOrdersTest.java @@ -0,0 +1,78 @@ +package kitchenpos.eatinorders.domain; + +import kitchenpos.ToBeFixtures; +import kitchenpos.eatinorders.EatInOrderFixture; +import kitchenpos.eatinorders.tobe.domain.entity.EatInOrder; +import kitchenpos.eatinorders.tobe.domain.entity.OrderLineItem; +import kitchenpos.eatinorders.tobe.domain.entity.OrderLineItems; +import kitchenpos.eatinorders.tobe.domain.repository.EatInOrderRepository; +import kitchenpos.eatinorders.tobe.domain.repository.OrderTableRepository; +import kitchenpos.menus.tobe.domain.entity.Menu; +import kitchenpos.menus.tobe.domain.service.ChangedMenuSender; +import org.assertj.core.api.Assertions; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.mockito.Mockito; +import org.springframework.beans.factory.annotation.Autowired; + +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.boot.test.mock.mockito.MockBean; + +import java.math.BigDecimal; +import java.util.List; +import java.util.UUID; + +@SpringBootTest +@DisplayName("주문 BC 메뉴 업데이트 도메인 서비스") +public class UpdateMenuInOrdersTest { + @Autowired + private ChangedMenuSender changedMenuSender; + @MockBean + private EatInOrderRepository orderRepository; + @MockBean + private OrderTableRepository tableRepository; + + private UUID 메뉴_식별자; + + @BeforeEach + void setUp() { + 메뉴_식별자 = UUID.randomUUID(); + } + + @Test + @DisplayName("메뉴가 비공개로 변경될 경우 예외가 발생한다.") + public void exception_changedDisplayed() { + EatInOrder 매장_식사 = EatInOrderFixture.eatInOrderOf(createDefaultOrderLineItems(), UUID.randomUUID()); + Assertions.assertThat(매장_식사.getId()).isNotNull(); + + Mockito.when(orderRepository.findAllByMenuId(메뉴_식별자)) + .thenReturn(List.of(매장_식사)); + + Menu 메뉴_비공개 = ToBeFixtures.menuCreateOf(메뉴_식별자, BigDecimal.ONE, false); + Assertions.assertThatThrownBy( + () -> changedMenuSender.sendAtChangedMenu(메뉴_비공개) + ).isInstanceOf(IllegalStateException.class); + } + + @Test + @DisplayName("메뉴 금액이 변경되어 주문 항목 금액과 다를 경우 예외가 발생한다.") + public void exception_changedPrice() { + EatInOrder 매장_식사 = EatInOrderFixture.eatInOrderOf(createDefaultOrderLineItems(), UUID.randomUUID()); + Assertions.assertThat(매장_식사.getId()).isNotNull(); + + Mockito.when(orderRepository.findAllByMenuId(메뉴_식별자)) + .thenReturn(List.of(매장_식사)); + + Menu 메뉴_금액_변경 = ToBeFixtures.menuCreateOf(메뉴_식별자, BigDecimal.TWO, true); + Assertions.assertThatThrownBy( + () -> changedMenuSender.sendAtChangedMenu(메뉴_금액_변경) + ).isInstanceOf(IllegalArgumentException.class); + } + + private OrderLineItems createDefaultOrderLineItems() { + OrderLineItem orderLineItem = EatInOrderFixture.orderLineItemOf( + 1, BigDecimal.ONE, 메뉴_식별자); + return new OrderLineItems(List.of(orderLineItem)); + } +} diff --git a/src/test/java/kitchenpos/menus/domain/CleanNameTest.java b/src/test/java/kitchenpos/menus/domain/CleanNameTest.java index b2da391b7..8ede741b4 100644 --- a/src/test/java/kitchenpos/menus/domain/CleanNameTest.java +++ b/src/test/java/kitchenpos/menus/domain/CleanNameTest.java @@ -1,8 +1,8 @@ package kitchenpos.menus.domain; import kitchenpos.menus.application.FakeMenuPurgomalumClient; -import kitchenpos.menus.tobe.domain.CleanName; -import kitchenpos.menus.tobe.domain.MenuNameValidationService; +import kitchenpos.menus.tobe.domain.common.CleanName; +import kitchenpos.menus.tobe.domain.service.MenuNameValidationService; import kitchenpos.products.infra.PurgomalumClient; import org.assertj.core.api.Assertions; import org.junit.jupiter.api.BeforeEach; diff --git a/src/test/java/kitchenpos/menus/domain/FakeMenuRepository.java b/src/test/java/kitchenpos/menus/domain/FakeMenuRepository.java new file mode 100644 index 000000000..7978ad0c2 --- /dev/null +++ b/src/test/java/kitchenpos/menus/domain/FakeMenuRepository.java @@ -0,0 +1,21 @@ +package kitchenpos.menus.domain; + +import kitchenpos.menus.tobe.domain.entity.Menu; +import kitchenpos.menus.tobe.domain.repository.MenuRepository; + +import java.util.*; + +public class FakeMenuRepository implements MenuRepository { + private Map repository = new HashMap<>(); + + @Override + public Menu save(Menu menu) { + repository.put(menu.getId(), menu); + return menu; + } + + @Override + public Optional findById(UUID id) { + return Optional.ofNullable(repository.get(id)); + } +} diff --git a/src/test/java/kitchenpos/menus/domain/MenuGroupTest.java b/src/test/java/kitchenpos/menus/domain/MenuGroupTest.java index 77eb0ab8e..63f9d668e 100644 --- a/src/test/java/kitchenpos/menus/domain/MenuGroupTest.java +++ b/src/test/java/kitchenpos/menus/domain/MenuGroupTest.java @@ -1,6 +1,6 @@ package kitchenpos.menus.domain; -import kitchenpos.menus.tobe.domain.MenuGroup; +import kitchenpos.menus.tobe.domain.entity.MenuGroup; import org.assertj.core.api.Assertions; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; diff --git a/src/test/java/kitchenpos/menus/domain/MenuProductTest.java b/src/test/java/kitchenpos/menus/domain/MenuProductTest.java index 677ed0e9b..e45a468a8 100644 --- a/src/test/java/kitchenpos/menus/domain/MenuProductTest.java +++ b/src/test/java/kitchenpos/menus/domain/MenuProductTest.java @@ -1,10 +1,10 @@ package kitchenpos.menus.domain; -import kitchenpos.menus.tobe.domain.MenuProduct; import kitchenpos.ToBeFixtures; -import kitchenpos.menus.tobe.domain.MenuProducts; -import kitchenpos.menus.tobe.domain.Price; +import kitchenpos.menus.tobe.domain.entity.MenuProducts; +import kitchenpos.menus.tobe.domain.entity.MenuProduct; +import kitchenpos.menus.tobe.domain.common.Price; import kitchenpos.products.tobe.domain.Product; import org.assertj.core.api.Assertions; import org.junit.jupiter.api.BeforeEach; diff --git a/src/test/java/kitchenpos/menus/domain/MenuTest.java b/src/test/java/kitchenpos/menus/domain/MenuTest.java index d8d1858e1..d4cb34302 100644 --- a/src/test/java/kitchenpos/menus/domain/MenuTest.java +++ b/src/test/java/kitchenpos/menus/domain/MenuTest.java @@ -2,10 +2,9 @@ import kitchenpos.ToBeFixtures; import kitchenpos.menus.application.FakeMenuPurgomalumClient; -import kitchenpos.menus.tobe.domain.Menu; -import kitchenpos.menus.tobe.domain.MenuGroup; -import kitchenpos.menus.tobe.domain.MenuNameValidationService; -import kitchenpos.menus.tobe.domain.MenuProduct; +import kitchenpos.menus.tobe.domain.entity.Menu; +import kitchenpos.menus.tobe.domain.service.MenuNameValidationService; +import kitchenpos.menus.tobe.domain.entity.MenuProduct; import kitchenpos.products.infra.PurgomalumClient; import org.assertj.core.api.Assertions; import org.junit.jupiter.api.BeforeEach; @@ -36,23 +35,6 @@ void setUp() { @Nested @DisplayName("메뉴 생성 테스트") class CreateTest { - @Test - @DisplayName("메뉴를 생성한다.") - public void create() { - MenuGroup 치킨 = toBeFixtures.치킨; - List 치킨_상품_목록 = createMenuProducts(); - Menu 메뉴 = new Menu( - UUID.randomUUID(), - "튀김", - BigDecimal.valueOf(400_000), - true, - 치킨_상품_목록, - 치킨.getId() - ); - - Assertions.assertThat(메뉴.getId()).isNotNull(); - } - @NullSource @ValueSource(strings = "-1") @ParameterizedTest diff --git a/src/test/java/kitchenpos/menus/domain/PriceTest.java b/src/test/java/kitchenpos/menus/domain/PriceTest.java index 3b0b8ce4a..4da8ba314 100644 --- a/src/test/java/kitchenpos/menus/domain/PriceTest.java +++ b/src/test/java/kitchenpos/menus/domain/PriceTest.java @@ -1,6 +1,6 @@ package kitchenpos.menus.domain; -import kitchenpos.menus.tobe.domain.Price; +import kitchenpos.menus.tobe.domain.common.Price; import org.assertj.core.api.Assertions; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; diff --git a/src/test/resources/application.properties b/src/test/resources/application.properties index 7c50c69fd..e1f35ff6d 100644 --- a/src/test/resources/application.properties +++ b/src/test/resources/application.properties @@ -1,6 +1,7 @@ spring.datasource.url=jdbc:h2:mem:test;DB_CLOSE_DELAY=-1 spring.datasource.username=sa spring.flyway.enabled=false +spring.jpa.hibernate.ddl-auto=none spring.jpa.properties.hibernate.format_sql=true spring.jpa.show-sql=true logging.level.org.hibernate.type.descriptor.sql.BasicBinder=TRACE