diff --git a/README.md b/README.md index 7175c9e711..c98a8afec1 100644 --- a/README.md +++ b/README.md @@ -19,3 +19,59 @@ | 단체 지정 | table group | 통합 계산을 위해 개별 주문 테이블을 그룹화하는 기능 | | 주문 항목 | order line item | 주문에 속하는 수량이 있는 메뉴 | | 매장 식사 | eat in | 포장하지 않고 매장에서 식사하는 것 | + +## 요구 사항 + +### 상품 + +- 상품을 생성할 수 있다. + - 상품 가격은 0원 이상이어야 한다. +- 상품 목록을 조회할 수 있다. + +### 메뉴 그룹 + +- 메뉴 그룹을 생성할 수 있다. +- 메뉴 그룹의 목록을 조회할 수 있다. + +### 메뉴 + +- 메뉴를 생성할 수 있다. + - 메뉴 가격은 0원 이상이어야 한다. + - 메뉴는 존재하는 메뉴 그룹에 속해야 한다. + - 메뉴는 존재하는 상품들만 포함해야 한다. + - 메뉴의 가격은 메뉴에 속하는 상품의 가격 합보다 작거나 같아야 한다. +- 메뉴 목록을 조회할 수 있다. + +### 주문 + +- 주문을 생성할 수 있다. + - 주문 항목이 있어야 한다. + - 주문 항목의 메뉴가 모두 존재해야 한다. + - 주문은 존재하는 주문 테이블에 속해야 한다. + - 주문이 속한 주문 테이블은 빈 주문 테이블이 아니어야 한다. +- 주문 상태를 변경할 수 있다. + - 상태를 변경하려는 주문이 존재해야 한다. + - 이미 완료된 주문의 상태는 변경할 수 없다. + +### 주문 테이블 + +- 주문 테이블을 생성할 수 있다. +- 주문 테이블 목록을 조회할 수 있다. +- 주문 테이블을 빈 테이블로 변경할 수 있다. + - 변경 대상 테이블이 존재해야 한다. + - 변경 대상 테이블이 단체 지정되어 있지 않아야 한다. + - 변경 대상 테이블의 주문 상태가 조리 또는 식사가 아니어야 한다. +- 테이블의 방문한 손님 수를 변경할 수 있다. + - 방문한 손님 수는 0 이상이어야 한다. + - 변경 대상 테이블이 존재해야 한다. + - 변경 대상 테이블이 빈 테이블이 아니어야 한다. + +### 단체 지정 + +- 단체 지정을 할 수 있다. + - 지정하려는 테이블은 2개 이상이어야 한다. + - 지정하려는 테이블이 모두 존재하는 테이블이어야 한다. + - 지정하려는 테이블이 빈 테이블이어야 한다. + - 이미 지정된 테이블을 단체 지정할 수는 없다. +- 단체 지정을 해제할 수 있다. + - 해제하려는 테이블의 주문 상태가 조리 또는 식사가 아니어야 한다. diff --git a/build.gradle b/build.gradle index 976e56fd2d..dc08e8de53 100644 --- a/build.gradle +++ b/build.gradle @@ -6,7 +6,7 @@ plugins { group = 'camp.nextstep.edu' version = '0.0.1-SNAPSHOT' -sourceCompatibility = '1.8' +sourceCompatibility = '1.11' repositories { mavenCentral() diff --git a/src/main/java/kitchenpos/application/TableGroupService.java b/src/main/java/kitchenpos/application/TableGroupService.java index 69b9b4ffdf..e9bdae86c8 100644 --- a/src/main/java/kitchenpos/application/TableGroupService.java +++ b/src/main/java/kitchenpos/application/TableGroupService.java @@ -1,5 +1,9 @@ package kitchenpos.application; +import java.time.LocalDateTime; +import java.util.List; +import java.util.Objects; +import java.util.stream.Collectors; import kitchenpos.dao.OrderDao; import kitchenpos.dao.OrderTableDao; import kitchenpos.dao.TableGroupDao; @@ -10,19 +14,14 @@ import org.springframework.transaction.annotation.Transactional; import org.springframework.util.CollectionUtils; -import java.time.LocalDateTime; -import java.util.Arrays; -import java.util.List; -import java.util.Objects; -import java.util.stream.Collectors; - @Service public class TableGroupService { private final OrderDao orderDao; private final OrderTableDao orderTableDao; private final TableGroupDao tableGroupDao; - public TableGroupService(final OrderDao orderDao, final OrderTableDao orderTableDao, final TableGroupDao tableGroupDao) { + public TableGroupService(final OrderDao orderDao, final OrderTableDao orderTableDao, + final TableGroupDao tableGroupDao) { this.orderDao = orderDao; this.orderTableDao = orderTableDao; this.tableGroupDao = tableGroupDao; @@ -76,7 +75,7 @@ public void ungroup(final Long tableGroupId) { .collect(Collectors.toList()); if (orderDao.existsByOrderTableIdInAndOrderStatusIn( - orderTableIds, Arrays.asList(OrderStatus.COOKING.name(), OrderStatus.MEAL.name()))) { + orderTableIds, List.of(OrderStatus.COOKING.name(), OrderStatus.MEAL.name()))) { throw new IllegalArgumentException(); } diff --git a/src/main/java/kitchenpos/application/TableService.java b/src/main/java/kitchenpos/application/TableService.java index 2831a2e675..b994d07cea 100644 --- a/src/main/java/kitchenpos/application/TableService.java +++ b/src/main/java/kitchenpos/application/TableService.java @@ -1,5 +1,7 @@ package kitchenpos.application; +import java.util.List; +import java.util.Objects; import kitchenpos.dao.OrderDao; import kitchenpos.dao.OrderTableDao; import kitchenpos.domain.OrderStatus; @@ -7,10 +9,6 @@ import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; -import java.util.Arrays; -import java.util.List; -import java.util.Objects; - @Service public class TableService { private final OrderDao orderDao; @@ -43,7 +41,7 @@ public OrderTable changeEmpty(final Long orderTableId, final OrderTable orderTab } if (orderDao.existsByOrderTableIdAndOrderStatusIn( - orderTableId, Arrays.asList(OrderStatus.COOKING.name(), OrderStatus.MEAL.name()))) { + orderTableId, List.of(OrderStatus.COOKING.name(), OrderStatus.MEAL.name()))) { throw new IllegalArgumentException(); } diff --git a/src/test/java/kitchenpos/application/MenuGroupServiceTest.java b/src/test/java/kitchenpos/application/MenuGroupServiceTest.java new file mode 100644 index 0000000000..fb5f13839e --- /dev/null +++ b/src/test/java/kitchenpos/application/MenuGroupServiceTest.java @@ -0,0 +1,43 @@ +package kitchenpos.application; + +import static kitchenpos.support.TestFixtureFactory.메뉴_그룹을_생성한다; +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertAll; + +import java.util.List; +import kitchenpos.domain.MenuGroup; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; + +@ServiceTest +class MenuGroupServiceTest { + + @Autowired + private MenuGroupService menuGroupService; + + @Test + void 메뉴_그룹을_생성할_수_있다() { + MenuGroup menuGroup = 메뉴_그룹을_생성한다("메뉴 그룹"); + + MenuGroup savedMenuGroup = menuGroupService.create(menuGroup); + + assertAll( + () -> assertThat(savedMenuGroup.getId()).isNotNull(), + () -> assertThat(savedMenuGroup).usingRecursiveComparison() + .ignoringFields("id") + .isEqualTo(menuGroup) + ); + } + + @Test + void 메뉴_그룹의_목록을_조회할_수_있다() { + MenuGroup menuGroup1 = menuGroupService.create(메뉴_그룹을_생성한다("메뉴 그룹1")); + MenuGroup menuGroup2 = menuGroupService.create(메뉴_그룹을_생성한다("메뉴 그룹2")); + + List actual = menuGroupService.list(); + + assertThat(actual).hasSize(2) + .usingFieldByFieldElementComparator() + .containsExactly(menuGroup1, menuGroup2); + } +} \ No newline at end of file diff --git a/src/test/java/kitchenpos/application/MenuServiceTest.java b/src/test/java/kitchenpos/application/MenuServiceTest.java new file mode 100644 index 0000000000..67ec4d0e3f --- /dev/null +++ b/src/test/java/kitchenpos/application/MenuServiceTest.java @@ -0,0 +1,107 @@ +package kitchenpos.application; + +import static kitchenpos.support.TestFixtureFactory.메뉴_그룹을_생성한다; +import static kitchenpos.support.TestFixtureFactory.메뉴_상품을_생성한다; +import static kitchenpos.support.TestFixtureFactory.메뉴를_생성한다; +import static kitchenpos.support.TestFixtureFactory.상품을_생성한다; +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.junit.jupiter.api.Assertions.assertAll; + +import java.math.BigDecimal; +import java.util.List; +import kitchenpos.dao.MenuGroupDao; +import kitchenpos.dao.ProductDao; +import kitchenpos.domain.Menu; +import kitchenpos.domain.MenuProduct; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; + +@ServiceTest +class MenuServiceTest { + + @Autowired + private ProductDao productDao; + @Autowired + private MenuGroupDao menuGroupDao; + @Autowired + private MenuService menuService; + + @Test + void 메뉴를_생성할_수_있다() { + Long menuGroupId = menuGroupDao.save(메뉴_그룹을_생성한다("메뉴 그룹")) + .getId(); + Long productId = productDao.save(상품을_생성한다("상품", new BigDecimal(1_000))) + .getId(); + MenuProduct menuProduct = 메뉴_상품을_생성한다(null, productId, 1); + Menu menu = 메뉴를_생성한다("메뉴", new BigDecimal(0), menuGroupId, List.of(menuProduct)); + + Menu savedMenu = menuService.create(menu); + + assertAll( + () -> assertThat(savedMenu.getId()).isNotNull(), + () -> assertThat(savedMenu.getPrice().compareTo(menu.getPrice())).isZero(), + () -> assertThat(savedMenu).usingRecursiveComparison() + .ignoringFields("id", "price", "menuProducts") + .isEqualTo(savedMenu), + () -> assertThat(savedMenu.getMenuProducts()).hasSize(1) + .usingElementComparatorIgnoringFields("seq") + .containsOnly(menuProduct) + ); + } + + @Test + void 메뉴_가격이_0원_미만이면_예외를_반환한다() { + Menu menu = 메뉴를_생성한다("메뉴", new BigDecimal(-1), null, null); + + assertThatThrownBy(() -> menuService.create(menu)).isInstanceOf(IllegalArgumentException.class); + } + + @Test + void 메뉴_그룹이_존재하지_않으면_예외를_반환한다() { + Menu menu = 메뉴를_생성한다("메뉴", new BigDecimal(0), 0L, null); + + assertThatThrownBy(() -> menuService.create(menu)).isInstanceOf(IllegalArgumentException.class); + } + + @Test + void 존재하지_않는_상품이_메뉴에_포함되어_있으면_예외를_반환한다() { + Long menuGroupId = menuGroupDao.save(메뉴_그룹을_생성한다("메뉴 그룹")) + .getId(); + MenuProduct menuProduct = 메뉴_상품을_생성한다(null, 0L, 1); + Menu menu = 메뉴를_생성한다("메뉴", new BigDecimal(2_000), menuGroupId, List.of(menuProduct)); + + assertThatThrownBy(() -> menuService.create(menu)).isInstanceOf(IllegalArgumentException.class); + } + + @Test + void 메뉴_가격이_메뉴_상품_가격의_합보다_크면_예외를_반환한다() { + Long menuGroupId = menuGroupDao.save(메뉴_그룹을_생성한다("메뉴 그룹")) + .getId(); + Long productId = productDao.save(상품을_생성한다("상품", new BigDecimal(1_000))) + .getId(); + MenuProduct menuProduct = 메뉴_상품을_생성한다(null, productId, 1); + Menu menu = 메뉴를_생성한다("메뉴", new BigDecimal(2_000), menuGroupId, List.of(menuProduct)); + + assertThatThrownBy(() -> menuService.create(menu)).isInstanceOf(IllegalArgumentException.class); + } + + @Test + void 모든_메뉴를_조회할_수_있다() { + Long menuGroupId = menuGroupDao.save(메뉴_그룹을_생성한다("메뉴 그룹")) + .getId(); + Long productId = productDao.save(상품을_생성한다("상품", new BigDecimal(1_000))) + .getId(); + MenuProduct menuProduct = 메뉴_상품을_생성한다(null, productId, 1); + Menu menu1 = menuService.create( + 메뉴를_생성한다("메뉴1", new BigDecimal(0), menuGroupId, List.of(menuProduct))); + Menu menu2 = menuService.create( + 메뉴를_생성한다("메뉴2", new BigDecimal(0), menuGroupId, List.of(menuProduct))); + + List actual = menuService.list(); + + assertThat(actual).hasSize(2) + .usingElementComparatorIgnoringFields("price", "menuProducts") + .containsExactly(menu1, menu2); + } +} diff --git a/src/test/java/kitchenpos/application/OrderServiceTest.java b/src/test/java/kitchenpos/application/OrderServiceTest.java new file mode 100644 index 0000000000..e952a205d8 --- /dev/null +++ b/src/test/java/kitchenpos/application/OrderServiceTest.java @@ -0,0 +1,150 @@ +package kitchenpos.application; + +import static kitchenpos.domain.OrderStatus.COMPLETION; +import static kitchenpos.domain.OrderStatus.MEAL; +import static kitchenpos.support.TestFixtureFactory.메뉴_그룹을_생성한다; +import static kitchenpos.support.TestFixtureFactory.메뉴를_생성한다; +import static kitchenpos.support.TestFixtureFactory.주문_테이블을_생성한다; +import static kitchenpos.support.TestFixtureFactory.주문_항목을_생성한다; +import static kitchenpos.support.TestFixtureFactory.주문을_생성한다; +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.junit.jupiter.api.Assertions.assertAll; + +import java.math.BigDecimal; +import java.time.LocalDateTime; +import java.util.List; +import kitchenpos.dao.MenuDao; +import kitchenpos.dao.MenuGroupDao; +import kitchenpos.dao.OrderTableDao; +import kitchenpos.domain.Order; +import kitchenpos.domain.OrderLineItem; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; + +@ServiceTest +class OrderServiceTest { + + @Autowired + private MenuGroupDao menuGroupDao; + @Autowired + private MenuDao menuDao; + @Autowired + private OrderTableDao orderTableDao; + @Autowired + private OrderService orderService; + + @Test + void 주문을_생성할_수_있다() { + Long menuGroupId = menuGroupDao.save(메뉴_그룹을_생성한다("메뉴 그룹")) + .getId(); + Long menuId = menuDao.save(메뉴를_생성한다("메뉴", new BigDecimal(1_000), menuGroupId, null)) + .getId(); + Long orderTableId = orderTableDao.save(주문_테이블을_생성한다(null, 1, false)) + .getId(); + OrderLineItem orderLineItem = 주문_항목을_생성한다(null, menuId, 1); + Order order = 주문을_생성한다(orderTableId, null, LocalDateTime.now(), List.of(orderLineItem)); + + Order savedOrder = orderService.create(order); + + assertAll( + () -> assertThat(savedOrder.getId()).isNotNull(), + () -> assertThat(savedOrder.getOrderStatus()).isNotNull(), + () -> assertThat(orderLineItem.getOrderId()).isEqualTo(savedOrder.getId()) + ); + } + + @Test + void 생성하려는_주문에_주문_항목이_없으면_예외를_반환한다() { + Long orderTableId = orderTableDao.save(주문_테이블을_생성한다(null, 1, false)) + .getId(); + Order order = 주문을_생성한다(orderTableId, null, LocalDateTime.now(), List.of()); + + assertThatThrownBy(() -> orderService.create(order)).isInstanceOf(IllegalArgumentException.class); + } + + @Test + void 생성하려는_주문이_속한_주문_테이블이_존재하지_않으면_예외를_반환한다() { + Long menuGroupId = menuGroupDao.save(메뉴_그룹을_생성한다("메뉴 그룹")) + .getId(); + Long menuId = menuDao.save(메뉴를_생성한다("메뉴", new BigDecimal(1_000), menuGroupId, null)) + .getId(); + OrderLineItem orderLineItem = 주문_항목을_생성한다(null, menuId, 1); + Order order = 주문을_생성한다(0L, null, LocalDateTime.now(), List.of(orderLineItem)); + + assertThatThrownBy(() -> orderService.create(order)).isInstanceOf(IllegalArgumentException.class); + } + + @Test + void 생성하려는_주문이_속한_주문_테이블이_빈_주문_테이블이면_예외를_반환한다() { + Long menuGroupId = menuGroupDao.save(메뉴_그룹을_생성한다("메뉴 그룹")) + .getId(); + Long menuId = menuDao.save(메뉴를_생성한다("메뉴", new BigDecimal(1_000), menuGroupId, null)) + .getId(); + Long orderTableId = orderTableDao.save(주문_테이블을_생성한다(null, 1, true)) + .getId(); + OrderLineItem orderLineItem = 주문_항목을_생성한다(null, menuId, 1); + Order order = 주문을_생성한다(orderTableId, null, LocalDateTime.now(), List.of(orderLineItem)); + + assertThatThrownBy(() -> orderService.create(order)).isInstanceOf(IllegalArgumentException.class); + } + + @Test + void 모든_주문_목록을_조회할_수_있다() { + Long menuGroupId = menuGroupDao.save(메뉴_그룹을_생성한다("메뉴 그룹")) + .getId(); + Long menuId = menuDao.save(메뉴를_생성한다("메뉴", new BigDecimal(1_000), menuGroupId, null)) + .getId(); + Long orderTableId = orderTableDao.save(주문_테이블을_생성한다(null, 1, false)) + .getId(); + OrderLineItem orderLineItem = 주문_항목을_생성한다(null, menuId, 1); + Order order1 = orderService.create(주문을_생성한다(orderTableId, null, LocalDateTime.now(), List.of(orderLineItem))); + Order order2 = orderService.create(주문을_생성한다(orderTableId, null, LocalDateTime.now(), List.of(orderLineItem))); + + List actual = orderService.list(); + + assertThat(actual).hasSize(2) + .usingElementComparatorIgnoringFields("orderLineItems") + .containsExactly(order1, order2); + } + + @Test + void 주문_상태를_변경할_수_있다() { + Long menuGroupId = menuGroupDao.save(메뉴_그룹을_생성한다("메뉴 그룹")) + .getId(); + Long menuId = menuDao.save(메뉴를_생성한다("메뉴", new BigDecimal(1_000), menuGroupId, null)) + .getId(); + Long orderTableId = orderTableDao.save(주문_테이블을_생성한다(null, 1, false)) + .getId(); + OrderLineItem orderLineItem = 주문_항목을_생성한다(null, menuId, 1); + Order order = orderService.create(주문을_생성한다(orderTableId, null, LocalDateTime.now(), List.of(orderLineItem))); + order.setOrderStatus(MEAL.name()); + + Order changedOrder = orderService.changeOrderStatus(order.getId(), order); + + assertThat(changedOrder.getOrderStatus()).isEqualTo(MEAL.name()); + } + + @Test + void 상태를_변경하려는_주문이_존재하지_않으면_예외를_반환한다() { + assertThatThrownBy(() -> orderService.changeOrderStatus(0L, null)) + .isInstanceOf(IllegalArgumentException.class); + } + + @Test + void 상태를_변경하려는_주문이_완료된_주문이면_예외를_반환한다() { + Long menuGroupId = menuGroupDao.save(메뉴_그룹을_생성한다("메뉴 그룹")) + .getId(); + Long menuId = menuDao.save(메뉴를_생성한다("메뉴", new BigDecimal(1_000), menuGroupId, null)) + .getId(); + Long orderTableId = orderTableDao.save(주문_테이블을_생성한다(null, 1, false)) + .getId(); + OrderLineItem orderLineItem = 주문_항목을_생성한다(null, menuId, 1); + Order order = orderService.create(주문을_생성한다(orderTableId, null, LocalDateTime.now(), List.of(orderLineItem))); + order.setOrderStatus(COMPLETION.name()); + orderService.changeOrderStatus(order.getId(), order); + + assertThatThrownBy(() -> orderService.changeOrderStatus(order.getId(), order)) + .isInstanceOf(IllegalArgumentException.class); + } +} diff --git a/src/test/java/kitchenpos/application/ProductServiceTest.java b/src/test/java/kitchenpos/application/ProductServiceTest.java new file mode 100644 index 0000000000..04bc88e182 --- /dev/null +++ b/src/test/java/kitchenpos/application/ProductServiceTest.java @@ -0,0 +1,50 @@ +package kitchenpos.application; + +import static kitchenpos.support.TestFixtureFactory.상품을_생성한다; +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.junit.jupiter.api.Assertions.assertAll; + +import java.math.BigDecimal; +import java.util.List; +import kitchenpos.domain.Product; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; + +@ServiceTest +class ProductServiceTest { + + @Autowired + private ProductService productService; + + @Test + void 상품을_생성할_수_있다() { + Product product = 상품을_생성한다("상품", new BigDecimal(0)); + + Product savedProduct = productService.create(product); + + assertAll( + () -> assertThat(savedProduct.getId()).isNotNull(), + () -> assertThat(savedProduct.getName()).isEqualTo(product.getName()), + () -> assertThat(savedProduct.getPrice().compareTo(product.getPrice())).isZero() + ); + } + + @Test + void 상품_가격이_0원_미만이면_예외를_반환한다() { + Product product = 상품을_생성한다("상품", new BigDecimal(-1)); + + assertThatThrownBy(() -> productService.create(product)).isInstanceOf(IllegalArgumentException.class); + } + + @Test + void 상품_목록을_조회할_수_있다() { + Product savedProduct = productService.create(상품을_생성한다("상품", new BigDecimal(0))); + + List products = productService.list(); + + assertThat(products).hasSize(1) + .usingFieldByFieldElementComparator() + .containsOnly(savedProduct); + } +} \ No newline at end of file diff --git a/src/test/java/kitchenpos/application/ServiceTest.java b/src/test/java/kitchenpos/application/ServiceTest.java new file mode 100644 index 0000000000..95009368c6 --- /dev/null +++ b/src/test/java/kitchenpos/application/ServiceTest.java @@ -0,0 +1,15 @@ +package kitchenpos.application; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.transaction.annotation.Transactional; + +@Target(ElementType.TYPE) +@Retention(RetentionPolicy.RUNTIME) +@SpringBootTest +@Transactional +public @interface ServiceTest { +} diff --git a/src/test/java/kitchenpos/application/TableGroupServiceTest.java b/src/test/java/kitchenpos/application/TableGroupServiceTest.java new file mode 100644 index 0000000000..23f4377393 --- /dev/null +++ b/src/test/java/kitchenpos/application/TableGroupServiceTest.java @@ -0,0 +1,111 @@ +package kitchenpos.application; + +import static kitchenpos.domain.OrderStatus.COOKING; +import static kitchenpos.support.TestFixtureFactory.단체_지정을_생성한다; +import static kitchenpos.support.TestFixtureFactory.주문_테이블을_생성한다; +import static kitchenpos.support.TestFixtureFactory.주문을_생성한다; +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.junit.jupiter.api.Assertions.assertAll; +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; + +import java.time.LocalDateTime; +import java.util.List; +import kitchenpos.dao.OrderDao; +import kitchenpos.dao.OrderTableDao; +import kitchenpos.domain.OrderTable; +import kitchenpos.domain.TableGroup; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; + +@ServiceTest +class TableGroupServiceTest { + + @Autowired + private OrderTableDao orderTableDao; + @Autowired + private OrderDao orderDao; + @Autowired + private TableGroupService tableGroupService; + + @Test + void 단체_지정을_할_수_있다() { + OrderTable orderTable1 = orderTableDao.save(주문_테이블을_생성한다(null, 1, true)); + OrderTable orderTable2 = orderTableDao.save(주문_테이블을_생성한다(null, 2, true)); + TableGroup tableGroup = 단체_지정을_생성한다(LocalDateTime.now(), List.of(orderTable1, orderTable2)); + + TableGroup savedTableGroup = tableGroupService.create(tableGroup); + + orderTable1.setTableGroupId(savedTableGroup.getId()); + orderTable1.setEmpty(false); + orderTable2.setTableGroupId(savedTableGroup.getId()); + orderTable2.setEmpty(false); + + assertAll( + () -> assertThat(savedTableGroup.getId()).isNotNull(), + () -> assertThat(savedTableGroup).usingRecursiveComparison() + .ignoringFields("id", "orderTables") + .isEqualTo(tableGroup), + () -> assertThat(savedTableGroup.getOrderTables()) + .usingFieldByFieldElementComparator() + .containsExactly(orderTable1, orderTable2) + ); + } + + @Test + void 단체_지정하려는_테이블이_2개_미만이면_예외를_반환한다() { + OrderTable orderTable = orderTableDao.save(주문_테이블을_생성한다(null, 1, true)); + TableGroup tableGroup = 단체_지정을_생성한다(LocalDateTime.now(), List.of(orderTable)); + + assertThatThrownBy(() -> tableGroupService.create(tableGroup)).isInstanceOf(IllegalArgumentException.class); + } + + @Test + void 단체_지정하려는_테이블이_존재하지_않으면_예외를_반환한다() { + OrderTable orderTable1 = orderTableDao.save(주문_테이블을_생성한다(null, 1, true)); + OrderTable orderTable2 = 주문_테이블을_생성한다(null, 2, true); + TableGroup tableGroup = 단체_지정을_생성한다(LocalDateTime.now(), List.of(orderTable1, orderTable2)); + + assertThatThrownBy(() -> tableGroupService.create(tableGroup)).isInstanceOf(IllegalArgumentException.class); + } + + @Test + void 단체_지정하려는_테이블이_빈_테이블이_아니면_예외를_반환한다() { + OrderTable orderTable1 = orderTableDao.save(주문_테이블을_생성한다(null, 1, true)); + OrderTable orderTable2 = orderTableDao.save(주문_테이블을_생성한다(null, 2, false)); + TableGroup tableGroup = 단체_지정을_생성한다(LocalDateTime.now(), List.of(orderTable1, orderTable2)); + + assertThatThrownBy(() -> tableGroupService.create(tableGroup)).isInstanceOf(IllegalArgumentException.class); + } + + @Test + void 이미_지정된_테이블을_단체_지정할_수_없다() { + OrderTable orderTable1 = orderTableDao.save(주문_테이블을_생성한다(null, 1, true)); + OrderTable orderTable2 = orderTableDao.save(주문_테이블을_생성한다(null, 2, true)); + TableGroup tableGroup = 단체_지정을_생성한다(LocalDateTime.now(), List.of(orderTable1, orderTable2)); + tableGroupService.create(tableGroup); + + assertThatThrownBy(() -> tableGroupService.create(tableGroup)).isInstanceOf(IllegalArgumentException.class); + } + + @Test + void 테이블의_단체_지정을_해제할_수_있다() { + OrderTable orderTable1 = orderTableDao.save(주문_테이블을_생성한다(null, 1, true)); + OrderTable orderTable2 = orderTableDao.save(주문_테이블을_생성한다(null, 2, true)); + Long tableGroupId = tableGroupService.create( + 단체_지정을_생성한다(LocalDateTime.now(), List.of(orderTable1, orderTable2))).getId(); + + assertDoesNotThrow(() -> tableGroupService.ungroup(tableGroupId)); + } + + @Test + void 단체_지정하려는_테이블의_주문_목록_중_식사_중인_주문이_있을_경우_예외를_반환한다() { + OrderTable orderTable1 = orderTableDao.save(주문_테이블을_생성한다(null, 1, true)); + OrderTable orderTable2 = orderTableDao.save(주문_테이블을_생성한다(null, 2, true)); + Long tableGroupId = tableGroupService.create( + 단체_지정을_생성한다(LocalDateTime.now(), List.of(orderTable1, orderTable2))).getId(); + orderDao.save(주문을_생성한다(orderTable1.getId(), COOKING.name(), LocalDateTime.now(), null)); + + assertThatThrownBy(() -> tableGroupService.ungroup(tableGroupId)).isInstanceOf(IllegalArgumentException.class); + } +} \ No newline at end of file diff --git a/src/test/java/kitchenpos/application/TableServiceTest.java b/src/test/java/kitchenpos/application/TableServiceTest.java new file mode 100644 index 0000000000..4b9867e88c --- /dev/null +++ b/src/test/java/kitchenpos/application/TableServiceTest.java @@ -0,0 +1,133 @@ +package kitchenpos.application; + +import static kitchenpos.domain.OrderStatus.COOKING; +import static kitchenpos.domain.OrderStatus.MEAL; +import static kitchenpos.support.TestFixtureFactory.단체_지정을_생성한다; +import static kitchenpos.support.TestFixtureFactory.주문_테이블을_생성한다; +import static kitchenpos.support.TestFixtureFactory.주문을_생성한다; +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.junit.jupiter.api.Assertions.assertAll; + +import java.time.LocalDateTime; +import java.util.List; +import kitchenpos.dao.OrderDao; +import kitchenpos.dao.OrderTableDao; +import kitchenpos.dao.TableGroupDao; +import kitchenpos.domain.OrderTable; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; + +@ServiceTest +class TableServiceTest { + + @Autowired + private TableGroupDao tableGroupDao; + @Autowired + private OrderTableDao orderTableDao; + @Autowired + private OrderDao orderDao; + @Autowired + private TableService tableService; + + @Test + void 주문_테이블을_생성할_수_있다() { + OrderTable orderTable = 주문_테이블을_생성한다(null, 1, false); + + OrderTable savedOrderTable = tableService.create(orderTable); + + assertAll( + () -> assertThat(savedOrderTable.getId()).isNotNull(), + () -> assertThat(savedOrderTable).usingRecursiveComparison() + .ignoringFields("id") + .isEqualTo(orderTable) + ); + } + + @Test + void 주문_테이블_목록을_조회할_수_있다() { + OrderTable orderTable1 = tableService.create(주문_테이블을_생성한다(null, 1, false)); + OrderTable orderTable2 = tableService.create(주문_테이블을_생성한다(null, 0, true)); + + List actual = tableService.list(); + + assertThat(actual).hasSize(2) + .usingFieldByFieldElementComparator() + .containsExactly(orderTable1, orderTable2); + } + + @Test + void 주문_테이블을_빈_테이블로_변경할_수_있다() { + OrderTable orderTable = tableService.create(주문_테이블을_생성한다(null, 1, false)); + + OrderTable changedOrderTable = tableService.changeEmpty(orderTable.getId(), 주문_테이블을_생성한다(null, 1, true)); + + assertThat(changedOrderTable.isEmpty()).isTrue(); + } + + @Test + void 변경_대상_테이블이_존재하지_않으면_예외를_반환한다() { + assertThatThrownBy(() -> tableService.changeEmpty(0L, null)) + .isInstanceOf(IllegalArgumentException.class); + } + + @Test + void 변경_대상_테이블이_단체_지정되어_있으면_예외를_반환한다() { + OrderTable orderTable1 = tableService.create(주문_테이블을_생성한다(null, 1, true)); + OrderTable orderTable2 = tableService.create(주문_테이블을_생성한다(null, 0, true)); + orderTable1.setTableGroupId( + tableGroupDao.save(단체_지정을_생성한다(LocalDateTime.now(), List.of(orderTable1, orderTable2))).getId()); + orderTableDao.save(orderTable1); + + assertThatThrownBy(() -> tableService.changeEmpty(orderTable1.getId(), orderTable1)) + .isInstanceOf(IllegalArgumentException.class); + } + + @Test + void 변경_대상_테이블의_주문_목록_중_식사_중인_주문이_있을_경우_예외를_반환한다() { + OrderTable orderTable = tableService.create(주문_테이블을_생성한다(null, 1, false)); + orderDao.save(주문을_생성한다(orderTable.getId(), COOKING.name(), LocalDateTime.now(), null)); + + assertThatThrownBy(() -> tableService.changeEmpty(orderTable.getId(), orderTable)) + .isInstanceOf(IllegalArgumentException.class); + } + + @Test + void 변경_대상_테이블의_주문_목록_중_조리_중인_주문이_있을_경우_예외를_반환한다() { + OrderTable orderTable = tableService.create(주문_테이블을_생성한다(null, 1, false)); + orderDao.save(주문을_생성한다(orderTable.getId(), MEAL.name(), LocalDateTime.now(), null)); + + assertThatThrownBy(() -> tableService.changeEmpty(orderTable.getId(), orderTable)) + .isInstanceOf(IllegalArgumentException.class); + } + + @Test + void 테이블의_방문한_손님_수를_변경할_수_있다() { + OrderTable orderTable = tableService.create(주문_테이블을_생성한다(null, 0, false)); + orderTable.setNumberOfGuests(1); + + tableService.changeNumberOfGuests(orderTable.getId(), orderTable); + + assertThat(orderTable.getNumberOfGuests()).isOne(); + } + + @Test + void 변경하려는_인원이_0명_미만이면_예외를_반환한다() { + assertThatThrownBy(() -> tableService.changeNumberOfGuests(1L, 주문_테이블을_생성한다(0L, -1, false))) + .isInstanceOf(IllegalArgumentException.class); + } + + @Test + void 인원_변경_테이블이_존재하지_않으면_예외를_반환한다() { + assertThatThrownBy(() -> tableService.changeNumberOfGuests(0L, 주문_테이블을_생성한다(0L, 1, false))) + .isInstanceOf(IllegalArgumentException.class); + } + + @Test + void 인원_변경_테이블이_빈_테이블이면_예외를_반환한다() { + OrderTable orderTable = tableService.create(주문_테이블을_생성한다(null, 0, true)); + + assertThatThrownBy(() -> tableService.changeNumberOfGuests(orderTable.getId(), orderTable)) + .isInstanceOf(IllegalArgumentException.class); + } +} diff --git a/src/test/java/kitchenpos/dao/DaoTest.java b/src/test/java/kitchenpos/dao/DaoTest.java new file mode 100644 index 0000000000..35b7bde63a --- /dev/null +++ b/src/test/java/kitchenpos/dao/DaoTest.java @@ -0,0 +1,16 @@ +package kitchenpos.dao; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; +import org.springframework.boot.test.autoconfigure.jdbc.JdbcTest; +import org.springframework.context.annotation.ComponentScan.Filter; +import org.springframework.context.annotation.FilterType; +import org.springframework.stereotype.Repository; + +@Target(ElementType.TYPE) +@Retention(RetentionPolicy.RUNTIME) +@JdbcTest(includeFilters = @Filter(type = FilterType.ANNOTATION, classes = {Repository.class})) +public @interface DaoTest { +} diff --git a/src/test/java/kitchenpos/dao/MenuDaoTest.java b/src/test/java/kitchenpos/dao/MenuDaoTest.java new file mode 100644 index 0000000000..61b075a55b --- /dev/null +++ b/src/test/java/kitchenpos/dao/MenuDaoTest.java @@ -0,0 +1,87 @@ +package kitchenpos.dao; + +import static kitchenpos.support.TestFixtureFactory.메뉴_그룹을_생성한다; +import static kitchenpos.support.TestFixtureFactory.메뉴를_생성한다; +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertAll; + +import java.math.BigDecimal; +import java.util.List; +import java.util.Optional; +import kitchenpos.domain.Menu; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; + +@DaoTest +class MenuDaoTest { + + @Autowired + private MenuGroupDao menuGroupDao; + @Autowired + private MenuDao menuDao; + + @Test + void 메뉴를_저장하면_id가_채워진다() { + Long menuGroupId = menuGroupDao.save(메뉴_그룹을_생성한다("메뉴 그룹")).getId(); + Menu menu = 메뉴를_생성한다("메뉴", new BigDecimal(0), menuGroupId, null); + + Menu savedMenu = menuDao.save(menu); + + assertAll( + () -> assertThat(savedMenu.getId()).isNotNull(), + () -> assertThat(savedMenu.getPrice().compareTo(menu.getPrice())).isZero(), + () -> assertThat(savedMenu).usingRecursiveComparison() + .ignoringFields("id", "price") + .isEqualTo(menu) + ); + } + + @Test + void id로_메뉴를_조회할_수_있다() { + Long menuGroupId = menuGroupDao.save(메뉴_그룹을_생성한다("메뉴 그룹")).getId(); + Menu menu = menuDao.save(메뉴를_생성한다("메뉴", new BigDecimal(0), menuGroupId, null)); + + Menu actual = menuDao.findById(menu.getId()) + .orElseGet(Assertions::fail); + + assertAll( + () -> assertThat(actual.getPrice().compareTo(menu.getPrice())).isZero(), + () -> assertThat(actual).usingRecursiveComparison() + .ignoringFields("price") + .isEqualTo(menu) + ); + } + + @Test + void 없는_메뉴_id로_조회하면_Optional_empty를_반환한다() { + Optional actual = menuDao.findById(0L); + + assertThat(actual).isEmpty(); + } + + @Test + void 모든_메뉴를_조회할_수_있다() { + Long menuGroupId = menuGroupDao.save(메뉴_그룹을_생성한다("메뉴 그룹")).getId(); + Menu menu1 = menuDao.save(메뉴를_생성한다("메뉴1", new BigDecimal(0), menuGroupId, null)); + Menu menu2 = menuDao.save(메뉴를_생성한다("메뉴2", new BigDecimal(0), menuGroupId, null)); + + List actual = menuDao.findAll(); + + assertThat(actual).hasSize(2) + .usingElementComparatorIgnoringFields("price") + .containsExactly(menu1, menu2); + } + + @Test + void id_목록에_있는_메뉴의_개수를_셀_수_있다() { + Long menuGroupId = menuGroupDao.save(메뉴_그룹을_생성한다("메뉴 그룹")).getId(); + Menu menu1 = menuDao.save(메뉴를_생성한다("메뉴1", new BigDecimal(0), menuGroupId, null)); + Menu menu2 = menuDao.save(메뉴를_생성한다("메뉴2", new BigDecimal(0), menuGroupId, null)); + List ids = List.of(menu1.getId(), menu2.getId()); + + long count = menuDao.countByIdIn(ids); + + assertThat(count).isEqualTo(ids.size()); + } +} \ No newline at end of file diff --git a/src/test/java/kitchenpos/dao/MenuGroupDaoTest.java b/src/test/java/kitchenpos/dao/MenuGroupDaoTest.java new file mode 100644 index 0000000000..bfe1bb39f2 --- /dev/null +++ b/src/test/java/kitchenpos/dao/MenuGroupDaoTest.java @@ -0,0 +1,79 @@ +package kitchenpos.dao; + +import static kitchenpos.support.TestFixtureFactory.메뉴_그룹을_생성한다; +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertAll; + +import java.util.List; +import java.util.Optional; +import kitchenpos.domain.MenuGroup; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; + +@DaoTest +class MenuGroupDaoTest { + + @Autowired + private MenuGroupDao menuGroupDao; + + @Test + void 메뉴_그룹을_저장하면_id값이_채워진다() { + MenuGroup menuGroup = 메뉴_그룹을_생성한다("메뉴 그룹"); + + MenuGroup savedMenuGroup = menuGroupDao.save(menuGroup); + + assertAll( + () -> assertThat(savedMenuGroup).usingRecursiveComparison() + .ignoringFields("id") + .isEqualTo(menuGroup), + () -> assertThat(savedMenuGroup.getId()).isNotNull() + ); + } + + @Test + void 메뉴_그룹을_id로_조회할_수_있다() { + MenuGroup menuGroup = menuGroupDao.save(메뉴_그룹을_생성한다("메뉴 그룹")); + + MenuGroup actual = menuGroupDao.findById(menuGroup.getId()) + .orElseGet(Assertions::fail); + + assertThat(actual).usingRecursiveComparison() + .isEqualTo(menuGroup); + } + + @Test + void 없는_메뉴_그룹_id로_조회하면_Optional_empty를_반환한다() { + Optional actual = menuGroupDao.findById(0L); + + assertThat(actual).isEmpty(); + } + + @Test + void 모든_메뉴그룹을_조회할_수_있다() { + MenuGroup menuGroup1 = menuGroupDao.save(메뉴_그룹을_생성한다("메뉴 그룹1")); + MenuGroup menuGroup2 = menuGroupDao.save(메뉴_그룹을_생성한다("메뉴 그룹2")); + + List actual = menuGroupDao.findAll(); + + assertThat(actual).hasSize(2) + .usingFieldByFieldElementComparator() + .containsExactly(menuGroup1, menuGroup2); + } + + @Test + void 메뉴_그룹이_존재하면_true를_반환한다() { + MenuGroup menuGroup = menuGroupDao.save(메뉴_그룹을_생성한다("메뉴 그룹")); + + boolean actual = menuGroupDao.existsById(menuGroup.getId()); + + assertThat(actual).isTrue(); + } + + @Test + void 메뉴_그룹이_존재하지_않으면_false를_반환한다() { + boolean actual = menuGroupDao.existsById(0L); + + assertThat(actual).isFalse(); + } +} \ No newline at end of file diff --git a/src/test/java/kitchenpos/dao/MenuProductDaoTest.java b/src/test/java/kitchenpos/dao/MenuProductDaoTest.java new file mode 100644 index 0000000000..b5075070b7 --- /dev/null +++ b/src/test/java/kitchenpos/dao/MenuProductDaoTest.java @@ -0,0 +1,117 @@ +package kitchenpos.dao; + +import static kitchenpos.support.TestFixtureFactory.메뉴_그룹을_생성한다; +import static kitchenpos.support.TestFixtureFactory.메뉴_상품을_생성한다; +import static kitchenpos.support.TestFixtureFactory.메뉴를_생성한다; +import static kitchenpos.support.TestFixtureFactory.상품을_생성한다; +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertAll; + +import java.math.BigDecimal; +import java.util.List; +import java.util.Optional; +import kitchenpos.domain.MenuProduct; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; + +@DaoTest +class MenuProductDaoTest { + + @Autowired + private MenuGroupDao menuGroupDao; + @Autowired + private MenuDao menuDao; + @Autowired + private ProductDao productDao; + @Autowired + private MenuProductDao menuProductDao; + + @Test + void 메뉴_상품을_저장하면_seq가_채워진다() { + Long menuGroupId = menuGroupDao.save(메뉴_그룹을_생성한다("메뉴 그룹")) + .getId(); + Long menuId = menuDao.save(메뉴를_생성한다("메뉴", new BigDecimal(0), menuGroupId, null)) + .getId(); + Long productId = productDao.save(상품을_생성한다("상품", new BigDecimal(0))) + .getId(); + MenuProduct menuProduct = 메뉴_상품을_생성한다(menuId, productId, 1); + + MenuProduct savedMenuProduct = menuProductDao.save(menuProduct); + + assertAll( + () -> assertThat(savedMenuProduct.getSeq()).isNotNull(), + () -> assertThat(savedMenuProduct).usingRecursiveComparison() + .ignoringFields("seq") + .isEqualTo(menuProduct) + ); + } + + @Test + void id로_메뉴를_조회할_수_있다() { + Long menuGroupId = menuGroupDao.save(메뉴_그룹을_생성한다("메뉴 그룹")) + .getId(); + Long menuId = menuDao.save(메뉴를_생성한다("메뉴", new BigDecimal(0), menuGroupId, null)) + .getId(); + Long productId = productDao.save(상품을_생성한다("상품", new BigDecimal(0))) + .getId(); + MenuProduct menuProduct = menuProductDao.save(메뉴_상품을_생성한다(menuId, productId, 1)); + + MenuProduct actual = menuProductDao.findById(menuProduct.getSeq()) + .orElseGet(Assertions::fail); + + assertThat(actual).usingRecursiveComparison() + .isEqualTo(menuProduct); + } + + @Test + void 없는_메뉴_상품_id로_조회하면_Optional_empty를_반환한다() { + Optional actual = menuProductDao.findById(0L); + + assertThat(actual).isEmpty(); + } + + @Test + void 모든_메뉴_상품을_조회할_수_있다() { + Long menuGroupId = menuGroupDao.save(메뉴_그룹을_생성한다("메뉴 그룹")) + .getId(); + Long menuId1 = menuDao.save(메뉴를_생성한다("메뉴1", new BigDecimal(0), menuGroupId, null)) + .getId(); + Long menuId2 = menuDao.save(메뉴를_생성한다("메뉴2", new BigDecimal(0), menuGroupId, null)) + .getId(); + Long productId1 = productDao.save(상품을_생성한다("상품1", new BigDecimal(0))) + .getId(); + Long productId2 = productDao.save(상품을_생성한다("상품2", new BigDecimal(0))) + .getId(); + MenuProduct menuProduct1 = menuProductDao.save(메뉴_상품을_생성한다(menuId1, productId1, 1)); + MenuProduct menuProduct2 = menuProductDao.save(메뉴_상품을_생성한다(menuId2, productId2, 2)); + + List actual = menuProductDao.findAll(); + + assertThat(actual).hasSize(2) + .usingFieldByFieldElementComparator() + .containsExactly(menuProduct1, menuProduct2); + } + + @Test + void 메뉴_id에_해당하는_모든_메뉴_상품을_조회할_수_있다() { + Long menuGroupId = menuGroupDao.save(메뉴_그룹을_생성한다("메뉴 그룹")) + .getId(); + Long menuId1 = menuDao.save(메뉴를_생성한다("메뉴1", new BigDecimal(0), menuGroupId, null)) + .getId(); + Long menuId2 = menuDao.save(메뉴를_생성한다("메뉴2", new BigDecimal(0), menuGroupId, null)) + .getId(); + Long productId1 = productDao.save(상품을_생성한다("상품1", new BigDecimal(0))) + .getId(); + Long productId2 = productDao.save(상품을_생성한다("상품2", new BigDecimal(0))) + .getId(); + MenuProduct menuProduct1 = menuProductDao.save(메뉴_상품을_생성한다(menuId1, productId1, 1)); + menuProductDao.save(메뉴_상품을_생성한다(menuId2, productId2, 2)); + + List actual = menuProductDao.findAllByMenuId(menuId1); + + assertThat(actual).hasSize(1) + .usingFieldByFieldElementComparator() + .containsExactly(menuProduct1); + } +} \ No newline at end of file diff --git a/src/test/java/kitchenpos/dao/OrderDaoTest.java b/src/test/java/kitchenpos/dao/OrderDaoTest.java new file mode 100644 index 0000000000..2f562c1efd --- /dev/null +++ b/src/test/java/kitchenpos/dao/OrderDaoTest.java @@ -0,0 +1,134 @@ +package kitchenpos.dao; + +import static kitchenpos.domain.OrderStatus.COOKING; +import static kitchenpos.domain.OrderStatus.MEAL; +import static kitchenpos.support.TestFixtureFactory.주문_테이블을_생성한다; +import static kitchenpos.support.TestFixtureFactory.주문을_생성한다; +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertAll; + +import java.time.LocalDateTime; +import java.util.List; +import java.util.Optional; +import kitchenpos.domain.Order; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; + +@DaoTest +class OrderDaoTest { + + @Autowired + private OrderTableDao orderTableDao; + @Autowired + private OrderDao orderDao; + + @Test + void 주문을_저장하면_id가_채워진다() { + Long orderTableId = orderTableDao.save(주문_테이블을_생성한다(null, 1, false)) + .getId(); + Order order = 주문을_생성한다(orderTableId, COOKING.name(), LocalDateTime.now(), null); + + Order savedOrder = orderDao.save(order); + + assertAll( + () -> assertThat(savedOrder.getId()).isNotNull(), + () -> assertThat(savedOrder).usingRecursiveComparison() + .ignoringFields("id") + .isEqualTo(order) + ); + } + + @Test + void 저장하는_주문의_id가_null이_아니면_업데이트_한다() { + Long orderTableId = orderTableDao.save(주문_테이블을_생성한다(null, 1, false)) + .getId(); + Long orderId = orderDao.save(주문을_생성한다(orderTableId, COOKING.name(), LocalDateTime.now(), null)) + .getId(); + Order updateOrder = 주문을_생성한다(orderTableId, MEAL.name(), LocalDateTime.now(), null); + updateOrder.setId(orderId); + + Order savedOrder = orderDao.save(updateOrder); + + assertThat(savedOrder).usingRecursiveComparison() + .isEqualTo(updateOrder); + } + + @Test + void id로_주문을_조회할_수_있다() { + Long orderTableId = orderTableDao.save(주문_테이블을_생성한다(null, 1, false)) + .getId(); + Order order = orderDao.save(주문을_생성한다(orderTableId, COOKING.name(), LocalDateTime.now(), null)); + + Order actual = orderDao.findById(order.getId()) + .orElseGet(Assertions::fail); + + assertThat(actual).usingRecursiveComparison() + .isEqualTo(order); + } + + @Test + void 없는_id로_주문을_조회하면_Optional_empty를_반환한다() { + Optional actual = orderDao.findById(0L); + + assertThat(actual).isEmpty(); + } + + @Test + void 모든_주문을_조회할_수_있다() { + Long orderTableId = orderTableDao.save(주문_테이블을_생성한다(null, 1, false)) + .getId(); + Order order1 = orderDao.save(주문을_생성한다(orderTableId, COOKING.name(), LocalDateTime.now(), null)); + Order order2 = orderDao.save(주문을_생성한다(orderTableId, MEAL.name(), LocalDateTime.now(), null)); + + List actual = orderDao.findAll(); + + assertThat(actual).hasSize(2) + .usingFieldByFieldElementComparator() + .containsExactly(order1, order2); + } + + @Test + void 주문_테이블에_해당하고_주문_상태_목록에_있는_주문이_있으면_true를_반환한다() { + Long orderTableId = orderTableDao.save(주문_테이블을_생성한다(null, 1, false)) + .getId(); + orderDao.save(주문을_생성한다(orderTableId, COOKING.name(), LocalDateTime.now(), null)); + + boolean actual = orderDao.existsByOrderTableIdAndOrderStatusIn(orderTableId, List.of(COOKING.name())); + + assertThat(actual).isTrue(); + } + + @Test + void 주문_테이블에_해당하고_주문_상태_목록에_있는_주문이_없으면_false를_반환한다() { + Long orderTableId = orderTableDao.save(주문_테이블을_생성한다(null, 1, false)) + .getId(); + + boolean actual = orderDao.existsByOrderTableIdAndOrderStatusIn(orderTableId, List.of(COOKING.name())); + + assertThat(actual).isFalse(); + } + + @Test + void 주문_테이블_목록에_있으면서_주문_상태_목록에_있는_주문이_있으면_true를_반환한다() { + Long orderTableId = orderTableDao.save(주문_테이블을_생성한다(null, 1, false)) + .getId(); + orderDao.save(주문을_생성한다(orderTableId, COOKING.name(), LocalDateTime.now(), null)); + + boolean actual = orderDao.existsByOrderTableIdInAndOrderStatusIn(List.of(orderTableId), + List.of(COOKING.name())); + + assertThat(actual).isTrue(); + } + + @Test + void 주문_테이블_목록에_있으면서_주문_상태_목록에_있는_주문이_없으면_false를_반환한다() { + Long orderTableId = orderTableDao.save(주문_테이블을_생성한다(null, 1, false)) + .getId(); + + boolean actual = orderDao.existsByOrderTableIdInAndOrderStatusIn(List.of(orderTableId), + List.of(COOKING.name())); + + assertThat(actual).isFalse(); + } +} \ No newline at end of file diff --git a/src/test/java/kitchenpos/dao/OrderLineItemDaoTest.java b/src/test/java/kitchenpos/dao/OrderLineItemDaoTest.java new file mode 100644 index 0000000000..eba50c2b8f --- /dev/null +++ b/src/test/java/kitchenpos/dao/OrderLineItemDaoTest.java @@ -0,0 +1,125 @@ +package kitchenpos.dao; + +import static kitchenpos.domain.OrderStatus.COOKING; +import static kitchenpos.domain.OrderStatus.MEAL; +import static kitchenpos.support.TestFixtureFactory.메뉴_그룹을_생성한다; +import static kitchenpos.support.TestFixtureFactory.메뉴를_생성한다; +import static kitchenpos.support.TestFixtureFactory.주문_테이블을_생성한다; +import static kitchenpos.support.TestFixtureFactory.주문_항목을_생성한다; +import static kitchenpos.support.TestFixtureFactory.주문을_생성한다; +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertAll; + +import java.math.BigDecimal; +import java.time.LocalDateTime; +import java.util.List; +import java.util.Optional; +import kitchenpos.domain.OrderLineItem; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; + +@DaoTest +class OrderLineItemDaoTest { + + @Autowired + private MenuGroupDao menuGroupDao; + @Autowired + private MenuDao menuDao; + @Autowired + private OrderTableDao orderTableDao; + @Autowired + private OrderDao orderDao; + @Autowired + private OrderLineItemDao orderLineItemDao; + + @Test + void 주문_항목을_저장하면_id가_채워진다() { + Long menuGroupId = menuGroupDao.save(메뉴_그룹을_생성한다("메뉴 그룹")) + .getId(); + Long menuId = menuDao.save(메뉴를_생성한다("메뉴", new BigDecimal(1_000), menuGroupId, null)) + .getId(); + Long orderTableId = orderTableDao.save(주문_테이블을_생성한다(null, 1, true)) + .getId(); + Long orderId = orderDao.save(주문을_생성한다(orderTableId, COOKING.name(), LocalDateTime.now(), null)) + .getId(); + OrderLineItem orderLineItem = 주문_항목을_생성한다(orderId, menuId, 1); + + OrderLineItem savedOrderLineItem = orderLineItemDao.save(orderLineItem); + + assertAll( + () -> assertThat(savedOrderLineItem.getSeq()).isNotNull(), + () -> assertThat(savedOrderLineItem).usingRecursiveComparison() + .ignoringFields("seq") + .isEqualTo(orderLineItem) + ); + } + + @Test + void id로_주문_항목을_조회할_수_있다() { + Long menuGroupId = menuGroupDao.save(메뉴_그룹을_생성한다("메뉴 그룹")) + .getId(); + Long menuId = menuDao.save(메뉴를_생성한다("메뉴", new BigDecimal(1_000), menuGroupId, null)) + .getId(); + Long orderTableId = orderTableDao.save(주문_테이블을_생성한다(null, 1, true)) + .getId(); + Long orderId = orderDao.save(주문을_생성한다(orderTableId, COOKING.name(), LocalDateTime.now(), null)) + .getId(); + OrderLineItem orderLineItem = orderLineItemDao.save(주문_항목을_생성한다(orderId, menuId, 1)); + + OrderLineItem actual = orderLineItemDao.findById(orderLineItem.getSeq()) + .orElseGet(Assertions::fail); + + assertThat(actual).usingRecursiveComparison() + .isEqualTo(orderLineItem); + } + + @Test + void 없는_id로_주문_항목을_조회하면_Optional_empty를_반환한다() { + Optional actual = orderLineItemDao.findById(0L); + + assertThat(actual).isEmpty(); + } + + @Test + void 모든_주문_항목을_조회할_수_있다() { + Long menuGroupId = menuGroupDao.save(메뉴_그룹을_생성한다("메뉴 그룹")) + .getId(); + Long menuId = menuDao.save(메뉴를_생성한다("메뉴", new BigDecimal(1_000), menuGroupId, null)) + .getId(); + Long orderTableId = orderTableDao.save(주문_테이블을_생성한다(null, 1, true)) + .getId(); + Long orderId = orderDao.save(주문을_생성한다(orderTableId, COOKING.name(), LocalDateTime.now(), null)) + .getId(); + OrderLineItem orderLineItem1 = orderLineItemDao.save(주문_항목을_생성한다(orderId, menuId, 1)); + OrderLineItem orderLineItem2 = orderLineItemDao.save(주문_항목을_생성한다(orderId, menuId, 2)); + + List actual = orderLineItemDao.findAll(); + + assertThat(actual).hasSize(2) + .usingFieldByFieldElementComparator() + .containsExactly(orderLineItem1, orderLineItem2); + } + + @Test + void 주문에_포함된_주문_항목을_조회할_수_있다() { + Long menuGroupId = menuGroupDao.save(메뉴_그룹을_생성한다("메뉴 그룹")) + .getId(); + Long menuId = menuDao.save(메뉴를_생성한다("메뉴", new BigDecimal(1_000), menuGroupId, null)) + .getId(); + Long orderTableId = orderTableDao.save(주문_테이블을_생성한다(null, 1, true)) + .getId(); + Long orderId1 = orderDao.save(주문을_생성한다(orderTableId, COOKING.name(), LocalDateTime.now(), null)) + .getId(); + Long orderId2 = orderDao.save(주문을_생성한다(orderTableId, MEAL.name(), LocalDateTime.now(), null)) + .getId(); + OrderLineItem orderLineItem = orderLineItemDao.save(주문_항목을_생성한다(orderId1, menuId, 1)); + orderLineItemDao.save(주문_항목을_생성한다(orderId2, menuId, 1)); + + List actual = orderLineItemDao.findAllByOrderId(orderId1); + + assertThat(actual).hasSize(1) + .usingFieldByFieldElementComparator() + .containsExactly(orderLineItem); + } +} \ No newline at end of file diff --git a/src/test/java/kitchenpos/dao/OrderTableDaoTest.java b/src/test/java/kitchenpos/dao/OrderTableDaoTest.java new file mode 100644 index 0000000000..af84822f68 --- /dev/null +++ b/src/test/java/kitchenpos/dao/OrderTableDaoTest.java @@ -0,0 +1,127 @@ +package kitchenpos.dao; + +import static kitchenpos.support.TestFixtureFactory.단체_지정을_생성한다; +import static kitchenpos.support.TestFixtureFactory.주문_테이블을_생성한다; +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertAll; +import static org.junit.jupiter.api.Assertions.assertDoesNotThrow; + +import java.time.LocalDateTime; +import java.util.List; +import java.util.Optional; +import kitchenpos.domain.OrderTable; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; + +@DaoTest +class OrderTableDaoTest { + + @Autowired + private TableGroupDao tableGroupDao; + @Autowired + private OrderTableDao orderTableDao; + + @Test + void 주문_테이블을_저장하면_id가_채워진다() { + Long tableGroupId = tableGroupDao.save(단체_지정을_생성한다(LocalDateTime.now(), null)) + .getId(); + OrderTable orderTable = 주문_테이블을_생성한다(tableGroupId, 0, true); + + OrderTable savedOrderTable = orderTableDao.save(orderTable); + + assertAll( + () -> assertThat(savedOrderTable.getId()).isNotNull(), + () -> assertThat(savedOrderTable).usingRecursiveComparison() + .ignoringFields("id") + .isEqualTo(orderTable) + ); + } + + @Test + void 저장하는_주문_테이블의_id가_null이_아니면_업데이트한다() { + Long tableGroupId = tableGroupDao.save(단체_지정을_생성한다(LocalDateTime.now(), null)) + .getId(); + Long orderTableId = orderTableDao.save(주문_테이블을_생성한다(tableGroupId, 0, true)) + .getId(); + OrderTable updateOrderTable = 주문_테이블을_생성한다(tableGroupId, 1, false); + updateOrderTable.setId(orderTableId); + + OrderTable savedOrderTable = orderTableDao.save(updateOrderTable); + + assertThat(savedOrderTable).usingRecursiveComparison() + .isEqualTo(updateOrderTable); + } + + @Test + void 단체_지정_id는_null일_수_있다() { + OrderTable orderTable = 주문_테이블을_생성한다(null, 0, true); + + assertDoesNotThrow(() -> orderTableDao.save(orderTable)); + } + + @Test + void id로_주문_테이블을_조회할_수_있다() { + Long tableGroupId = tableGroupDao.save(단체_지정을_생성한다(LocalDateTime.now(), null)) + .getId(); + OrderTable orderTable = orderTableDao.save(주문_테이블을_생성한다(tableGroupId, 0, true)); + + OrderTable actual = orderTableDao.findById(orderTable.getId()) + .orElseGet(Assertions::fail); + + assertThat(actual).usingRecursiveComparison() + .isEqualTo(orderTable); + } + + @Test + void 없는_id로_주문_테이블을_조회하면_Optional_empty를_반환한다() { + Optional actual = orderTableDao.findById(0L); + + assertThat(actual).isEmpty(); + } + + @Test + void 모든_주문_테이블을_조회할_수_있다() { + Long tableGroupId = tableGroupDao.save(단체_지정을_생성한다(LocalDateTime.now(), null)) + .getId(); + OrderTable orderTable1 = orderTableDao.save(주문_테이블을_생성한다(tableGroupId, 0, true)); + OrderTable orderTable2 = orderTableDao.save(주문_테이블을_생성한다(tableGroupId, 1, false)); + + List actual = orderTableDao.findAll(); + + assertThat(actual).hasSize(2) + .usingFieldByFieldElementComparator() + .containsExactly(orderTable1, orderTable2); + } + + @Test + void id_목록에_있는_주문_테이블을_조회할_수_있다() { + Long tableGroupId = tableGroupDao.save(단체_지정을_생성한다(LocalDateTime.now(), null)) + .getId(); + OrderTable orderTable1 = orderTableDao.save(주문_테이블을_생성한다(tableGroupId, 0, true)); + orderTableDao.save(주문_테이블을_생성한다(tableGroupId, 1, false)); + List ids = List.of(orderTable1.getId()); + + List actual = orderTableDao.findAllByIdIn(ids); + + assertThat(actual).hasSize(1) + .usingFieldByFieldElementComparator() + .containsExactly(orderTable1); + } + + @Test + void 단체_지정_id로_주문_테이블을_조회할_수_있다() { + Long tableGroupId1 = tableGroupDao.save(단체_지정을_생성한다(LocalDateTime.now(), null)) + .getId(); + Long tableGroupId2 = tableGroupDao.save(단체_지정을_생성한다(LocalDateTime.now(), null)) + .getId(); + OrderTable orderTable1 = orderTableDao.save(주문_테이블을_생성한다(tableGroupId1, 0, true)); + orderTableDao.save(주문_테이블을_생성한다(tableGroupId2, 0, true)); + + List actual = orderTableDao.findAllByTableGroupId(tableGroupId1); + + assertThat(actual).hasSize(1) + .usingFieldByFieldElementComparator() + .containsExactly(orderTable1); + } +} \ No newline at end of file diff --git a/src/test/java/kitchenpos/dao/ProductDaoTest.java b/src/test/java/kitchenpos/dao/ProductDaoTest.java new file mode 100644 index 0000000000..ddaa578edf --- /dev/null +++ b/src/test/java/kitchenpos/dao/ProductDaoTest.java @@ -0,0 +1,64 @@ +package kitchenpos.dao; + +import static kitchenpos.support.TestFixtureFactory.상품을_생성한다; +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertAll; + +import java.math.BigDecimal; +import java.util.List; +import java.util.Optional; +import kitchenpos.domain.Product; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; + +@DaoTest +class ProductDaoTest { + + @Autowired + private ProductDao productDao; + + @Test + void 상품을_저장하면_id값이_채워진다() { + Product product = 상품을_생성한다("상품", new BigDecimal(0)); + + Product savedProduct = productDao.save(product); + + assertAll( + () -> assertThat(savedProduct.getId()).isNotNull(), + () -> assertThat(savedProduct.getName()).isEqualTo(product.getName()), + () -> assertThat(savedProduct.getPrice().compareTo(product.getPrice())).isZero() + ); + } + + @Test + void 상품을_id로_조회할_수_있다() { + Product product = productDao.save(상품을_생성한다("상품", new BigDecimal(0))); + + Product actual = productDao.findById(product.getId()) + .orElseGet(Assertions::fail); + + assertThat(actual).usingRecursiveComparison() + .isEqualTo(product); + } + + @Test + void 없는_상품_id로_조회하면_Optional_empty를_반환한다() { + Optional actual = productDao.findById(0L); + + assertThat(actual).isEmpty(); + } + + @Test + void 모든_상품을_조회할_수_있다() { + Product product1 = productDao.save(상품을_생성한다("상품1", new BigDecimal(1_000))); + Product product2 = productDao.save(상품을_생성한다("상품2", new BigDecimal(2_000))); + + List actual = productDao.findAll(); + + assertThat(actual).hasSize(2) + .usingFieldByFieldElementComparator() + .usingElementComparatorIgnoringFields("price") + .containsExactly(product1, product2); + } +} diff --git a/src/test/java/kitchenpos/dao/TableGroupDaoTest.java b/src/test/java/kitchenpos/dao/TableGroupDaoTest.java new file mode 100644 index 0000000000..2fdeb61f60 --- /dev/null +++ b/src/test/java/kitchenpos/dao/TableGroupDaoTest.java @@ -0,0 +1,64 @@ +package kitchenpos.dao; + +import static kitchenpos.support.TestFixtureFactory.단체_지정을_생성한다; +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertAll; + +import java.time.LocalDateTime; +import java.util.List; +import java.util.Optional; +import kitchenpos.domain.TableGroup; +import org.junit.jupiter.api.Assertions; +import org.junit.jupiter.api.Test; +import org.springframework.beans.factory.annotation.Autowired; + +@DaoTest +class TableGroupDaoTest { + + @Autowired + private TableGroupDao tableGroupDao; + + @Test + void 단체_지정을_저장_하면_id가_채워진다() { + TableGroup tableGroup = 단체_지정을_생성한다(LocalDateTime.now(), null); + + TableGroup savedTableGroup = tableGroupDao.save(tableGroup); + + assertAll( + () -> assertThat(savedTableGroup.getId()).isNotNull(), + () -> assertThat(savedTableGroup).usingRecursiveComparison() + .ignoringFields("id") + .isEqualTo(tableGroup) + ); + } + + @Test + void id로_단체_지정을_조회할_수_있다() { + TableGroup tableGroup = tableGroupDao.save(단체_지정을_생성한다(LocalDateTime.now(), null)); + + TableGroup actual = tableGroupDao.findById(tableGroup.getId()) + .orElseGet(Assertions::fail); + + assertThat(actual).usingRecursiveComparison() + .isEqualTo(tableGroup); + } + + @Test + void 없는_id로_단체_지정을_조회하면_Optional_empty를_반환한다() { + Optional actual = tableGroupDao.findById(0L); + + assertThat(actual).isEmpty(); + } + + @Test + void 모든_단체_지정을_조회할_수_있다() { + TableGroup tableGroup1 = tableGroupDao.save(단체_지정을_생성한다(LocalDateTime.now(), null)); + TableGroup tableGroup2 = tableGroupDao.save(단체_지정을_생성한다(LocalDateTime.now(), null)); + + List actual = tableGroupDao.findAll(); + + assertThat(actual).hasSize(2) + .usingFieldByFieldElementComparator() + .containsExactly(tableGroup1, tableGroup2); + } +} \ No newline at end of file diff --git a/src/test/java/kitchenpos/support/TestFixtureFactory.java b/src/test/java/kitchenpos/support/TestFixtureFactory.java new file mode 100644 index 0000000000..606148437a --- /dev/null +++ b/src/test/java/kitchenpos/support/TestFixtureFactory.java @@ -0,0 +1,83 @@ +package kitchenpos.support; + +import java.math.BigDecimal; +import java.time.LocalDateTime; +import java.util.List; +import kitchenpos.domain.Menu; +import kitchenpos.domain.MenuGroup; +import kitchenpos.domain.MenuProduct; +import kitchenpos.domain.Order; +import kitchenpos.domain.OrderLineItem; +import kitchenpos.domain.OrderTable; +import kitchenpos.domain.Product; +import kitchenpos.domain.TableGroup; + +public class TestFixtureFactory { + + private TestFixtureFactory() { + } + + public static Product 상품을_생성한다(final String name, final BigDecimal price) { + Product product = new Product(); + product.setName(name); + product.setPrice(price); + return product; + } + + public static MenuGroup 메뉴_그룹을_생성한다(final String name) { + MenuGroup menuGroup = new MenuGroup(); + menuGroup.setName(name); + return menuGroup; + } + + public static Menu 메뉴를_생성한다(final String name, final BigDecimal price, final Long menuGroupId, + final List menuProducts) { + Menu menu = new Menu(); + menu.setName(name); + menu.setPrice(price); + menu.setMenuGroupId(menuGroupId); + menu.setMenuProducts(menuProducts); + return menu; + } + + public static MenuProduct 메뉴_상품을_생성한다(final Long menuId, final Long productId, final long quantity) { + MenuProduct menuProduct = new MenuProduct(); + menuProduct.setMenuId(menuId); + menuProduct.setProductId(productId); + menuProduct.setQuantity(quantity); + return menuProduct; + } + + public static Order 주문을_생성한다(final Long orderTableId, final String orderStatus, final LocalDateTime orderedTime, + List orderLineItems) { + Order order = new Order(); + order.setOrderTableId(orderTableId); + order.setOrderStatus(orderStatus); + order.setOrderedTime(orderedTime); + order.setOrderLineItems(orderLineItems); + return order; + } + + public static OrderLineItem 주문_항목을_생성한다(final Long orderId, final Long menuId, final long quantity) { + OrderLineItem orderLineItem = new OrderLineItem(); + orderLineItem.setOrderId(orderId); + orderLineItem.setMenuId(menuId); + orderLineItem.setQuantity(quantity); + return orderLineItem; + } + + public static OrderTable 주문_테이블을_생성한다(final Long tableGroupId, final int numberOfGuests, final boolean empty) { + OrderTable orderTable = new OrderTable(); + orderTable.setTableGroupId(tableGroupId); + orderTable.setNumberOfGuests(numberOfGuests); + orderTable.setEmpty(empty); + return orderTable; + } + + public static TableGroup 단체_지정을_생성한다(final LocalDateTime createdDate, final List orderTables) { + TableGroup tableGroup = new TableGroup(); + tableGroup.setCreatedDate(createdDate); + tableGroup.setOrderTables(orderTables); + return tableGroup; + } +} diff --git a/src/test/resources/application.yml b/src/test/resources/application.yml new file mode 100644 index 0000000000..319de9f3a6 --- /dev/null +++ b/src/test/resources/application.yml @@ -0,0 +1,3 @@ +spring: + flyway: + enabled: false \ No newline at end of file diff --git a/src/test/resources/schema.sql b/src/test/resources/schema.sql new file mode 100644 index 0000000000..62033be6c8 --- /dev/null +++ b/src/test/resources/schema.sql @@ -0,0 +1,94 @@ +CREATE TABLE orders +( + id BIGINT(20) NOT NULL AUTO_INCREMENT, + order_table_id BIGINT(20) NOT NULL, + order_status VARCHAR(255) NOT NULL, + ordered_time DATETIME NOT NULL, + PRIMARY KEY (id) +); + +CREATE TABLE order_line_item +( + seq BIGINT(20) NOT NULL AUTO_INCREMENT, + order_id BIGINT(20) NOT NULL, + menu_id BIGINT(20) NOT NULL, + quantity BIGINT(20) NOT NULL, + PRIMARY KEY (seq) +); + +CREATE TABLE menu +( + id BIGINT(20) NOT NULL AUTO_INCREMENT, + name VARCHAR(255) NOT NULL, + price DECIMAL(19, 2) NOT NULL, + menu_group_id BIGINT(20) NOT NULL, + PRIMARY KEY (id) +); + +CREATE TABLE menu_group +( + id BIGINT(20) NOT NULL AUTO_INCREMENT, + name VARCHAR(255) NOT NULL, + PRIMARY KEY (id) +); + +CREATE TABLE menu_product +( + seq BIGINT(20) NOT NULL AUTO_INCREMENT, + menu_id BIGINT(20) NOT NULL, + product_id BIGINT(20) NOT NULL, + quantity BIGINT(20) NOT NULL, + PRIMARY KEY (seq) +); + +CREATE TABLE order_table +( + id BIGINT(20) NOT NULL AUTO_INCREMENT, + table_group_id BIGINT(20), + number_of_guests INT(11) NOT NULL, + empty BIT(1) NOT NULL, + PRIMARY KEY (id) +); + +CREATE TABLE table_group +( + id BIGINT(20) NOT NULL AUTO_INCREMENT, + created_date DATETIME NOT NULL, + PRIMARY KEY (id) +); + +CREATE TABLE product +( + id BIGINT(20) NOT NULL AUTO_INCREMENT, + name VARCHAR(255) NOT NULL, + price DECIMAL(19, 2) NOT NULL, + PRIMARY KEY (id) +); + +ALTER TABLE orders + ADD CONSTRAINT fk_orders_order_table + FOREIGN KEY (order_table_id) REFERENCES order_table (id); + +ALTER TABLE order_line_item + ADD CONSTRAINT fk_order_line_item_orders + FOREIGN KEY (order_id) REFERENCES orders (id); + +ALTER TABLE order_line_item + ADD CONSTRAINT fk_order_line_item_menu + FOREIGN KEY (menu_id) REFERENCES menu (id); + +ALTER TABLE menu + ADD CONSTRAINT fk_menu_menu_group + FOREIGN KEY (menu_group_id) REFERENCES menu_group (id); + +ALTER TABLE menu_product + ADD CONSTRAINT fk_menu_product_menu + FOREIGN KEY (menu_id) REFERENCES menu (id); + +ALTER TABLE menu_product + ADD CONSTRAINT fk_menu_product_product + FOREIGN KEY (product_id) REFERENCES product (id); + +ALTER TABLE order_table + ADD CONSTRAINT fk_order_table_table_group + FOREIGN KEY (table_group_id) REFERENCES table_group (id);