From 98a14afb945ca2db23816ebcfe0a9bb37d5dedbe Mon Sep 17 00:00:00 2001 From: skdev0619 Date: Mon, 3 Feb 2025 16:05:36 +0900 Subject: [PATCH 01/29] =?UTF-8?q?=EB=A9=94=EB=89=B4=EA=B7=B8=EB=A3=B9(Menu?= =?UTF-8?q?Group)=20=ED=85=8C=EC=8A=A4=ED=8A=B8=20=EC=BD=94=EB=93=9C=20?= =?UTF-8?q?=EC=B6=94=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 8 +-- .../application/MenuGroupServiceTest.java | 64 +++++++++++++++++++ 2 files changed, 68 insertions(+), 4 deletions(-) create mode 100644 src/test/java/kitchenpos/application/MenuGroupServiceTest.java diff --git a/README.md b/README.md index ad4912cf7..73a7b4c34 100644 --- a/README.md +++ b/README.md @@ -70,10 +70,10 @@ ex) - [ ] 모든 메뉴를 조회할 수 있다 ### 메뉴 그룹(menu_group) -- [ ] 메뉴판의 메뉴그룹명을 등록할 수 있다 - - [ ] 메뉴그룹명은 반드시 입력되어야 한다 - - [ ] 메뉴그룹명은 공백만 입력되어서는 안된다 -- [ ] 모든 메뉴 그룹을 조회할 수 있다 +- [x] 메뉴판의 메뉴그룹명을 등록할 수 있다 + - [x] 메뉴그룹명은 반드시 입력되어야 한다 + - [x] 메뉴그룹명은 공백만 입력되어서는 안된다 +- [x] 모든 메뉴 그룹을 조회할 수 있다 ### 주문(Order) **주문이란?** diff --git a/src/test/java/kitchenpos/application/MenuGroupServiceTest.java b/src/test/java/kitchenpos/application/MenuGroupServiceTest.java new file mode 100644 index 000000000..bd9bcfb71 --- /dev/null +++ b/src/test/java/kitchenpos/application/MenuGroupServiceTest.java @@ -0,0 +1,64 @@ +package kitchenpos.application; + +import kitchenpos.domain.MenuGroup; +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 org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.transaction.annotation.Transactional; + +import java.util.List; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException; + +@Transactional +@SpringBootTest +class MenuGroupServiceTest { + + @Autowired + private MenuGroupService menuGroupService; + + @DisplayName("메뉴그룹명을 입력하여 메뉴그룹을 등록한다") + @Test + void create() { + MenuGroup request = createMenuGroup("세트메뉴"); + + MenuGroup menuGroup = menuGroupService.create(request); + + assertThat(menuGroup.getName()).isEqualTo("세트메뉴"); + } + + @DisplayName("메뉴그룹명은 반드시 입력되어야 하며 공백만 입력할 수 없다") + @NullAndEmptySource + @ParameterizedTest + void validateName(String name) { + MenuGroup request = createMenuGroup(name); + + assertThatIllegalArgumentException() + .isThrownBy(() -> menuGroupService.create(request)); + } + + @DisplayName("모든 메뉴 그룹을 조회할 수 있다") + @Test + void findAll() { + menuGroupService.create(createMenuGroup("버거")); + menuGroupService.create(createMenuGroup("세트메뉴")); + menuGroupService.create(createMenuGroup("사이드")); + + List menuGroups = menuGroupService.findAll(); + + assertThat(menuGroups.size()).isEqualTo(3); + assertThat(menuGroups).extracting(MenuGroup::getName) + .contains("버거", "세트메뉴", "사이드"); + + } + + private MenuGroup createMenuGroup(String name) { + MenuGroup menuGroup = new MenuGroup(); + menuGroup.setName(name); + return menuGroup; + } +} From 5dd3cd7cc5c8a4be3324c6872f89a9de0ae8a01e Mon Sep 17 00:00:00 2001 From: skdev0619 Date: Mon, 3 Feb 2025 14:45:19 +0900 Subject: [PATCH 02/29] =?UTF-8?q?=EC=83=81=ED=92=88(Product)=20=ED=85=8C?= =?UTF-8?q?=EC=8A=A4=ED=8A=B8=20=EC=BD=94=EB=93=9C=20=EC=B6=94=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 20 +- .../application/ProductServiceTest.java | 194 ++++++++++++++++++ 2 files changed, 204 insertions(+), 10 deletions(-) create mode 100644 src/test/java/kitchenpos/application/ProductServiceTest.java diff --git a/README.md b/README.md index 73a7b4c34..ef5b17d6a 100644 --- a/README.md +++ b/README.md @@ -13,16 +13,16 @@ docker compose -p kitchenpos up -d ### 상품(product) **상품이란?** > 햄버거, 감자튀김, 치킨과 같은 각각의 개별적인 음식을 상품이라고 부른다. -- [ ] 상품을 등록할 수 있다 - - [ ] 상품명과 가격을 입력할 수 있다 - - [ ] 상품명과 가격은 반드시 입력되어야 한다 - - [ ] 상품명은 비속어가 있으면 등록할 수 없다 - - [ ] 가격은 0원 이상이어야 한다 -- [ ] 상품 가격을 수정할 수 있다 - - [ ] 상품 가격은 0원 이상이어야 한다 - - [ ] 메뉴의 가격이 메뉴에 속한 상품들의 가격 총 합보다 클 경우, 그 메뉴는 유효하지 않다. - - [ ] 유효하지 않은 메뉴는 노출하지 않는다 -- [ ] 모든 상품을 조회할 수 있다 +- [x] 상품을 등록할 수 있다 + - [x] 상품명과 가격을 입력할 수 있다 + - [x] 상품명과 가격은 반드시 입력되어야 한다 + - [x] 상품명은 비속어가 있으면 등록할 수 없다 + - [x] 가격은 0원 이상이어야 한다 +- [x] 상품 가격을 수정할 수 있다 + - [x] 상품 가격은 0원 이상이어야 한다 + - [x] 메뉴의 가격이 메뉴에 속한 상품들의 가격 총 합보다 클 경우, 그 메뉴는 유효하지 않다. + - [x] 유효하지 않은 메뉴는 노출하지 않는다 +- [x] 모든 상품을 조회할 수 있다 ### 메뉴(menu) **메뉴란?** diff --git a/src/test/java/kitchenpos/application/ProductServiceTest.java b/src/test/java/kitchenpos/application/ProductServiceTest.java new file mode 100644 index 000000000..fff1ad18b --- /dev/null +++ b/src/test/java/kitchenpos/application/ProductServiceTest.java @@ -0,0 +1,194 @@ +package kitchenpos.application; + +import kitchenpos.domain.Menu; +import kitchenpos.domain.MenuGroup; +import kitchenpos.domain.MenuProduct; +import kitchenpos.domain.Product; +import kitchenpos.infra.PurgomalumClient; +import org.assertj.core.groups.Tuple; +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 org.springframework.transaction.annotation.Transactional; + +import java.math.BigDecimal; +import java.util.List; +import java.util.UUID; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException; + +@Transactional +@SpringBootTest +class ProductServiceTest { + + @Autowired + private ProductService productService; + + @MockBean + private PurgomalumClient purgomalumClient; + + @Autowired + private MenuService menuService; + + @Autowired + private MenuGroupService menuGroupService; + + //region [상품 등록] + @DisplayName("상품명과 가격을 입력하여 상품을 생성한다") + @Test + void createProduct() { + Product request = createProduct("치킨버거", new BigDecimal(7000)); + + Product product = productService.create(request); + + assertThat(product) + .extracting(Product::getName, Product::getPrice) + .containsExactly("치킨버거", new BigDecimal(7000)); + } + + @DisplayName("상품명은 반드시 입력되어야 한다") + @Test + void notNullProductName() { + Product request = createProduct(null, new BigDecimal(7000)); + + assertThatIllegalArgumentException() + .isThrownBy(() -> productService.create(request)); + } + + @DisplayName("가격은 반드시 입력되어야 한다") + @Test + void notNullProductPrice() { + Product request = createProduct("치킨버거", null); + + assertThatIllegalArgumentException() + .isThrownBy(() -> productService.create(request)); + } + + @DisplayName("상품명은 비속어가 있으면 등록할 수 없다") + @Test + void validateProductName() { + Mockito.when(purgomalumClient.containsProfanity("bad word")).thenReturn(true); + Product request = createProduct("bad word", new BigDecimal(7000)); + + assertThatIllegalArgumentException() + .isThrownBy(() -> productService.create(request)); + } + + @DisplayName("상품의 가격은 0원 이상이어야 한다") + @Test + void validatePriceOnCreate() { + Product request = createProduct("치킨버거", new BigDecimal(-1)); + + assertThatIllegalArgumentException() + .isThrownBy(() -> productService.create(request)); + } + //endregion + + //region [상품 수정] + @DisplayName("상품의 가격을 수정할 수 있다") + @Test + void modifyPrice() { + Product product = productService.create(createProduct(UUID.randomUUID(), "치킨버거", new BigDecimal(7000))); + + product.setPrice(new BigDecimal(8000)); + Product modifiedProduct = productService.changePrice(product.getId(), product); + + assertThat(modifiedProduct.getPrice()).isEqualTo(new BigDecimal(8000)); + } + + @DisplayName("상품의 가격은 0원 이상인 경우만 수정 가능하다") + @Test + void validatePriceOnModify() { + Product product = productService.create(createProduct(UUID.randomUUID(), "치킨버거", new BigDecimal(7000))); + + assertThatIllegalArgumentException() + .isThrownBy(() -> productService.changePrice(product.getId(), createProduct("치킨버거", new BigDecimal(-1)))); + } + + @DisplayName("메뉴의 가격이 메뉴에 속한 상품들의 가격 총 합보다 클 경우, 유효하지 않은 메뉴이므로 메뉴판에 전시할 수 없다") + @Test + void validatePriceBySetMenu() { + //given + Product chicken = productService.create(createProduct("후라이드치킨", new BigDecimal(25000))); + Product coke = productService.create(createProduct("콜라", new BigDecimal(2500))); + + MenuGroup menuGroup = menuGroupService.create(createMenuGroup("세트메뉴")); + + MenuProduct chickenMenuProduct = createMenuProduct(chicken, 1); + MenuProduct cokeMenuProduct = createMenuProduct(coke, 1); + + BigDecimal productSum = chicken.getPrice().add(coke.getPrice()); + Menu menu = createMenu( + menuGroup.getId(), + "후라이드치킨세트", + productSum, + List.of(chickenMenuProduct, cokeMenuProduct) + ); + Menu chickenSet = menuService.create(menu); + //when + BigDecimal newPrice = chicken.getPrice().add(new BigDecimal(1000)); + chicken.setPrice(newPrice); + productService.changePrice(chicken.getId(), chicken); + //when + assertThat(chickenSet.isDisplayed()).isFalse(); + } + //endregion + + //region [메뉴 조회] + @DisplayName("모든 메뉴를 조회할 수 있다") + @Test + void findAll() { + productService.create(createProduct("치킨버거", new BigDecimal(7000))); + productService.create(createProduct("새우버거", new BigDecimal(8000))); + + List products = productService.findAll(); + + assertThat(products).hasSize(2); + assertThat(products) + .extracting(Product::getName, product -> product.getPrice().intValue()) + .contains( + Tuple.tuple("치킨버거", 7000), + Tuple.tuple("새우버거", 8000) + ); + } + //endregion + + private Product createProduct(String name, BigDecimal price) { + return createProduct(null, name, price); + } + + private Product createProduct(UUID id, String name, BigDecimal price) { + Product product = new Product(); + product.setId(id); + product.setName(name); + product.setPrice(price); + return product; + } + + private MenuProduct createMenuProduct(Product product, int quantity) { + MenuProduct menuProduct = new MenuProduct(); + menuProduct.setProduct(product); + menuProduct.setProductId(product.getId()); + menuProduct.setQuantity(quantity); + return menuProduct; + } + + private MenuGroup createMenuGroup(String name) { + MenuGroup menuGroup = new MenuGroup(); + menuGroup.setName(name); + return menuGroup; + } + + private Menu createMenu(UUID menuGroupId, String name, BigDecimal price, List products) { + Menu menu = new Menu(); + menu.setMenuGroupId(menuGroupId); + menu.setName(name); + menu.setPrice(price); + menu.setMenuProducts(products); + return menu; + } +} From 668dad4e1aa352f286f5fbcaf02b0ff31a3259c3 Mon Sep 17 00:00:00 2001 From: skdev0619 Date: Mon, 3 Feb 2025 16:07:37 +0900 Subject: [PATCH 03/29] =?UTF-8?q?=EB=A9=94=EB=89=B4(Menu)=20=EB=93=B1?= =?UTF-8?q?=EB=A1=9D=20=ED=85=8C=EC=8A=A4=ED=8A=B8=20=EC=BD=94=EB=93=9C=20?= =?UTF-8?q?=EC=B6=94=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 19 +- .../application/MenuServiceTest.java | 204 ++++++++++++++++++ 2 files changed, 213 insertions(+), 10 deletions(-) create mode 100644 src/test/java/kitchenpos/application/MenuServiceTest.java diff --git a/README.md b/README.md index ef5b17d6a..46853f18e 100644 --- a/README.md +++ b/README.md @@ -46,16 +46,15 @@ ex) > 치킨버거 > 치킨버거세트 > 콜라 > 감자튀김 > 새우버거 > 새우버거세트 > 사이다 > 치즈스틱 ``` -- [ ] 메뉴를 등록할 수 있다 - - [ ] 단일 또는 여러 상품을 조합하여 메뉴를 만들 수 있다 - - [ ] 각 메뉴를 구성하는 상품과 그 수량을 선택할 수 있다 - - [ ] 각 메뉴를 구성하는 상품의 수량은 0이상이어야 한다 - - [ ] 메뉴는 메뉴명, 가격, 메뉴판 전시 여부(전시 O/ 전시 X) 정보를 가진다 - - [ ] 메뉴명, 가격, 메뉴판 전시 여부는 반드시 입력되어야 한다 - - [ ] 메뉴명에 비속어가 있으면 입력할 수 없다 - - [ ] 메뉴의 가격은 0원 이상이어야 한다 - - [ ] 메뉴의 가격이 포함된 상품 가격 총합과 동일하거나 할인된 가격일 경우만 등록 가능하다 - - [ ] 메뉴는 하나의 메뉴그룹을 가진다 +- [x] 메뉴를 등록할 수 있다 + - [x] 단일 또는 여러 상품을 조합하여 메뉴를 만들 수 있다 + - [x] 각 메뉴를 구성하는 상품과 그 수량을 선택할 수 있다 + - [x] 각 메뉴를 구성하는 상품의 수량은 0이상이어야 한다 + - [x] 메뉴는 메뉴명, 가격, 메뉴판 전시 여부(전시 O/ 전시 X), 메뉴그룹을 가진다 + - [x] 메뉴명, 가격은 반드시 입력되어야 한다 + - [x] 메뉴명에 비속어가 있으면 입력할 수 없다 + - [x] 메뉴의 가격은 0원 이상이어야 한다 + - [x] 메뉴의 가격이 포함된 상품 가격 총합과 동일하거나 할인된 가격일 경우만 등록 가능하다 - [ ] 메뉴는 가격을 수정할 수 있다 - [ ] 메뉴의 가격이 0원 이상이어야 한다 diff --git a/src/test/java/kitchenpos/application/MenuServiceTest.java b/src/test/java/kitchenpos/application/MenuServiceTest.java new file mode 100644 index 000000000..f85462aa7 --- /dev/null +++ b/src/test/java/kitchenpos/application/MenuServiceTest.java @@ -0,0 +1,204 @@ +package kitchenpos.application; + +import kitchenpos.domain.*; +import kitchenpos.infra.PurgomalumClient; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.NullSource; +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 org.springframework.transaction.annotation.Transactional; + +import java.math.BigDecimal; +import java.util.List; +import java.util.UUID; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException; + +@Transactional +@SpringBootTest +class MenuServiceTest { + + private static final UUID BURGER_PRODUCT_ID = UUID.randomUUID(); + private static final UUID SIDE_PRODUCT_ID = UUID.randomUUID(); + private static final UUID COKE_PRODUCT_ID = UUID.randomUUID(); + private static final UUID MENU_GROUP_ID = UUID.randomUUID(); + + @Autowired + private MenuService menuService; + + @Autowired + private ProductRepository productRepository; + + @Autowired + private MenuGroupRepository menuGroupRepository; + + @MockBean + private PurgomalumClient purgomalumClient; + + @BeforeEach + void setUp() { + productRepository.save(createProduct(BURGER_PRODUCT_ID, "치킨버거", new BigDecimal(7000))); + productRepository.save(createProduct(SIDE_PRODUCT_ID, "감자튀김", new BigDecimal(2000))); + productRepository.save(createProduct(COKE_PRODUCT_ID, "콜라", new BigDecimal(2000))); + + menuGroupRepository.save(createMenuGroup(MENU_GROUP_ID, "세트메뉴")); + } + + //region [메뉴 등록] + @DisplayName("단일 상품으로 메뉴를 등록할 수 있다") + @Test + void createMenuByProduct() { + MenuProduct chickenBurger = createMenuProduct(BURGER_PRODUCT_ID, 1); + Menu menu = createMenu(MENU_GROUP_ID, "치킨버거", new BigDecimal(7000), List.of(chickenBurger)); + + Menu resultMenu = menuService.create(menu); + + assertThat(resultMenu.getName()).isEqualTo("치킨버거"); + assertThat(resultMenu.getPrice()).isEqualTo(new BigDecimal(7000)); + assertThat(resultMenu.isDisplayed()).isFalse(); + assertThat(resultMenu.getMenuProducts()).hasSize(1); + assertThat(resultMenu.getMenuGroup()).isNotNull(); + assertThat(resultMenu.getMenuGroup().getId()).isEqualTo(MENU_GROUP_ID); + } + + @DisplayName("여러 상품으로 조합하여 하나의 메뉴를 등록할 수 있다") + @Test + void createMenuByProducts() { + //given + MenuProduct chickenBurger = createMenuProduct(BURGER_PRODUCT_ID, 1); + MenuProduct side = createMenuProduct(SIDE_PRODUCT_ID, 1); + MenuProduct coke = createMenuProduct(COKE_PRODUCT_ID, 1); + + Menu menu = createMenu( + MENU_GROUP_ID, + "치킨버거세트", + new BigDecimal(10000), + List.of(chickenBurger, side, coke) + ); + //when + Menu resultMenu = menuService.create(menu); + //then + assertThat(resultMenu.getName()).isEqualTo("치킨버거세트"); + assertThat(resultMenu.getPrice()).isEqualTo(new BigDecimal(10000)); + assertThat(resultMenu.getMenuProducts()).hasSize(3); + assertThat(resultMenu.getMenuGroup()).isNotNull(); + assertThat(resultMenu.getMenuGroup().getId()).isEqualTo(MENU_GROUP_ID); + } + + @DisplayName("각 메뉴를 구성하는 상품의 수량은 0이상이어야 한다") + @Test + void validateMenuProductQuantity() { + MenuProduct chickenBurger = createMenuProduct(BURGER_PRODUCT_ID, 1); + MenuProduct coke = createMenuProduct(COKE_PRODUCT_ID, -1); + Menu menu = createMenu( + MENU_GROUP_ID, + "치킨버거+음료", + new BigDecimal(9000), + List.of(chickenBurger, coke) + ); + + assertThatIllegalArgumentException() + .isThrownBy(() -> menuService.create(menu)); + } + + @DisplayName("메뉴명은 반드시 입력되어야 한다") + @ParameterizedTest + @NullSource + void notNullName(String nullName) { + MenuProduct chickenBurger = createMenuProduct(BURGER_PRODUCT_ID, 1); + Menu menu = createMenu(MENU_GROUP_ID, nullName, new BigDecimal(7000), List.of(chickenBurger)); + + assertThatIllegalArgumentException() + .isThrownBy(() -> menuService.create(menu)); + } + + @DisplayName("메뉴명에 비속어가 있으면 등록할 수 없다") + @Test + void validateMenuName() { + Mockito.when(purgomalumClient.containsProfanity("bad word")).thenReturn(true); + + MenuProduct chickenBurger = createMenuProduct(BURGER_PRODUCT_ID, 1); + Menu menu = createMenu(MENU_GROUP_ID, "bad word", new BigDecimal(7000), List.of(chickenBurger)); + + assertThatIllegalArgumentException() + .isThrownBy(() -> menuService.create(menu)); + } + + @DisplayName("가격은 반드시 입력되어야 한다") + @ParameterizedTest + @NullSource + void notNullPrice(BigDecimal nullPrice) { + MenuProduct chickenBurger = createMenuProduct(BURGER_PRODUCT_ID, 1); + Menu menu = createMenu(MENU_GROUP_ID, "치킨버거", nullPrice, List.of(chickenBurger)); + + assertThatIllegalArgumentException() + .isThrownBy(() -> menuService.create(menu)); + } + + @DisplayName("메뉴의 가격은 0원 이상이어야 한다") + @Test + void nonNegativeMenuPrice() { + MenuProduct chickenBurger = createMenuProduct(BURGER_PRODUCT_ID, 1); + Menu menu = createMenu(MENU_GROUP_ID, "치킨버거", new BigDecimal(-1), List.of(chickenBurger)); + + assertThatIllegalArgumentException() + .isThrownBy(() -> menuService.create(menu)); + } + + @DisplayName("메뉴의 가격이 포함된 상품 가격 총합과 동일하거나 할인된 가격일 경우만 등록 가능하다") + @Test + void validateMenuPrice() { + //given + MenuProduct chickenBurger = createMenuProduct(BURGER_PRODUCT_ID, 1); //7000원 + MenuProduct side = createMenuProduct(SIDE_PRODUCT_ID, 1); //2000원 + MenuProduct coke = createMenuProduct(COKE_PRODUCT_ID, 1); //2000원 + + Menu menu = createMenu( + MENU_GROUP_ID, + "치킨버거세트", + new BigDecimal(11001), + List.of(chickenBurger, side, coke) + ); + //when, then + assertThatIllegalArgumentException() + .isThrownBy(() -> menuService.create(menu)); + } + //endregion + + private Product createProduct(UUID id, String name, BigDecimal price) { + Product product = new Product(); + product.setId(id); + product.setName(name); + product.setPrice(price); + return product; + } + + private Menu createMenu(UUID menuGroupId, String name, BigDecimal price, List products) { + Menu menu = new Menu(); + menu.setMenuGroupId(menuGroupId); + menu.setName(name); + menu.setPrice(price); + menu.setMenuProducts(products); + return menu; + } + + private MenuProduct createMenuProduct(UUID productId, int quantity) { + MenuProduct menuProduct = new MenuProduct(); + menuProduct.setProductId(productId); + menuProduct.setQuantity(quantity); + return menuProduct; + } + + private MenuGroup createMenuGroup(UUID id, String name) { + MenuGroup menuGroup = new MenuGroup(); + menuGroup.setId(id); + menuGroup.setName(name); + return menuGroup; + } +} From 176fd286feb8be00875f99affc6ed9720e795dce Mon Sep 17 00:00:00 2001 From: skdev0619 Date: Mon, 3 Feb 2025 15:10:56 +0900 Subject: [PATCH 04/29] =?UTF-8?q?=EB=A9=94=EB=89=B4(Menu)=20=EC=88=98?= =?UTF-8?q?=EC=A0=95,=20=EC=A0=84=EC=8B=9C/=EB=B9=84=EC=A0=84=EC=8B=9C,=20?= =?UTF-8?q?=EC=A1=B0=ED=9A=8C=20=ED=85=8C=EC=8A=A4=ED=8A=B8=20=EC=BD=94?= =?UTF-8?q?=EB=93=9C=20=EC=B6=94=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 18 +-- .../application/MenuServiceTest.java | 144 +++++++++++++++++- 2 files changed, 151 insertions(+), 11 deletions(-) diff --git a/README.md b/README.md index 46853f18e..9f984a25d 100644 --- a/README.md +++ b/README.md @@ -56,17 +56,17 @@ ex) - [x] 메뉴의 가격은 0원 이상이어야 한다 - [x] 메뉴의 가격이 포함된 상품 가격 총합과 동일하거나 할인된 가격일 경우만 등록 가능하다 -- [ ] 메뉴는 가격을 수정할 수 있다 - - [ ] 메뉴의 가격이 0원 이상이어야 한다 - - [ ] 메뉴의 가격은 포함된 상품 가격 총합과 동일하거나 할인된 가격으로만 수정할 수 있다 +- [x] 메뉴는 가격을 수정할 수 있다 + - [x] 메뉴의 가격이 0원 이상이어야 한다 + - [x] 메뉴의 가격은 포함된 상품 가격 총합과 동일하거나 할인된 가격으로만 수정할 수 있다 -- [ ] 메뉴판에 메뉴를 전시한다 - - [ ] 메뉴판 전시 여부를 O로 변경한다 - - [ ] 메뉴의 가격이 포함된 상품 가격 총합과 동일하거나 할인된 가격인 경우만 전시할 수 있다 +- [x] 메뉴판에 메뉴를 전시한다 + - [x] 메뉴판 전시 여부를 O로 변경한다 + - [x] 메뉴의 가격이 포함된 상품 가격 총합과 동일하거나 할인된 가격인 경우만 전시할 수 있다 -- [ ] 메뉴판에서 메뉴를 내린다 - - [ ] 메뉴판 전시 여부를 X로 변경한다 -- [ ] 모든 메뉴를 조회할 수 있다 +- [x] 메뉴판에서 메뉴를 내린다 + - [x] 메뉴판 전시 여부를 X로 변경한다 +- [x] 모든 메뉴를 조회할 수 있다 ### 메뉴 그룹(menu_group) - [x] 메뉴판의 메뉴그룹명을 등록할 수 있다 diff --git a/src/test/java/kitchenpos/application/MenuServiceTest.java b/src/test/java/kitchenpos/application/MenuServiceTest.java index f85462aa7..a25b13a43 100644 --- a/src/test/java/kitchenpos/application/MenuServiceTest.java +++ b/src/test/java/kitchenpos/application/MenuServiceTest.java @@ -2,6 +2,7 @@ import kitchenpos.domain.*; import kitchenpos.infra.PurgomalumClient; +import org.assertj.core.groups.Tuple; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; @@ -17,8 +18,7 @@ import java.util.List; import java.util.UUID; -import static org.assertj.core.api.Assertions.assertThat; -import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException; +import static org.assertj.core.api.Assertions.*; @Transactional @SpringBootTest @@ -171,6 +171,146 @@ void validateMenuPrice() { } //endregion + //region[메뉴 수정] + @DisplayName("메뉴는 가격을 수정할 수 있다") + @Test + void changeMenuPrice() { + MenuProduct chickenBurger = createMenuProduct(BURGER_PRODUCT_ID, 1); + Menu menu = menuService.create( + createMenu( + MENU_GROUP_ID, + "치킨버거", + new BigDecimal(7000), + List.of(chickenBurger))); + + menu.setPrice(new BigDecimal(6500)); + Menu newPriceMenu = menuService.changePrice(menu.getId(), menu); + + assertThat(newPriceMenu.getPrice()).isEqualTo(new BigDecimal(6500)); + } + + @DisplayName("메뉴의 가격이 0원 미만이면 변경할 수 없다") + @Test + void canNotChangeNegativePrice() { + MenuProduct chickenBurger = createMenuProduct(BURGER_PRODUCT_ID, 1); + Menu menu = menuService.create( + createMenu( + MENU_GROUP_ID, + "치킨버거", + new BigDecimal(7000), + List.of(chickenBurger))); + + menu.setPrice(new BigDecimal(-1)); + + assertThatIllegalArgumentException() + .isThrownBy(() -> menuService.changePrice(menu.getId(), menu)); + } + + @DisplayName("메뉴의 가격은 포함된 상품 가격 총합과 동일하거나 할인된 가격으로만 수정 가능하다") + @Test + void validateMenuPriceOnModify() { + //given + MenuProduct chickenBurger = createMenuProduct(BURGER_PRODUCT_ID, 1); //7000원 + MenuProduct side = createMenuProduct(SIDE_PRODUCT_ID, 1); //2000원 + MenuProduct coke = createMenuProduct(COKE_PRODUCT_ID, 1); //2000원 + + Menu menu = createMenu( + MENU_GROUP_ID, + "치킨버거세트", + new BigDecimal(11000), + List.of(chickenBurger, side, coke) + ); + Menu resultMenu = menuService.create(menu); + + resultMenu.setPrice(new BigDecimal(11001)); + assertThatIllegalArgumentException() + .isThrownBy(() -> menuService.changePrice(resultMenu.getId(), resultMenu)); + } + //endregion + + //region [메뉴 전시] + @DisplayName("메뉴를 메뉴판에 전시한다") + @Test + void display() { + MenuProduct chickenBurger = createMenuProduct(BURGER_PRODUCT_ID, 1); + Menu menu = menuService.create( + createMenu( + MENU_GROUP_ID, + "치킨버거", + new BigDecimal(7000), + List.of(chickenBurger) + ) + ); + + Menu resultMenu = menuService.display(menu.getId()); + + assertThat(resultMenu.isDisplayed()).isTrue(); + } + + @DisplayName("메뉴의 가격이 포함된 상품 가격 총합과 동일하거나 할인된 가격인 경우만 전시할 수 있다") + @Test + void validateMenuPriceOnDisplay() { + //given + MenuProduct chickenBurger = createMenuProduct(BURGER_PRODUCT_ID, 1); //7000원 + MenuProduct side = createMenuProduct(SIDE_PRODUCT_ID, 1); //2000원 + MenuProduct coke = createMenuProduct(COKE_PRODUCT_ID, 1); //2000원 + + Menu menu = createMenu( + MENU_GROUP_ID, + "치킨버거세트", + new BigDecimal(11000), + List.of(chickenBurger, side, coke) + ); + Menu resultMenu = menuService.create(menu); + + resultMenu.setPrice(new BigDecimal(11001)); + assertThatIllegalStateException() + .isThrownBy(() -> menuService.display(resultMenu.getId())); + } + + @DisplayName("메뉴판의 전시여부를 X로 변경한다") + @Test + void hide() { + MenuProduct chickenBurger = createMenuProduct(BURGER_PRODUCT_ID, 1); + Menu menu = menuService.create( + createMenu( + MENU_GROUP_ID, + "치킨버거", + new BigDecimal(7000), + List.of(chickenBurger) + ) + ); + + Menu resultMenu = menuService.hide(menu.getId()); + + assertThat(resultMenu.isDisplayed()).isFalse(); + } + //endregion + + //region [메뉴 조회] + @DisplayName("모든 메뉴들을 조회할 수 있다") + @Test + void findAll() { + MenuProduct chickenBurger = createMenuProduct(BURGER_PRODUCT_ID, 1); //7000원 + MenuProduct side = createMenuProduct(SIDE_PRODUCT_ID, 1); //2000원 + MenuProduct coke = createMenuProduct(COKE_PRODUCT_ID, 1); //2000원 + + menuService.create(createMenu(MENU_GROUP_ID, "치킨버거", new BigDecimal(7000), List.of(chickenBurger))); + menuService.create(createMenu(MENU_GROUP_ID, "감자튀김", new BigDecimal(2000), List.of(side))); + menuService.create(createMenu(MENU_GROUP_ID, "콜라", new BigDecimal(2000), List.of(coke))); + + List allMenus = menuService.findAll(); + assertThat(allMenus.size()).isEqualTo(3); + assertThat(allMenus) + .extracting(Menu::getName, menu -> menu.getPrice().intValue()) + .contains( + Tuple.tuple("치킨버거", 7000), + Tuple.tuple("감자튀김", 2000), + Tuple.tuple("콜라", 2000) + ); + } + //endregion + private Product createProduct(UUID id, String name, BigDecimal price) { Product product = new Product(); product.setId(id); From ecda79c70c61d527d58539f58af68e393bebce9a Mon Sep 17 00:00:00 2001 From: skdev0619 Date: Mon, 3 Feb 2025 16:09:21 +0900 Subject: [PATCH 05/29] =?UTF-8?q?=EC=A3=BC=EB=AC=B8=20=EC=83=9D=EC=84=B1?= =?UTF-8?q?=20=ED=85=8C=EC=8A=A4=ED=8A=B8=20=EC=BD=94=EB=93=9C=20=EC=B6=94?= =?UTF-8?q?=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 22 +- .../application/OrderServiceTest.java | 305 ++++++++++++++++++ 2 files changed, 316 insertions(+), 11 deletions(-) create mode 100644 src/test/java/kitchenpos/application/OrderServiceTest.java diff --git a/README.md b/README.md index 9f984a25d..4b419cae2 100644 --- a/README.md +++ b/README.md @@ -109,17 +109,17 @@ ex) 주문의 종류에 따른 주문 상태의 변화는 아래 도식도를 참고하도록 한다 ![설명](./assets/OrderFlowChart.png) -- [ ] 주문은 생성할 수 있다 - - [ ] 주문의 종류는 배달(DELIVERY), 포장(TAKEOUT), 매장 내 취식(EAT_IN) 중 선택할 수 있다 - - [ ] 어떤 메뉴를 몇 개 시킬지에 대한 주문 상세 내역이 1개 이상 있어야 한다 - - [ ] 배달, 포장의 경우, 주문한 메뉴의 수량이 0이상이어야 한다 - - [ ] 메뉴판에 전시되지 않은 메뉴는 주문할 수 없다 - - [ ] 메뉴의 가격과 주문 내역의 가격은 동일해야 한다 - - [ ] 배달의 경우, 배달 주소가 반드시 입력되어야 한다 - - [ ] 배달 주소는 공백만 입력되어서는 안된다 - - [ ] 매장 내 취식의 경우, 매장 내 배정된 주문 테이블이 있어야 한다 - - [ ] 주문 테이블의 사융 유무가 사용 중이어야 한다 - - [ ] 주문의 상태는 '대기(WAITING)'가 된다 +- [x] 주문은 생성할 수 있다 + - [x] 주문의 종류는 배달(DELIVERY), 포장(TAKEOUT), 매장 내 취식(EAT_IN) 중 선택할 수 있다 + - [x] 어떤 메뉴를 몇 개 시킬지에 대한 주문 상세 내역이 1개 이상 있어야 한다 + - [x] 배달, 포장의 경우, 주문한 메뉴의 수량이 0이상이어야 한다 + - [x] 메뉴판에 전시되지 않은 메뉴는 주문할 수 없다 + - [x] 메뉴의 가격과 주문 내역의 가격은 동일해야 한다 + - [x] 배달의 경우, 배달 주소가 반드시 입력되어야 한다 + - [x] 배달 주소는 공백만 입력되어서는 안된다 + - [x] 매장 내 취식의 경우, 매장 내 배정된 주문 테이블이 있어야 한다 + - [x] 주문 테이블의 사융 유무가 사용 중이어야 한다 + - [x] 주문의 상태는 '대기(WAITING)'가 된다 - [ ] 대기하고 있는 주문을 수락한다 - [ ] 주문의 상태가 대기(WAITING)일 때 주문 수락이 가능하다 - [ ] 배달 주문의 경우, 라이더에게 주문 정보(주문 총액, 배달 주소)를 제공하여 배달하도록 한다 diff --git a/src/test/java/kitchenpos/application/OrderServiceTest.java b/src/test/java/kitchenpos/application/OrderServiceTest.java new file mode 100644 index 000000000..b29fed45d --- /dev/null +++ b/src/test/java/kitchenpos/application/OrderServiceTest.java @@ -0,0 +1,305 @@ +package kitchenpos.application; + +import kitchenpos.domain.*; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.MethodSource; +import org.junit.jupiter.params.provider.NullAndEmptySource; +import org.junit.jupiter.params.provider.NullSource; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.transaction.annotation.Transactional; + +import java.math.BigDecimal; +import java.time.LocalDateTime; +import java.util.Collections; +import java.util.List; +import java.util.NoSuchElementException; +import java.util.UUID; +import java.util.stream.Stream; + +import static org.assertj.core.api.Assertions.*; + +@Transactional +@SpringBootTest +class OrderServiceTest { + + private static final UUID DISPLAY_MENU_ID = UUID.randomUUID(); + private static final UUID UNDISPLAYED_MENU_ID = UUID.randomUUID(); + private static final UUID ORDER_TABLE_ID = UUID.randomUUID(); + + @Autowired + private ProductRepository productRepository; + + @Autowired + private MenuRepository menuRepository; + + @Autowired + private MenuGroupRepository menuGroupRepository; + + @Autowired + private OrderTableRepository orderTableRepository; + + @Autowired + private OrderService orderService; + + + @BeforeEach + void setUp() { + Product product1 = productRepository.save(createProduct(UUID.randomUUID(), "전시", new BigDecimal(25000))); + Product product2 = productRepository.save(createProduct(UUID.randomUUID(), "비전시", new BigDecimal(7000))); + + UUID menuGroupId = UUID.randomUUID(); + MenuGroup menuGroup = menuGroupRepository.save(createMenuGroup(menuGroupId, "단품")); + + MenuProduct displayMenuProduct = createMenuProduct(product1.getId(), product1, 1); + menuRepository.save(createMenu(DISPLAY_MENU_ID, menuGroup, menuGroup.getId(), "전시메뉴", new BigDecimal(25000), true, List.of(displayMenuProduct))); + + MenuProduct unDisplayMenuProduct = createMenuProduct(product2.getId(), product2, 1); + menuRepository.save(createMenu(UNDISPLAYED_MENU_ID, menuGroup, menuGroup.getId(), "비전시메뉴", new BigDecimal(7000), false, List.of(unDisplayMenuProduct))); + } + + //region [주문 생성] + @DisplayName("주문의 종류는 반드시 입력해야 한다") + @NullSource + @ParameterizedTest + void orderType(OrderType status) { + OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal("25000"), 1); + Order nullOrderTypeRequest = createOrder(status, List.of(orderLineItem), "", null, null); + + assertThatIllegalArgumentException() + .isThrownBy(() -> orderService.create(nullOrderTypeRequest)); + } + + @DisplayName("포장 주문을 생성한다. 주문이 정상적으로 생성되면 상태는 대기 중으로 변경된다") + @Test + void createTakeOutOrder() { + OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal("25000"), 1); + Order orderRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); + + Order orderResult = orderService.create(orderRequest); + + assertThat(orderResult.getType()).isEqualTo(OrderType.TAKEOUT); + assertThat(orderResult.getOrderLineItems()).isNotNull(); + assertThat(orderResult.getOrderLineItems()).hasSize(1); + assertThat(orderResult.getDeliveryAddress()).isNull(); + assertThat(orderResult.getStatus()).isEqualTo(OrderStatus.WAITING); + } + + @DisplayName("배달 주문을 생성한다. 주문이 정상적으로 생성되면 상태는 대기 중으로 변경된다") + @Test + void createDeliveryOrder() { + OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal("25000"), 1); + Order orderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XX호", LocalDateTime.now()); + + Order orderResult = orderService.create(orderRequest); + + assertThat(orderResult.getType()).isEqualTo(OrderType.DELIVERY); + assertThat(orderResult.getOrderLineItems()).isNotNull(); + assertThat(orderResult.getOrderLineItems()).hasSize(1); + assertThat(orderResult.getDeliveryAddress()).isNotNull(); + assertThat(orderResult.getDeliveryAddress()).isEqualTo("경기도 고양시..XX동 XX호"); + assertThat(orderResult.getStatus()).isEqualTo(OrderStatus.WAITING); + } + + @DisplayName("매장 내 식사 주문을 생성한다. 주문이 정상적으로 생성되면 상태는 대기 중으로 변경된다") + @Test + void createEatInOrder() { + OrderTable request = createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4); + OrderTable orderTable = orderTableRepository.save(request); + + OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal("25000"), 1); + Order orderRequest = createEatInOrder(List.of(orderLineItem), orderTable.getId(), LocalDateTime.now()); + + Order orderResult = orderService.create(orderRequest); + + assertThat(orderResult.getType()).isEqualTo(OrderType.EAT_IN); + assertThat(orderResult.getOrderLineItems()).isNotNull(); + assertThat(orderResult.getOrderLineItems()).hasSize(1); + assertThat(orderResult.getDeliveryAddress()).isNull(); + assertThat(orderResult.getStatus()).isEqualTo(OrderStatus.WAITING); + } + + @DisplayName("어떤 메뉴를 몇 개 시킬지에 대한 주문 상세 내역이 1개 이상 있어야 한다") + @ParameterizedTest + @MethodSource("nullOrEmptyList") + void notNullOrderLineItems(List orderLineItems) { + Order takeOutRequest = createTakeOutOrder(orderLineItems, LocalDateTime.now()); + Order deliveryOrderRequest = createDeliveryOrder(orderLineItems, "경기도 고양시..XX동 XX호", LocalDateTime.now()); + OrderTable orderTable = orderTableRepository.save(createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); + Order eatInOrderRequest = createEatInOrder(orderLineItems, orderTable.getId(), LocalDateTime.now()); + + assertThatIllegalArgumentException() + .isThrownBy(() -> orderService.create(takeOutRequest)); + assertThatIllegalArgumentException() + .isThrownBy(() -> orderService.create(deliveryOrderRequest)); + assertThatIllegalArgumentException() + .isThrownBy(() -> orderService.create(eatInOrderRequest)); + } + + private static Stream nullOrEmptyList() { + return Stream.of(null, Collections.emptyList()); + } + + @DisplayName("배달/포장 주문의 경우, 주문한 메뉴의 수량이 0개 이상이어야 한다") + @Test + void validateQuantity() { + int negativeQuantity = -1; + OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal("25000"), negativeQuantity); + Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); + Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XX호", LocalDateTime.now()); + + assertThatIllegalArgumentException() + .isThrownBy(() -> orderService.create(takeOutRequest)); + assertThatIllegalArgumentException() + .isThrownBy(() -> orderService.create(deliveryOrderRequest)); + } + + @DisplayName("메뉴판에 전시하지 않은 메뉴는 주문할 수 없다") + @Test + void validateMenuOrder() { + OrderLineItem undisplayMenuOrderItem = createOrderLineItem(UNDISPLAYED_MENU_ID, new BigDecimal("25000"), 1); + Order takeOutRequest = createTakeOutOrder(List.of(undisplayMenuOrderItem), LocalDateTime.now()); + Order deliveryOrderRequest = createDeliveryOrder(List.of(undisplayMenuOrderItem), "경기도 고양시..XX동 XX호", LocalDateTime.now()); + OrderTable orderTable = orderTableRepository.save(createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); + Order eatInOrderRequest = createEatInOrder(List.of(undisplayMenuOrderItem), orderTable.getId(), LocalDateTime.now()); + + assertThatIllegalStateException() + .isThrownBy(() -> orderService.create(takeOutRequest)); + assertThatIllegalStateException() + .isThrownBy(() -> orderService.create(deliveryOrderRequest)); + assertThatIllegalStateException() + .isThrownBy(() -> orderService.create(eatInOrderRequest)); + } + + @DisplayName("메뉴의 가격과 주문 내역의 가격은 동일해야 한다") + @Test + void validateOrderPrice() { + BigDecimal menuPrice = menuRepository.findById(DISPLAY_MENU_ID).get().getPrice(); + + OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, menuPrice.add(BigDecimal.ONE), 1); + Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); + Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XX호", LocalDateTime.now()); + OrderTable orderTable = orderTableRepository.save(createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); + Order eatInOrderRequest = createEatInOrder(List.of(orderLineItem), orderTable.getId(), LocalDateTime.now()); + + assertThatIllegalArgumentException() + .isThrownBy(() -> orderService.create(takeOutRequest)); + assertThatIllegalArgumentException() + .isThrownBy(() -> orderService.create(deliveryOrderRequest)); + assertThatIllegalArgumentException() + .isThrownBy(() -> orderService.create(eatInOrderRequest)); + } + + @DisplayName("배달의 경우, 배달 주소가 반드시 입력되어야 하며, 공백만 입력되어서는 안된다") + @ParameterizedTest + @NullAndEmptySource + void notNullOrNotEmpty(String deliveryAddress) { + OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), deliveryAddress, LocalDateTime.now()); + + assertThatIllegalArgumentException() + .isThrownBy(() -> orderService.create(deliveryOrderRequest)); + } + + @DisplayName("매장 내 취식일 경우, 고객에게 배정된 주문 테이블이 있어야 한다") + @Test + void validateOrderTable() { + UUID unknownTableId = UUID.randomUUID(); + OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + Order eatInOrderRequest = createEatInOrder(List.of(orderLineItem), unknownTableId, LocalDateTime.now()); + + assertThatThrownBy(() -> orderService.create(eatInOrderRequest)) + .isInstanceOf(NoSuchElementException.class); + } + + @DisplayName("매장 내 취식일 경우, 주문 테이블의 사용유무가 사용 중이어야 한다") + @Test + void validateOrderTableStatus() { + boolean tableOccupied = false; + OrderTable orderTable = orderTableRepository.save(createOrderTable(ORDER_TABLE_ID, "1번테이블", tableOccupied, 0)); + OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + Order eatInOrderRequest = createEatInOrder(List.of(orderLineItem), orderTable.getId(), LocalDateTime.now()); + + assertThatIllegalStateException() + .isThrownBy(() -> orderService.create(eatInOrderRequest)); + } + //endregion + + private Product createProduct(UUID id, String name, BigDecimal price) { + Product product = new Product(); + product.setId(id); + product.setName(name); + product.setPrice(price); + return product; + } + + private MenuProduct createMenuProduct(UUID productId, Product product, int quantity) { + MenuProduct menuProduct = new MenuProduct(); + menuProduct.setProduct(product); + menuProduct.setProductId(productId); + menuProduct.setQuantity(quantity); + return menuProduct; + } + + private Menu createMenu(UUID id, MenuGroup menuGroup, UUID menuGroupId, String name, BigDecimal price, boolean displayed, List products) { + Menu menu = new Menu(); + menu.setId(id); + menu.setMenuGroup(menuGroup); + menu.setMenuGroupId(menuGroupId); + menu.setName(name); + menu.setPrice(price); + menu.setDisplayed(displayed); + menu.setMenuProducts(products); + return menu; + } + + private MenuGroup createMenuGroup(UUID id, String name) { + MenuGroup menuGroup = new MenuGroup(); + menuGroup.setId(id); + menuGroup.setName(name); + return menuGroup; + } + + private OrderTable createOrderTable(UUID id, String name, boolean occupied, int numberOfGuests) { + OrderTable orderTable = new OrderTable(); + orderTable.setId(id); + orderTable.setName(name); + orderTable.setOccupied(occupied); + orderTable.setNumberOfGuests(numberOfGuests); + return orderTable; + } + + private Order createTakeOutOrder(List orderLineItems, LocalDateTime orderDateTime) { + return createOrder(OrderType.TAKEOUT, orderLineItems, null, null, orderDateTime); + } + + private Order createDeliveryOrder(List orderLineItems, String deliveryAddress, LocalDateTime orderDateTime) { + return createOrder(OrderType.DELIVERY, orderLineItems, deliveryAddress, null, orderDateTime); + } + + private Order createEatInOrder(List orderLineItems, UUID orderTableId, LocalDateTime orderDateTime) { + return createOrder(OrderType.EAT_IN, orderLineItems, null, orderTableId, orderDateTime); + } + + + private Order createOrder(OrderType orderType, List orderLineItems, String deliveryAddress, UUID orderTableId, LocalDateTime orderDateTime) { + Order order = new Order(); + order.setType(orderType); + order.setOrderLineItems(orderLineItems); + order.setDeliveryAddress(deliveryAddress); + order.setOrderTableId(orderTableId); + order.setOrderDateTime(orderDateTime); + return order; + } + + private OrderLineItem createOrderLineItem(UUID menuId, BigDecimal price, int quantity) { + OrderLineItem orderLineItem = new OrderLineItem(); + orderLineItem.setMenuId(menuId); + orderLineItem.setPrice(price); + orderLineItem.setQuantity(quantity); + return orderLineItem; + } +} From 05f1ae73d726293ce7d4fd4807fd129b3df8a2af Mon Sep 17 00:00:00 2001 From: skdev0619 Date: Mon, 3 Feb 2025 15:31:18 +0900 Subject: [PATCH 06/29] =?UTF-8?q?=EC=A3=BC=EB=AC=B8=20=EC=88=98=EB=9D=BD?= =?UTF-8?q?=20=ED=85=8C=EC=8A=A4=ED=8A=B8=20=EC=BD=94=EB=93=9C=20=EC=B6=94?= =?UTF-8?q?=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 6 ++-- .../application/OrderServiceTest.java | 28 +++++++++++++++++++ 2 files changed, 31 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 4b419cae2..adfcc8124 100644 --- a/README.md +++ b/README.md @@ -120,10 +120,10 @@ ex) - [x] 매장 내 취식의 경우, 매장 내 배정된 주문 테이블이 있어야 한다 - [x] 주문 테이블의 사융 유무가 사용 중이어야 한다 - [x] 주문의 상태는 '대기(WAITING)'가 된다 -- [ ] 대기하고 있는 주문을 수락한다 - - [ ] 주문의 상태가 대기(WAITING)일 때 주문 수락이 가능하다 +- [x] 대기하고 있는 주문을 수락한다 + - [x] 주문의 상태가 대기(WAITING)일 때 주문 수락이 가능하다 - [ ] 배달 주문의 경우, 라이더에게 주문 정보(주문 총액, 배달 주소)를 제공하여 배달하도록 한다 - - [ ] 주문의 상태를 주문 수락(ACCEPTED)으로 변경한다 + - [x] 주문의 상태를 주문 수락(ACCEPTED)으로 변경한다 - [ ] 수락한 주문을 기반으로 음식을 제공한다 - [ ] 수락한 주문의 상태는 주문 수락(ACCEPTED)이어야 한다 - [ ] 음식 제공 후, 주문 상태를 음식 제공됨(SERVED)으로 변경한다 diff --git a/src/test/java/kitchenpos/application/OrderServiceTest.java b/src/test/java/kitchenpos/application/OrderServiceTest.java index b29fed45d..731749e52 100644 --- a/src/test/java/kitchenpos/application/OrderServiceTest.java +++ b/src/test/java/kitchenpos/application/OrderServiceTest.java @@ -5,6 +5,7 @@ import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.EnumSource; import org.junit.jupiter.params.provider.MethodSource; import org.junit.jupiter.params.provider.NullAndEmptySource; import org.junit.jupiter.params.provider.NullSource; @@ -228,6 +229,33 @@ void validateOrderTableStatus() { } //endregion + //region [주문 수락] + @DisplayName("대기 중인 주문을 수락한다") + @Test + void acceptOrderStatus() { + OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); + Order takeOutOrder = orderService.create(takeOutRequest); + + Order acceptOrder = orderService.accept(takeOutOrder.getId()); + + assertThat(acceptOrder.getStatus()).isEqualTo(OrderStatus.ACCEPTED); + } + + @DisplayName("주문의 상태가 대기(WAITING)일 때 주문 수락이 가능하다") + @EnumSource(value = OrderStatus.class, names = "WAITING", mode = EnumSource.Mode.EXCLUDE) + @ParameterizedTest + void validateAcceptStatus(OrderStatus orderStatus) { + OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); + Order takeOutOrder = orderService.create(takeOutRequest); + + takeOutOrder.setStatus(orderStatus); + assertThatIllegalStateException() + .isThrownBy(() -> orderService.accept(takeOutOrder.getId())); + } + //endregion + private Product createProduct(UUID id, String name, BigDecimal price) { Product product = new Product(); product.setId(id); From 247f6fe09aae8aac71c905bf3e9b5c6adf5ea0fc Mon Sep 17 00:00:00 2001 From: skdev0619 Date: Mon, 3 Feb 2025 15:32:58 +0900 Subject: [PATCH 07/29] =?UTF-8?q?=EC=9D=8C=EC=8B=9D=EC=A0=9C=EA=B3=B5?= =?UTF-8?q?=EB=90=A8=20=ED=85=8C=EC=8A=A4=ED=8A=B8=20=EC=BD=94=EB=93=9C=20?= =?UTF-8?q?=EC=B6=94=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 6 ++-- .../application/OrderServiceTest.java | 28 +++++++++++++++++++ 2 files changed, 31 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index adfcc8124..1fc367646 100644 --- a/README.md +++ b/README.md @@ -124,9 +124,9 @@ ex) - [x] 주문의 상태가 대기(WAITING)일 때 주문 수락이 가능하다 - [ ] 배달 주문의 경우, 라이더에게 주문 정보(주문 총액, 배달 주소)를 제공하여 배달하도록 한다 - [x] 주문의 상태를 주문 수락(ACCEPTED)으로 변경한다 -- [ ] 수락한 주문을 기반으로 음식을 제공한다 - - [ ] 수락한 주문의 상태는 주문 수락(ACCEPTED)이어야 한다 - - [ ] 음식 제공 후, 주문 상태를 음식 제공됨(SERVED)으로 변경한다 +- [x] 수락한 주문을 기반으로 음식을 제공한다 + - [x] 수락한 주문의 상태는 주문 수락(ACCEPTED)이어야 한다 + - [x] 음식 제공 후, 주문 상태를 음식 제공됨(SERVED)으로 변경한다 - [ ] 배달 주문의 경우, 배달을 시작한다 - [ ] 주문의 상태가 음식 제공됨(SERVED)일 때 배달 가능하다 - [ ] 주문의 상태를 배달 중(DELIVERING)으로 변경한다 diff --git a/src/test/java/kitchenpos/application/OrderServiceTest.java b/src/test/java/kitchenpos/application/OrderServiceTest.java index 731749e52..5c358c537 100644 --- a/src/test/java/kitchenpos/application/OrderServiceTest.java +++ b/src/test/java/kitchenpos/application/OrderServiceTest.java @@ -256,6 +256,34 @@ void validateAcceptStatus(OrderStatus orderStatus) { } //endregion + //region [음식 제공됨] + @DisplayName("주문 상태를 음식 제공됨(SERVED)로 변경한다") + @Test + void served() { + OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); + Order takeOutOrder = orderService.create(takeOutRequest); + Order acceptOrder = orderService.accept(takeOutOrder.getId()); + + Order servedOrder = orderService.serve(acceptOrder.getId()); + + assertThat(servedOrder.getStatus()).isEqualTo(OrderStatus.SERVED); + } + + @DisplayName("주문의 상태가 주문 수락(ACCEPTED)일 때 음식 제공 가능하다") + @EnumSource(value = OrderStatus.class, names = "ACCEPTED", mode = EnumSource.Mode.EXCLUDE) + @ParameterizedTest + void validateServedStatus(OrderStatus orderStatus) { + OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); + Order takeOutOrder = orderService.create(takeOutRequest); + + takeOutOrder.setStatus(orderStatus); + assertThatIllegalStateException() + .isThrownBy(() -> orderService.serve(takeOutOrder.getId())); + } + //endregion + private Product createProduct(UUID id, String name, BigDecimal price) { Product product = new Product(); product.setId(id); From cf5a26bb0b6e9018e73cc04c387c9bf7bd788c9f Mon Sep 17 00:00:00 2001 From: skdev0619 Date: Mon, 3 Feb 2025 15:34:13 +0900 Subject: [PATCH 08/29] =?UTF-8?q?=EB=B0=B0=EB=8B=AC=20=EC=A4=91,=20?= =?UTF-8?q?=EB=B0=B0=EB=8B=AC=EC=99=84=EB=A3=8C=20=ED=85=8C=EC=8A=A4?= =?UTF-8?q?=ED=8A=B8=20=EC=BD=94=EB=93=9C=20=EC=B6=94=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 12 ++-- .../application/OrderServiceTest.java | 56 +++++++++++++++++++ 2 files changed, 62 insertions(+), 6 deletions(-) diff --git a/README.md b/README.md index 1fc367646..5f57b7cca 100644 --- a/README.md +++ b/README.md @@ -127,12 +127,12 @@ ex) - [x] 수락한 주문을 기반으로 음식을 제공한다 - [x] 수락한 주문의 상태는 주문 수락(ACCEPTED)이어야 한다 - [x] 음식 제공 후, 주문 상태를 음식 제공됨(SERVED)으로 변경한다 -- [ ] 배달 주문의 경우, 배달을 시작한다 - - [ ] 주문의 상태가 음식 제공됨(SERVED)일 때 배달 가능하다 - - [ ] 주문의 상태를 배달 중(DELIVERING)으로 변경한다 -- [ ] 배달 주문의 경우, 배달이 완료한다 - - [ ] 주문의 상태가 배달 중(DELIVERING)인 경우만 배달 완료할 수 있다 - - [ ] 주문 상태를 배달 완료(DELIVERED)으로 변경한다 +- [x] 배달 주문의 경우, 배달을 시작한다 + - [x] 주문의 상태가 음식 제공됨(SERVED)일 때 배달 가능하다 + - [x] 주문의 상태를 배달 중(DELIVERING)으로 변경한다 +- [x] 배달 주문의 경우, 배달이 완료한다 + - [x] 주문의 상태가 배달 중(DELIVERING)인 경우만 배달 완료할 수 있다 + - [x] 주문 상태를 배달 완료(DELIVERED)으로 변경한다 - [ ] 주문을 완료한다 - [ ] 주문 유형에 따라 아래와 같은 주문 상태일 때만 완료할 수 있다 - [ ] 배달은 주문 상태가 배달 완료(DELIVERED)여야 한다 diff --git a/src/test/java/kitchenpos/application/OrderServiceTest.java b/src/test/java/kitchenpos/application/OrderServiceTest.java index 5c358c537..4b988b8e9 100644 --- a/src/test/java/kitchenpos/application/OrderServiceTest.java +++ b/src/test/java/kitchenpos/application/OrderServiceTest.java @@ -284,6 +284,62 @@ void validateServedStatus(OrderStatus orderStatus) { } //endregion + //region [배달 시작] + @DisplayName("배달 주문의 경우 음식이 제공되면 주문 상태를 배달 중(DELIVERING)으로 변경한다") + @Test + void startDelivery() { + OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", LocalDateTime.now()); + Order order = orderService.create(deliveryOrderRequest); + + order.setStatus(OrderStatus.SERVED); + Order deliveryStartorder = orderService.startDelivery(order.getId()); + + assertThat(deliveryStartorder.getStatus()).isEqualTo(OrderStatus.DELIVERING); + } + + @DisplayName("주문 상태가 음식 제공됨(SERVED)인 경우, 배달 시작이 가능하다") + @EnumSource(value = OrderStatus.class, names = "SERVED", mode = EnumSource.Mode.EXCLUDE) + @ParameterizedTest + void validateDeliveryStartStatus(OrderStatus orderStatus) { + OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", LocalDateTime.now()); + Order order = orderService.create(deliveryOrderRequest); + + order.setStatus(orderStatus); + assertThatIllegalStateException() + .isThrownBy(() -> orderService.startDelivery(order.getId())); + } + //endregion + + //region [배달 완료] + @DisplayName("배달 완료한 주문 상태를 배달완료(DELIVERED)로 변경한다") + @Test + void endDelivery() { + OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", LocalDateTime.now()); + Order order = orderService.create(deliveryOrderRequest); + + order.setStatus(OrderStatus.DELIVERING); + Order deliveryStartorder = orderService.completeDelivery(order.getId()); + + assertThat(deliveryStartorder.getStatus()).isEqualTo(OrderStatus.DELIVERED); + } + + @DisplayName("주문 상태가 배달 중(DELIVERING)인 경우, 배달완료(DELIVERED)로 변경 가능하다") + @ParameterizedTest + @EnumSource(value = OrderStatus.class, names = "DELIVERING", mode = EnumSource.Mode.EXCLUDE) + void validateDeliveryEndStatus(OrderStatus orderStatus) { + OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", LocalDateTime.now()); + Order order = orderService.create(deliveryOrderRequest); + + order.setStatus(orderStatus); + assertThatIllegalStateException() + .isThrownBy(() -> orderService.completeDelivery(order.getId())); + } + //endregion + private Product createProduct(UUID id, String name, BigDecimal price) { Product product = new Product(); product.setId(id); From f421d1359e12dffd395fc89e20b9173bab0e33a4 Mon Sep 17 00:00:00 2001 From: skdev0619 Date: Mon, 3 Feb 2025 15:54:35 +0900 Subject: [PATCH 09/29] =?UTF-8?q?=EC=A3=BC=EB=AC=B8=20=EC=99=84=EB=A3=8C?= =?UTF-8?q?=20=ED=85=8C=EC=8A=A4=ED=8A=B8=20=EC=BD=94=EB=93=9C=20=EC=B6=94?= =?UTF-8?q?=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 16 +-- .../application/OrderServiceTest.java | 136 ++++++++++++++++++ 2 files changed, 144 insertions(+), 8 deletions(-) diff --git a/README.md b/README.md index 5f57b7cca..c2468001d 100644 --- a/README.md +++ b/README.md @@ -133,14 +133,14 @@ ex) - [x] 배달 주문의 경우, 배달이 완료한다 - [x] 주문의 상태가 배달 중(DELIVERING)인 경우만 배달 완료할 수 있다 - [x] 주문 상태를 배달 완료(DELIVERED)으로 변경한다 -- [ ] 주문을 완료한다 - - [ ] 주문 유형에 따라 아래와 같은 주문 상태일 때만 완료할 수 있다 - - [ ] 배달은 주문 상태가 배달 완료(DELIVERED)여야 한다 - - [ ] 매장 내 취식/포장은 주문 상태가 음식 제공됨(SERVED)이어야 한다 - - [ ] 매장 내 취식의 경우, 해당 테이블에 미완료된 주문이 없다면 테이블을 정리한다 - - [ ] 고객의 수를 0명으로 변경한다 - - [ ] 주문 테이블의 사용유무가 사용안함으로 변경한다 - - [ ] 주문의 상태를 주문완료(COMPLETED)로 변경한다 +- [x] 주문을 완료한다 + - [x] 주문 유형에 따라 아래와 같은 주문 상태일 때만 완료할 수 있다 + - [x] 배달은 주문 상태가 배달 완료(DELIVERED)여야 한다 + - [x] 매장 내 취식/포장은 주문 상태가 음식 제공됨(SERVED)이어야 한다 + - [x] 매장 내 취식의 경우, 해당 테이블에 미완료된 주문이 없다면 테이블을 정리한다 + - [x] 고객의 수를 0명으로 변경한다 + - [x] 주문 테이블의 사용유무가 사용안함으로 변경한다 + - [x] 주문의 상태를 주문완료(COMPLETED)로 변경한다 - [ ] 모든 주문 목록을 조회할 수 있다 ## 용어 사전 diff --git a/src/test/java/kitchenpos/application/OrderServiceTest.java b/src/test/java/kitchenpos/application/OrderServiceTest.java index 4b988b8e9..4cb006e0e 100644 --- a/src/test/java/kitchenpos/application/OrderServiceTest.java +++ b/src/test/java/kitchenpos/application/OrderServiceTest.java @@ -340,6 +340,128 @@ void validateDeliveryEndStatus(OrderStatus orderStatus) { } //endregion + //region [주문 완료] + @DisplayName("배달 주문의 상태를 주문 완료로 변경한다") + @Test + void complete() { + //given + OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", LocalDateTime.now()); + Order order = createDeliveredOrder(deliveryOrderRequest); + //when + Order complete = orderService.complete(order.getId()); + //then + assertThat(complete.getStatus()).isEqualTo(OrderStatus.COMPLETED); + } + + @DisplayName("배달 주문의 경우, 주문의 상태가 배달 완료(DELIVERED)인 경우만 주문을 완료할 수 있다") + @EnumSource(value = OrderStatus.class, names = "DELIVERED", mode = EnumSource.Mode.EXCLUDE) + @ParameterizedTest + void completeOrderByDelivery(OrderStatus orderStatus) { + OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", LocalDateTime.now()); + Order order = orderService.create(deliveryOrderRequest); + + order.setStatus(orderStatus); + assertThatIllegalStateException() + .isThrownBy(() -> orderService.complete(order.getId())); + } + + @DisplayName("포장 주문의 상태를 주문 완료로 변경한다") + @Test + void completeByTakeOut() { + //given + OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); + Order servedOrder = createServedOrder(takeOutRequest); + //when + Order complete = orderService.complete(servedOrder.getId()); + //then + assertThat(complete.getStatus()).isEqualTo(OrderStatus.COMPLETED); + } + + @DisplayName("매장 내 취식 주문 상태를 주문 완료로 변경한다") + @Test + void completeByEatIn() { + OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + OrderTable orderTable = orderTableRepository.save(createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); + Order eatInRequest = createEatInOrder(List.of(orderLineItem), orderTable.getId(), LocalDateTime.now()); + Order servedOrder = createServedOrder(eatInRequest); + //when + Order complete = orderService.complete(servedOrder.getId()); + //then + assertThat(complete.getStatus()).isEqualTo(OrderStatus.COMPLETED); + } + + @DisplayName("포장/매장 내 취식의 경우, 주문의 상태가 음식 제공됨(SERVED)인 경우만 주문을 완료할 수 있다") + @EnumSource(value = OrderStatus.class, names = "SERVED", mode = EnumSource.Mode.EXCLUDE) + @ParameterizedTest + void completeOrderByEatInOrTakeOut(OrderStatus orderStatus) { + //given + OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); + + OrderTable orderTable = orderTableRepository.save(createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); + Order eatInRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); + + Order takeoutOrder = orderService.create(takeOutRequest); + Order eatInOrder = orderService.create(eatInRequest); + //when + takeoutOrder.setStatus(orderStatus); + eatInOrder.setStatus(orderStatus); + //then + assertThatIllegalStateException() + .isThrownBy(() -> orderService.complete(takeoutOrder.getId())); + assertThatIllegalStateException() + .isThrownBy(() -> orderService.complete(eatInOrder.getId())); + } + + @DisplayName("매장 내 식사의 경우, 주문 테이블의 모든 주문이 완료 상태가 아닐 때 테이블은 사용 중이며 손님의 수는 0으로 초기화되지 않는다") + @Test + void completeOrderByEatIn() { + //given + OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + OrderTable orderTable = orderTableRepository.save(createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); + Order eatInRequest = createEatInOrder(List.of(orderLineItem), orderTable.getId(), LocalDateTime.now()); + //주문 상태가 SERVED인 주문1,2 생성 + Order servedOrder1 = createServedOrder(eatInRequest); + Order servedOrder2 = createServedOrder(eatInRequest); + + //when + Order complete = orderService.complete(servedOrder1.getId()); + + //then + assertThat(complete.getStatus()).isEqualTo(OrderStatus.COMPLETED); + assertThat(complete.getOrderTable().isOccupied()).isTrue(); + assertThat(complete.getOrderTable().getNumberOfGuests()).isNotZero(); + } + + @DisplayName("매장 내 취식의 경우, 주문 테이블에의 모든 주문이 완료되면 테이블의 사용유무를 안함으로 변경하고 고객의 수를 0명으로 변경한다") + @Test + void clearOrderTable() { + //given + OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + OrderTable orderTable = orderTableRepository.save(createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); + Order eatInRequest = createEatInOrder(List.of(orderLineItem), orderTable.getId(), LocalDateTime.now()); + + Order servedOrder1 = createServedOrder(eatInRequest); + Order servedOrder2 = createServedOrder(eatInRequest); + + //when + Order complete1 = orderService.complete(servedOrder1.getId()); + Order complete2 = orderService.complete(servedOrder2.getId()); + + //then + assertThat(complete1.getStatus()).isEqualTo(OrderStatus.COMPLETED); + assertThat(complete1.getOrderTable().isOccupied()).isFalse(); + assertThat(complete1.getOrderTable().getNumberOfGuests()).isZero(); + + assertThat(complete2.getStatus()).isEqualTo(OrderStatus.COMPLETED); + assertThat(complete2.getOrderTable().isOccupied()).isFalse(); + assertThat(complete2.getOrderTable().getNumberOfGuests()).isZero(); + } + //endregion + private Product createProduct(UUID id, String name, BigDecimal price) { Product product = new Product(); product.setId(id); @@ -414,4 +536,18 @@ private OrderLineItem createOrderLineItem(UUID menuId, BigDecimal price, int qua orderLineItem.setQuantity(quantity); return orderLineItem; } + + private Order createDeliveredOrder(Order deliveryOrder) { + Order order = orderService.create(deliveryOrder); + Order accept = orderService.accept(order.getId()); + Order serve = orderService.serve(accept.getId()); + Order startDelivery = orderService.startDelivery(serve.getId()); + return orderService.completeDelivery(startDelivery.getId()); + } + + private Order createServedOrder(Order orderRequest) { + Order takeOutOrder = orderService.create(orderRequest); + Order accept = orderService.accept(takeOutOrder.getId()); + return orderService.serve(accept.getId()); + } } From f048ab0b8d99834c7a7a61cde253bd25f96a80e7 Mon Sep 17 00:00:00 2001 From: skdev0619 Date: Mon, 3 Feb 2025 15:55:16 +0900 Subject: [PATCH 10/29] =?UTF-8?q?=EC=A3=BC=EB=AC=B8=20=EC=A1=B0=ED=9A=8C?= =?UTF-8?q?=20=ED=85=8C=EC=8A=A4=ED=8A=B8=20=EC=BD=94=EB=93=9C=20=EC=B6=94?= =?UTF-8?q?=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 2 +- .../application/OrderServiceTest.java | 22 +++++++++++++++++++ 2 files changed, 23 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index c2468001d..f8b946fec 100644 --- a/README.md +++ b/README.md @@ -141,7 +141,7 @@ ex) - [x] 고객의 수를 0명으로 변경한다 - [x] 주문 테이블의 사용유무가 사용안함으로 변경한다 - [x] 주문의 상태를 주문완료(COMPLETED)로 변경한다 -- [ ] 모든 주문 목록을 조회할 수 있다 +- [x] 모든 주문 목록을 조회할 수 있다 ## 용어 사전 diff --git a/src/test/java/kitchenpos/application/OrderServiceTest.java b/src/test/java/kitchenpos/application/OrderServiceTest.java index 4cb006e0e..647576584 100644 --- a/src/test/java/kitchenpos/application/OrderServiceTest.java +++ b/src/test/java/kitchenpos/application/OrderServiceTest.java @@ -462,6 +462,28 @@ void clearOrderTable() { } //endregion + //region [주문 조회] + @DisplayName("모든 주문들을 조회할 수 있다") + @Test + void findAll(){ + //given + OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + OrderTable orderTable = orderTableRepository.save(createOrderTable(UUID.randomUUID(), "1번테이블", true, 4)); + + Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); + Order deliveryRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XX호", LocalDateTime.now()); + Order eatInOrderRequest = createEatInOrder(List.of(orderLineItem), orderTable.getId(), LocalDateTime.now()); + + Order takeOutOrder = orderService.create(takeOutRequest); + Order deliveryOrder = orderService.create(deliveryRequest); + Order eatInOrder = orderService.create(eatInOrderRequest); + //when + List orders = orderService.findAll(); + //then + assertThat(orders).hasSize(3); + } + //endregion + private Product createProduct(UUID id, String name, BigDecimal price) { Product product = new Product(); product.setId(id); From b889deb5b1fc62d91376299b059125c385dd1b15 Mon Sep 17 00:00:00 2001 From: skdev0619 Date: Mon, 3 Feb 2025 16:01:48 +0900 Subject: [PATCH 11/29] =?UTF-8?q?=EC=A3=BC=EB=AC=B8=20=ED=85=8C=EC=9D=B4?= =?UTF-8?q?=EB=B8=94=20=EB=93=B1=EB=A1=9D,=20=EB=B0=B0=EC=A0=95=20?= =?UTF-8?q?=ED=85=8C=EC=8A=A4=ED=8A=B8=20=EC=BD=94=EB=93=9C=20=EC=B6=94?= =?UTF-8?q?=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 22 +-- .../application/OrderTableServiceTest.java | 162 ++++++++++++++++++ 2 files changed, 173 insertions(+), 11 deletions(-) create mode 100644 src/test/java/kitchenpos/application/OrderTableServiceTest.java diff --git a/README.md b/README.md index f8b946fec..36eb892c4 100644 --- a/README.md +++ b/README.md @@ -85,17 +85,17 @@ ex) - 매장 내 취식(EAT_IN)하는 고객의 경우, 테이블이 배정되어야 한다 - 테이블 내에서 주문 내역을 기반으로 주문이 이루어진다 ``` -- [ ] 주문 테이블을 등록할 수 있다 - - [ ] 테이블에 이름을 지정할 수 있다 - - [ ] 테이블 이름은 반드시 입력되어야 한다 - - [ ] 테이블 이름은 공백만 입력되어서는 안된다 - - [ ] 테이블에 있는 고객의 수를 확인할 수 있다 - - [ ] 테이블 최초 등록 시에는 고객의 수를 0명으로 등록한다 - - [ ] 테이블 사용 유무(사용 중/사용 안함)을 알 수 있다 - - [ ] 테이블 최초 등록 시에는 테이블 사용 안함으로 등록한다 - -- [ ] 주문 테이블에 고객이 배정된다 - - [ ] 테이블의 사용 유무를 사용 중으로 변경한다 +- [x] 주문 테이블을 등록할 수 있다 + - [x] 테이블에 이름을 지정할 수 있다 + - [x] 테이블 이름은 반드시 입력되어야 한다 + - [x] 테이블 이름은 공백만 입력되어서는 안된다 + - [x] 테이블에 있는 고객의 수를 확인할 수 있다 + - [x] 테이블 최초 등록 시에는 고객의 수를 0명으로 등록한다 + - [x] 테이블 사용 유무(사용 중/사용 안함)을 알 수 있다 + - [x] 테이블 최초 등록 시에는 테이블 사용 안함으로 등록한다 + +- [x] 주문 테이블에 고객이 배정된다 + - [x] 테이블의 사용 유무를 사용 중으로 변경한다 - [ ] 주문 테이블을 정리한다 - [ ] 주문 상태가 완료가 아니면 정리할 수 없다 diff --git a/src/test/java/kitchenpos/application/OrderTableServiceTest.java b/src/test/java/kitchenpos/application/OrderTableServiceTest.java new file mode 100644 index 000000000..a54cf27be --- /dev/null +++ b/src/test/java/kitchenpos/application/OrderTableServiceTest.java @@ -0,0 +1,162 @@ +package kitchenpos.application; + +import kitchenpos.domain.*; +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 org.springframework.beans.factory.annotation.Autowired; +import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.transaction.annotation.Transactional; + +import java.math.BigDecimal; +import java.time.LocalDateTime; +import java.util.List; +import java.util.UUID; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException; + +@Transactional +@SpringBootTest +class OrderTableServiceTest { + + @Autowired + private OrderTableService orderTableService; + + @Autowired + private OrderService orderService; + + @Autowired + private ProductRepository productRepository; + + @Autowired + private MenuRepository menuRepository; + + @Autowired + private MenuGroupRepository menuGroupRepository; + + //region [주문 테이블 등록] + @DisplayName("주문 테이블의 이름을 지정하여 생성할 수 있다") + @Test + void createOrderTable() { + OrderTable request = createOrderTable("1번테이블"); + + OrderTable orderTable = orderTableService.create(request); + + assertThat(orderTable.getName()).isEqualTo("1번테이블"); + } + + @DisplayName("주문 테이블의 이름은 공백만 입력할 수 없으며 반드시 입력되어야 한다") + @NullAndEmptySource + @ParameterizedTest + void notNullTableName(String name) { + OrderTable request = createOrderTable(name); + + assertThatIllegalArgumentException() + .isThrownBy(() -> orderTableService.create(request)); + } + + @DisplayName("주문 테이블 생성 시, 고객의 수는 0명, 테이블의 사용유무는 사용안함이다") + @Test + void createOrderTableWithNullName() { + OrderTable request = createOrderTable("1번"); + + OrderTable orderTable = orderTableService.create(request); + + assertThat(orderTable.getNumberOfGuests()).isZero(); + assertThat(orderTable.isOccupied()).isFalse(); + } + //endregion + + //region [고객을 주문 테이블에 배정] + @DisplayName("주문 테이블에 고객이 배정되면 테이블의 사용유무가 사용 중으로 바뀐다") + @Test + void sit() { + OrderTable orderTable = orderTableService.create(createOrderTable("1번테이블")); + + OrderTable resultOrderTable = orderTableService.sit(orderTable.getId()); + + assertThat(resultOrderTable.isOccupied()).isTrue(); + } + //endregion + + private Product createProduct(UUID id, String name, BigDecimal price) { + Product product = new Product(); + product.setId(id); + product.setName(name); + product.setPrice(price); + return product; + } + + private MenuProduct createMenuProduct(UUID productId, Product product, int quantity) { + MenuProduct menuProduct = new MenuProduct(); + menuProduct.setProduct(product); + menuProduct.setProductId(productId); + menuProduct.setQuantity(quantity); + return menuProduct; + } + + private Menu createMenu(UUID id, MenuGroup menuGroup, UUID menuGroupId, String name, BigDecimal price, boolean displayed, List products) { + Menu menu = new Menu(); + menu.setId(id); + menu.setMenuGroup(menuGroup); + menu.setMenuGroupId(menuGroupId); + menu.setName(name); + menu.setPrice(price); + menu.setDisplayed(displayed); + menu.setMenuProducts(products); + return menu; + } + + private MenuGroup createMenuGroup(UUID id, String name) { + MenuGroup menuGroup = new MenuGroup(); + menuGroup.setId(id); + menuGroup.setName(name); + return menuGroup; + } + + private OrderTable createOrderTable(String name) { + return createOrderTable(null, name, 0); + } + + private OrderTable createOrderTable(UUID id, String name, int numberOfGuests) { + OrderTable orderTable = new OrderTable(); + orderTable.setId(id); + orderTable.setName(name); + orderTable.setNumberOfGuests(numberOfGuests); + return orderTable; + } + + private Order createEatInOrder(List orderLineItems, UUID orderTableId, LocalDateTime orderDateTime) { + return createOrder(OrderType.EAT_IN, orderLineItems, null, orderTableId, orderDateTime); + } + + private Order createOrder(OrderType orderType, List orderLineItems, String deliveryAddress, UUID orderTableId, LocalDateTime orderDateTime) { + Order order = new Order(); + order.setType(orderType); + order.setOrderLineItems(orderLineItems); + order.setDeliveryAddress(deliveryAddress); + order.setOrderTableId(orderTableId); + order.setOrderDateTime(orderDateTime); + return order; + } + + private OrderLineItem createOrderLineItem(UUID menuId, BigDecimal price, int quantity) { + OrderLineItem orderLineItem = new OrderLineItem(); + orderLineItem.setMenuId(menuId); + orderLineItem.setPrice(price); + orderLineItem.setQuantity(quantity); + return orderLineItem; + } + + private Order createUnnamedOrder(UUID orderTableId) { + Product unnamedProduct = productRepository.save(createProduct(UUID.randomUUID(), "unnamed", BigDecimal.ZERO)); + MenuGroup menuGroup = menuGroupRepository.save(createMenuGroup(UUID.randomUUID(), "unnamed")); + MenuProduct displayMenuProduct = createMenuProduct(unnamedProduct.getId(), unnamedProduct, 1); + Menu unknownMenu = menuRepository.save(createMenu(UUID.randomUUID(), menuGroup, menuGroup.getId(), "unnamed", BigDecimal.ZERO, true, List.of(displayMenuProduct))); + + OrderLineItem orderLineItem = createOrderLineItem(unknownMenu.getId(), BigDecimal.ZERO, 1); + return orderService.create(createEatInOrder(List.of(orderLineItem), orderTableId, LocalDateTime.now())); + } +} \ No newline at end of file From e96e419a42d57f15d45a3dd9b7187544da57e0e8 Mon Sep 17 00:00:00 2001 From: skdev0619 Date: Mon, 3 Feb 2025 16:02:41 +0900 Subject: [PATCH 12/29] =?UTF-8?q?=EC=A3=BC=EB=AC=B8=20=ED=85=8C=EC=9D=B4?= =?UTF-8?q?=EB=B8=94=20=EC=A0=95=EB=A6=AC,=20=EA=B3=A0=EA=B0=9D=EC=9D=98?= =?UTF-8?q?=20=EC=88=98=20=EB=B3=80=EA=B2=BD,=20=EC=A1=B0=ED=9A=8C=20?= =?UTF-8?q?=ED=85=8C=EC=8A=A4=ED=8A=B8=20=EC=BD=94=EB=93=9C=20=EC=B6=94?= =?UTF-8?q?=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 14 ++-- .../application/OrderTableServiceTest.java | 84 ++++++++++++++++++- 2 files changed, 89 insertions(+), 9 deletions(-) diff --git a/README.md b/README.md index 36eb892c4..fa4a0505c 100644 --- a/README.md +++ b/README.md @@ -97,13 +97,13 @@ ex) - [x] 주문 테이블에 고객이 배정된다 - [x] 테이블의 사용 유무를 사용 중으로 변경한다 -- [ ] 주문 테이블을 정리한다 - - [ ] 주문 상태가 완료가 아니면 정리할 수 없다 - - [ ] 고객의 수 0명, 테이블 사용유무 사용안함으로 변경한다 -- [ ] 테이블에 앉아있는 고객의 수를 변경할 수 있다 - - [ ] 고객의 수를 0 미만으로는 변경할 수 없다 - - [ ] 테이블의 사용유무가 사용안함이면 안된다 -- [ ] 모든 주문 테이블을 조회할 수 있다 +- [x] 주문 테이블을 정리한다 + - [x] 주문 상태가 완료가 아니면 정리할 수 없다 + - [x] 고객의 수 0명, 테이블 사용유무 사용안함으로 변경한다 +- [x] 테이블에 앉아있는 고객의 수를 변경할 수 있다 + - [x] 고객의 수를 0 미만으로는 변경할 수 없다 + - [x] 테이블의 사용유무가 사용안함이면 안된다 +- [x] 모든 주문 테이블을 조회할 수 있다 ### 주문(orders) 주문의 종류에 따른 주문 상태의 변화는 아래 도식도를 참고하도록 한다 diff --git a/src/test/java/kitchenpos/application/OrderTableServiceTest.java b/src/test/java/kitchenpos/application/OrderTableServiceTest.java index a54cf27be..8357612b3 100644 --- a/src/test/java/kitchenpos/application/OrderTableServiceTest.java +++ b/src/test/java/kitchenpos/application/OrderTableServiceTest.java @@ -4,6 +4,7 @@ import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.EnumSource; import org.junit.jupiter.params.provider.NullAndEmptySource; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.context.SpringBootTest; @@ -14,8 +15,8 @@ import java.util.List; import java.util.UUID; -import static org.assertj.core.api.Assertions.assertThat; -import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException; +import static org.assertj.core.api.Assertions.*; +import static org.assertj.core.api.Assertions.assertThatIllegalStateException; @Transactional @SpringBootTest @@ -81,6 +82,85 @@ void sit() { } //endregion + //region [주문테이블 정리] + @DisplayName("테이블의 주문 상태가 완료가 아니면 정리할 수 없다") + @EnumSource(value = OrderStatus.class, names = "COMPLETED", mode = EnumSource.Mode.EXCLUDE) + @ParameterizedTest + void validateOrderStatus(OrderStatus status) { + //given + OrderTable orderTable = orderTableService.create(createOrderTable("1번테이블")); + orderTableService.sit(orderTable.getId()); + orderTable.setNumberOfGuests(4); + orderTableService.changeNumberOfGuests(orderTable.getId(), orderTable); + + Order order = createUnnamedOrder(orderTable.getId()); + //when, then + order.setStatus(status); + assertThatIllegalStateException() + .isThrownBy(() -> orderTableService.clear(orderTable.getId())); + } + + @DisplayName("테이블 정리하면 손님의 수 0명, 테이블 사용유무 안함으로 변경된다") + @Test + void clear() { + //given + OrderTable orderTable = orderTableService.create(createOrderTable("1번테이블")); + orderTableService.sit(orderTable.getId()); + orderTable.setNumberOfGuests(4); + orderTableService.changeNumberOfGuests(orderTable.getId(), orderTable); + + Order order = createUnnamedOrder(orderTable.getId()); + //when + order.setStatus(OrderStatus.COMPLETED); + OrderTable clearOrder = orderTableService.clear(orderTable.getId()); + //then + assertThat(clearOrder.getNumberOfGuests()).isZero(); + assertThat(clearOrder.isOccupied()).isFalse(); + } + //endregion + + //region [고객의 수 변경] + @DisplayName("테이블의 고객 수를 0미만으로 변경할 수 없다") + @Test + void changeNumberOfGuestsByNegative() { + OrderTable orderTable = orderTableService.create(createOrderTable("1번테이블")); + + orderTable.setNumberOfGuests(-1); + + assertThatIllegalArgumentException() + .isThrownBy(() -> orderTableService.changeNumberOfGuests(orderTable.getId(), orderTable)); + } + + @DisplayName("테이블의 사용유무가 사용안함이면 손님의 수를 변경할 수 없다") + @Test + void changeNumberOfGuestsByUnUse() { + OrderTable orderTable = orderTableService.create(createOrderTable("1번테이블")); + + orderTable.setOccupied(false); + orderTable.setNumberOfGuests(10); + + assertThatIllegalStateException() + .isThrownBy(() -> orderTableService.changeNumberOfGuests(orderTable.getId(), orderTable)); + } + //endregion + + //region [모든 주문 테이블 조회] + @DisplayName("모든 테이블 조회가 가능하다") + @Test + void findAll() { + orderTableService.create(createOrderTable("1번테이블")); + orderTableService.create(createOrderTable("2번테이블")); + orderTableService.create(createOrderTable("3번테이블")); + + List orderTables = orderTableService.findAll(); + + assertThat(orderTables).hasSize(3); + assertThat(orderTables) + .extracting(OrderTable::getName) + .contains("1번테이블", "2번테이블", "3번테이블"); + } + //endregion + private Product createProduct(UUID id, String name, BigDecimal price) { Product product = new Product(); product.setId(id); From 4520add989c0d583512858d44fd2b1f3352e86aa Mon Sep 17 00:00:00 2001 From: skdev0619 Date: Mon, 3 Feb 2025 17:04:22 +0900 Subject: [PATCH 13/29] =?UTF-8?q?textFixture=20=EC=A0=81=EC=9A=A9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../application/MenuGroupServiceTest.java | 17 +- .../application/MenuServiceTest.java | 134 ++++++--------- .../application/OrderServiceTest.java | 159 ++++++------------ .../application/OrderTableServiceTest.java | 101 ++--------- .../application/ProductServiceTest.java | 70 +++----- .../application/fixture/MenuFixture.java | 31 ++++ .../application/fixture/MenuGroupFixture.java | 22 +++ .../fixture/MenuProductFixture.java | 27 +++ .../application/fixture/OrderFixture.java | 34 ++++ .../fixture/OrderTableFixture.java | 28 +++ .../application/fixture/ProductFixture.java | 24 +++ 11 files changed, 314 insertions(+), 333 deletions(-) create mode 100644 src/test/java/kitchenpos/application/fixture/MenuFixture.java create mode 100644 src/test/java/kitchenpos/application/fixture/MenuGroupFixture.java create mode 100644 src/test/java/kitchenpos/application/fixture/MenuProductFixture.java create mode 100644 src/test/java/kitchenpos/application/fixture/OrderFixture.java create mode 100644 src/test/java/kitchenpos/application/fixture/OrderTableFixture.java create mode 100644 src/test/java/kitchenpos/application/fixture/ProductFixture.java diff --git a/src/test/java/kitchenpos/application/MenuGroupServiceTest.java b/src/test/java/kitchenpos/application/MenuGroupServiceTest.java index bd9bcfb71..29a3de1a0 100644 --- a/src/test/java/kitchenpos/application/MenuGroupServiceTest.java +++ b/src/test/java/kitchenpos/application/MenuGroupServiceTest.java @@ -1,5 +1,6 @@ package kitchenpos.application; +import kitchenpos.application.fixture.MenuGroupFixture; import kitchenpos.domain.MenuGroup; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; @@ -24,7 +25,7 @@ class MenuGroupServiceTest { @DisplayName("메뉴그룹명을 입력하여 메뉴그룹을 등록한다") @Test void create() { - MenuGroup request = createMenuGroup("세트메뉴"); + MenuGroup request = MenuGroupFixture.createMenuGroup("세트메뉴"); MenuGroup menuGroup = menuGroupService.create(request); @@ -35,7 +36,7 @@ void create() { @NullAndEmptySource @ParameterizedTest void validateName(String name) { - MenuGroup request = createMenuGroup(name); + MenuGroup request = MenuGroupFixture.createMenuGroup(name); assertThatIllegalArgumentException() .isThrownBy(() -> menuGroupService.create(request)); @@ -44,9 +45,9 @@ void validateName(String name) { @DisplayName("모든 메뉴 그룹을 조회할 수 있다") @Test void findAll() { - menuGroupService.create(createMenuGroup("버거")); - menuGroupService.create(createMenuGroup("세트메뉴")); - menuGroupService.create(createMenuGroup("사이드")); + menuGroupService.create(MenuGroupFixture.createMenuGroup("버거")); + menuGroupService.create(MenuGroupFixture.createMenuGroup("세트메뉴")); + menuGroupService.create(MenuGroupFixture.createMenuGroup("사이드")); List menuGroups = menuGroupService.findAll(); @@ -55,10 +56,4 @@ void findAll() { .contains("버거", "세트메뉴", "사이드"); } - - private MenuGroup createMenuGroup(String name) { - MenuGroup menuGroup = new MenuGroup(); - menuGroup.setName(name); - return menuGroup; - } } diff --git a/src/test/java/kitchenpos/application/MenuServiceTest.java b/src/test/java/kitchenpos/application/MenuServiceTest.java index a25b13a43..96941cbe7 100644 --- a/src/test/java/kitchenpos/application/MenuServiceTest.java +++ b/src/test/java/kitchenpos/application/MenuServiceTest.java @@ -1,6 +1,13 @@ package kitchenpos.application; -import kitchenpos.domain.*; +import kitchenpos.application.fixture.MenuFixture; +import kitchenpos.application.fixture.MenuGroupFixture; +import kitchenpos.application.fixture.MenuProductFixture; +import kitchenpos.application.fixture.ProductFixture; +import kitchenpos.domain.Menu; +import kitchenpos.domain.MenuGroupRepository; +import kitchenpos.domain.MenuProduct; +import kitchenpos.domain.ProductRepository; import kitchenpos.infra.PurgomalumClient; import org.assertj.core.groups.Tuple; import org.junit.jupiter.api.BeforeEach; @@ -43,19 +50,19 @@ class MenuServiceTest { @BeforeEach void setUp() { - productRepository.save(createProduct(BURGER_PRODUCT_ID, "치킨버거", new BigDecimal(7000))); - productRepository.save(createProduct(SIDE_PRODUCT_ID, "감자튀김", new BigDecimal(2000))); - productRepository.save(createProduct(COKE_PRODUCT_ID, "콜라", new BigDecimal(2000))); + productRepository.save(ProductFixture.createProduct(BURGER_PRODUCT_ID, "치킨버거", new BigDecimal(7000))); + productRepository.save(ProductFixture.createProduct(SIDE_PRODUCT_ID, "감자튀김", new BigDecimal(2000))); + productRepository.save(ProductFixture.createProduct(COKE_PRODUCT_ID, "콜라", new BigDecimal(2000))); - menuGroupRepository.save(createMenuGroup(MENU_GROUP_ID, "세트메뉴")); + menuGroupRepository.save(MenuGroupFixture.createMenuGroup(MENU_GROUP_ID, "세트메뉴")); } //region [메뉴 등록] @DisplayName("단일 상품으로 메뉴를 등록할 수 있다") @Test void createMenuByProduct() { - MenuProduct chickenBurger = createMenuProduct(BURGER_PRODUCT_ID, 1); - Menu menu = createMenu(MENU_GROUP_ID, "치킨버거", new BigDecimal(7000), List.of(chickenBurger)); + MenuProduct chickenBurger = MenuProductFixture.createMenuProduct(BURGER_PRODUCT_ID, 1); + Menu menu = MenuFixture.createMenu(MENU_GROUP_ID, "치킨버거", new BigDecimal(7000), List.of(chickenBurger)); Menu resultMenu = menuService.create(menu); @@ -71,11 +78,11 @@ void createMenuByProduct() { @Test void createMenuByProducts() { //given - MenuProduct chickenBurger = createMenuProduct(BURGER_PRODUCT_ID, 1); - MenuProduct side = createMenuProduct(SIDE_PRODUCT_ID, 1); - MenuProduct coke = createMenuProduct(COKE_PRODUCT_ID, 1); + MenuProduct chickenBurger = MenuProductFixture.createMenuProduct(BURGER_PRODUCT_ID, 1); + MenuProduct side = MenuProductFixture.createMenuProduct(SIDE_PRODUCT_ID, 1); + MenuProduct coke = MenuProductFixture.createMenuProduct(COKE_PRODUCT_ID, 1); - Menu menu = createMenu( + Menu menu = MenuFixture.createMenu( MENU_GROUP_ID, "치킨버거세트", new BigDecimal(10000), @@ -94,9 +101,9 @@ void createMenuByProducts() { @DisplayName("각 메뉴를 구성하는 상품의 수량은 0이상이어야 한다") @Test void validateMenuProductQuantity() { - MenuProduct chickenBurger = createMenuProduct(BURGER_PRODUCT_ID, 1); - MenuProduct coke = createMenuProduct(COKE_PRODUCT_ID, -1); - Menu menu = createMenu( + MenuProduct chickenBurger = MenuProductFixture.createMenuProduct(BURGER_PRODUCT_ID, 1); + MenuProduct coke = MenuProductFixture.createMenuProduct(COKE_PRODUCT_ID, -1); + Menu menu = MenuFixture.createMenu( MENU_GROUP_ID, "치킨버거+음료", new BigDecimal(9000), @@ -111,8 +118,8 @@ void validateMenuProductQuantity() { @ParameterizedTest @NullSource void notNullName(String nullName) { - MenuProduct chickenBurger = createMenuProduct(BURGER_PRODUCT_ID, 1); - Menu menu = createMenu(MENU_GROUP_ID, nullName, new BigDecimal(7000), List.of(chickenBurger)); + MenuProduct chickenBurger = MenuProductFixture.createMenuProduct(BURGER_PRODUCT_ID, 1); + Menu menu = MenuFixture.createMenu(MENU_GROUP_ID, nullName, new BigDecimal(7000), List.of(chickenBurger)); assertThatIllegalArgumentException() .isThrownBy(() -> menuService.create(menu)); @@ -123,8 +130,8 @@ void notNullName(String nullName) { void validateMenuName() { Mockito.when(purgomalumClient.containsProfanity("bad word")).thenReturn(true); - MenuProduct chickenBurger = createMenuProduct(BURGER_PRODUCT_ID, 1); - Menu menu = createMenu(MENU_GROUP_ID, "bad word", new BigDecimal(7000), List.of(chickenBurger)); + MenuProduct chickenBurger = MenuProductFixture.createMenuProduct(BURGER_PRODUCT_ID, 1); + Menu menu = MenuFixture.createMenu(MENU_GROUP_ID, "bad word", new BigDecimal(7000), List.of(chickenBurger)); assertThatIllegalArgumentException() .isThrownBy(() -> menuService.create(menu)); @@ -134,8 +141,8 @@ void validateMenuName() { @ParameterizedTest @NullSource void notNullPrice(BigDecimal nullPrice) { - MenuProduct chickenBurger = createMenuProduct(BURGER_PRODUCT_ID, 1); - Menu menu = createMenu(MENU_GROUP_ID, "치킨버거", nullPrice, List.of(chickenBurger)); + MenuProduct chickenBurger = MenuProductFixture.createMenuProduct(BURGER_PRODUCT_ID, 1); + Menu menu = MenuFixture.createMenu(MENU_GROUP_ID, "치킨버거", nullPrice, List.of(chickenBurger)); assertThatIllegalArgumentException() .isThrownBy(() -> menuService.create(menu)); @@ -144,8 +151,8 @@ void notNullPrice(BigDecimal nullPrice) { @DisplayName("메뉴의 가격은 0원 이상이어야 한다") @Test void nonNegativeMenuPrice() { - MenuProduct chickenBurger = createMenuProduct(BURGER_PRODUCT_ID, 1); - Menu menu = createMenu(MENU_GROUP_ID, "치킨버거", new BigDecimal(-1), List.of(chickenBurger)); + MenuProduct chickenBurger = MenuProductFixture.createMenuProduct(BURGER_PRODUCT_ID, 1); + Menu menu = MenuFixture.createMenu(MENU_GROUP_ID, "치킨버거", new BigDecimal(-1), List.of(chickenBurger)); assertThatIllegalArgumentException() .isThrownBy(() -> menuService.create(menu)); @@ -155,11 +162,11 @@ void nonNegativeMenuPrice() { @Test void validateMenuPrice() { //given - MenuProduct chickenBurger = createMenuProduct(BURGER_PRODUCT_ID, 1); //7000원 - MenuProduct side = createMenuProduct(SIDE_PRODUCT_ID, 1); //2000원 - MenuProduct coke = createMenuProduct(COKE_PRODUCT_ID, 1); //2000원 + MenuProduct chickenBurger = MenuProductFixture.createMenuProduct(BURGER_PRODUCT_ID, 1); //7000원 + MenuProduct side = MenuProductFixture.createMenuProduct(SIDE_PRODUCT_ID, 1); //2000원 + MenuProduct coke = MenuProductFixture.createMenuProduct(COKE_PRODUCT_ID, 1); //2000원 - Menu menu = createMenu( + Menu menu = MenuFixture.createMenu( MENU_GROUP_ID, "치킨버거세트", new BigDecimal(11001), @@ -175,9 +182,9 @@ void validateMenuPrice() { @DisplayName("메뉴는 가격을 수정할 수 있다") @Test void changeMenuPrice() { - MenuProduct chickenBurger = createMenuProduct(BURGER_PRODUCT_ID, 1); + MenuProduct chickenBurger = MenuProductFixture.createMenuProduct(BURGER_PRODUCT_ID, 1); Menu menu = menuService.create( - createMenu( + MenuFixture.createMenu( MENU_GROUP_ID, "치킨버거", new BigDecimal(7000), @@ -192,9 +199,9 @@ void changeMenuPrice() { @DisplayName("메뉴의 가격이 0원 미만이면 변경할 수 없다") @Test void canNotChangeNegativePrice() { - MenuProduct chickenBurger = createMenuProduct(BURGER_PRODUCT_ID, 1); + MenuProduct chickenBurger = MenuProductFixture.createMenuProduct(BURGER_PRODUCT_ID, 1); Menu menu = menuService.create( - createMenu( + MenuFixture.createMenu( MENU_GROUP_ID, "치킨버거", new BigDecimal(7000), @@ -210,11 +217,11 @@ void canNotChangeNegativePrice() { @Test void validateMenuPriceOnModify() { //given - MenuProduct chickenBurger = createMenuProduct(BURGER_PRODUCT_ID, 1); //7000원 - MenuProduct side = createMenuProduct(SIDE_PRODUCT_ID, 1); //2000원 - MenuProduct coke = createMenuProduct(COKE_PRODUCT_ID, 1); //2000원 + MenuProduct chickenBurger = MenuProductFixture.createMenuProduct(BURGER_PRODUCT_ID, 1); //7000원 + MenuProduct side = MenuProductFixture.createMenuProduct(SIDE_PRODUCT_ID, 1); //2000원 + MenuProduct coke = MenuProductFixture.createMenuProduct(COKE_PRODUCT_ID, 1); //2000원 - Menu menu = createMenu( + Menu menu = MenuFixture.createMenu( MENU_GROUP_ID, "치킨버거세트", new BigDecimal(11000), @@ -232,9 +239,9 @@ void validateMenuPriceOnModify() { @DisplayName("메뉴를 메뉴판에 전시한다") @Test void display() { - MenuProduct chickenBurger = createMenuProduct(BURGER_PRODUCT_ID, 1); + MenuProduct chickenBurger = MenuProductFixture.createMenuProduct(BURGER_PRODUCT_ID, 1); Menu menu = menuService.create( - createMenu( + MenuFixture.createMenu( MENU_GROUP_ID, "치킨버거", new BigDecimal(7000), @@ -251,11 +258,11 @@ void display() { @Test void validateMenuPriceOnDisplay() { //given - MenuProduct chickenBurger = createMenuProduct(BURGER_PRODUCT_ID, 1); //7000원 - MenuProduct side = createMenuProduct(SIDE_PRODUCT_ID, 1); //2000원 - MenuProduct coke = createMenuProduct(COKE_PRODUCT_ID, 1); //2000원 + MenuProduct chickenBurger = MenuProductFixture.createMenuProduct(BURGER_PRODUCT_ID, 1); //7000원 + MenuProduct side = MenuProductFixture.createMenuProduct(SIDE_PRODUCT_ID, 1); //2000원 + MenuProduct coke = MenuProductFixture.createMenuProduct(COKE_PRODUCT_ID, 1); //2000원 - Menu menu = createMenu( + Menu menu = MenuFixture.createMenu( MENU_GROUP_ID, "치킨버거세트", new BigDecimal(11000), @@ -271,9 +278,9 @@ void validateMenuPriceOnDisplay() { @DisplayName("메뉴판의 전시여부를 X로 변경한다") @Test void hide() { - MenuProduct chickenBurger = createMenuProduct(BURGER_PRODUCT_ID, 1); + MenuProduct chickenBurger = MenuProductFixture.createMenuProduct(BURGER_PRODUCT_ID, 1); Menu menu = menuService.create( - createMenu( + MenuFixture.createMenu( MENU_GROUP_ID, "치킨버거", new BigDecimal(7000), @@ -291,13 +298,13 @@ void hide() { @DisplayName("모든 메뉴들을 조회할 수 있다") @Test void findAll() { - MenuProduct chickenBurger = createMenuProduct(BURGER_PRODUCT_ID, 1); //7000원 - MenuProduct side = createMenuProduct(SIDE_PRODUCT_ID, 1); //2000원 - MenuProduct coke = createMenuProduct(COKE_PRODUCT_ID, 1); //2000원 + MenuProduct chickenBurger = MenuProductFixture.createMenuProduct(BURGER_PRODUCT_ID, 1); //7000원 + MenuProduct side = MenuProductFixture.createMenuProduct(SIDE_PRODUCT_ID, 1); //2000원 + MenuProduct coke = MenuProductFixture.createMenuProduct(COKE_PRODUCT_ID, 1); //2000원 - menuService.create(createMenu(MENU_GROUP_ID, "치킨버거", new BigDecimal(7000), List.of(chickenBurger))); - menuService.create(createMenu(MENU_GROUP_ID, "감자튀김", new BigDecimal(2000), List.of(side))); - menuService.create(createMenu(MENU_GROUP_ID, "콜라", new BigDecimal(2000), List.of(coke))); + menuService.create(MenuFixture.createMenu(MENU_GROUP_ID, "치킨버거", new BigDecimal(7000), List.of(chickenBurger))); + menuService.create(MenuFixture.createMenu(MENU_GROUP_ID, "감자튀김", new BigDecimal(2000), List.of(side))); + menuService.create(MenuFixture.createMenu(MENU_GROUP_ID, "콜라", new BigDecimal(2000), List.of(coke))); List allMenus = menuService.findAll(); assertThat(allMenus.size()).isEqualTo(3); @@ -310,35 +317,4 @@ void findAll() { ); } //endregion - - private Product createProduct(UUID id, String name, BigDecimal price) { - Product product = new Product(); - product.setId(id); - product.setName(name); - product.setPrice(price); - return product; - } - - private Menu createMenu(UUID menuGroupId, String name, BigDecimal price, List products) { - Menu menu = new Menu(); - menu.setMenuGroupId(menuGroupId); - menu.setName(name); - menu.setPrice(price); - menu.setMenuProducts(products); - return menu; - } - - private MenuProduct createMenuProduct(UUID productId, int quantity) { - MenuProduct menuProduct = new MenuProduct(); - menuProduct.setProductId(productId); - menuProduct.setQuantity(quantity); - return menuProduct; - } - - private MenuGroup createMenuGroup(UUID id, String name) { - MenuGroup menuGroup = new MenuGroup(); - menuGroup.setId(id); - menuGroup.setName(name); - return menuGroup; - } } diff --git a/src/test/java/kitchenpos/application/OrderServiceTest.java b/src/test/java/kitchenpos/application/OrderServiceTest.java index 647576584..52f66fb7b 100644 --- a/src/test/java/kitchenpos/application/OrderServiceTest.java +++ b/src/test/java/kitchenpos/application/OrderServiceTest.java @@ -1,5 +1,6 @@ package kitchenpos.application; +import kitchenpos.application.fixture.*; import kitchenpos.domain.*; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; @@ -49,17 +50,17 @@ class OrderServiceTest { @BeforeEach void setUp() { - Product product1 = productRepository.save(createProduct(UUID.randomUUID(), "전시", new BigDecimal(25000))); - Product product2 = productRepository.save(createProduct(UUID.randomUUID(), "비전시", new BigDecimal(7000))); + Product product1 = productRepository.save(ProductFixture.createProduct(UUID.randomUUID(), "전시", new BigDecimal(25000))); + Product product2 = productRepository.save(ProductFixture.createProduct(UUID.randomUUID(), "비전시", new BigDecimal(7000))); UUID menuGroupId = UUID.randomUUID(); - MenuGroup menuGroup = menuGroupRepository.save(createMenuGroup(menuGroupId, "단품")); + MenuGroup menuGroup = menuGroupRepository.save(MenuGroupFixture.createMenuGroup(menuGroupId, "단품")); - MenuProduct displayMenuProduct = createMenuProduct(product1.getId(), product1, 1); - menuRepository.save(createMenu(DISPLAY_MENU_ID, menuGroup, menuGroup.getId(), "전시메뉴", new BigDecimal(25000), true, List.of(displayMenuProduct))); + MenuProduct displayMenuProduct = MenuProductFixture.createMenuProduct(product1, 1); + menuRepository.save(MenuFixture.createMenu(DISPLAY_MENU_ID, menuGroup, menuGroup.getId(), "전시메뉴", new BigDecimal(25000), true, List.of(displayMenuProduct))); - MenuProduct unDisplayMenuProduct = createMenuProduct(product2.getId(), product2, 1); - menuRepository.save(createMenu(UNDISPLAYED_MENU_ID, menuGroup, menuGroup.getId(), "비전시메뉴", new BigDecimal(7000), false, List.of(unDisplayMenuProduct))); + MenuProduct unDisplayMenuProduct = MenuProductFixture.createMenuProduct(product2, 1); + menuRepository.save(MenuFixture.createMenu(UNDISPLAYED_MENU_ID, menuGroup, menuGroup.getId(), "비전시메뉴", new BigDecimal(7000), false, List.of(unDisplayMenuProduct))); } //region [주문 생성] @@ -67,8 +68,8 @@ void setUp() { @NullSource @ParameterizedTest void orderType(OrderType status) { - OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal("25000"), 1); - Order nullOrderTypeRequest = createOrder(status, List.of(orderLineItem), "", null, null); + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal("25000"), 1); + Order nullOrderTypeRequest = OrderFixture.createOrder(status, List.of(orderLineItem), "", null, null); assertThatIllegalArgumentException() .isThrownBy(() -> orderService.create(nullOrderTypeRequest)); @@ -77,7 +78,7 @@ void orderType(OrderType status) { @DisplayName("포장 주문을 생성한다. 주문이 정상적으로 생성되면 상태는 대기 중으로 변경된다") @Test void createTakeOutOrder() { - OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal("25000"), 1); + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal("25000"), 1); Order orderRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); Order orderResult = orderService.create(orderRequest); @@ -92,7 +93,7 @@ void createTakeOutOrder() { @DisplayName("배달 주문을 생성한다. 주문이 정상적으로 생성되면 상태는 대기 중으로 변경된다") @Test void createDeliveryOrder() { - OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal("25000"), 1); + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal("25000"), 1); Order orderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XX호", LocalDateTime.now()); Order orderResult = orderService.create(orderRequest); @@ -108,10 +109,10 @@ void createDeliveryOrder() { @DisplayName("매장 내 식사 주문을 생성한다. 주문이 정상적으로 생성되면 상태는 대기 중으로 변경된다") @Test void createEatInOrder() { - OrderTable request = createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4); + OrderTable request = OrderTableFixture.createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4); OrderTable orderTable = orderTableRepository.save(request); - OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal("25000"), 1); + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal("25000"), 1); Order orderRequest = createEatInOrder(List.of(orderLineItem), orderTable.getId(), LocalDateTime.now()); Order orderResult = orderService.create(orderRequest); @@ -129,7 +130,7 @@ void createEatInOrder() { void notNullOrderLineItems(List orderLineItems) { Order takeOutRequest = createTakeOutOrder(orderLineItems, LocalDateTime.now()); Order deliveryOrderRequest = createDeliveryOrder(orderLineItems, "경기도 고양시..XX동 XX호", LocalDateTime.now()); - OrderTable orderTable = orderTableRepository.save(createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); + OrderTable orderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); Order eatInOrderRequest = createEatInOrder(orderLineItems, orderTable.getId(), LocalDateTime.now()); assertThatIllegalArgumentException() @@ -148,7 +149,7 @@ private static Stream nullOrEmptyList() { @Test void validateQuantity() { int negativeQuantity = -1; - OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal("25000"), negativeQuantity); + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal("25000"), negativeQuantity); Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XX호", LocalDateTime.now()); @@ -161,10 +162,10 @@ void validateQuantity() { @DisplayName("메뉴판에 전시하지 않은 메뉴는 주문할 수 없다") @Test void validateMenuOrder() { - OrderLineItem undisplayMenuOrderItem = createOrderLineItem(UNDISPLAYED_MENU_ID, new BigDecimal("25000"), 1); + OrderLineItem undisplayMenuOrderItem = OrderFixture.createOrderLineItem(UNDISPLAYED_MENU_ID, new BigDecimal("25000"), 1); Order takeOutRequest = createTakeOutOrder(List.of(undisplayMenuOrderItem), LocalDateTime.now()); Order deliveryOrderRequest = createDeliveryOrder(List.of(undisplayMenuOrderItem), "경기도 고양시..XX동 XX호", LocalDateTime.now()); - OrderTable orderTable = orderTableRepository.save(createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); + OrderTable orderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); Order eatInOrderRequest = createEatInOrder(List.of(undisplayMenuOrderItem), orderTable.getId(), LocalDateTime.now()); assertThatIllegalStateException() @@ -180,10 +181,10 @@ void validateMenuOrder() { void validateOrderPrice() { BigDecimal menuPrice = menuRepository.findById(DISPLAY_MENU_ID).get().getPrice(); - OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, menuPrice.add(BigDecimal.ONE), 1); + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, menuPrice.add(BigDecimal.ONE), 1); Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XX호", LocalDateTime.now()); - OrderTable orderTable = orderTableRepository.save(createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); + OrderTable orderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); Order eatInOrderRequest = createEatInOrder(List.of(orderLineItem), orderTable.getId(), LocalDateTime.now()); assertThatIllegalArgumentException() @@ -198,7 +199,7 @@ void validateOrderPrice() { @ParameterizedTest @NullAndEmptySource void notNullOrNotEmpty(String deliveryAddress) { - OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), deliveryAddress, LocalDateTime.now()); assertThatIllegalArgumentException() @@ -209,7 +210,7 @@ void notNullOrNotEmpty(String deliveryAddress) { @Test void validateOrderTable() { UUID unknownTableId = UUID.randomUUID(); - OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); Order eatInOrderRequest = createEatInOrder(List.of(orderLineItem), unknownTableId, LocalDateTime.now()); assertThatThrownBy(() -> orderService.create(eatInOrderRequest)) @@ -220,8 +221,8 @@ void validateOrderTable() { @Test void validateOrderTableStatus() { boolean tableOccupied = false; - OrderTable orderTable = orderTableRepository.save(createOrderTable(ORDER_TABLE_ID, "1번테이블", tableOccupied, 0)); - OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + OrderTable orderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(ORDER_TABLE_ID, "1번테이블", tableOccupied, 0)); + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); Order eatInOrderRequest = createEatInOrder(List.of(orderLineItem), orderTable.getId(), LocalDateTime.now()); assertThatIllegalStateException() @@ -233,7 +234,7 @@ void validateOrderTableStatus() { @DisplayName("대기 중인 주문을 수락한다") @Test void acceptOrderStatus() { - OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); Order takeOutOrder = orderService.create(takeOutRequest); @@ -246,7 +247,7 @@ void acceptOrderStatus() { @EnumSource(value = OrderStatus.class, names = "WAITING", mode = EnumSource.Mode.EXCLUDE) @ParameterizedTest void validateAcceptStatus(OrderStatus orderStatus) { - OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); Order takeOutOrder = orderService.create(takeOutRequest); @@ -260,7 +261,7 @@ void validateAcceptStatus(OrderStatus orderStatus) { @DisplayName("주문 상태를 음식 제공됨(SERVED)로 변경한다") @Test void served() { - OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); Order takeOutOrder = orderService.create(takeOutRequest); Order acceptOrder = orderService.accept(takeOutOrder.getId()); @@ -274,7 +275,7 @@ void served() { @EnumSource(value = OrderStatus.class, names = "ACCEPTED", mode = EnumSource.Mode.EXCLUDE) @ParameterizedTest void validateServedStatus(OrderStatus orderStatus) { - OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); Order takeOutOrder = orderService.create(takeOutRequest); @@ -288,7 +289,7 @@ void validateServedStatus(OrderStatus orderStatus) { @DisplayName("배달 주문의 경우 음식이 제공되면 주문 상태를 배달 중(DELIVERING)으로 변경한다") @Test void startDelivery() { - OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", LocalDateTime.now()); Order order = orderService.create(deliveryOrderRequest); @@ -302,7 +303,7 @@ void startDelivery() { @EnumSource(value = OrderStatus.class, names = "SERVED", mode = EnumSource.Mode.EXCLUDE) @ParameterizedTest void validateDeliveryStartStatus(OrderStatus orderStatus) { - OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", LocalDateTime.now()); Order order = orderService.create(deliveryOrderRequest); @@ -316,7 +317,7 @@ void validateDeliveryStartStatus(OrderStatus orderStatus) { @DisplayName("배달 완료한 주문 상태를 배달완료(DELIVERED)로 변경한다") @Test void endDelivery() { - OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", LocalDateTime.now()); Order order = orderService.create(deliveryOrderRequest); @@ -330,7 +331,7 @@ void endDelivery() { @ParameterizedTest @EnumSource(value = OrderStatus.class, names = "DELIVERING", mode = EnumSource.Mode.EXCLUDE) void validateDeliveryEndStatus(OrderStatus orderStatus) { - OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", LocalDateTime.now()); Order order = orderService.create(deliveryOrderRequest); @@ -345,7 +346,7 @@ void validateDeliveryEndStatus(OrderStatus orderStatus) { @Test void complete() { //given - OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", LocalDateTime.now()); Order order = createDeliveredOrder(deliveryOrderRequest); //when @@ -358,7 +359,7 @@ void complete() { @EnumSource(value = OrderStatus.class, names = "DELIVERED", mode = EnumSource.Mode.EXCLUDE) @ParameterizedTest void completeOrderByDelivery(OrderStatus orderStatus) { - OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", LocalDateTime.now()); Order order = orderService.create(deliveryOrderRequest); @@ -371,7 +372,7 @@ void completeOrderByDelivery(OrderStatus orderStatus) { @Test void completeByTakeOut() { //given - OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); Order servedOrder = createServedOrder(takeOutRequest); //when @@ -383,8 +384,8 @@ void completeByTakeOut() { @DisplayName("매장 내 취식 주문 상태를 주문 완료로 변경한다") @Test void completeByEatIn() { - OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - OrderTable orderTable = orderTableRepository.save(createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + OrderTable orderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); Order eatInRequest = createEatInOrder(List.of(orderLineItem), orderTable.getId(), LocalDateTime.now()); Order servedOrder = createServedOrder(eatInRequest); //when @@ -398,10 +399,10 @@ void completeByEatIn() { @ParameterizedTest void completeOrderByEatInOrTakeOut(OrderStatus orderStatus) { //given - OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); - OrderTable orderTable = orderTableRepository.save(createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); + OrderTable orderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); Order eatInRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); Order takeoutOrder = orderService.create(takeOutRequest); @@ -420,8 +421,8 @@ void completeOrderByEatInOrTakeOut(OrderStatus orderStatus) { @Test void completeOrderByEatIn() { //given - OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - OrderTable orderTable = orderTableRepository.save(createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + OrderTable orderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); Order eatInRequest = createEatInOrder(List.of(orderLineItem), orderTable.getId(), LocalDateTime.now()); //주문 상태가 SERVED인 주문1,2 생성 Order servedOrder1 = createServedOrder(eatInRequest); @@ -440,8 +441,8 @@ void completeOrderByEatIn() { @Test void clearOrderTable() { //given - OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - OrderTable orderTable = orderTableRepository.save(createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + OrderTable orderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); Order eatInRequest = createEatInOrder(List.of(orderLineItem), orderTable.getId(), LocalDateTime.now()); Order servedOrder1 = createServedOrder(eatInRequest); @@ -465,10 +466,10 @@ void clearOrderTable() { //region [주문 조회] @DisplayName("모든 주문들을 조회할 수 있다") @Test - void findAll(){ + void findAll() { //given - OrderLineItem orderLineItem = createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - OrderTable orderTable = orderTableRepository.save(createOrderTable(UUID.randomUUID(), "1번테이블", true, 4)); + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + OrderTable orderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(UUID.randomUUID(), "1번테이블", true, 4)); Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); Order deliveryRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XX호", LocalDateTime.now()); @@ -484,79 +485,17 @@ void findAll(){ } //endregion - private Product createProduct(UUID id, String name, BigDecimal price) { - Product product = new Product(); - product.setId(id); - product.setName(name); - product.setPrice(price); - return product; - } - - private MenuProduct createMenuProduct(UUID productId, Product product, int quantity) { - MenuProduct menuProduct = new MenuProduct(); - menuProduct.setProduct(product); - menuProduct.setProductId(productId); - menuProduct.setQuantity(quantity); - return menuProduct; - } - - private Menu createMenu(UUID id, MenuGroup menuGroup, UUID menuGroupId, String name, BigDecimal price, boolean displayed, List products) { - Menu menu = new Menu(); - menu.setId(id); - menu.setMenuGroup(menuGroup); - menu.setMenuGroupId(menuGroupId); - menu.setName(name); - menu.setPrice(price); - menu.setDisplayed(displayed); - menu.setMenuProducts(products); - return menu; - } - - private MenuGroup createMenuGroup(UUID id, String name) { - MenuGroup menuGroup = new MenuGroup(); - menuGroup.setId(id); - menuGroup.setName(name); - return menuGroup; - } - - private OrderTable createOrderTable(UUID id, String name, boolean occupied, int numberOfGuests) { - OrderTable orderTable = new OrderTable(); - orderTable.setId(id); - orderTable.setName(name); - orderTable.setOccupied(occupied); - orderTable.setNumberOfGuests(numberOfGuests); - return orderTable; - } private Order createTakeOutOrder(List orderLineItems, LocalDateTime orderDateTime) { - return createOrder(OrderType.TAKEOUT, orderLineItems, null, null, orderDateTime); + return OrderFixture.createOrder(OrderType.TAKEOUT, orderLineItems, null, null, orderDateTime); } private Order createDeliveryOrder(List orderLineItems, String deliveryAddress, LocalDateTime orderDateTime) { - return createOrder(OrderType.DELIVERY, orderLineItems, deliveryAddress, null, orderDateTime); + return OrderFixture.createOrder(OrderType.DELIVERY, orderLineItems, deliveryAddress, null, orderDateTime); } private Order createEatInOrder(List orderLineItems, UUID orderTableId, LocalDateTime orderDateTime) { - return createOrder(OrderType.EAT_IN, orderLineItems, null, orderTableId, orderDateTime); - } - - - private Order createOrder(OrderType orderType, List orderLineItems, String deliveryAddress, UUID orderTableId, LocalDateTime orderDateTime) { - Order order = new Order(); - order.setType(orderType); - order.setOrderLineItems(orderLineItems); - order.setDeliveryAddress(deliveryAddress); - order.setOrderTableId(orderTableId); - order.setOrderDateTime(orderDateTime); - return order; - } - - private OrderLineItem createOrderLineItem(UUID menuId, BigDecimal price, int quantity) { - OrderLineItem orderLineItem = new OrderLineItem(); - orderLineItem.setMenuId(menuId); - orderLineItem.setPrice(price); - orderLineItem.setQuantity(quantity); - return orderLineItem; + return OrderFixture.createOrder(OrderType.EAT_IN, orderLineItems, null, orderTableId, orderDateTime); } private Order createDeliveredOrder(Order deliveryOrder) { diff --git a/src/test/java/kitchenpos/application/OrderTableServiceTest.java b/src/test/java/kitchenpos/application/OrderTableServiceTest.java index 8357612b3..3ec9d16d7 100644 --- a/src/test/java/kitchenpos/application/OrderTableServiceTest.java +++ b/src/test/java/kitchenpos/application/OrderTableServiceTest.java @@ -1,5 +1,6 @@ package kitchenpos.application; +import kitchenpos.application.fixture.*; import kitchenpos.domain.*; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Test; @@ -16,7 +17,6 @@ import java.util.UUID; import static org.assertj.core.api.Assertions.*; -import static org.assertj.core.api.Assertions.assertThatIllegalStateException; @Transactional @SpringBootTest @@ -41,7 +41,7 @@ class OrderTableServiceTest { @DisplayName("주문 테이블의 이름을 지정하여 생성할 수 있다") @Test void createOrderTable() { - OrderTable request = createOrderTable("1번테이블"); + OrderTable request = OrderTableFixture.createOrderTable("1번테이블"); OrderTable orderTable = orderTableService.create(request); @@ -52,7 +52,7 @@ void createOrderTable() { @NullAndEmptySource @ParameterizedTest void notNullTableName(String name) { - OrderTable request = createOrderTable(name); + OrderTable request = OrderTableFixture.createOrderTable(name); assertThatIllegalArgumentException() .isThrownBy(() -> orderTableService.create(request)); @@ -61,7 +61,7 @@ void notNullTableName(String name) { @DisplayName("주문 테이블 생성 시, 고객의 수는 0명, 테이블의 사용유무는 사용안함이다") @Test void createOrderTableWithNullName() { - OrderTable request = createOrderTable("1번"); + OrderTable request = OrderTableFixture.createOrderTable("1번"); OrderTable orderTable = orderTableService.create(request); @@ -74,7 +74,7 @@ void createOrderTableWithNullName() { @DisplayName("주문 테이블에 고객이 배정되면 테이블의 사용유무가 사용 중으로 바뀐다") @Test void sit() { - OrderTable orderTable = orderTableService.create(createOrderTable("1번테이블")); + OrderTable orderTable = orderTableService.create(OrderTableFixture.createOrderTable("1번테이블")); OrderTable resultOrderTable = orderTableService.sit(orderTable.getId()); @@ -88,7 +88,7 @@ void sit() { @ParameterizedTest void validateOrderStatus(OrderStatus status) { //given - OrderTable orderTable = orderTableService.create(createOrderTable("1번테이블")); + OrderTable orderTable = orderTableService.create(OrderTableFixture.createOrderTable("1번테이블")); orderTableService.sit(orderTable.getId()); orderTable.setNumberOfGuests(4); orderTableService.changeNumberOfGuests(orderTable.getId(), orderTable); @@ -104,7 +104,7 @@ void validateOrderStatus(OrderStatus status) { @Test void clear() { //given - OrderTable orderTable = orderTableService.create(createOrderTable("1번테이블")); + OrderTable orderTable = orderTableService.create(OrderTableFixture.createOrderTable("1번테이블")); orderTableService.sit(orderTable.getId()); orderTable.setNumberOfGuests(4); orderTableService.changeNumberOfGuests(orderTable.getId(), orderTable); @@ -123,7 +123,7 @@ void clear() { @DisplayName("테이블의 고객 수를 0미만으로 변경할 수 없다") @Test void changeNumberOfGuestsByNegative() { - OrderTable orderTable = orderTableService.create(createOrderTable("1번테이블")); + OrderTable orderTable = orderTableService.create(OrderTableFixture.createOrderTable("1번테이블")); orderTable.setNumberOfGuests(-1); @@ -134,7 +134,7 @@ void changeNumberOfGuestsByNegative() { @DisplayName("테이블의 사용유무가 사용안함이면 손님의 수를 변경할 수 없다") @Test void changeNumberOfGuestsByUnUse() { - OrderTable orderTable = orderTableService.create(createOrderTable("1번테이블")); + OrderTable orderTable = orderTableService.create(OrderTableFixture.createOrderTable("1번테이블")); orderTable.setOccupied(false); orderTable.setNumberOfGuests(10); @@ -148,9 +148,9 @@ void changeNumberOfGuestsByUnUse() { @DisplayName("모든 테이블 조회가 가능하다") @Test void findAll() { - orderTableService.create(createOrderTable("1번테이블")); - orderTableService.create(createOrderTable("2번테이블")); - orderTableService.create(createOrderTable("3번테이블")); + orderTableService.create(OrderTableFixture.createOrderTable("1번테이블")); + orderTableService.create(OrderTableFixture.createOrderTable("2번테이블")); + orderTableService.create(OrderTableFixture.createOrderTable("3번테이블")); List orderTables = orderTableService.findAll(); @@ -161,82 +161,17 @@ void findAll() { } //endregion - private Product createProduct(UUID id, String name, BigDecimal price) { - Product product = new Product(); - product.setId(id); - product.setName(name); - product.setPrice(price); - return product; - } - - private MenuProduct createMenuProduct(UUID productId, Product product, int quantity) { - MenuProduct menuProduct = new MenuProduct(); - menuProduct.setProduct(product); - menuProduct.setProductId(productId); - menuProduct.setQuantity(quantity); - return menuProduct; - } - - private Menu createMenu(UUID id, MenuGroup menuGroup, UUID menuGroupId, String name, BigDecimal price, boolean displayed, List products) { - Menu menu = new Menu(); - menu.setId(id); - menu.setMenuGroup(menuGroup); - menu.setMenuGroupId(menuGroupId); - menu.setName(name); - menu.setPrice(price); - menu.setDisplayed(displayed); - menu.setMenuProducts(products); - return menu; - } - - private MenuGroup createMenuGroup(UUID id, String name) { - MenuGroup menuGroup = new MenuGroup(); - menuGroup.setId(id); - menuGroup.setName(name); - return menuGroup; - } - - private OrderTable createOrderTable(String name) { - return createOrderTable(null, name, 0); - } - - private OrderTable createOrderTable(UUID id, String name, int numberOfGuests) { - OrderTable orderTable = new OrderTable(); - orderTable.setId(id); - orderTable.setName(name); - orderTable.setNumberOfGuests(numberOfGuests); - return orderTable; - } - private Order createEatInOrder(List orderLineItems, UUID orderTableId, LocalDateTime orderDateTime) { - return createOrder(OrderType.EAT_IN, orderLineItems, null, orderTableId, orderDateTime); - } - - private Order createOrder(OrderType orderType, List orderLineItems, String deliveryAddress, UUID orderTableId, LocalDateTime orderDateTime) { - Order order = new Order(); - order.setType(orderType); - order.setOrderLineItems(orderLineItems); - order.setDeliveryAddress(deliveryAddress); - order.setOrderTableId(orderTableId); - order.setOrderDateTime(orderDateTime); - return order; - } - - private OrderLineItem createOrderLineItem(UUID menuId, BigDecimal price, int quantity) { - OrderLineItem orderLineItem = new OrderLineItem(); - orderLineItem.setMenuId(menuId); - orderLineItem.setPrice(price); - orderLineItem.setQuantity(quantity); - return orderLineItem; + return OrderFixture.createOrder(OrderType.EAT_IN, orderLineItems, null, orderTableId, orderDateTime); } private Order createUnnamedOrder(UUID orderTableId) { - Product unnamedProduct = productRepository.save(createProduct(UUID.randomUUID(), "unnamed", BigDecimal.ZERO)); - MenuGroup menuGroup = menuGroupRepository.save(createMenuGroup(UUID.randomUUID(), "unnamed")); - MenuProduct displayMenuProduct = createMenuProduct(unnamedProduct.getId(), unnamedProduct, 1); - Menu unknownMenu = menuRepository.save(createMenu(UUID.randomUUID(), menuGroup, menuGroup.getId(), "unnamed", BigDecimal.ZERO, true, List.of(displayMenuProduct))); + Product unnamedProduct = productRepository.save(ProductFixture.createProduct(UUID.randomUUID(), "unnamed", BigDecimal.ZERO)); + MenuGroup menuGroup = menuGroupRepository.save(MenuGroupFixture.createMenuGroup(UUID.randomUUID(), "unnamed")); + MenuProduct displayMenuProduct = MenuProductFixture.createMenuProduct(unnamedProduct, 1); + Menu unknownMenu = menuRepository.save(MenuFixture.createMenu(UUID.randomUUID(), menuGroup, menuGroup.getId(), "unnamed", BigDecimal.ZERO, true, List.of(displayMenuProduct))); - OrderLineItem orderLineItem = createOrderLineItem(unknownMenu.getId(), BigDecimal.ZERO, 1); + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(unknownMenu.getId(), BigDecimal.ZERO, 1); return orderService.create(createEatInOrder(List.of(orderLineItem), orderTableId, LocalDateTime.now())); } } \ No newline at end of file diff --git a/src/test/java/kitchenpos/application/ProductServiceTest.java b/src/test/java/kitchenpos/application/ProductServiceTest.java index fff1ad18b..49f25bb8b 100644 --- a/src/test/java/kitchenpos/application/ProductServiceTest.java +++ b/src/test/java/kitchenpos/application/ProductServiceTest.java @@ -1,5 +1,9 @@ package kitchenpos.application; +import kitchenpos.application.fixture.MenuFixture; +import kitchenpos.application.fixture.MenuGroupFixture; +import kitchenpos.application.fixture.MenuProductFixture; +import kitchenpos.application.fixture.ProductFixture; import kitchenpos.domain.Menu; import kitchenpos.domain.MenuGroup; import kitchenpos.domain.MenuProduct; @@ -41,7 +45,7 @@ class ProductServiceTest { @DisplayName("상품명과 가격을 입력하여 상품을 생성한다") @Test void createProduct() { - Product request = createProduct("치킨버거", new BigDecimal(7000)); + Product request = ProductFixture.createProduct("치킨버거", new BigDecimal(7000)); Product product = productService.create(request); @@ -53,7 +57,7 @@ void createProduct() { @DisplayName("상품명은 반드시 입력되어야 한다") @Test void notNullProductName() { - Product request = createProduct(null, new BigDecimal(7000)); + Product request = ProductFixture.createProduct(null, new BigDecimal(7000)); assertThatIllegalArgumentException() .isThrownBy(() -> productService.create(request)); @@ -62,7 +66,7 @@ void notNullProductName() { @DisplayName("가격은 반드시 입력되어야 한다") @Test void notNullProductPrice() { - Product request = createProduct("치킨버거", null); + Product request = ProductFixture.createProduct("치킨버거", null); assertThatIllegalArgumentException() .isThrownBy(() -> productService.create(request)); @@ -72,7 +76,7 @@ void notNullProductPrice() { @Test void validateProductName() { Mockito.when(purgomalumClient.containsProfanity("bad word")).thenReturn(true); - Product request = createProduct("bad word", new BigDecimal(7000)); + Product request = ProductFixture.createProduct("bad word", new BigDecimal(7000)); assertThatIllegalArgumentException() .isThrownBy(() -> productService.create(request)); @@ -81,7 +85,7 @@ void validateProductName() { @DisplayName("상품의 가격은 0원 이상이어야 한다") @Test void validatePriceOnCreate() { - Product request = createProduct("치킨버거", new BigDecimal(-1)); + Product request = ProductFixture.createProduct("치킨버거", new BigDecimal(-1)); assertThatIllegalArgumentException() .isThrownBy(() -> productService.create(request)); @@ -92,7 +96,7 @@ void validatePriceOnCreate() { @DisplayName("상품의 가격을 수정할 수 있다") @Test void modifyPrice() { - Product product = productService.create(createProduct(UUID.randomUUID(), "치킨버거", new BigDecimal(7000))); + Product product = productService.create(ProductFixture.createProduct(UUID.randomUUID(), "치킨버거", new BigDecimal(7000))); product.setPrice(new BigDecimal(8000)); Product modifiedProduct = productService.changePrice(product.getId(), product); @@ -103,26 +107,26 @@ void modifyPrice() { @DisplayName("상품의 가격은 0원 이상인 경우만 수정 가능하다") @Test void validatePriceOnModify() { - Product product = productService.create(createProduct(UUID.randomUUID(), "치킨버거", new BigDecimal(7000))); + Product product = productService.create(ProductFixture.createProduct(UUID.randomUUID(), "치킨버거", new BigDecimal(7000))); assertThatIllegalArgumentException() - .isThrownBy(() -> productService.changePrice(product.getId(), createProduct("치킨버거", new BigDecimal(-1)))); + .isThrownBy(() -> productService.changePrice(product.getId(), ProductFixture.createProduct("치킨버거", new BigDecimal(-1)))); } @DisplayName("메뉴의 가격이 메뉴에 속한 상품들의 가격 총 합보다 클 경우, 유효하지 않은 메뉴이므로 메뉴판에 전시할 수 없다") @Test void validatePriceBySetMenu() { //given - Product chicken = productService.create(createProduct("후라이드치킨", new BigDecimal(25000))); - Product coke = productService.create(createProduct("콜라", new BigDecimal(2500))); + Product chicken = productService.create(ProductFixture.createProduct("후라이드치킨", new BigDecimal(25000))); + Product coke = productService.create(ProductFixture.createProduct("콜라", new BigDecimal(2500))); - MenuGroup menuGroup = menuGroupService.create(createMenuGroup("세트메뉴")); + MenuGroup menuGroup = menuGroupService.create(MenuGroupFixture.createMenuGroup("세트메뉴")); - MenuProduct chickenMenuProduct = createMenuProduct(chicken, 1); - MenuProduct cokeMenuProduct = createMenuProduct(coke, 1); + MenuProduct chickenMenuProduct = MenuProductFixture.createMenuProduct(chicken, 1); + MenuProduct cokeMenuProduct = MenuProductFixture.createMenuProduct(coke, 1); BigDecimal productSum = chicken.getPrice().add(coke.getPrice()); - Menu menu = createMenu( + Menu menu = MenuFixture.createMenu( menuGroup.getId(), "후라이드치킨세트", productSum, @@ -142,8 +146,8 @@ void validatePriceBySetMenu() { @DisplayName("모든 메뉴를 조회할 수 있다") @Test void findAll() { - productService.create(createProduct("치킨버거", new BigDecimal(7000))); - productService.create(createProduct("새우버거", new BigDecimal(8000))); + productService.create(ProductFixture.createProduct("치킨버거", new BigDecimal(7000))); + productService.create(ProductFixture.createProduct("새우버거", new BigDecimal(8000))); List products = productService.findAll(); @@ -157,38 +161,4 @@ void findAll() { } //endregion - private Product createProduct(String name, BigDecimal price) { - return createProduct(null, name, price); - } - - private Product createProduct(UUID id, String name, BigDecimal price) { - Product product = new Product(); - product.setId(id); - product.setName(name); - product.setPrice(price); - return product; - } - - private MenuProduct createMenuProduct(Product product, int quantity) { - MenuProduct menuProduct = new MenuProduct(); - menuProduct.setProduct(product); - menuProduct.setProductId(product.getId()); - menuProduct.setQuantity(quantity); - return menuProduct; - } - - private MenuGroup createMenuGroup(String name) { - MenuGroup menuGroup = new MenuGroup(); - menuGroup.setName(name); - return menuGroup; - } - - private Menu createMenu(UUID menuGroupId, String name, BigDecimal price, List products) { - Menu menu = new Menu(); - menu.setMenuGroupId(menuGroupId); - menu.setName(name); - menu.setPrice(price); - menu.setMenuProducts(products); - return menu; - } } diff --git a/src/test/java/kitchenpos/application/fixture/MenuFixture.java b/src/test/java/kitchenpos/application/fixture/MenuFixture.java new file mode 100644 index 000000000..5c3f4401e --- /dev/null +++ b/src/test/java/kitchenpos/application/fixture/MenuFixture.java @@ -0,0 +1,31 @@ +package kitchenpos.application.fixture; + +import kitchenpos.domain.Menu; +import kitchenpos.domain.MenuGroup; +import kitchenpos.domain.MenuProduct; + +import java.math.BigDecimal; +import java.util.List; +import java.util.UUID; + +public class MenuFixture { + + public static Menu createMenu(UUID menuGroupId, String name, BigDecimal price, List products) { + return createMenu(null, null, menuGroupId, name, price, false, products); + } + + public static Menu createMenu(UUID id, MenuGroup menuGroup, UUID menuGroupId, String name, BigDecimal price, boolean displayed, List products) { + Menu menu = new Menu(); + menu.setId(id); + menu.setMenuGroup(menuGroup); + menu.setMenuGroupId(menuGroupId); + menu.setName(name); + menu.setPrice(price); + menu.setDisplayed(displayed); + menu.setMenuProducts(products); + return menu; + } + + private MenuFixture() { + } +} diff --git a/src/test/java/kitchenpos/application/fixture/MenuGroupFixture.java b/src/test/java/kitchenpos/application/fixture/MenuGroupFixture.java new file mode 100644 index 000000000..f5054d3a2 --- /dev/null +++ b/src/test/java/kitchenpos/application/fixture/MenuGroupFixture.java @@ -0,0 +1,22 @@ +package kitchenpos.application.fixture; + +import kitchenpos.domain.MenuGroup; + +import java.util.UUID; + +public class MenuGroupFixture { + + public static MenuGroup createMenuGroup(String name) { + return createMenuGroup(null, name); + } + + public static MenuGroup createMenuGroup(UUID id, String name) { + MenuGroup menuGroup = new MenuGroup(); + menuGroup.setId(id); + menuGroup.setName(name); + return menuGroup; + } + + private MenuGroupFixture() { + } +} diff --git a/src/test/java/kitchenpos/application/fixture/MenuProductFixture.java b/src/test/java/kitchenpos/application/fixture/MenuProductFixture.java new file mode 100644 index 000000000..f08f0c2ce --- /dev/null +++ b/src/test/java/kitchenpos/application/fixture/MenuProductFixture.java @@ -0,0 +1,27 @@ +package kitchenpos.application.fixture; + +import kitchenpos.domain.MenuProduct; +import kitchenpos.domain.Product; + +import java.util.UUID; + +public class MenuProductFixture { + + public static MenuProduct createMenuProduct(UUID productId, int quantity) { + MenuProduct menuProduct = new MenuProduct(); + menuProduct.setProductId(productId); + menuProduct.setQuantity(quantity); + return menuProduct; + } + + public static MenuProduct createMenuProduct(Product product, int quantity) { + MenuProduct menuProduct = new MenuProduct(); + menuProduct.setProduct(product); + menuProduct.setProductId(product.getId()); + menuProduct.setQuantity(quantity); + return menuProduct; + } + + private MenuProductFixture() { + } +} diff --git a/src/test/java/kitchenpos/application/fixture/OrderFixture.java b/src/test/java/kitchenpos/application/fixture/OrderFixture.java new file mode 100644 index 000000000..31726291e --- /dev/null +++ b/src/test/java/kitchenpos/application/fixture/OrderFixture.java @@ -0,0 +1,34 @@ +package kitchenpos.application.fixture; + +import kitchenpos.domain.Order; +import kitchenpos.domain.OrderLineItem; +import kitchenpos.domain.OrderType; + +import java.math.BigDecimal; +import java.time.LocalDateTime; +import java.util.List; +import java.util.UUID; + +public class OrderFixture { + + public static Order createOrder(OrderType orderType, List orderLineItems, String deliveryAddress, UUID orderTableId, LocalDateTime orderDateTime) { + Order order = new Order(); + order.setType(orderType); + order.setOrderLineItems(orderLineItems); + order.setDeliveryAddress(deliveryAddress); + order.setOrderTableId(orderTableId); + order.setOrderDateTime(orderDateTime); + return order; + } + + public static OrderLineItem createOrderLineItem(UUID menuId, BigDecimal price, int quantity) { + OrderLineItem orderLineItem = new OrderLineItem(); + orderLineItem.setMenuId(menuId); + orderLineItem.setPrice(price); + orderLineItem.setQuantity(quantity); + return orderLineItem; + } + + private OrderFixture() { + } +} diff --git a/src/test/java/kitchenpos/application/fixture/OrderTableFixture.java b/src/test/java/kitchenpos/application/fixture/OrderTableFixture.java new file mode 100644 index 000000000..37a36db48 --- /dev/null +++ b/src/test/java/kitchenpos/application/fixture/OrderTableFixture.java @@ -0,0 +1,28 @@ +package kitchenpos.application.fixture; + +import kitchenpos.domain.OrderTable; + +import java.util.UUID; + +public class OrderTableFixture { + + public static OrderTable createOrderTable(String name) { + return createOrderTable(null, name, 0); + } + + public static OrderTable createOrderTable(UUID id, String name, int numberOfGuests) { + return createOrderTable(id, name, false, numberOfGuests); + } + + public static OrderTable createOrderTable(UUID id, String name, boolean occupied, int numberOfGuests) { + OrderTable orderTable = new OrderTable(); + orderTable.setId(id); + orderTable.setName(name); + orderTable.setOccupied(occupied); + orderTable.setNumberOfGuests(numberOfGuests); + return orderTable; + } + + private OrderTableFixture() { + } +} diff --git a/src/test/java/kitchenpos/application/fixture/ProductFixture.java b/src/test/java/kitchenpos/application/fixture/ProductFixture.java new file mode 100644 index 000000000..35890e582 --- /dev/null +++ b/src/test/java/kitchenpos/application/fixture/ProductFixture.java @@ -0,0 +1,24 @@ +package kitchenpos.application.fixture; + +import kitchenpos.domain.Product; + +import java.math.BigDecimal; +import java.util.UUID; + +public class ProductFixture { + + public static Product createProduct(String name, BigDecimal price) { + return createProduct(null, name, price); + } + + public static Product createProduct(UUID id, String name, BigDecimal price) { + Product product = new Product(); + product.setId(id); + product.setName(name); + product.setPrice(price); + return product; + } + + private ProductFixture() { + } +} From 6e274fb60d8fd02e5662d9b7b658636ce811513d Mon Sep 17 00:00:00 2001 From: skdev0619 Date: Wed, 5 Feb 2025 13:54:06 +0900 Subject: [PATCH 14/29] =?UTF-8?q?@Nested=20=EC=A0=81=EC=9A=A9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../application/MenuGroupServiceTest.java | 35 +- .../application/MenuServiceTest.java | 432 +++++----- .../application/OrderServiceTest.java | 816 +++++++++--------- .../application/OrderTableServiceTest.java | 163 ++-- .../application/ProductServiceTest.java | 182 ++-- 5 files changed, 843 insertions(+), 785 deletions(-) diff --git a/src/test/java/kitchenpos/application/MenuGroupServiceTest.java b/src/test/java/kitchenpos/application/MenuGroupServiceTest.java index 29a3de1a0..b09bff283 100644 --- a/src/test/java/kitchenpos/application/MenuGroupServiceTest.java +++ b/src/test/java/kitchenpos/application/MenuGroupServiceTest.java @@ -3,6 +3,7 @@ import kitchenpos.application.fixture.MenuGroupFixture; import kitchenpos.domain.MenuGroup; import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.NullAndEmptySource; @@ -22,26 +23,32 @@ class MenuGroupServiceTest { @Autowired private MenuGroupService menuGroupService; - @DisplayName("메뉴그룹명을 입력하여 메뉴그룹을 등록한다") - @Test - void create() { - MenuGroup request = MenuGroupFixture.createMenuGroup("세트메뉴"); + @DisplayName("메뉴 그룹을 생성할 수 있다") + @Nested + class MenuGroupCreator { - MenuGroup menuGroup = menuGroupService.create(request); + @DisplayName("메뉴그룹명을 입력하여 메뉴그룹을 등록한다") + @Test + void createMenuGroup() { + MenuGroup request = MenuGroupFixture.createMenuGroup("세트메뉴"); - assertThat(menuGroup.getName()).isEqualTo("세트메뉴"); - } + MenuGroup menuGroup = menuGroupService.create(request); - @DisplayName("메뉴그룹명은 반드시 입력되어야 하며 공백만 입력할 수 없다") - @NullAndEmptySource - @ParameterizedTest - void validateName(String name) { - MenuGroup request = MenuGroupFixture.createMenuGroup(name); + assertThat(menuGroup.getName()).isEqualTo("세트메뉴"); + } - assertThatIllegalArgumentException() - .isThrownBy(() -> menuGroupService.create(request)); + @DisplayName("메뉴그룹명은 반드시 입력되어야 하며 공백만 입력할 수 없다") + @NullAndEmptySource + @ParameterizedTest + void validateName(String name) { + MenuGroup request = MenuGroupFixture.createMenuGroup(name); + + assertThatIllegalArgumentException() + .isThrownBy(() -> menuGroupService.create(request)); + } } + @DisplayName("모든 메뉴 그룹을 조회할 수 있다") @Test void findAll() { diff --git a/src/test/java/kitchenpos/application/MenuServiceTest.java b/src/test/java/kitchenpos/application/MenuServiceTest.java index 96941cbe7..7293a86b2 100644 --- a/src/test/java/kitchenpos/application/MenuServiceTest.java +++ b/src/test/java/kitchenpos/application/MenuServiceTest.java @@ -12,6 +12,7 @@ import org.assertj.core.groups.Tuple; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.NullSource; @@ -57,222 +58,232 @@ void setUp() { menuGroupRepository.save(MenuGroupFixture.createMenuGroup(MENU_GROUP_ID, "세트메뉴")); } - //region [메뉴 등록] - @DisplayName("단일 상품으로 메뉴를 등록할 수 있다") - @Test - void createMenuByProduct() { - MenuProduct chickenBurger = MenuProductFixture.createMenuProduct(BURGER_PRODUCT_ID, 1); - Menu menu = MenuFixture.createMenu(MENU_GROUP_ID, "치킨버거", new BigDecimal(7000), List.of(chickenBurger)); - - Menu resultMenu = menuService.create(menu); - - assertThat(resultMenu.getName()).isEqualTo("치킨버거"); - assertThat(resultMenu.getPrice()).isEqualTo(new BigDecimal(7000)); - assertThat(resultMenu.isDisplayed()).isFalse(); - assertThat(resultMenu.getMenuProducts()).hasSize(1); - assertThat(resultMenu.getMenuGroup()).isNotNull(); - assertThat(resultMenu.getMenuGroup().getId()).isEqualTo(MENU_GROUP_ID); - } - - @DisplayName("여러 상품으로 조합하여 하나의 메뉴를 등록할 수 있다") - @Test - void createMenuByProducts() { - //given - MenuProduct chickenBurger = MenuProductFixture.createMenuProduct(BURGER_PRODUCT_ID, 1); - MenuProduct side = MenuProductFixture.createMenuProduct(SIDE_PRODUCT_ID, 1); - MenuProduct coke = MenuProductFixture.createMenuProduct(COKE_PRODUCT_ID, 1); - - Menu menu = MenuFixture.createMenu( - MENU_GROUP_ID, - "치킨버거세트", - new BigDecimal(10000), - List.of(chickenBurger, side, coke) - ); - //when - Menu resultMenu = menuService.create(menu); - //then - assertThat(resultMenu.getName()).isEqualTo("치킨버거세트"); - assertThat(resultMenu.getPrice()).isEqualTo(new BigDecimal(10000)); - assertThat(resultMenu.getMenuProducts()).hasSize(3); - assertThat(resultMenu.getMenuGroup()).isNotNull(); - assertThat(resultMenu.getMenuGroup().getId()).isEqualTo(MENU_GROUP_ID); - } - - @DisplayName("각 메뉴를 구성하는 상품의 수량은 0이상이어야 한다") - @Test - void validateMenuProductQuantity() { - MenuProduct chickenBurger = MenuProductFixture.createMenuProduct(BURGER_PRODUCT_ID, 1); - MenuProduct coke = MenuProductFixture.createMenuProduct(COKE_PRODUCT_ID, -1); - Menu menu = MenuFixture.createMenu( - MENU_GROUP_ID, - "치킨버거+음료", - new BigDecimal(9000), - List.of(chickenBurger, coke) - ); - - assertThatIllegalArgumentException() - .isThrownBy(() -> menuService.create(menu)); - } - - @DisplayName("메뉴명은 반드시 입력되어야 한다") - @ParameterizedTest - @NullSource - void notNullName(String nullName) { - MenuProduct chickenBurger = MenuProductFixture.createMenuProduct(BURGER_PRODUCT_ID, 1); - Menu menu = MenuFixture.createMenu(MENU_GROUP_ID, nullName, new BigDecimal(7000), List.of(chickenBurger)); - - assertThatIllegalArgumentException() - .isThrownBy(() -> menuService.create(menu)); - } - - @DisplayName("메뉴명에 비속어가 있으면 등록할 수 없다") - @Test - void validateMenuName() { - Mockito.when(purgomalumClient.containsProfanity("bad word")).thenReturn(true); - - MenuProduct chickenBurger = MenuProductFixture.createMenuProduct(BURGER_PRODUCT_ID, 1); - Menu menu = MenuFixture.createMenu(MENU_GROUP_ID, "bad word", new BigDecimal(7000), List.of(chickenBurger)); - - assertThatIllegalArgumentException() - .isThrownBy(() -> menuService.create(menu)); - } - - @DisplayName("가격은 반드시 입력되어야 한다") - @ParameterizedTest - @NullSource - void notNullPrice(BigDecimal nullPrice) { - MenuProduct chickenBurger = MenuProductFixture.createMenuProduct(BURGER_PRODUCT_ID, 1); - Menu menu = MenuFixture.createMenu(MENU_GROUP_ID, "치킨버거", nullPrice, List.of(chickenBurger)); - - assertThatIllegalArgumentException() - .isThrownBy(() -> menuService.create(menu)); - } - - @DisplayName("메뉴의 가격은 0원 이상이어야 한다") - @Test - void nonNegativeMenuPrice() { - MenuProduct chickenBurger = MenuProductFixture.createMenuProduct(BURGER_PRODUCT_ID, 1); - Menu menu = MenuFixture.createMenu(MENU_GROUP_ID, "치킨버거", new BigDecimal(-1), List.of(chickenBurger)); - - assertThatIllegalArgumentException() - .isThrownBy(() -> menuService.create(menu)); - } - - @DisplayName("메뉴의 가격이 포함된 상품 가격 총합과 동일하거나 할인된 가격일 경우만 등록 가능하다") - @Test - void validateMenuPrice() { - //given - MenuProduct chickenBurger = MenuProductFixture.createMenuProduct(BURGER_PRODUCT_ID, 1); //7000원 - MenuProduct side = MenuProductFixture.createMenuProduct(SIDE_PRODUCT_ID, 1); //2000원 - MenuProduct coke = MenuProductFixture.createMenuProduct(COKE_PRODUCT_ID, 1); //2000원 - - Menu menu = MenuFixture.createMenu( - MENU_GROUP_ID, - "치킨버거세트", - new BigDecimal(11001), - List.of(chickenBurger, side, coke) - ); - //when, then - assertThatIllegalArgumentException() - .isThrownBy(() -> menuService.create(menu)); + @DisplayName("메뉴를 생성할 수 있다") + @Nested + class MenuCreator { + @DisplayName("단일 상품으로 메뉴를 등록할 수 있다") + @Test + void createMenuByProduct() { + MenuProduct chickenBurger = MenuProductFixture.createMenuProduct(BURGER_PRODUCT_ID, 1); + Menu menu = MenuFixture.createMenu(MENU_GROUP_ID, "치킨버거", new BigDecimal(7000), List.of(chickenBurger)); + + Menu resultMenu = menuService.create(menu); + + assertThat(resultMenu.getName()).isEqualTo("치킨버거"); + assertThat(resultMenu.getPrice()).isEqualTo(new BigDecimal(7000)); + assertThat(resultMenu.isDisplayed()).isFalse(); + assertThat(resultMenu.getMenuProducts()).hasSize(1); + assertThat(resultMenu.getMenuGroup()).isNotNull(); + assertThat(resultMenu.getMenuGroup().getId()).isEqualTo(MENU_GROUP_ID); + } + + @DisplayName("여러 상품으로 조합하여 하나의 메뉴를 등록할 수 있다") + @Test + void createMenuByProducts() { + //given + MenuProduct chickenBurger = MenuProductFixture.createMenuProduct(BURGER_PRODUCT_ID, 1); + MenuProduct side = MenuProductFixture.createMenuProduct(SIDE_PRODUCT_ID, 1); + MenuProduct coke = MenuProductFixture.createMenuProduct(COKE_PRODUCT_ID, 1); + + Menu menu = MenuFixture.createMenu( + MENU_GROUP_ID, + "치킨버거세트", + new BigDecimal(10000), + List.of(chickenBurger, side, coke) + ); + //when + Menu resultMenu = menuService.create(menu); + //then + assertThat(resultMenu.getName()).isEqualTo("치킨버거세트"); + assertThat(resultMenu.getPrice()).isEqualTo(new BigDecimal(10000)); + assertThat(resultMenu.getMenuProducts()).hasSize(3); + assertThat(resultMenu.getMenuGroup()).isNotNull(); + assertThat(resultMenu.getMenuGroup().getId()).isEqualTo(MENU_GROUP_ID); + } + + @DisplayName("각 메뉴를 구성하는 상품의 수량은 0이상이어야 한다") + @Test + void validateMenuProductQuantity() { + MenuProduct chickenBurger = MenuProductFixture.createMenuProduct(BURGER_PRODUCT_ID, 1); + MenuProduct coke = MenuProductFixture.createMenuProduct(COKE_PRODUCT_ID, -1); + Menu menu = MenuFixture.createMenu( + MENU_GROUP_ID, + "치킨버거+음료", + new BigDecimal(9000), + List.of(chickenBurger, coke) + ); + + assertThatIllegalArgumentException() + .isThrownBy(() -> menuService.create(menu)); + } + + @DisplayName("메뉴명은 반드시 입력되어야 한다") + @ParameterizedTest + @NullSource + void notNullName(String nullName) { + MenuProduct chickenBurger = MenuProductFixture.createMenuProduct(BURGER_PRODUCT_ID, 1); + Menu menu = MenuFixture.createMenu(MENU_GROUP_ID, nullName, new BigDecimal(7000), List.of(chickenBurger)); + + assertThatIllegalArgumentException() + .isThrownBy(() -> menuService.create(menu)); + } + + @DisplayName("메뉴명에 비속어가 있으면 등록할 수 없다") + @Test + void validateMenuName() { + Mockito.when(purgomalumClient.containsProfanity("bad word")).thenReturn(true); + + MenuProduct chickenBurger = MenuProductFixture.createMenuProduct(BURGER_PRODUCT_ID, 1); + Menu menu = MenuFixture.createMenu(MENU_GROUP_ID, "bad word", new BigDecimal(7000), List.of(chickenBurger)); + + assertThatIllegalArgumentException() + .isThrownBy(() -> menuService.create(menu)); + } + + @DisplayName("가격은 반드시 입력되어야 한다") + @ParameterizedTest + @NullSource + void notNullPrice(BigDecimal nullPrice) { + MenuProduct chickenBurger = MenuProductFixture.createMenuProduct(BURGER_PRODUCT_ID, 1); + Menu menu = MenuFixture.createMenu(MENU_GROUP_ID, "치킨버거", nullPrice, List.of(chickenBurger)); + + assertThatIllegalArgumentException() + .isThrownBy(() -> menuService.create(menu)); + } + + @DisplayName("메뉴의 가격은 0원 이상이어야 한다") + @Test + void nonNegativeMenuPrice() { + MenuProduct chickenBurger = MenuProductFixture.createMenuProduct(BURGER_PRODUCT_ID, 1); + Menu menu = MenuFixture.createMenu(MENU_GROUP_ID, "치킨버거", new BigDecimal(-1), List.of(chickenBurger)); + + assertThatIllegalArgumentException() + .isThrownBy(() -> menuService.create(menu)); + } + + @DisplayName("메뉴의 가격이 포함된 상품 가격 총합과 동일하거나 할인된 가격일 경우만 등록 가능하다") + @Test + void validateMenuPrice() { + //given + MenuProduct chickenBurger = MenuProductFixture.createMenuProduct(BURGER_PRODUCT_ID, 1); //7000원 + MenuProduct side = MenuProductFixture.createMenuProduct(SIDE_PRODUCT_ID, 1); //2000원 + MenuProduct coke = MenuProductFixture.createMenuProduct(COKE_PRODUCT_ID, 1); //2000원 + + Menu menu = MenuFixture.createMenu( + MENU_GROUP_ID, + "치킨버거세트", + new BigDecimal(11001), + List.of(chickenBurger, side, coke) + ); + //when, then + assertThatIllegalArgumentException() + .isThrownBy(() -> menuService.create(menu)); + } } - //endregion - //region[메뉴 수정] @DisplayName("메뉴는 가격을 수정할 수 있다") - @Test - void changeMenuPrice() { - MenuProduct chickenBurger = MenuProductFixture.createMenuProduct(BURGER_PRODUCT_ID, 1); - Menu menu = menuService.create( - MenuFixture.createMenu( - MENU_GROUP_ID, - "치킨버거", - new BigDecimal(7000), - List.of(chickenBurger))); - - menu.setPrice(new BigDecimal(6500)); - Menu newPriceMenu = menuService.changePrice(menu.getId(), menu); - - assertThat(newPriceMenu.getPrice()).isEqualTo(new BigDecimal(6500)); - } - - @DisplayName("메뉴의 가격이 0원 미만이면 변경할 수 없다") - @Test - void canNotChangeNegativePrice() { - MenuProduct chickenBurger = MenuProductFixture.createMenuProduct(BURGER_PRODUCT_ID, 1); - Menu menu = menuService.create( - MenuFixture.createMenu( - MENU_GROUP_ID, - "치킨버거", - new BigDecimal(7000), - List.of(chickenBurger))); - - menu.setPrice(new BigDecimal(-1)); + @Nested + class MenuPriceUpdater { + + @DisplayName("메뉴는 가격을 수정할 수 있다") + @Test + void changeMenuPrice() { + MenuProduct chickenBurger = MenuProductFixture.createMenuProduct(BURGER_PRODUCT_ID, 1); + Menu menu = menuService.create( + MenuFixture.createMenu( + MENU_GROUP_ID, + "치킨버거", + new BigDecimal(7000), + List.of(chickenBurger))); + + menu.setPrice(new BigDecimal(6500)); + Menu newPriceMenu = menuService.changePrice(menu.getId(), menu); + + assertThat(newPriceMenu.getPrice()).isEqualTo(new BigDecimal(6500)); + } + + @DisplayName("메뉴의 가격이 0원 미만이면 변경할 수 없다") + @Test + void canNotChangeNegativePrice() { + MenuProduct chickenBurger = MenuProductFixture.createMenuProduct(BURGER_PRODUCT_ID, 1); + Menu menu = menuService.create( + MenuFixture.createMenu( + MENU_GROUP_ID, + "치킨버거", + new BigDecimal(7000), + List.of(chickenBurger))); + + menu.setPrice(new BigDecimal(-1)); + + assertThatIllegalArgumentException() + .isThrownBy(() -> menuService.changePrice(menu.getId(), menu)); + } + + @DisplayName("메뉴의 가격은 포함된 상품 가격 총합과 동일하거나 할인된 가격으로만 수정 가능하다") + @Test + void validateMenuPriceOnModify() { + //given + MenuProduct chickenBurger = MenuProductFixture.createMenuProduct(BURGER_PRODUCT_ID, 1); //7000원 + MenuProduct side = MenuProductFixture.createMenuProduct(SIDE_PRODUCT_ID, 1); //2000원 + MenuProduct coke = MenuProductFixture.createMenuProduct(COKE_PRODUCT_ID, 1); //2000원 + + Menu menu = MenuFixture.createMenu( + MENU_GROUP_ID, + "치킨버거세트", + new BigDecimal(11000), + List.of(chickenBurger, side, coke) + ); + Menu resultMenu = menuService.create(menu); + + resultMenu.setPrice(new BigDecimal(11001)); + assertThatIllegalArgumentException() + .isThrownBy(() -> menuService.changePrice(resultMenu.getId(), resultMenu)); + } - assertThatIllegalArgumentException() - .isThrownBy(() -> menuService.changePrice(menu.getId(), menu)); } - @DisplayName("메뉴의 가격은 포함된 상품 가격 총합과 동일하거나 할인된 가격으로만 수정 가능하다") - @Test - void validateMenuPriceOnModify() { - //given - MenuProduct chickenBurger = MenuProductFixture.createMenuProduct(BURGER_PRODUCT_ID, 1); //7000원 - MenuProduct side = MenuProductFixture.createMenuProduct(SIDE_PRODUCT_ID, 1); //2000원 - MenuProduct coke = MenuProductFixture.createMenuProduct(COKE_PRODUCT_ID, 1); //2000원 - - Menu menu = MenuFixture.createMenu( - MENU_GROUP_ID, - "치킨버거세트", - new BigDecimal(11000), - List.of(chickenBurger, side, coke) - ); - Menu resultMenu = menuService.create(menu); - - resultMenu.setPrice(new BigDecimal(11001)); - assertThatIllegalArgumentException() - .isThrownBy(() -> menuService.changePrice(resultMenu.getId(), resultMenu)); - } - //endregion - - //region [메뉴 전시] - @DisplayName("메뉴를 메뉴판에 전시한다") - @Test - void display() { - MenuProduct chickenBurger = MenuProductFixture.createMenuProduct(BURGER_PRODUCT_ID, 1); - Menu menu = menuService.create( - MenuFixture.createMenu( - MENU_GROUP_ID, - "치킨버거", - new BigDecimal(7000), - List.of(chickenBurger) - ) - ); - - Menu resultMenu = menuService.display(menu.getId()); - - assertThat(resultMenu.isDisplayed()).isTrue(); - } - - @DisplayName("메뉴의 가격이 포함된 상품 가격 총합과 동일하거나 할인된 가격인 경우만 전시할 수 있다") - @Test - void validateMenuPriceOnDisplay() { - //given - MenuProduct chickenBurger = MenuProductFixture.createMenuProduct(BURGER_PRODUCT_ID, 1); //7000원 - MenuProduct side = MenuProductFixture.createMenuProduct(SIDE_PRODUCT_ID, 1); //2000원 - MenuProduct coke = MenuProductFixture.createMenuProduct(COKE_PRODUCT_ID, 1); //2000원 - - Menu menu = MenuFixture.createMenu( - MENU_GROUP_ID, - "치킨버거세트", - new BigDecimal(11000), - List.of(chickenBurger, side, coke) - ); - Menu resultMenu = menuService.create(menu); - - resultMenu.setPrice(new BigDecimal(11001)); - assertThatIllegalStateException() - .isThrownBy(() -> menuService.display(resultMenu.getId())); + @DisplayName("메뉴를 전시할 수 있다") + @Nested + class MenuDisplay { + + @DisplayName("메뉴를 메뉴판에 전시한다") + @Test + void display() { + MenuProduct chickenBurger = MenuProductFixture.createMenuProduct(BURGER_PRODUCT_ID, 1); + Menu menu = menuService.create( + MenuFixture.createMenu( + MENU_GROUP_ID, + "치킨버거", + new BigDecimal(7000), + List.of(chickenBurger) + ) + ); + + Menu resultMenu = menuService.display(menu.getId()); + + assertThat(resultMenu.isDisplayed()).isTrue(); + } + + @DisplayName("메뉴의 가격이 포함된 상품 가격 총합과 동일하거나 할인된 가격인 경우만 전시할 수 있다") + @Test + void validateMenuPriceOnDisplay() { + //given + MenuProduct chickenBurger = MenuProductFixture.createMenuProduct(BURGER_PRODUCT_ID, 1); //7000원 + MenuProduct side = MenuProductFixture.createMenuProduct(SIDE_PRODUCT_ID, 1); //2000원 + MenuProduct coke = MenuProductFixture.createMenuProduct(COKE_PRODUCT_ID, 1); //2000원 + + Menu menu = MenuFixture.createMenu( + MENU_GROUP_ID, + "치킨버거세트", + new BigDecimal(11000), + List.of(chickenBurger, side, coke) + ); + Menu resultMenu = menuService.create(menu); + + resultMenu.setPrice(new BigDecimal(11001)); + assertThatIllegalStateException() + .isThrownBy(() -> menuService.display(resultMenu.getId())); + } } @DisplayName("메뉴판의 전시여부를 X로 변경한다") @@ -292,7 +303,6 @@ void hide() { assertThat(resultMenu.isDisplayed()).isFalse(); } - //endregion //region [메뉴 조회] @DisplayName("모든 메뉴들을 조회할 수 있다") diff --git a/src/test/java/kitchenpos/application/OrderServiceTest.java b/src/test/java/kitchenpos/application/OrderServiceTest.java index 52f66fb7b..925253cce 100644 --- a/src/test/java/kitchenpos/application/OrderServiceTest.java +++ b/src/test/java/kitchenpos/application/OrderServiceTest.java @@ -4,6 +4,7 @@ import kitchenpos.domain.*; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.EnumSource; @@ -63,406 +64,427 @@ void setUp() { menuRepository.save(MenuFixture.createMenu(UNDISPLAYED_MENU_ID, menuGroup, menuGroup.getId(), "비전시메뉴", new BigDecimal(7000), false, List.of(unDisplayMenuProduct))); } - //region [주문 생성] - @DisplayName("주문의 종류는 반드시 입력해야 한다") - @NullSource - @ParameterizedTest - void orderType(OrderType status) { - OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal("25000"), 1); - Order nullOrderTypeRequest = OrderFixture.createOrder(status, List.of(orderLineItem), "", null, null); + @DisplayName("주문을 생성할 수 있다") + @Nested + class OrderCreator { + + @DisplayName("주문의 종류는 반드시 입력해야 한다") + @NullSource + @ParameterizedTest + void orderType(OrderType status) { + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal("25000"), 1); + Order nullOrderTypeRequest = OrderFixture.createOrder(status, List.of(orderLineItem), "", null, null); + + assertThatIllegalArgumentException() + .isThrownBy(() -> orderService.create(nullOrderTypeRequest)); + } + + @DisplayName("포장 주문을 생성한다. 주문이 정상적으로 생성되면 상태는 대기 중으로 변경된다") + @Test + void takeOutOrder() { + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal("25000"), 1); + Order orderRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); + + Order orderResult = orderService.create(orderRequest); + + assertThat(orderResult.getType()).isEqualTo(OrderType.TAKEOUT); + assertThat(orderResult.getOrderLineItems()).isNotNull(); + assertThat(orderResult.getOrderLineItems()).hasSize(1); + assertThat(orderResult.getDeliveryAddress()).isNull(); + assertThat(orderResult.getStatus()).isEqualTo(OrderStatus.WAITING); + } + + @DisplayName("배달 주문을 생성한다. 주문이 정상적으로 생성되면 상태는 대기 중으로 변경된다") + @Test + void deliveryOrder() { + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal("25000"), 1); + Order orderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XX호", LocalDateTime.now()); + + Order orderResult = orderService.create(orderRequest); + + assertThat(orderResult.getType()).isEqualTo(OrderType.DELIVERY); + assertThat(orderResult.getOrderLineItems()).isNotNull(); + assertThat(orderResult.getOrderLineItems()).hasSize(1); + assertThat(orderResult.getDeliveryAddress()).isNotNull(); + assertThat(orderResult.getDeliveryAddress()).isEqualTo("경기도 고양시..XX동 XX호"); + assertThat(orderResult.getStatus()).isEqualTo(OrderStatus.WAITING); + } + + @DisplayName("매장 내 식사 주문을 생성한다. 주문이 정상적으로 생성되면 상태는 대기 중으로 변경된다") + @Test + void eatInOrder() { + OrderTable request = OrderTableFixture.createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4); + OrderTable orderTable = orderTableRepository.save(request); + + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal("25000"), 1); + Order orderRequest = createEatInOrder(List.of(orderLineItem), orderTable.getId(), LocalDateTime.now()); + + Order orderResult = orderService.create(orderRequest); + + assertThat(orderResult.getType()).isEqualTo(OrderType.EAT_IN); + assertThat(orderResult.getOrderLineItems()).isNotNull(); + assertThat(orderResult.getOrderLineItems()).hasSize(1); + assertThat(orderResult.getDeliveryAddress()).isNull(); + assertThat(orderResult.getStatus()).isEqualTo(OrderStatus.WAITING); + } + + @DisplayName("어떤 메뉴를 몇 개 시킬지에 대한 주문 상세 내역이 1개 이상 있어야 한다") + @ParameterizedTest + @MethodSource("nullOrEmptyList") + void notNullOrderLineItems(List orderLineItems) { + Order takeOutRequest = createTakeOutOrder(orderLineItems, LocalDateTime.now()); + Order deliveryOrderRequest = createDeliveryOrder(orderLineItems, "경기도 고양시..XX동 XX호", LocalDateTime.now()); + OrderTable orderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); + Order eatInOrderRequest = createEatInOrder(orderLineItems, orderTable.getId(), LocalDateTime.now()); + + assertThatIllegalArgumentException() + .isThrownBy(() -> orderService.create(takeOutRequest)); + assertThatIllegalArgumentException() + .isThrownBy(() -> orderService.create(deliveryOrderRequest)); + assertThatIllegalArgumentException() + .isThrownBy(() -> orderService.create(eatInOrderRequest)); + } + + private static Stream nullOrEmptyList() { + return Stream.of(null, Collections.emptyList()); + } + + @DisplayName("배달/포장 주문의 경우, 주문한 메뉴의 수량이 0개 이상이어야 한다") + @Test + void validateQuantity() { + int negativeQuantity = -1; + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal("25000"), negativeQuantity); + Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); + Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XX호", LocalDateTime.now()); + + assertThatIllegalArgumentException() + .isThrownBy(() -> orderService.create(takeOutRequest)); + assertThatIllegalArgumentException() + .isThrownBy(() -> orderService.create(deliveryOrderRequest)); + } + + @DisplayName("메뉴판에 전시하지 않은 메뉴는 주문할 수 없다") + @Test + void validateMenuOrder() { + OrderLineItem undisplayMenuOrderItem = OrderFixture.createOrderLineItem(UNDISPLAYED_MENU_ID, new BigDecimal("25000"), 1); + Order takeOutRequest = createTakeOutOrder(List.of(undisplayMenuOrderItem), LocalDateTime.now()); + Order deliveryOrderRequest = createDeliveryOrder(List.of(undisplayMenuOrderItem), "경기도 고양시..XX동 XX호", LocalDateTime.now()); + OrderTable orderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); + Order eatInOrderRequest = createEatInOrder(List.of(undisplayMenuOrderItem), orderTable.getId(), LocalDateTime.now()); + + assertThatIllegalStateException() + .isThrownBy(() -> orderService.create(takeOutRequest)); + assertThatIllegalStateException() + .isThrownBy(() -> orderService.create(deliveryOrderRequest)); + assertThatIllegalStateException() + .isThrownBy(() -> orderService.create(eatInOrderRequest)); + } + + @DisplayName("메뉴의 가격과 주문 내역의 가격은 동일해야 한다") + @Test + void validateOrderPrice() { + BigDecimal menuPrice = menuRepository.findById(DISPLAY_MENU_ID).get().getPrice(); + + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, menuPrice.add(BigDecimal.ONE), 1); + Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); + Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XX호", LocalDateTime.now()); + OrderTable orderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); + Order eatInOrderRequest = createEatInOrder(List.of(orderLineItem), orderTable.getId(), LocalDateTime.now()); + + assertThatIllegalArgumentException() + .isThrownBy(() -> orderService.create(takeOutRequest)); + assertThatIllegalArgumentException() + .isThrownBy(() -> orderService.create(deliveryOrderRequest)); + assertThatIllegalArgumentException() + .isThrownBy(() -> orderService.create(eatInOrderRequest)); + } + + @DisplayName("배달의 경우, 배달 주소가 반드시 입력되어야 하며, 공백만 입력되어서는 안된다") + @ParameterizedTest + @NullAndEmptySource + void notNullOrNotEmpty(String deliveryAddress) { + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), deliveryAddress, LocalDateTime.now()); + + assertThatIllegalArgumentException() + .isThrownBy(() -> orderService.create(deliveryOrderRequest)); + } + + @DisplayName("매장 내 취식일 경우, 고객에게 배정된 주문 테이블이 있어야 한다") + @Test + void validateOrderTable() { + UUID unknownTableId = UUID.randomUUID(); + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + Order eatInOrderRequest = createEatInOrder(List.of(orderLineItem), unknownTableId, LocalDateTime.now()); + + assertThatThrownBy(() -> orderService.create(eatInOrderRequest)) + .isInstanceOf(NoSuchElementException.class); + } + + @DisplayName("매장 내 취식일 경우, 주문 테이블의 사용유무가 사용 중이어야 한다") + @Test + void validateOrderTableStatus() { + boolean tableOccupied = false; + OrderTable orderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(ORDER_TABLE_ID, "1번테이블", tableOccupied, 0)); + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + Order eatInOrderRequest = createEatInOrder(List.of(orderLineItem), orderTable.getId(), LocalDateTime.now()); + + assertThatIllegalStateException() + .isThrownBy(() -> orderService.create(eatInOrderRequest)); + } + } + + + @DisplayName("주문을 수락할 수 있다") + @Nested + class OrderAccepter { + @DisplayName("대기 중인 주문을 수락한다") + @Test + void acceptOrderStatus() { + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); + Order takeOutOrder = orderService.create(takeOutRequest); + + Order acceptOrder = orderService.accept(takeOutOrder.getId()); + + assertThat(acceptOrder.getStatus()).isEqualTo(OrderStatus.ACCEPTED); + } + + @DisplayName("주문의 상태가 대기(WAITING)일 때 주문 수락이 가능하다") + @EnumSource(value = OrderStatus.class, names = "WAITING", mode = EnumSource.Mode.EXCLUDE) + @ParameterizedTest + void validateAcceptStatus(OrderStatus orderStatus) { + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); + Order takeOutOrder = orderService.create(takeOutRequest); + + takeOutOrder.setStatus(orderStatus); + assertThatIllegalStateException() + .isThrownBy(() -> orderService.accept(takeOutOrder.getId())); + } + } + + + @DisplayName("수락된 주문을 토대로 음식을 제공할 수 있다") + @Nested + class OrderServer { + + @DisplayName("주문 상태를 음식 제공됨(SERVED)로 변경한다") + @Test + void served() { + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); + Order takeOutOrder = orderService.create(takeOutRequest); + Order acceptOrder = orderService.accept(takeOutOrder.getId()); + + Order servedOrder = orderService.serve(acceptOrder.getId()); + + assertThat(servedOrder.getStatus()).isEqualTo(OrderStatus.SERVED); + } + + @DisplayName("주문의 상태가 주문 수락(ACCEPTED)일 때 음식 제공 가능하다") + @EnumSource(value = OrderStatus.class, names = "ACCEPTED", mode = EnumSource.Mode.EXCLUDE) + @ParameterizedTest + void validateServedStatus(OrderStatus orderStatus) { + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); + Order takeOutOrder = orderService.create(takeOutRequest); + + takeOutOrder.setStatus(orderStatus); + assertThatIllegalStateException() + .isThrownBy(() -> orderService.serve(takeOutOrder.getId())); + } + + } + + @DisplayName("배달 주문의 경우, 주문 상태를 배달 중으로 변경할 수 있다") + @Nested + class DeliveryStarter { + + @DisplayName("배달 주문의 경우 음식이 제공되면 주문 상태를 배달 중(DELIVERING)으로 변경한다") + @Test + void startDelivery() { + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", LocalDateTime.now()); + Order order = orderService.create(deliveryOrderRequest); + + order.setStatus(OrderStatus.SERVED); + Order deliveryStartorder = orderService.startDelivery(order.getId()); + + assertThat(deliveryStartorder.getStatus()).isEqualTo(OrderStatus.DELIVERING); + } + + @DisplayName("주문 상태가 음식 제공됨(SERVED)인 경우, 배달 시작이 가능하다") + @EnumSource(value = OrderStatus.class, names = "SERVED", mode = EnumSource.Mode.EXCLUDE) + @ParameterizedTest + void validateDeliveryStartStatus(OrderStatus orderStatus) { + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", LocalDateTime.now()); + Order order = orderService.create(deliveryOrderRequest); + + order.setStatus(orderStatus); + assertThatIllegalStateException() + .isThrownBy(() -> orderService.startDelivery(order.getId())); + } + } + + @DisplayName("배달 주문의 경우, 주문 상태를 배달 완료로 변경할 수 있다") + @Nested + class DeliveryCompleter { + + @DisplayName("배달 완료한 주문 상태를 배달완료(DELIVERED)로 변경한다") + @Test + void endDelivery() { + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", LocalDateTime.now()); + Order order = orderService.create(deliveryOrderRequest); + + order.setStatus(OrderStatus.DELIVERING); + Order deliveryStartorder = orderService.completeDelivery(order.getId()); + + assertThat(deliveryStartorder.getStatus()).isEqualTo(OrderStatus.DELIVERED); + } + + @DisplayName("주문 상태가 배달 중(DELIVERING)인 경우, 배달완료(DELIVERED)로 변경 가능하다") + @ParameterizedTest + @EnumSource(value = OrderStatus.class, names = "DELIVERING", mode = EnumSource.Mode.EXCLUDE) + void validateDeliveryEndStatus(OrderStatus orderStatus) { + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", LocalDateTime.now()); + Order order = orderService.create(deliveryOrderRequest); + + order.setStatus(orderStatus); + assertThatIllegalStateException() + .isThrownBy(() -> orderService.completeDelivery(order.getId())); + } + } + + @DisplayName("주문의 상태를 주문 완료로 변경할 수 있다") + @Nested + class OrderCompleter { + + @DisplayName("배달 주문의 상태를 주문 완료로 변경한다") + @Test + void complete() { + //given + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", LocalDateTime.now()); + Order order = createDeliveredOrder(deliveryOrderRequest); + //when + Order complete = orderService.complete(order.getId()); + //then + assertThat(complete.getStatus()).isEqualTo(OrderStatus.COMPLETED); + } + + @DisplayName("배달 주문의 경우, 주문의 상태가 배달 완료(DELIVERED)인 경우만 주문을 완료할 수 있다") + @EnumSource(value = OrderStatus.class, names = "DELIVERED", mode = EnumSource.Mode.EXCLUDE) + @ParameterizedTest + void completeOrderByDelivery(OrderStatus orderStatus) { + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", LocalDateTime.now()); + Order order = orderService.create(deliveryOrderRequest); + + order.setStatus(orderStatus); + assertThatIllegalStateException() + .isThrownBy(() -> orderService.complete(order.getId())); + } + + @DisplayName("포장 주문의 상태를 주문 완료로 변경한다") + @Test + void completeByTakeOut() { + //given + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); + Order servedOrder = createServedOrder(takeOutRequest); + //when + Order complete = orderService.complete(servedOrder.getId()); + //then + assertThat(complete.getStatus()).isEqualTo(OrderStatus.COMPLETED); + } + + @DisplayName("매장 내 취식 주문 상태를 주문 완료로 변경한다") + @Test + void completeByEatIn() { + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + OrderTable orderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); + Order eatInRequest = createEatInOrder(List.of(orderLineItem), orderTable.getId(), LocalDateTime.now()); + Order servedOrder = createServedOrder(eatInRequest); + //when + Order complete = orderService.complete(servedOrder.getId()); + //then + assertThat(complete.getStatus()).isEqualTo(OrderStatus.COMPLETED); + } + + @DisplayName("포장/매장 내 취식의 경우, 주문의 상태가 음식 제공됨(SERVED)인 경우만 주문을 완료할 수 있다") + @EnumSource(value = OrderStatus.class, names = "SERVED", mode = EnumSource.Mode.EXCLUDE) + @ParameterizedTest + void completeOrderByEatInOrTakeOut(OrderStatus orderStatus) { + //given + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); + + OrderTable orderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); + Order eatInRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); + + Order takeoutOrder = orderService.create(takeOutRequest); + Order eatInOrder = orderService.create(eatInRequest); + //when + takeoutOrder.setStatus(orderStatus); + eatInOrder.setStatus(orderStatus); + //then + assertThatIllegalStateException() + .isThrownBy(() -> orderService.complete(takeoutOrder.getId())); + assertThatIllegalStateException() + .isThrownBy(() -> orderService.complete(eatInOrder.getId())); + } + + @DisplayName("매장 내 식사의 경우, 주문 테이블의 모든 주문이 완료 상태가 아닐 때 테이블은 사용 중이며 손님의 수는 0으로 초기화되지 않는다") + @Test + void completeOrderByEatIn() { + //given + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + OrderTable orderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); + Order eatInRequest = createEatInOrder(List.of(orderLineItem), orderTable.getId(), LocalDateTime.now()); + //주문 상태가 SERVED인 주문1,2 생성 + Order servedOrder1 = createServedOrder(eatInRequest); + Order servedOrder2 = createServedOrder(eatInRequest); + + //when + Order complete = orderService.complete(servedOrder1.getId()); + + //then + assertThat(complete.getStatus()).isEqualTo(OrderStatus.COMPLETED); + assertThat(complete.getOrderTable().isOccupied()).isTrue(); + assertThat(complete.getOrderTable().getNumberOfGuests()).isNotZero(); + } + + @DisplayName("매장 내 취식의 경우, 주문 테이블에의 모든 주문이 완료되면 테이블의 사용유무를 안함으로 변경하고 고객의 수를 0명으로 변경한다") + @Test + void clearOrderTable() { + //given + OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); + OrderTable orderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); + Order eatInRequest = createEatInOrder(List.of(orderLineItem), orderTable.getId(), LocalDateTime.now()); + + Order servedOrder1 = createServedOrder(eatInRequest); + Order servedOrder2 = createServedOrder(eatInRequest); + + //when + Order complete1 = orderService.complete(servedOrder1.getId()); + Order complete2 = orderService.complete(servedOrder2.getId()); + + //then + assertThat(complete1.getStatus()).isEqualTo(OrderStatus.COMPLETED); + assertThat(complete1.getOrderTable().isOccupied()).isFalse(); + assertThat(complete1.getOrderTable().getNumberOfGuests()).isZero(); + + assertThat(complete2.getStatus()).isEqualTo(OrderStatus.COMPLETED); + assertThat(complete2.getOrderTable().isOccupied()).isFalse(); + assertThat(complete2.getOrderTable().getNumberOfGuests()).isZero(); + } - assertThatIllegalArgumentException() - .isThrownBy(() -> orderService.create(nullOrderTypeRequest)); } - @DisplayName("포장 주문을 생성한다. 주문이 정상적으로 생성되면 상태는 대기 중으로 변경된다") - @Test - void createTakeOutOrder() { - OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal("25000"), 1); - Order orderRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); - - Order orderResult = orderService.create(orderRequest); - - assertThat(orderResult.getType()).isEqualTo(OrderType.TAKEOUT); - assertThat(orderResult.getOrderLineItems()).isNotNull(); - assertThat(orderResult.getOrderLineItems()).hasSize(1); - assertThat(orderResult.getDeliveryAddress()).isNull(); - assertThat(orderResult.getStatus()).isEqualTo(OrderStatus.WAITING); - } - - @DisplayName("배달 주문을 생성한다. 주문이 정상적으로 생성되면 상태는 대기 중으로 변경된다") - @Test - void createDeliveryOrder() { - OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal("25000"), 1); - Order orderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XX호", LocalDateTime.now()); - - Order orderResult = orderService.create(orderRequest); - - assertThat(orderResult.getType()).isEqualTo(OrderType.DELIVERY); - assertThat(orderResult.getOrderLineItems()).isNotNull(); - assertThat(orderResult.getOrderLineItems()).hasSize(1); - assertThat(orderResult.getDeliveryAddress()).isNotNull(); - assertThat(orderResult.getDeliveryAddress()).isEqualTo("경기도 고양시..XX동 XX호"); - assertThat(orderResult.getStatus()).isEqualTo(OrderStatus.WAITING); - } - - @DisplayName("매장 내 식사 주문을 생성한다. 주문이 정상적으로 생성되면 상태는 대기 중으로 변경된다") - @Test - void createEatInOrder() { - OrderTable request = OrderTableFixture.createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4); - OrderTable orderTable = orderTableRepository.save(request); - - OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal("25000"), 1); - Order orderRequest = createEatInOrder(List.of(orderLineItem), orderTable.getId(), LocalDateTime.now()); - - Order orderResult = orderService.create(orderRequest); - - assertThat(orderResult.getType()).isEqualTo(OrderType.EAT_IN); - assertThat(orderResult.getOrderLineItems()).isNotNull(); - assertThat(orderResult.getOrderLineItems()).hasSize(1); - assertThat(orderResult.getDeliveryAddress()).isNull(); - assertThat(orderResult.getStatus()).isEqualTo(OrderStatus.WAITING); - } - - @DisplayName("어떤 메뉴를 몇 개 시킬지에 대한 주문 상세 내역이 1개 이상 있어야 한다") - @ParameterizedTest - @MethodSource("nullOrEmptyList") - void notNullOrderLineItems(List orderLineItems) { - Order takeOutRequest = createTakeOutOrder(orderLineItems, LocalDateTime.now()); - Order deliveryOrderRequest = createDeliveryOrder(orderLineItems, "경기도 고양시..XX동 XX호", LocalDateTime.now()); - OrderTable orderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); - Order eatInOrderRequest = createEatInOrder(orderLineItems, orderTable.getId(), LocalDateTime.now()); - - assertThatIllegalArgumentException() - .isThrownBy(() -> orderService.create(takeOutRequest)); - assertThatIllegalArgumentException() - .isThrownBy(() -> orderService.create(deliveryOrderRequest)); - assertThatIllegalArgumentException() - .isThrownBy(() -> orderService.create(eatInOrderRequest)); - } - - private static Stream nullOrEmptyList() { - return Stream.of(null, Collections.emptyList()); - } - - @DisplayName("배달/포장 주문의 경우, 주문한 메뉴의 수량이 0개 이상이어야 한다") - @Test - void validateQuantity() { - int negativeQuantity = -1; - OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal("25000"), negativeQuantity); - Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); - Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XX호", LocalDateTime.now()); - - assertThatIllegalArgumentException() - .isThrownBy(() -> orderService.create(takeOutRequest)); - assertThatIllegalArgumentException() - .isThrownBy(() -> orderService.create(deliveryOrderRequest)); - } - - @DisplayName("메뉴판에 전시하지 않은 메뉴는 주문할 수 없다") - @Test - void validateMenuOrder() { - OrderLineItem undisplayMenuOrderItem = OrderFixture.createOrderLineItem(UNDISPLAYED_MENU_ID, new BigDecimal("25000"), 1); - Order takeOutRequest = createTakeOutOrder(List.of(undisplayMenuOrderItem), LocalDateTime.now()); - Order deliveryOrderRequest = createDeliveryOrder(List.of(undisplayMenuOrderItem), "경기도 고양시..XX동 XX호", LocalDateTime.now()); - OrderTable orderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); - Order eatInOrderRequest = createEatInOrder(List.of(undisplayMenuOrderItem), orderTable.getId(), LocalDateTime.now()); - - assertThatIllegalStateException() - .isThrownBy(() -> orderService.create(takeOutRequest)); - assertThatIllegalStateException() - .isThrownBy(() -> orderService.create(deliveryOrderRequest)); - assertThatIllegalStateException() - .isThrownBy(() -> orderService.create(eatInOrderRequest)); - } - - @DisplayName("메뉴의 가격과 주문 내역의 가격은 동일해야 한다") - @Test - void validateOrderPrice() { - BigDecimal menuPrice = menuRepository.findById(DISPLAY_MENU_ID).get().getPrice(); - - OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, menuPrice.add(BigDecimal.ONE), 1); - Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); - Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XX호", LocalDateTime.now()); - OrderTable orderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); - Order eatInOrderRequest = createEatInOrder(List.of(orderLineItem), orderTable.getId(), LocalDateTime.now()); - - assertThatIllegalArgumentException() - .isThrownBy(() -> orderService.create(takeOutRequest)); - assertThatIllegalArgumentException() - .isThrownBy(() -> orderService.create(deliveryOrderRequest)); - assertThatIllegalArgumentException() - .isThrownBy(() -> orderService.create(eatInOrderRequest)); - } - - @DisplayName("배달의 경우, 배달 주소가 반드시 입력되어야 하며, 공백만 입력되어서는 안된다") - @ParameterizedTest - @NullAndEmptySource - void notNullOrNotEmpty(String deliveryAddress) { - OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), deliveryAddress, LocalDateTime.now()); - - assertThatIllegalArgumentException() - .isThrownBy(() -> orderService.create(deliveryOrderRequest)); - } - - @DisplayName("매장 내 취식일 경우, 고객에게 배정된 주문 테이블이 있어야 한다") - @Test - void validateOrderTable() { - UUID unknownTableId = UUID.randomUUID(); - OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - Order eatInOrderRequest = createEatInOrder(List.of(orderLineItem), unknownTableId, LocalDateTime.now()); - - assertThatThrownBy(() -> orderService.create(eatInOrderRequest)) - .isInstanceOf(NoSuchElementException.class); - } - - @DisplayName("매장 내 취식일 경우, 주문 테이블의 사용유무가 사용 중이어야 한다") - @Test - void validateOrderTableStatus() { - boolean tableOccupied = false; - OrderTable orderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(ORDER_TABLE_ID, "1번테이블", tableOccupied, 0)); - OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - Order eatInOrderRequest = createEatInOrder(List.of(orderLineItem), orderTable.getId(), LocalDateTime.now()); - - assertThatIllegalStateException() - .isThrownBy(() -> orderService.create(eatInOrderRequest)); - } - //endregion - - //region [주문 수락] - @DisplayName("대기 중인 주문을 수락한다") - @Test - void acceptOrderStatus() { - OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); - Order takeOutOrder = orderService.create(takeOutRequest); - - Order acceptOrder = orderService.accept(takeOutOrder.getId()); - - assertThat(acceptOrder.getStatus()).isEqualTo(OrderStatus.ACCEPTED); - } - - @DisplayName("주문의 상태가 대기(WAITING)일 때 주문 수락이 가능하다") - @EnumSource(value = OrderStatus.class, names = "WAITING", mode = EnumSource.Mode.EXCLUDE) - @ParameterizedTest - void validateAcceptStatus(OrderStatus orderStatus) { - OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); - Order takeOutOrder = orderService.create(takeOutRequest); - - takeOutOrder.setStatus(orderStatus); - assertThatIllegalStateException() - .isThrownBy(() -> orderService.accept(takeOutOrder.getId())); - } - //endregion - - //region [음식 제공됨] - @DisplayName("주문 상태를 음식 제공됨(SERVED)로 변경한다") - @Test - void served() { - OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); - Order takeOutOrder = orderService.create(takeOutRequest); - Order acceptOrder = orderService.accept(takeOutOrder.getId()); - - Order servedOrder = orderService.serve(acceptOrder.getId()); - - assertThat(servedOrder.getStatus()).isEqualTo(OrderStatus.SERVED); - } - - @DisplayName("주문의 상태가 주문 수락(ACCEPTED)일 때 음식 제공 가능하다") - @EnumSource(value = OrderStatus.class, names = "ACCEPTED", mode = EnumSource.Mode.EXCLUDE) - @ParameterizedTest - void validateServedStatus(OrderStatus orderStatus) { - OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); - Order takeOutOrder = orderService.create(takeOutRequest); - - takeOutOrder.setStatus(orderStatus); - assertThatIllegalStateException() - .isThrownBy(() -> orderService.serve(takeOutOrder.getId())); - } - //endregion - - //region [배달 시작] - @DisplayName("배달 주문의 경우 음식이 제공되면 주문 상태를 배달 중(DELIVERING)으로 변경한다") - @Test - void startDelivery() { - OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", LocalDateTime.now()); - Order order = orderService.create(deliveryOrderRequest); - - order.setStatus(OrderStatus.SERVED); - Order deliveryStartorder = orderService.startDelivery(order.getId()); - - assertThat(deliveryStartorder.getStatus()).isEqualTo(OrderStatus.DELIVERING); - } - - @DisplayName("주문 상태가 음식 제공됨(SERVED)인 경우, 배달 시작이 가능하다") - @EnumSource(value = OrderStatus.class, names = "SERVED", mode = EnumSource.Mode.EXCLUDE) - @ParameterizedTest - void validateDeliveryStartStatus(OrderStatus orderStatus) { - OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", LocalDateTime.now()); - Order order = orderService.create(deliveryOrderRequest); - - order.setStatus(orderStatus); - assertThatIllegalStateException() - .isThrownBy(() -> orderService.startDelivery(order.getId())); - } - //endregion - - //region [배달 완료] - @DisplayName("배달 완료한 주문 상태를 배달완료(DELIVERED)로 변경한다") - @Test - void endDelivery() { - OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", LocalDateTime.now()); - Order order = orderService.create(deliveryOrderRequest); - - order.setStatus(OrderStatus.DELIVERING); - Order deliveryStartorder = orderService.completeDelivery(order.getId()); - - assertThat(deliveryStartorder.getStatus()).isEqualTo(OrderStatus.DELIVERED); - } - - @DisplayName("주문 상태가 배달 중(DELIVERING)인 경우, 배달완료(DELIVERED)로 변경 가능하다") - @ParameterizedTest - @EnumSource(value = OrderStatus.class, names = "DELIVERING", mode = EnumSource.Mode.EXCLUDE) - void validateDeliveryEndStatus(OrderStatus orderStatus) { - OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", LocalDateTime.now()); - Order order = orderService.create(deliveryOrderRequest); - - order.setStatus(orderStatus); - assertThatIllegalStateException() - .isThrownBy(() -> orderService.completeDelivery(order.getId())); - } - //endregion - - //region [주문 완료] - @DisplayName("배달 주문의 상태를 주문 완료로 변경한다") - @Test - void complete() { - //given - OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", LocalDateTime.now()); - Order order = createDeliveredOrder(deliveryOrderRequest); - //when - Order complete = orderService.complete(order.getId()); - //then - assertThat(complete.getStatus()).isEqualTo(OrderStatus.COMPLETED); - } - - @DisplayName("배달 주문의 경우, 주문의 상태가 배달 완료(DELIVERED)인 경우만 주문을 완료할 수 있다") - @EnumSource(value = OrderStatus.class, names = "DELIVERED", mode = EnumSource.Mode.EXCLUDE) - @ParameterizedTest - void completeOrderByDelivery(OrderStatus orderStatus) { - OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", LocalDateTime.now()); - Order order = orderService.create(deliveryOrderRequest); - - order.setStatus(orderStatus); - assertThatIllegalStateException() - .isThrownBy(() -> orderService.complete(order.getId())); - } - - @DisplayName("포장 주문의 상태를 주문 완료로 변경한다") - @Test - void completeByTakeOut() { - //given - OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); - Order servedOrder = createServedOrder(takeOutRequest); - //when - Order complete = orderService.complete(servedOrder.getId()); - //then - assertThat(complete.getStatus()).isEqualTo(OrderStatus.COMPLETED); - } - - @DisplayName("매장 내 취식 주문 상태를 주문 완료로 변경한다") - @Test - void completeByEatIn() { - OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - OrderTable orderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); - Order eatInRequest = createEatInOrder(List.of(orderLineItem), orderTable.getId(), LocalDateTime.now()); - Order servedOrder = createServedOrder(eatInRequest); - //when - Order complete = orderService.complete(servedOrder.getId()); - //then - assertThat(complete.getStatus()).isEqualTo(OrderStatus.COMPLETED); - } - - @DisplayName("포장/매장 내 취식의 경우, 주문의 상태가 음식 제공됨(SERVED)인 경우만 주문을 완료할 수 있다") - @EnumSource(value = OrderStatus.class, names = "SERVED", mode = EnumSource.Mode.EXCLUDE) - @ParameterizedTest - void completeOrderByEatInOrTakeOut(OrderStatus orderStatus) { - //given - OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); - - OrderTable orderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); - Order eatInRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); - - Order takeoutOrder = orderService.create(takeOutRequest); - Order eatInOrder = orderService.create(eatInRequest); - //when - takeoutOrder.setStatus(orderStatus); - eatInOrder.setStatus(orderStatus); - //then - assertThatIllegalStateException() - .isThrownBy(() -> orderService.complete(takeoutOrder.getId())); - assertThatIllegalStateException() - .isThrownBy(() -> orderService.complete(eatInOrder.getId())); - } - - @DisplayName("매장 내 식사의 경우, 주문 테이블의 모든 주문이 완료 상태가 아닐 때 테이블은 사용 중이며 손님의 수는 0으로 초기화되지 않는다") - @Test - void completeOrderByEatIn() { - //given - OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - OrderTable orderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); - Order eatInRequest = createEatInOrder(List.of(orderLineItem), orderTable.getId(), LocalDateTime.now()); - //주문 상태가 SERVED인 주문1,2 생성 - Order servedOrder1 = createServedOrder(eatInRequest); - Order servedOrder2 = createServedOrder(eatInRequest); - - //when - Order complete = orderService.complete(servedOrder1.getId()); - - //then - assertThat(complete.getStatus()).isEqualTo(OrderStatus.COMPLETED); - assertThat(complete.getOrderTable().isOccupied()).isTrue(); - assertThat(complete.getOrderTable().getNumberOfGuests()).isNotZero(); - } - - @DisplayName("매장 내 취식의 경우, 주문 테이블에의 모든 주문이 완료되면 테이블의 사용유무를 안함으로 변경하고 고객의 수를 0명으로 변경한다") - @Test - void clearOrderTable() { - //given - OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - OrderTable orderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); - Order eatInRequest = createEatInOrder(List.of(orderLineItem), orderTable.getId(), LocalDateTime.now()); - - Order servedOrder1 = createServedOrder(eatInRequest); - Order servedOrder2 = createServedOrder(eatInRequest); - - //when - Order complete1 = orderService.complete(servedOrder1.getId()); - Order complete2 = orderService.complete(servedOrder2.getId()); - - //then - assertThat(complete1.getStatus()).isEqualTo(OrderStatus.COMPLETED); - assertThat(complete1.getOrderTable().isOccupied()).isFalse(); - assertThat(complete1.getOrderTable().getNumberOfGuests()).isZero(); - - assertThat(complete2.getStatus()).isEqualTo(OrderStatus.COMPLETED); - assertThat(complete2.getOrderTable().isOccupied()).isFalse(); - assertThat(complete2.getOrderTable().getNumberOfGuests()).isZero(); - } - //endregion - //region [주문 조회] @DisplayName("모든 주문들을 조회할 수 있다") @Test diff --git a/src/test/java/kitchenpos/application/OrderTableServiceTest.java b/src/test/java/kitchenpos/application/OrderTableServiceTest.java index 3ec9d16d7..e1532cb93 100644 --- a/src/test/java/kitchenpos/application/OrderTableServiceTest.java +++ b/src/test/java/kitchenpos/application/OrderTableServiceTest.java @@ -3,6 +3,7 @@ import kitchenpos.application.fixture.*; import kitchenpos.domain.*; import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.EnumSource; @@ -37,38 +38,41 @@ class OrderTableServiceTest { @Autowired private MenuGroupRepository menuGroupRepository; - //region [주문 테이블 등록] - @DisplayName("주문 테이블의 이름을 지정하여 생성할 수 있다") - @Test - void createOrderTable() { - OrderTable request = OrderTableFixture.createOrderTable("1번테이블"); + @DisplayName("주문 테이블을 등록할 수 있다") + @Nested + class OrderTableCreator { - OrderTable orderTable = orderTableService.create(request); + @DisplayName("주문 테이블의 이름을 지정하여 생성할 수 있다") + @Test + void createOrderTable() { + OrderTable request = OrderTableFixture.createOrderTable("1번테이블"); - assertThat(orderTable.getName()).isEqualTo("1번테이블"); - } + OrderTable orderTable = orderTableService.create(request); - @DisplayName("주문 테이블의 이름은 공백만 입력할 수 없으며 반드시 입력되어야 한다") - @NullAndEmptySource - @ParameterizedTest - void notNullTableName(String name) { - OrderTable request = OrderTableFixture.createOrderTable(name); + assertThat(orderTable.getName()).isEqualTo("1번테이블"); + } - assertThatIllegalArgumentException() - .isThrownBy(() -> orderTableService.create(request)); - } + @DisplayName("주문 테이블의 이름은 공백만 입력할 수 없으며 반드시 입력되어야 한다") + @NullAndEmptySource + @ParameterizedTest + void notNullTableName(String name) { + OrderTable request = OrderTableFixture.createOrderTable(name); - @DisplayName("주문 테이블 생성 시, 고객의 수는 0명, 테이블의 사용유무는 사용안함이다") - @Test - void createOrderTableWithNullName() { - OrderTable request = OrderTableFixture.createOrderTable("1번"); + assertThatIllegalArgumentException() + .isThrownBy(() -> orderTableService.create(request)); + } + + @DisplayName("주문 테이블 생성 시, 고객의 수는 0명, 테이블의 사용유무는 사용안함이다") + @Test + void createOrderTableWithNullName() { + OrderTable request = OrderTableFixture.createOrderTable("1번"); - OrderTable orderTable = orderTableService.create(request); + OrderTable orderTable = orderTableService.create(request); - assertThat(orderTable.getNumberOfGuests()).isZero(); - assertThat(orderTable.isOccupied()).isFalse(); + assertThat(orderTable.getNumberOfGuests()).isZero(); + assertThat(orderTable.isOccupied()).isFalse(); + } } - //endregion //region [고객을 주문 테이블에 배정] @DisplayName("주문 테이블에 고객이 배정되면 테이블의 사용유무가 사용 중으로 바뀐다") @@ -82,67 +86,74 @@ void sit() { } //endregion - //region [주문테이블 정리] - @DisplayName("테이블의 주문 상태가 완료가 아니면 정리할 수 없다") - @EnumSource(value = OrderStatus.class, names = "COMPLETED", mode = EnumSource.Mode.EXCLUDE) - @ParameterizedTest - void validateOrderStatus(OrderStatus status) { - //given - OrderTable orderTable = orderTableService.create(OrderTableFixture.createOrderTable("1번테이블")); - orderTableService.sit(orderTable.getId()); - orderTable.setNumberOfGuests(4); - orderTableService.changeNumberOfGuests(orderTable.getId(), orderTable); - - Order order = createUnnamedOrder(orderTable.getId()); - //when, then - order.setStatus(status); - assertThatIllegalStateException() - .isThrownBy(() -> orderTableService.clear(orderTable.getId())); + @Nested + @DisplayName("주문 테이블을 정리할 수 있다") + class TableCleaner { + + @DisplayName("테이블의 주문 상태가 완료가 아니면 정리할 수 없다") + @EnumSource(value = OrderStatus.class, names = "COMPLETED", mode = EnumSource.Mode.EXCLUDE) + @ParameterizedTest + void validateOrderStatus(OrderStatus status) { + //given + OrderTable orderTable = orderTableService.create(OrderTableFixture.createOrderTable("1번테이블")); + orderTableService.sit(orderTable.getId()); + orderTable.setNumberOfGuests(4); + orderTableService.changeNumberOfGuests(orderTable.getId(), orderTable); + + Order order = createUnnamedOrder(orderTable.getId()); + //when, then + order.setStatus(status); + assertThatIllegalStateException() + .isThrownBy(() -> orderTableService.clear(orderTable.getId())); + } + + @DisplayName("테이블 정리하면 손님의 수 0명, 테이블 사용유무 안함으로 변경된다") + @Test + void clear() { + //given + OrderTable orderTable = orderTableService.create(OrderTableFixture.createOrderTable("1번테이블")); + orderTableService.sit(orderTable.getId()); + orderTable.setNumberOfGuests(4); + orderTableService.changeNumberOfGuests(orderTable.getId(), orderTable); + + Order order = createUnnamedOrder(orderTable.getId()); + //when + order.setStatus(OrderStatus.COMPLETED); + OrderTable clearOrder = orderTableService.clear(orderTable.getId()); + //then + assertThat(clearOrder.getNumberOfGuests()).isZero(); + assertThat(clearOrder.isOccupied()).isFalse(); + } } - @DisplayName("테이블 정리하면 손님의 수 0명, 테이블 사용유무 안함으로 변경된다") - @Test - void clear() { - //given - OrderTable orderTable = orderTableService.create(OrderTableFixture.createOrderTable("1번테이블")); - orderTableService.sit(orderTable.getId()); - orderTable.setNumberOfGuests(4); - orderTableService.changeNumberOfGuests(orderTable.getId(), orderTable); - - Order order = createUnnamedOrder(orderTable.getId()); - //when - order.setStatus(OrderStatus.COMPLETED); - OrderTable clearOrder = orderTableService.clear(orderTable.getId()); - //then - assertThat(clearOrder.getNumberOfGuests()).isZero(); - assertThat(clearOrder.isOccupied()).isFalse(); - } - //endregion + @DisplayName("주문 테이블의 고객의 수를 변경할 수 있다") + @Nested + class GuestNumberUpdater { - //region [고객의 수 변경] - @DisplayName("테이블의 고객 수를 0미만으로 변경할 수 없다") - @Test - void changeNumberOfGuestsByNegative() { - OrderTable orderTable = orderTableService.create(OrderTableFixture.createOrderTable("1번테이블")); + @DisplayName("테이블의 고객 수를 0미만으로 변경할 수 없다") + @Test + void changeNumberOfGuestsByNegative() { + OrderTable orderTable = orderTableService.create(OrderTableFixture.createOrderTable("1번테이블")); - orderTable.setNumberOfGuests(-1); + orderTable.setNumberOfGuests(-1); - assertThatIllegalArgumentException() - .isThrownBy(() -> orderTableService.changeNumberOfGuests(orderTable.getId(), orderTable)); - } + assertThatIllegalArgumentException() + .isThrownBy(() -> orderTableService.changeNumberOfGuests(orderTable.getId(), orderTable)); + } - @DisplayName("테이블의 사용유무가 사용안함이면 손님의 수를 변경할 수 없다") - @Test - void changeNumberOfGuestsByUnUse() { - OrderTable orderTable = orderTableService.create(OrderTableFixture.createOrderTable("1번테이블")); + @DisplayName("테이블의 사용유무가 사용안함이면 손님의 수를 변경할 수 없다") + @Test + void changeNumberOfGuestsByUnUse() { + OrderTable orderTable = orderTableService.create(OrderTableFixture.createOrderTable("1번테이블")); - orderTable.setOccupied(false); - orderTable.setNumberOfGuests(10); + orderTable.setOccupied(false); + orderTable.setNumberOfGuests(10); + + assertThatIllegalStateException() + .isThrownBy(() -> orderTableService.changeNumberOfGuests(orderTable.getId(), orderTable)); + } - assertThatIllegalStateException() - .isThrownBy(() -> orderTableService.changeNumberOfGuests(orderTable.getId(), orderTable)); } - //endregion //region [모든 주문 테이블 조회] @DisplayName("모든 테이블 조회가 가능하다") diff --git a/src/test/java/kitchenpos/application/ProductServiceTest.java b/src/test/java/kitchenpos/application/ProductServiceTest.java index 49f25bb8b..3e50c208d 100644 --- a/src/test/java/kitchenpos/application/ProductServiceTest.java +++ b/src/test/java/kitchenpos/application/ProductServiceTest.java @@ -11,12 +11,13 @@ import kitchenpos.infra.PurgomalumClient; import org.assertj.core.groups.Tuple; import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Nested; 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 org.springframework.transaction.annotation.Transactional; +import org.springframework.test.context.TestConstructor; import java.math.BigDecimal; import java.util.List; @@ -25,7 +26,7 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException; -@Transactional +@TestConstructor(autowireMode = TestConstructor.AutowireMode.ALL) @SpringBootTest class ProductServiceTest { @@ -41,106 +42,113 @@ class ProductServiceTest { @Autowired private MenuGroupService menuGroupService; - //region [상품 등록] - @DisplayName("상품명과 가격을 입력하여 상품을 생성한다") - @Test - void createProduct() { - Product request = ProductFixture.createProduct("치킨버거", new BigDecimal(7000)); + @DisplayName("상품을 생성할 수 있다") + @Nested + class ProductCreator { - Product product = productService.create(request); + @DisplayName("상품명과 가격을 입력하여 상품을 생성한다") + @Test + void createProduct() { + Product request = ProductFixture.createProduct("치킨버거", new BigDecimal(7000)); - assertThat(product) - .extracting(Product::getName, Product::getPrice) - .containsExactly("치킨버거", new BigDecimal(7000)); - } + Product product = productService.create(request); - @DisplayName("상품명은 반드시 입력되어야 한다") - @Test - void notNullProductName() { - Product request = ProductFixture.createProduct(null, new BigDecimal(7000)); + assertThat(product) + .extracting(Product::getName, Product::getPrice) + .containsExactly("치킨버거", new BigDecimal(7000)); + } - assertThatIllegalArgumentException() - .isThrownBy(() -> productService.create(request)); - } + @DisplayName("상품명은 반드시 입력되어야 한다") + @Test + void notNullProductName() { + Product request = ProductFixture.createProduct(null, new BigDecimal(7000)); - @DisplayName("가격은 반드시 입력되어야 한다") - @Test - void notNullProductPrice() { - Product request = ProductFixture.createProduct("치킨버거", null); + assertThatIllegalArgumentException() + .isThrownBy(() -> productService.create(request)); + } - assertThatIllegalArgumentException() - .isThrownBy(() -> productService.create(request)); - } + @DisplayName("가격은 반드시 입력되어야 한다") + @Test + void notNullProductPrice() { + Product request = ProductFixture.createProduct("치킨버거", null); - @DisplayName("상품명은 비속어가 있으면 등록할 수 없다") - @Test - void validateProductName() { - Mockito.when(purgomalumClient.containsProfanity("bad word")).thenReturn(true); - Product request = ProductFixture.createProduct("bad word", new BigDecimal(7000)); + assertThatIllegalArgumentException() + .isThrownBy(() -> productService.create(request)); + } - assertThatIllegalArgumentException() - .isThrownBy(() -> productService.create(request)); - } + @DisplayName("상품명은 비속어가 있으면 등록할 수 없다") + @Test + void validateProductName() { + Mockito.when(purgomalumClient.containsProfanity("bad word")).thenReturn(true); + Product request = ProductFixture.createProduct("bad word", new BigDecimal(7000)); - @DisplayName("상품의 가격은 0원 이상이어야 한다") - @Test - void validatePriceOnCreate() { - Product request = ProductFixture.createProduct("치킨버거", new BigDecimal(-1)); + assertThatIllegalArgumentException() + .isThrownBy(() -> productService.create(request)); + } - assertThatIllegalArgumentException() - .isThrownBy(() -> productService.create(request)); - } - //endregion + @DisplayName("상품의 가격은 0원 이상이어야 한다") + @Test + void validatePriceOnCreate() { + Product request = ProductFixture.createProduct("치킨버거", new BigDecimal(-1)); - //region [상품 수정] - @DisplayName("상품의 가격을 수정할 수 있다") - @Test - void modifyPrice() { - Product product = productService.create(ProductFixture.createProduct(UUID.randomUUID(), "치킨버거", new BigDecimal(7000))); - - product.setPrice(new BigDecimal(8000)); - Product modifiedProduct = productService.changePrice(product.getId(), product); - - assertThat(modifiedProduct.getPrice()).isEqualTo(new BigDecimal(8000)); - } + assertThatIllegalArgumentException() + .isThrownBy(() -> productService.create(request)); + } - @DisplayName("상품의 가격은 0원 이상인 경우만 수정 가능하다") - @Test - void validatePriceOnModify() { - Product product = productService.create(ProductFixture.createProduct(UUID.randomUUID(), "치킨버거", new BigDecimal(7000))); - - assertThatIllegalArgumentException() - .isThrownBy(() -> productService.changePrice(product.getId(), ProductFixture.createProduct("치킨버거", new BigDecimal(-1)))); } - @DisplayName("메뉴의 가격이 메뉴에 속한 상품들의 가격 총 합보다 클 경우, 유효하지 않은 메뉴이므로 메뉴판에 전시할 수 없다") - @Test - void validatePriceBySetMenu() { - //given - Product chicken = productService.create(ProductFixture.createProduct("후라이드치킨", new BigDecimal(25000))); - Product coke = productService.create(ProductFixture.createProduct("콜라", new BigDecimal(2500))); - - MenuGroup menuGroup = menuGroupService.create(MenuGroupFixture.createMenuGroup("세트메뉴")); - - MenuProduct chickenMenuProduct = MenuProductFixture.createMenuProduct(chicken, 1); - MenuProduct cokeMenuProduct = MenuProductFixture.createMenuProduct(coke, 1); - - BigDecimal productSum = chicken.getPrice().add(coke.getPrice()); - Menu menu = MenuFixture.createMenu( - menuGroup.getId(), - "후라이드치킨세트", - productSum, - List.of(chickenMenuProduct, cokeMenuProduct) - ); - Menu chickenSet = menuService.create(menu); - //when - BigDecimal newPrice = chicken.getPrice().add(new BigDecimal(1000)); - chicken.setPrice(newPrice); - productService.changePrice(chicken.getId(), chicken); - //when - assertThat(chickenSet.isDisplayed()).isFalse(); + @DisplayName("상품의 가격을 수정할 수 있다") + @Nested + class ProductPriceUpdater { + + @DisplayName("상품의 가격을 수정할 수 있다") + @Test + void modifyPrice() { + Product product = productService.create(ProductFixture.createProduct(UUID.randomUUID(), "치킨버거", new BigDecimal(7000))); + + product.setPrice(new BigDecimal(8000)); + Product modifiedProduct = productService.changePrice(product.getId(), product); + + assertThat(modifiedProduct.getPrice()).isEqualTo(new BigDecimal(8000)); + } + + @DisplayName("상품의 가격은 0원 이상인 경우만 수정 가능하다") + @Test + void validatePriceOnModify() { + Product product = productService.create(ProductFixture.createProduct(UUID.randomUUID(), "치킨버거", new BigDecimal(7000))); + + assertThatIllegalArgumentException() + .isThrownBy(() -> productService.changePrice(product.getId(), ProductFixture.createProduct("치킨버거", new BigDecimal(-1)))); + } + + @DisplayName("메뉴의 가격이 메뉴에 속한 상품들의 가격 총 합보다 클 경우, 유효하지 않은 메뉴이므로 메뉴판에 전시할 수 없다") + @Test + void validatePriceBySetMenu() { + //given + Product chicken = productService.create(ProductFixture.createProduct("후라이드치킨", new BigDecimal(25000))); + Product coke = productService.create(ProductFixture.createProduct("콜라", new BigDecimal(2500))); + + MenuGroup menuGroup = menuGroupService.create(MenuGroupFixture.createMenuGroup("세트메뉴")); + + MenuProduct chickenMenuProduct = MenuProductFixture.createMenuProduct(chicken, 1); + MenuProduct cokeMenuProduct = MenuProductFixture.createMenuProduct(coke, 1); + + BigDecimal productSum = chicken.getPrice().add(coke.getPrice()); + Menu menu = MenuFixture.createMenu( + menuGroup.getId(), + "후라이드치킨세트", + productSum, + List.of(chickenMenuProduct, cokeMenuProduct) + ); + Menu chickenSet = menuService.create(menu); + //when + BigDecimal newPrice = chicken.getPrice().add(new BigDecimal(1000)); + chicken.setPrice(newPrice); + productService.changePrice(chicken.getId(), chicken); + //when + assertThat(chickenSet.isDisplayed()).isFalse(); + } } - //endregion //region [메뉴 조회] @DisplayName("모든 메뉴를 조회할 수 있다") From c41369b0c969bde1e18dace8ca36d54745907d75 Mon Sep 17 00:00:00 2001 From: skdev0619 Date: Wed, 5 Feb 2025 14:11:21 +0900 Subject: [PATCH 15/29] =?UTF-8?q?AssertAll=20=EC=A0=81=EC=9A=A9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../application/MenuGroupServiceTest.java | 9 +- .../application/MenuServiceTest.java | 46 ++++--- .../application/OrderServiceTest.java | 126 ++++++++++-------- 3 files changed, 106 insertions(+), 75 deletions(-) diff --git a/src/test/java/kitchenpos/application/MenuGroupServiceTest.java b/src/test/java/kitchenpos/application/MenuGroupServiceTest.java index b09bff283..1f80ce848 100644 --- a/src/test/java/kitchenpos/application/MenuGroupServiceTest.java +++ b/src/test/java/kitchenpos/application/MenuGroupServiceTest.java @@ -15,6 +15,7 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException; +import static org.junit.jupiter.api.Assertions.assertAll; @Transactional @SpringBootTest @@ -58,9 +59,11 @@ void findAll() { List menuGroups = menuGroupService.findAll(); - assertThat(menuGroups.size()).isEqualTo(3); - assertThat(menuGroups).extracting(MenuGroup::getName) - .contains("버거", "세트메뉴", "사이드"); + assertAll( + () -> assertThat(menuGroups.size()).isEqualTo(3), + () -> assertThat(menuGroups).extracting(MenuGroup::getName) + .contains("버거", "세트메뉴", "사이드") + ); } } diff --git a/src/test/java/kitchenpos/application/MenuServiceTest.java b/src/test/java/kitchenpos/application/MenuServiceTest.java index 7293a86b2..85d6028fa 100644 --- a/src/test/java/kitchenpos/application/MenuServiceTest.java +++ b/src/test/java/kitchenpos/application/MenuServiceTest.java @@ -27,6 +27,7 @@ import java.util.UUID; import static org.assertj.core.api.Assertions.*; +import static org.junit.jupiter.api.Assertions.assertAll; @Transactional @SpringBootTest @@ -69,12 +70,14 @@ void createMenuByProduct() { Menu resultMenu = menuService.create(menu); - assertThat(resultMenu.getName()).isEqualTo("치킨버거"); - assertThat(resultMenu.getPrice()).isEqualTo(new BigDecimal(7000)); - assertThat(resultMenu.isDisplayed()).isFalse(); - assertThat(resultMenu.getMenuProducts()).hasSize(1); - assertThat(resultMenu.getMenuGroup()).isNotNull(); - assertThat(resultMenu.getMenuGroup().getId()).isEqualTo(MENU_GROUP_ID); + assertAll( + () -> assertThat(resultMenu.getName()).isEqualTo("치킨버거"), + () -> assertThat(resultMenu.getPrice()).isEqualTo(new BigDecimal(7000)), + () -> assertThat(resultMenu.isDisplayed()).isFalse(), + () -> assertThat(resultMenu.getMenuProducts()).hasSize(1), + () -> assertThat(resultMenu.getMenuGroup()).isNotNull(), + () -> assertThat(resultMenu.getMenuGroup().getId()).isEqualTo(MENU_GROUP_ID) + ); } @DisplayName("여러 상품으로 조합하여 하나의 메뉴를 등록할 수 있다") @@ -94,11 +97,13 @@ void createMenuByProducts() { //when Menu resultMenu = menuService.create(menu); //then - assertThat(resultMenu.getName()).isEqualTo("치킨버거세트"); - assertThat(resultMenu.getPrice()).isEqualTo(new BigDecimal(10000)); - assertThat(resultMenu.getMenuProducts()).hasSize(3); - assertThat(resultMenu.getMenuGroup()).isNotNull(); - assertThat(resultMenu.getMenuGroup().getId()).isEqualTo(MENU_GROUP_ID); + assertAll( + () -> assertThat(resultMenu.getName()).isEqualTo("치킨버거세트"), + () -> assertThat(resultMenu.getPrice()).isEqualTo(new BigDecimal(10000)), + () -> assertThat(resultMenu.getMenuProducts()).hasSize(3), + () -> assertThat(resultMenu.getMenuGroup()).isNotNull(), + () -> assertThat(resultMenu.getMenuGroup().getId()).isEqualTo(MENU_GROUP_ID) + ); } @DisplayName("각 메뉴를 구성하는 상품의 수량은 0이상이어야 한다") @@ -317,14 +322,17 @@ void findAll() { menuService.create(MenuFixture.createMenu(MENU_GROUP_ID, "콜라", new BigDecimal(2000), List.of(coke))); List allMenus = menuService.findAll(); - assertThat(allMenus.size()).isEqualTo(3); - assertThat(allMenus) - .extracting(Menu::getName, menu -> menu.getPrice().intValue()) - .contains( - Tuple.tuple("치킨버거", 7000), - Tuple.tuple("감자튀김", 2000), - Tuple.tuple("콜라", 2000) - ); + + assertAll( + () -> assertThat(allMenus.size()).isEqualTo(3), + () -> assertThat(allMenus) + .extracting(Menu::getName, menu -> menu.getPrice().intValue()) + .contains( + Tuple.tuple("치킨버거", 7000), + Tuple.tuple("감자튀김", 2000), + Tuple.tuple("콜라", 2000) + ) + ); } //endregion } diff --git a/src/test/java/kitchenpos/application/OrderServiceTest.java b/src/test/java/kitchenpos/application/OrderServiceTest.java index 925253cce..1eed5d660 100644 --- a/src/test/java/kitchenpos/application/OrderServiceTest.java +++ b/src/test/java/kitchenpos/application/OrderServiceTest.java @@ -24,6 +24,7 @@ import java.util.stream.Stream; import static org.assertj.core.api.Assertions.*; +import static org.junit.jupiter.api.Assertions.assertAll; @Transactional @SpringBootTest @@ -87,11 +88,13 @@ void takeOutOrder() { Order orderResult = orderService.create(orderRequest); - assertThat(orderResult.getType()).isEqualTo(OrderType.TAKEOUT); - assertThat(orderResult.getOrderLineItems()).isNotNull(); - assertThat(orderResult.getOrderLineItems()).hasSize(1); - assertThat(orderResult.getDeliveryAddress()).isNull(); - assertThat(orderResult.getStatus()).isEqualTo(OrderStatus.WAITING); + assertAll( + () -> assertThat(orderResult.getType()).isEqualTo(OrderType.TAKEOUT), + () -> assertThat(orderResult.getOrderLineItems()).isNotNull(), + () -> assertThat(orderResult.getOrderLineItems()).hasSize(1), + () -> assertThat(orderResult.getDeliveryAddress()).isNull(), + () -> assertThat(orderResult.getStatus()).isEqualTo(OrderStatus.WAITING) + ); } @DisplayName("배달 주문을 생성한다. 주문이 정상적으로 생성되면 상태는 대기 중으로 변경된다") @@ -102,12 +105,14 @@ void deliveryOrder() { Order orderResult = orderService.create(orderRequest); - assertThat(orderResult.getType()).isEqualTo(OrderType.DELIVERY); - assertThat(orderResult.getOrderLineItems()).isNotNull(); - assertThat(orderResult.getOrderLineItems()).hasSize(1); - assertThat(orderResult.getDeliveryAddress()).isNotNull(); - assertThat(orderResult.getDeliveryAddress()).isEqualTo("경기도 고양시..XX동 XX호"); - assertThat(orderResult.getStatus()).isEqualTo(OrderStatus.WAITING); + assertAll( + () -> assertThat(orderResult.getType()).isEqualTo(OrderType.DELIVERY), + () -> assertThat(orderResult.getOrderLineItems()).isNotNull(), + () -> assertThat(orderResult.getOrderLineItems()).hasSize(1), + () -> assertThat(orderResult.getDeliveryAddress()).isNotNull(), + () -> assertThat(orderResult.getDeliveryAddress()).isEqualTo("경기도 고양시..XX동 XX호"), + () -> assertThat(orderResult.getStatus()).isEqualTo(OrderStatus.WAITING) + ); } @DisplayName("매장 내 식사 주문을 생성한다. 주문이 정상적으로 생성되면 상태는 대기 중으로 변경된다") @@ -121,11 +126,13 @@ void eatInOrder() { Order orderResult = orderService.create(orderRequest); - assertThat(orderResult.getType()).isEqualTo(OrderType.EAT_IN); - assertThat(orderResult.getOrderLineItems()).isNotNull(); - assertThat(orderResult.getOrderLineItems()).hasSize(1); - assertThat(orderResult.getDeliveryAddress()).isNull(); - assertThat(orderResult.getStatus()).isEqualTo(OrderStatus.WAITING); + assertAll( + () -> assertThat(orderResult.getType()).isEqualTo(OrderType.EAT_IN), + () -> assertThat(orderResult.getOrderLineItems()).isNotNull(), + () -> assertThat(orderResult.getOrderLineItems()).hasSize(1), + () -> assertThat(orderResult.getDeliveryAddress()).isNull(), + () -> assertThat(orderResult.getStatus()).isEqualTo(OrderStatus.WAITING) + ); } @DisplayName("어떤 메뉴를 몇 개 시킬지에 대한 주문 상세 내역이 1개 이상 있어야 한다") @@ -137,12 +144,14 @@ void notNullOrderLineItems(List orderLineItems) { OrderTable orderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); Order eatInOrderRequest = createEatInOrder(orderLineItems, orderTable.getId(), LocalDateTime.now()); - assertThatIllegalArgumentException() - .isThrownBy(() -> orderService.create(takeOutRequest)); - assertThatIllegalArgumentException() - .isThrownBy(() -> orderService.create(deliveryOrderRequest)); - assertThatIllegalArgumentException() - .isThrownBy(() -> orderService.create(eatInOrderRequest)); + assertAll( + () -> assertThatIllegalArgumentException() + .isThrownBy(() -> orderService.create(takeOutRequest)), + () -> assertThatIllegalArgumentException() + .isThrownBy(() -> orderService.create(deliveryOrderRequest)), + () -> assertThatIllegalArgumentException() + .isThrownBy(() -> orderService.create(eatInOrderRequest)) + ); } private static Stream nullOrEmptyList() { @@ -157,10 +166,12 @@ void validateQuantity() { Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XX호", LocalDateTime.now()); - assertThatIllegalArgumentException() - .isThrownBy(() -> orderService.create(takeOutRequest)); - assertThatIllegalArgumentException() - .isThrownBy(() -> orderService.create(deliveryOrderRequest)); + assertAll( + () -> assertThatIllegalArgumentException() + .isThrownBy(() -> orderService.create(takeOutRequest)), + () -> assertThatIllegalArgumentException() + .isThrownBy(() -> orderService.create(deliveryOrderRequest)) + ); } @DisplayName("메뉴판에 전시하지 않은 메뉴는 주문할 수 없다") @@ -172,12 +183,14 @@ void validateMenuOrder() { OrderTable orderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); Order eatInOrderRequest = createEatInOrder(List.of(undisplayMenuOrderItem), orderTable.getId(), LocalDateTime.now()); - assertThatIllegalStateException() - .isThrownBy(() -> orderService.create(takeOutRequest)); - assertThatIllegalStateException() - .isThrownBy(() -> orderService.create(deliveryOrderRequest)); - assertThatIllegalStateException() - .isThrownBy(() -> orderService.create(eatInOrderRequest)); + assertAll( + () -> assertThatIllegalStateException() + .isThrownBy(() -> orderService.create(takeOutRequest)), + () -> assertThatIllegalStateException() + .isThrownBy(() -> orderService.create(deliveryOrderRequest)), + () -> assertThatIllegalStateException() + .isThrownBy(() -> orderService.create(eatInOrderRequest)) + ); } @DisplayName("메뉴의 가격과 주문 내역의 가격은 동일해야 한다") @@ -191,12 +204,14 @@ void validateOrderPrice() { OrderTable orderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); Order eatInOrderRequest = createEatInOrder(List.of(orderLineItem), orderTable.getId(), LocalDateTime.now()); - assertThatIllegalArgumentException() - .isThrownBy(() -> orderService.create(takeOutRequest)); - assertThatIllegalArgumentException() - .isThrownBy(() -> orderService.create(deliveryOrderRequest)); - assertThatIllegalArgumentException() - .isThrownBy(() -> orderService.create(eatInOrderRequest)); + assertAll( + () -> assertThatIllegalArgumentException() + .isThrownBy(() -> orderService.create(takeOutRequest)), + () -> assertThatIllegalArgumentException() + .isThrownBy(() -> orderService.create(deliveryOrderRequest)), + () -> assertThatIllegalArgumentException() + .isThrownBy(() -> orderService.create(eatInOrderRequest)) + ); } @DisplayName("배달의 경우, 배달 주소가 반드시 입력되어야 하며, 공백만 입력되어서는 안된다") @@ -432,10 +447,12 @@ void completeOrderByEatInOrTakeOut(OrderStatus orderStatus) { takeoutOrder.setStatus(orderStatus); eatInOrder.setStatus(orderStatus); //then - assertThatIllegalStateException() - .isThrownBy(() -> orderService.complete(takeoutOrder.getId())); - assertThatIllegalStateException() - .isThrownBy(() -> orderService.complete(eatInOrder.getId())); + assertAll( + () -> assertThatIllegalStateException() + .isThrownBy(() -> orderService.complete(takeoutOrder.getId())), + () -> assertThatIllegalStateException() + .isThrownBy(() -> orderService.complete(eatInOrder.getId())) + ); } @DisplayName("매장 내 식사의 경우, 주문 테이블의 모든 주문이 완료 상태가 아닐 때 테이블은 사용 중이며 손님의 수는 0으로 초기화되지 않는다") @@ -453,9 +470,11 @@ void completeOrderByEatIn() { Order complete = orderService.complete(servedOrder1.getId()); //then - assertThat(complete.getStatus()).isEqualTo(OrderStatus.COMPLETED); - assertThat(complete.getOrderTable().isOccupied()).isTrue(); - assertThat(complete.getOrderTable().getNumberOfGuests()).isNotZero(); + assertAll( + () -> assertThat(complete.getStatus()).isEqualTo(OrderStatus.COMPLETED), + () -> assertThat(complete.getOrderTable().isOccupied()).isTrue(), + () -> assertThat(complete.getOrderTable().getNumberOfGuests()).isNotZero() + ); } @DisplayName("매장 내 취식의 경우, 주문 테이블에의 모든 주문이 완료되면 테이블의 사용유무를 안함으로 변경하고 고객의 수를 0명으로 변경한다") @@ -474,15 +493,16 @@ void clearOrderTable() { Order complete2 = orderService.complete(servedOrder2.getId()); //then - assertThat(complete1.getStatus()).isEqualTo(OrderStatus.COMPLETED); - assertThat(complete1.getOrderTable().isOccupied()).isFalse(); - assertThat(complete1.getOrderTable().getNumberOfGuests()).isZero(); - - assertThat(complete2.getStatus()).isEqualTo(OrderStatus.COMPLETED); - assertThat(complete2.getOrderTable().isOccupied()).isFalse(); - assertThat(complete2.getOrderTable().getNumberOfGuests()).isZero(); + assertAll( + () -> assertThat(complete1.getStatus()).isEqualTo(OrderStatus.COMPLETED), + () -> assertThat(complete1.getOrderTable().isOccupied()).isFalse(), + () -> assertThat(complete1.getOrderTable().getNumberOfGuests()).isZero(), + + () -> assertThat(complete2.getStatus()).isEqualTo(OrderStatus.COMPLETED), + () -> assertThat(complete2.getOrderTable().isOccupied()).isFalse(), + () -> assertThat(complete2.getOrderTable().getNumberOfGuests()).isZero() + ); } - } //region [주문 조회] From 12de2317294f9ca7e79f641114037da943c41d63 Mon Sep 17 00:00:00 2001 From: skdev0619 Date: Wed, 5 Feb 2025 14:24:53 +0900 Subject: [PATCH 16/29] =?UTF-8?q?ReflectionTestUtils=20=EC=A0=81=EC=9A=A9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../application/MenuServiceTest.java | 9 +++++---- .../application/OrderServiceTest.java | 19 ++++++++++--------- .../application/OrderTableServiceTest.java | 15 ++++++++------- .../application/ProductServiceTest.java | 5 +++-- 4 files changed, 26 insertions(+), 22 deletions(-) diff --git a/src/test/java/kitchenpos/application/MenuServiceTest.java b/src/test/java/kitchenpos/application/MenuServiceTest.java index 85d6028fa..395df4724 100644 --- a/src/test/java/kitchenpos/application/MenuServiceTest.java +++ b/src/test/java/kitchenpos/application/MenuServiceTest.java @@ -20,6 +20,7 @@ import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.boot.test.mock.mockito.MockBean; +import org.springframework.test.util.ReflectionTestUtils; import org.springframework.transaction.annotation.Transactional; import java.math.BigDecimal; @@ -201,7 +202,7 @@ void changeMenuPrice() { new BigDecimal(7000), List.of(chickenBurger))); - menu.setPrice(new BigDecimal(6500)); + ReflectionTestUtils.setField(menu, "price", new BigDecimal(6500)); Menu newPriceMenu = menuService.changePrice(menu.getId(), menu); assertThat(newPriceMenu.getPrice()).isEqualTo(new BigDecimal(6500)); @@ -218,7 +219,7 @@ void canNotChangeNegativePrice() { new BigDecimal(7000), List.of(chickenBurger))); - menu.setPrice(new BigDecimal(-1)); + ReflectionTestUtils.setField(menu, "price", new BigDecimal(-1)); assertThatIllegalArgumentException() .isThrownBy(() -> menuService.changePrice(menu.getId(), menu)); @@ -240,7 +241,7 @@ void validateMenuPriceOnModify() { ); Menu resultMenu = menuService.create(menu); - resultMenu.setPrice(new BigDecimal(11001)); + ReflectionTestUtils.setField(resultMenu, "price", new BigDecimal(11001)); assertThatIllegalArgumentException() .isThrownBy(() -> menuService.changePrice(resultMenu.getId(), resultMenu)); } @@ -285,7 +286,7 @@ void validateMenuPriceOnDisplay() { ); Menu resultMenu = menuService.create(menu); - resultMenu.setPrice(new BigDecimal(11001)); + ReflectionTestUtils.setField(resultMenu, "price", new BigDecimal(11001)); assertThatIllegalStateException() .isThrownBy(() -> menuService.display(resultMenu.getId())); } diff --git a/src/test/java/kitchenpos/application/OrderServiceTest.java b/src/test/java/kitchenpos/application/OrderServiceTest.java index 1eed5d660..41203f411 100644 --- a/src/test/java/kitchenpos/application/OrderServiceTest.java +++ b/src/test/java/kitchenpos/application/OrderServiceTest.java @@ -13,6 +13,7 @@ import org.junit.jupiter.params.provider.NullSource; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.test.util.ReflectionTestUtils; import org.springframework.transaction.annotation.Transactional; import java.math.BigDecimal; @@ -273,7 +274,7 @@ void validateAcceptStatus(OrderStatus orderStatus) { Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); Order takeOutOrder = orderService.create(takeOutRequest); - takeOutOrder.setStatus(orderStatus); + ReflectionTestUtils.setField(takeOutOrder, "status", orderStatus); assertThatIllegalStateException() .isThrownBy(() -> orderService.accept(takeOutOrder.getId())); } @@ -305,7 +306,7 @@ void validateServedStatus(OrderStatus orderStatus) { Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); Order takeOutOrder = orderService.create(takeOutRequest); - takeOutOrder.setStatus(orderStatus); + ReflectionTestUtils.setField(takeOutOrder, "status", orderStatus); assertThatIllegalStateException() .isThrownBy(() -> orderService.serve(takeOutOrder.getId())); } @@ -323,7 +324,7 @@ void startDelivery() { Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", LocalDateTime.now()); Order order = orderService.create(deliveryOrderRequest); - order.setStatus(OrderStatus.SERVED); + ReflectionTestUtils.setField(order, "status", OrderStatus.SERVED); Order deliveryStartorder = orderService.startDelivery(order.getId()); assertThat(deliveryStartorder.getStatus()).isEqualTo(OrderStatus.DELIVERING); @@ -337,7 +338,7 @@ void validateDeliveryStartStatus(OrderStatus orderStatus) { Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", LocalDateTime.now()); Order order = orderService.create(deliveryOrderRequest); - order.setStatus(orderStatus); + ReflectionTestUtils.setField(order, "status", orderStatus); assertThatIllegalStateException() .isThrownBy(() -> orderService.startDelivery(order.getId())); } @@ -354,7 +355,7 @@ void endDelivery() { Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", LocalDateTime.now()); Order order = orderService.create(deliveryOrderRequest); - order.setStatus(OrderStatus.DELIVERING); + ReflectionTestUtils.setField(order, "status", OrderStatus.DELIVERING); Order deliveryStartorder = orderService.completeDelivery(order.getId()); assertThat(deliveryStartorder.getStatus()).isEqualTo(OrderStatus.DELIVERED); @@ -368,7 +369,7 @@ void validateDeliveryEndStatus(OrderStatus orderStatus) { Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", LocalDateTime.now()); Order order = orderService.create(deliveryOrderRequest); - order.setStatus(orderStatus); + ReflectionTestUtils.setField(order, "status", orderStatus); assertThatIllegalStateException() .isThrownBy(() -> orderService.completeDelivery(order.getId())); } @@ -399,7 +400,7 @@ void completeOrderByDelivery(OrderStatus orderStatus) { Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", LocalDateTime.now()); Order order = orderService.create(deliveryOrderRequest); - order.setStatus(orderStatus); + ReflectionTestUtils.setField(order, "status", orderStatus); assertThatIllegalStateException() .isThrownBy(() -> orderService.complete(order.getId())); } @@ -444,8 +445,8 @@ void completeOrderByEatInOrTakeOut(OrderStatus orderStatus) { Order takeoutOrder = orderService.create(takeOutRequest); Order eatInOrder = orderService.create(eatInRequest); //when - takeoutOrder.setStatus(orderStatus); - eatInOrder.setStatus(orderStatus); + ReflectionTestUtils.setField(takeoutOrder, "status", orderStatus); + ReflectionTestUtils.setField(eatInOrder, "status", orderStatus); //then assertAll( () -> assertThatIllegalStateException() diff --git a/src/test/java/kitchenpos/application/OrderTableServiceTest.java b/src/test/java/kitchenpos/application/OrderTableServiceTest.java index e1532cb93..cb27f6288 100644 --- a/src/test/java/kitchenpos/application/OrderTableServiceTest.java +++ b/src/test/java/kitchenpos/application/OrderTableServiceTest.java @@ -10,6 +10,7 @@ import org.junit.jupiter.params.provider.NullAndEmptySource; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.context.SpringBootTest; +import org.springframework.test.util.ReflectionTestUtils; import org.springframework.transaction.annotation.Transactional; import java.math.BigDecimal; @@ -97,12 +98,12 @@ void validateOrderStatus(OrderStatus status) { //given OrderTable orderTable = orderTableService.create(OrderTableFixture.createOrderTable("1번테이블")); orderTableService.sit(orderTable.getId()); - orderTable.setNumberOfGuests(4); + ReflectionTestUtils.setField(orderTable, "numberOfGuests", 4); orderTableService.changeNumberOfGuests(orderTable.getId(), orderTable); Order order = createUnnamedOrder(orderTable.getId()); //when, then - order.setStatus(status); + ReflectionTestUtils.setField(order, "status", status); assertThatIllegalStateException() .isThrownBy(() -> orderTableService.clear(orderTable.getId())); } @@ -113,12 +114,12 @@ void clear() { //given OrderTable orderTable = orderTableService.create(OrderTableFixture.createOrderTable("1번테이블")); orderTableService.sit(orderTable.getId()); - orderTable.setNumberOfGuests(4); + ReflectionTestUtils.setField(orderTable, "numberOfGuests", 4); orderTableService.changeNumberOfGuests(orderTable.getId(), orderTable); Order order = createUnnamedOrder(orderTable.getId()); //when - order.setStatus(OrderStatus.COMPLETED); + ReflectionTestUtils.setField(order, "status", OrderStatus.COMPLETED); OrderTable clearOrder = orderTableService.clear(orderTable.getId()); //then assertThat(clearOrder.getNumberOfGuests()).isZero(); @@ -135,7 +136,7 @@ class GuestNumberUpdater { void changeNumberOfGuestsByNegative() { OrderTable orderTable = orderTableService.create(OrderTableFixture.createOrderTable("1번테이블")); - orderTable.setNumberOfGuests(-1); + ReflectionTestUtils.setField(orderTable, "numberOfGuests", -1); assertThatIllegalArgumentException() .isThrownBy(() -> orderTableService.changeNumberOfGuests(orderTable.getId(), orderTable)); @@ -146,8 +147,8 @@ void changeNumberOfGuestsByNegative() { void changeNumberOfGuestsByUnUse() { OrderTable orderTable = orderTableService.create(OrderTableFixture.createOrderTable("1번테이블")); - orderTable.setOccupied(false); - orderTable.setNumberOfGuests(10); + ReflectionTestUtils.setField(orderTable, "occupied", false); + ReflectionTestUtils.setField(orderTable, "numberOfGuests", 10); assertThatIllegalStateException() .isThrownBy(() -> orderTableService.changeNumberOfGuests(orderTable.getId(), orderTable)); diff --git a/src/test/java/kitchenpos/application/ProductServiceTest.java b/src/test/java/kitchenpos/application/ProductServiceTest.java index 3e50c208d..d58676674 100644 --- a/src/test/java/kitchenpos/application/ProductServiceTest.java +++ b/src/test/java/kitchenpos/application/ProductServiceTest.java @@ -18,6 +18,7 @@ import org.springframework.boot.test.context.SpringBootTest; import org.springframework.boot.test.mock.mockito.MockBean; import org.springframework.test.context.TestConstructor; +import org.springframework.test.util.ReflectionTestUtils; import java.math.BigDecimal; import java.util.List; @@ -106,7 +107,7 @@ class ProductPriceUpdater { void modifyPrice() { Product product = productService.create(ProductFixture.createProduct(UUID.randomUUID(), "치킨버거", new BigDecimal(7000))); - product.setPrice(new BigDecimal(8000)); + ReflectionTestUtils.setField(product, "price", new BigDecimal(8000)); Product modifiedProduct = productService.changePrice(product.getId(), product); assertThat(modifiedProduct.getPrice()).isEqualTo(new BigDecimal(8000)); @@ -143,7 +144,7 @@ void validatePriceBySetMenu() { Menu chickenSet = menuService.create(menu); //when BigDecimal newPrice = chicken.getPrice().add(new BigDecimal(1000)); - chicken.setPrice(newPrice); + ReflectionTestUtils.setField(chicken, "price", newPrice); productService.changePrice(chicken.getId(), chicken); //when assertThat(chickenSet.isDisplayed()).isFalse(); From bea5bdfb1afcbc51041ddb0dc229c5db73496c8a Mon Sep 17 00:00:00 2001 From: skdev0619 Date: Wed, 5 Feb 2025 15:57:23 +0900 Subject: [PATCH 17/29] =?UTF-8?q?MenuGroup=20=ED=85=8C=EC=8A=A4=ED=8A=B8?= =?UTF-8?q?=20=EC=86=8D=EB=8F=84=20=EA=B0=9C=EC=84=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../domain/JpaMenuGroupRepository.java | 8 ++++++ .../domain/MenuGroupRepository.java | 12 ++++++--- .../InMemoryMenuGroupRepository.java | 27 +++++++++++++++++++ .../application/MenuGroupServiceTest.java | 15 ++++++----- 4 files changed, 53 insertions(+), 9 deletions(-) create mode 100644 src/main/java/kitchenpos/domain/JpaMenuGroupRepository.java create mode 100644 src/test/java/kitchenpos/application/InMemoryMenuGroupRepository.java diff --git a/src/main/java/kitchenpos/domain/JpaMenuGroupRepository.java b/src/main/java/kitchenpos/domain/JpaMenuGroupRepository.java new file mode 100644 index 000000000..9ee56b2b3 --- /dev/null +++ b/src/main/java/kitchenpos/domain/JpaMenuGroupRepository.java @@ -0,0 +1,8 @@ +package kitchenpos.domain; + +import org.springframework.data.jpa.repository.JpaRepository; + +import java.util.UUID; + +public interface JpaMenuGroupRepository extends MenuGroupRepository, JpaRepository { +} diff --git a/src/main/java/kitchenpos/domain/MenuGroupRepository.java b/src/main/java/kitchenpos/domain/MenuGroupRepository.java index 13fa29eda..b5acec2f2 100644 --- a/src/main/java/kitchenpos/domain/MenuGroupRepository.java +++ b/src/main/java/kitchenpos/domain/MenuGroupRepository.java @@ -1,8 +1,14 @@ package kitchenpos.domain; -import org.springframework.data.jpa.repository.JpaRepository; - +import java.util.List; +import java.util.Optional; import java.util.UUID; -public interface MenuGroupRepository extends JpaRepository { +public interface MenuGroupRepository { + MenuGroup save(MenuGroup menuGroup); + + Optional findById(UUID id); + + List findAll(); } + diff --git a/src/test/java/kitchenpos/application/InMemoryMenuGroupRepository.java b/src/test/java/kitchenpos/application/InMemoryMenuGroupRepository.java new file mode 100644 index 000000000..f587340a2 --- /dev/null +++ b/src/test/java/kitchenpos/application/InMemoryMenuGroupRepository.java @@ -0,0 +1,27 @@ +package kitchenpos.application; + +import kitchenpos.domain.MenuGroup; +import kitchenpos.domain.MenuGroupRepository; + +import java.util.*; +import java.util.concurrent.ConcurrentHashMap; + +public class InMemoryMenuGroupRepository implements MenuGroupRepository { + private final Map menuGroups = new ConcurrentHashMap<>(); + + @Override + public MenuGroup save(MenuGroup menuGroup) { + menuGroups.put(menuGroup.getId(), menuGroup); + return menuGroup; + } + + @Override + public Optional findById(UUID id) { + return Optional.ofNullable(menuGroups.get(id)); + } + + @Override + public List findAll() { + return new ArrayList<>(menuGroups.values()); + } +} diff --git a/src/test/java/kitchenpos/application/MenuGroupServiceTest.java b/src/test/java/kitchenpos/application/MenuGroupServiceTest.java index 1f80ce848..f4bdc4156 100644 --- a/src/test/java/kitchenpos/application/MenuGroupServiceTest.java +++ b/src/test/java/kitchenpos/application/MenuGroupServiceTest.java @@ -2,14 +2,13 @@ import kitchenpos.application.fixture.MenuGroupFixture; import kitchenpos.domain.MenuGroup; +import kitchenpos.domain.MenuGroupRepository; +import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.NullAndEmptySource; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; -import org.springframework.transaction.annotation.Transactional; import java.util.List; @@ -17,13 +16,17 @@ import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException; import static org.junit.jupiter.api.Assertions.assertAll; -@Transactional -@SpringBootTest class MenuGroupServiceTest { - @Autowired + private MenuGroupRepository menuGroupRepository; private MenuGroupService menuGroupService; + @BeforeEach + void setUp() { + this.menuGroupRepository = new InMemoryMenuGroupRepository(); + this.menuGroupService = new MenuGroupService(menuGroupRepository); + } + @DisplayName("메뉴 그룹을 생성할 수 있다") @Nested class MenuGroupCreator { From 20f2580546dc23c45055f0f3f4396c9d8ceeea2b Mon Sep 17 00:00:00 2001 From: skdev0619 Date: Wed, 5 Feb 2025 17:27:10 +0900 Subject: [PATCH 18/29] =?UTF-8?q?Product=20=ED=85=8C=EC=8A=A4=ED=8A=B8=20?= =?UTF-8?q?=EC=86=8D=EB=8F=84=20=EA=B0=9C=EC=84=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../application/ProductService.java | 20 +++--- .../kitchenpos/domain/JpaMenuRepository.java | 15 +++++ .../domain/JpaProductRepository.java | 10 +++ .../kitchenpos/domain/MenuRepository.java | 19 +++--- .../kitchenpos/domain/ProductRepository.java | 12 +++- .../infra/DefaultPurgomalumClient.java | 25 ++++++++ .../kitchenpos/infra/PurgomalumClient.java | 24 +------ .../application/FakePurgomalumClient.java | 20 ++++++ .../application/InMemoryMenuRepository.java | 43 +++++++++++++ .../InMemoryProductRepository.java | 34 ++++++++++ .../application/ProductServiceTest.java | 63 +++++++++---------- 11 files changed, 208 insertions(+), 77 deletions(-) create mode 100644 src/main/java/kitchenpos/domain/JpaMenuRepository.java create mode 100644 src/main/java/kitchenpos/domain/JpaProductRepository.java create mode 100644 src/main/java/kitchenpos/infra/DefaultPurgomalumClient.java create mode 100644 src/test/java/kitchenpos/application/FakePurgomalumClient.java create mode 100644 src/test/java/kitchenpos/application/InMemoryMenuRepository.java create mode 100644 src/test/java/kitchenpos/application/InMemoryProductRepository.java diff --git a/src/main/java/kitchenpos/application/ProductService.java b/src/main/java/kitchenpos/application/ProductService.java index dc44b087b..8fb16c60f 100644 --- a/src/main/java/kitchenpos/application/ProductService.java +++ b/src/main/java/kitchenpos/application/ProductService.java @@ -1,10 +1,6 @@ package kitchenpos.application; -import kitchenpos.domain.Menu; -import kitchenpos.domain.MenuProduct; -import kitchenpos.domain.MenuRepository; -import kitchenpos.domain.Product; -import kitchenpos.domain.ProductRepository; +import kitchenpos.domain.*; import kitchenpos.infra.PurgomalumClient; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; @@ -22,9 +18,9 @@ public class ProductService { private final PurgomalumClient purgomalumClient; public ProductService( - final ProductRepository productRepository, - final MenuRepository menuRepository, - final PurgomalumClient purgomalumClient + final ProductRepository productRepository, + final MenuRepository menuRepository, + final PurgomalumClient purgomalumClient ) { this.productRepository = productRepository; this.menuRepository = menuRepository; @@ -55,16 +51,16 @@ public Product changePrice(final UUID productId, final Product request) { throw new IllegalArgumentException(); } final Product product = productRepository.findById(productId) - .orElseThrow(NoSuchElementException::new); + .orElseThrow(NoSuchElementException::new); product.setPrice(price); final List menus = menuRepository.findAllByProductId(productId); for (final Menu menu : menus) { BigDecimal sum = BigDecimal.ZERO; for (final MenuProduct menuProduct : menu.getMenuProducts()) { sum = sum.add( - menuProduct.getProduct() - .getPrice() - .multiply(BigDecimal.valueOf(menuProduct.getQuantity())) + menuProduct.getProduct() + .getPrice() + .multiply(BigDecimal.valueOf(menuProduct.getQuantity())) ); } if (menu.getPrice().compareTo(sum) > 0) { diff --git a/src/main/java/kitchenpos/domain/JpaMenuRepository.java b/src/main/java/kitchenpos/domain/JpaMenuRepository.java new file mode 100644 index 000000000..f7ab8f5c9 --- /dev/null +++ b/src/main/java/kitchenpos/domain/JpaMenuRepository.java @@ -0,0 +1,15 @@ +package kitchenpos.domain; + +import org.springframework.data.jpa.repository.JpaRepository; +import org.springframework.data.jpa.repository.Query; +import org.springframework.data.repository.query.Param; + +import java.util.List; +import java.util.UUID; + +public interface JpaMenuRepository extends MenuRepository, JpaRepository { + List findAllByIdIn(List ids); + + @Query("select m from Menu m join m.menuProducts mp where mp.product.id = :productId") + List findAllByProductId(@Param("productId") UUID productId); +} diff --git a/src/main/java/kitchenpos/domain/JpaProductRepository.java b/src/main/java/kitchenpos/domain/JpaProductRepository.java new file mode 100644 index 000000000..6f5e3fc57 --- /dev/null +++ b/src/main/java/kitchenpos/domain/JpaProductRepository.java @@ -0,0 +1,10 @@ +package kitchenpos.domain; + +import org.springframework.data.jpa.repository.JpaRepository; + +import java.util.List; +import java.util.UUID; + +public interface JpaProductRepository extends ProductRepository, JpaRepository { + List findAllByIdIn(List ids); +} diff --git a/src/main/java/kitchenpos/domain/MenuRepository.java b/src/main/java/kitchenpos/domain/MenuRepository.java index 27afa5fff..d0a2fdd78 100644 --- a/src/main/java/kitchenpos/domain/MenuRepository.java +++ b/src/main/java/kitchenpos/domain/MenuRepository.java @@ -1,15 +1,18 @@ package kitchenpos.domain; -import org.springframework.data.jpa.repository.JpaRepository; -import org.springframework.data.jpa.repository.Query; -import org.springframework.data.repository.query.Param; - import java.util.List; +import java.util.Optional; import java.util.UUID; -public interface MenuRepository extends JpaRepository { - List findAllByIdIn(List ids); +public interface MenuRepository { + Menu save(Menu menu); + + Optional findById(UUID id); + + List findAll(); - @Query("select m from Menu m join m.menuProducts mp where mp.product.id = :productId") - List findAllByProductId(@Param("productId") UUID productId); + List findAllByProductId(UUID productId); + + List findAllByIdIn(List ids); } + diff --git a/src/main/java/kitchenpos/domain/ProductRepository.java b/src/main/java/kitchenpos/domain/ProductRepository.java index b19420297..17baf3efe 100644 --- a/src/main/java/kitchenpos/domain/ProductRepository.java +++ b/src/main/java/kitchenpos/domain/ProductRepository.java @@ -1,10 +1,16 @@ package kitchenpos.domain; -import org.springframework.data.jpa.repository.JpaRepository; - import java.util.List; +import java.util.Optional; import java.util.UUID; -public interface ProductRepository extends JpaRepository { +public interface ProductRepository { List findAllByIdIn(List ids); + + Product save(Product product); + + Optional findById(UUID id); + + List findAll(); } + diff --git a/src/main/java/kitchenpos/infra/DefaultPurgomalumClient.java b/src/main/java/kitchenpos/infra/DefaultPurgomalumClient.java new file mode 100644 index 000000000..98e51f859 --- /dev/null +++ b/src/main/java/kitchenpos/infra/DefaultPurgomalumClient.java @@ -0,0 +1,25 @@ +package kitchenpos.infra; + +import org.springframework.boot.web.client.RestTemplateBuilder; +import org.springframework.stereotype.Component; +import org.springframework.web.client.RestTemplate; +import org.springframework.web.util.UriComponentsBuilder; + +import java.net.URI; + +@Component +public class DefaultPurgomalumClient implements PurgomalumClient { + private final RestTemplate restTemplate; + + public DefaultPurgomalumClient(final RestTemplateBuilder restTemplateBuilder) { + this.restTemplate = restTemplateBuilder.build(); + } + @Override + public boolean containsProfanity(final String text) { + final URI url = UriComponentsBuilder.fromUriString("https://www.purgomalum.com/service/containsprofanity") + .queryParam("text", text) + .build() + .toUri(); + return Boolean.parseBoolean(restTemplate.getForObject(url, String.class)); + } +} \ No newline at end of file diff --git a/src/main/java/kitchenpos/infra/PurgomalumClient.java b/src/main/java/kitchenpos/infra/PurgomalumClient.java index 2ed085bed..a54cf8297 100644 --- a/src/main/java/kitchenpos/infra/PurgomalumClient.java +++ b/src/main/java/kitchenpos/infra/PurgomalumClient.java @@ -1,25 +1,5 @@ package kitchenpos.infra; -import org.springframework.boot.web.client.RestTemplateBuilder; -import org.springframework.stereotype.Component; -import org.springframework.web.client.RestTemplate; -import org.springframework.web.util.UriComponentsBuilder; - -import java.net.URI; - -@Component -public class PurgomalumClient { - private final RestTemplate restTemplate; - - public PurgomalumClient(final RestTemplateBuilder restTemplateBuilder) { - this.restTemplate = restTemplateBuilder.build(); - } - - public boolean containsProfanity(final String text) { - final URI url = UriComponentsBuilder.fromUriString("https://www.purgomalum.com/service/containsprofanity") - .queryParam("text", text) - .build() - .toUri(); - return Boolean.parseBoolean(restTemplate.getForObject(url, String.class)); - } +public interface PurgomalumClient { + boolean containsProfanity(final String text); } diff --git a/src/test/java/kitchenpos/application/FakePurgomalumClient.java b/src/test/java/kitchenpos/application/FakePurgomalumClient.java new file mode 100644 index 000000000..b5e794fe4 --- /dev/null +++ b/src/test/java/kitchenpos/application/FakePurgomalumClient.java @@ -0,0 +1,20 @@ +package kitchenpos.application; + +import kitchenpos.infra.PurgomalumClient; + +import java.util.List; + +public class FakePurgomalumClient implements PurgomalumClient { + + private final List profanities; + + public FakePurgomalumClient(List profanities) { + this.profanities = profanities; + } + + @Override + public boolean containsProfanity(String text) { + return profanities.stream() + .anyMatch(text::contains); + } +} diff --git a/src/test/java/kitchenpos/application/InMemoryMenuRepository.java b/src/test/java/kitchenpos/application/InMemoryMenuRepository.java new file mode 100644 index 000000000..79fa169e0 --- /dev/null +++ b/src/test/java/kitchenpos/application/InMemoryMenuRepository.java @@ -0,0 +1,43 @@ +package kitchenpos.application; + +import kitchenpos.domain.Menu; +import kitchenpos.domain.MenuRepository; + +import java.util.*; +import java.util.concurrent.ConcurrentHashMap; + +public class InMemoryMenuRepository implements MenuRepository { + private Map menus = new ConcurrentHashMap<>(); + + @Override + public Menu save(Menu menu) { + menus.put(menu.getId(), menu); + return menu; + } + + @Override + public Optional findById(UUID id) { + return Optional.ofNullable(menus.get(id)); + } + + @Override + public List findAll() { + return new ArrayList<>(menus.values()); + } + + @Override + public List findAllByProductId(UUID productId) { + return menus.values() + .stream() + .filter(menu -> menu.getMenuProducts().stream(). + anyMatch(menuProduct -> menuProduct.getProduct().getId().equals(productId))) + .toList(); + } + + @Override + public List findAllByIdIn(List ids) { + return menus.values().stream() + .filter(menu -> ids.contains(menu.getId())) + .toList(); + } +} diff --git a/src/test/java/kitchenpos/application/InMemoryProductRepository.java b/src/test/java/kitchenpos/application/InMemoryProductRepository.java new file mode 100644 index 000000000..5604f1a08 --- /dev/null +++ b/src/test/java/kitchenpos/application/InMemoryProductRepository.java @@ -0,0 +1,34 @@ +package kitchenpos.application; + +import kitchenpos.domain.Product; +import kitchenpos.domain.ProductRepository; + +import java.util.*; +import java.util.concurrent.ConcurrentHashMap; + +public class InMemoryProductRepository implements ProductRepository { + private Map products = new ConcurrentHashMap<>(); + + @Override + public Product save(Product product) { + products.put(product.getId(), product); + return product; + } + + @Override + public Optional findById(UUID id) { + return Optional.ofNullable(products.get(id)); + } + + @Override + public List findAll() { + return new ArrayList<>(products.values()); + } + + @Override + public List findAllByIdIn(List ids) { + return products.values().stream() + .filter(product -> ids.contains(product.getId())) + .toList(); + } +} diff --git a/src/test/java/kitchenpos/application/ProductServiceTest.java b/src/test/java/kitchenpos/application/ProductServiceTest.java index d58676674..d74f0f4d6 100644 --- a/src/test/java/kitchenpos/application/ProductServiceTest.java +++ b/src/test/java/kitchenpos/application/ProductServiceTest.java @@ -4,20 +4,15 @@ import kitchenpos.application.fixture.MenuGroupFixture; import kitchenpos.application.fixture.MenuProductFixture; import kitchenpos.application.fixture.ProductFixture; -import kitchenpos.domain.Menu; -import kitchenpos.domain.MenuGroup; -import kitchenpos.domain.MenuProduct; -import kitchenpos.domain.Product; +import kitchenpos.domain.*; import kitchenpos.infra.PurgomalumClient; import org.assertj.core.groups.Tuple; +import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Nested; 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 org.springframework.test.context.TestConstructor; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; import org.springframework.test.util.ReflectionTestUtils; import java.math.BigDecimal; @@ -27,21 +22,22 @@ import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.Assertions.assertThatIllegalArgumentException; -@TestConstructor(autowireMode = TestConstructor.AutowireMode.ALL) -@SpringBootTest class ProductServiceTest { - @Autowired - private ProductService productService; - - @MockBean + private ProductRepository productRepository; + private MenuRepository menuRepository; private PurgomalumClient purgomalumClient; - - @Autowired - private MenuService menuService; - - @Autowired - private MenuGroupService menuGroupService; + private ProductService productService; + private MenuGroupRepository menuGroupRepository; + + @BeforeEach + void setUp() { + this.productRepository = new InMemoryProductRepository(); + this.menuRepository = new InMemoryMenuRepository(); + this.purgomalumClient = new FakePurgomalumClient(List.of("비속어", "욕설")); + this.productService = new ProductService(productRepository, menuRepository, purgomalumClient); + this.menuGroupRepository = new InMemoryMenuGroupRepository(); + } @DisplayName("상품을 생성할 수 있다") @Nested @@ -78,10 +74,10 @@ void notNullProductPrice() { } @DisplayName("상품명은 비속어가 있으면 등록할 수 없다") - @Test - void validateProductName() { - Mockito.when(purgomalumClient.containsProfanity("bad word")).thenReturn(true); - Product request = ProductFixture.createProduct("bad word", new BigDecimal(7000)); + @ParameterizedTest + @ValueSource(strings = {"비속어", "욕설이 포함된 상품명"}) + void validateProductName(String name) { + Product request = ProductFixture.createProduct(name, new BigDecimal(7000)); assertThatIllegalArgumentException() .isThrownBy(() -> productService.create(request)); @@ -129,25 +125,28 @@ void validatePriceBySetMenu() { Product chicken = productService.create(ProductFixture.createProduct("후라이드치킨", new BigDecimal(25000))); Product coke = productService.create(ProductFixture.createProduct("콜라", new BigDecimal(2500))); - MenuGroup menuGroup = menuGroupService.create(MenuGroupFixture.createMenuGroup("세트메뉴")); + MenuGroup menuGroup = menuGroupRepository.save(MenuGroupFixture.createMenuGroup(UUID.randomUUID(), "세트메뉴")); MenuProduct chickenMenuProduct = MenuProductFixture.createMenuProduct(chicken, 1); MenuProduct cokeMenuProduct = MenuProductFixture.createMenuProduct(coke, 1); BigDecimal productSum = chicken.getPrice().add(coke.getPrice()); - Menu menu = MenuFixture.createMenu( + Menu setMenu = menuRepository.save(MenuFixture.createMenu( + UUID.randomUUID(), + menuGroup, menuGroup.getId(), "후라이드치킨세트", productSum, + true, List.of(chickenMenuProduct, cokeMenuProduct) - ); - Menu chickenSet = menuService.create(menu); + )); //when - BigDecimal newPrice = chicken.getPrice().add(new BigDecimal(1000)); + BigDecimal newPrice = chicken.getPrice().add(new BigDecimal(-1000)); ReflectionTestUtils.setField(chicken, "price", newPrice); productService.changePrice(chicken.getId(), chicken); //when - assertThat(chickenSet.isDisplayed()).isFalse(); + Menu resultMenu = menuRepository.findById(setMenu.getId()).get(); + assertThat(resultMenu.isDisplayed()).isFalse(); } } @@ -168,6 +167,6 @@ void findAll() { Tuple.tuple("새우버거", 8000) ); } - //endregion + //endregion*/ } From d4b58c4c91f5c095787e850cea2ee5d570f1ff02 Mon Sep 17 00:00:00 2001 From: skdev0619 Date: Wed, 5 Feb 2025 17:33:17 +0900 Subject: [PATCH 19/29] =?UTF-8?q?Menu=20=ED=85=8C=EC=8A=A4=ED=8A=B8=20?= =?UTF-8?q?=EC=86=8D=EB=8F=84=20=EA=B0=9C=EC=84=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../application/MenuServiceTest.java | 40 +++++++------------ 1 file changed, 15 insertions(+), 25 deletions(-) diff --git a/src/test/java/kitchenpos/application/MenuServiceTest.java b/src/test/java/kitchenpos/application/MenuServiceTest.java index 395df4724..c5411691b 100644 --- a/src/test/java/kitchenpos/application/MenuServiceTest.java +++ b/src/test/java/kitchenpos/application/MenuServiceTest.java @@ -4,10 +4,7 @@ import kitchenpos.application.fixture.MenuGroupFixture; import kitchenpos.application.fixture.MenuProductFixture; import kitchenpos.application.fixture.ProductFixture; -import kitchenpos.domain.Menu; -import kitchenpos.domain.MenuGroupRepository; -import kitchenpos.domain.MenuProduct; -import kitchenpos.domain.ProductRepository; +import kitchenpos.domain.*; import kitchenpos.infra.PurgomalumClient; import org.assertj.core.groups.Tuple; import org.junit.jupiter.api.BeforeEach; @@ -16,12 +13,8 @@ import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.NullSource; -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 org.junit.jupiter.params.provider.ValueSource; import org.springframework.test.util.ReflectionTestUtils; -import org.springframework.transaction.annotation.Transactional; import java.math.BigDecimal; import java.util.List; @@ -30,8 +23,6 @@ import static org.assertj.core.api.Assertions.*; import static org.junit.jupiter.api.Assertions.assertAll; -@Transactional -@SpringBootTest class MenuServiceTest { private static final UUID BURGER_PRODUCT_ID = UUID.randomUUID(); @@ -39,20 +30,20 @@ class MenuServiceTest { private static final UUID COKE_PRODUCT_ID = UUID.randomUUID(); private static final UUID MENU_GROUP_ID = UUID.randomUUID(); - @Autowired - private MenuService menuService; - - @Autowired - private ProductRepository productRepository; - - @Autowired + private MenuRepository menuRepository; private MenuGroupRepository menuGroupRepository; - - @MockBean + private ProductRepository productRepository; private PurgomalumClient purgomalumClient; + private MenuService menuService; @BeforeEach void setUp() { + this.menuRepository = new InMemoryMenuRepository(); + this.menuGroupRepository = new InMemoryMenuGroupRepository(); + this.productRepository = new InMemoryProductRepository(); + this.purgomalumClient = new FakePurgomalumClient(List.of("비속어", "욕설")); + this.menuService = new MenuService(menuRepository, menuGroupRepository, productRepository, purgomalumClient); + productRepository.save(ProductFixture.createProduct(BURGER_PRODUCT_ID, "치킨버거", new BigDecimal(7000))); productRepository.save(ProductFixture.createProduct(SIDE_PRODUCT_ID, "감자튀김", new BigDecimal(2000))); productRepository.save(ProductFixture.createProduct(COKE_PRODUCT_ID, "콜라", new BigDecimal(2000))); @@ -135,12 +126,11 @@ void notNullName(String nullName) { } @DisplayName("메뉴명에 비속어가 있으면 등록할 수 없다") - @Test - void validateMenuName() { - Mockito.when(purgomalumClient.containsProfanity("bad word")).thenReturn(true); - + @ValueSource(strings = {"비속어", "욕설이 포함된 메뉴명"}) + @ParameterizedTest + void validateMenuName(String name) { MenuProduct chickenBurger = MenuProductFixture.createMenuProduct(BURGER_PRODUCT_ID, 1); - Menu menu = MenuFixture.createMenu(MENU_GROUP_ID, "bad word", new BigDecimal(7000), List.of(chickenBurger)); + Menu menu = MenuFixture.createMenu(MENU_GROUP_ID, name, new BigDecimal(7000), List.of(chickenBurger)); assertThatIllegalArgumentException() .isThrownBy(() -> menuService.create(menu)); From 844c123f9bd1dfbb5746f15a58b0f387f4c06b8c Mon Sep 17 00:00:00 2001 From: skdev0619 Date: Wed, 5 Feb 2025 17:57:10 +0900 Subject: [PATCH 20/29] =?UTF-8?q?Order,=20OrderTable=20=ED=85=8C=EC=8A=A4?= =?UTF-8?q?=ED=8A=B8=20=EC=86=8D=EB=8F=84=20=EA=B0=9C=EC=84=A0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../kitchenpos/domain/JpaOrderRepository.java | 9 +++++ .../domain/JpaOrderTableRepository.java | 8 ++++ .../kitchenpos/domain/OrderRepository.java | 13 +++++-- .../domain/OrderTableRepository.java | 11 ++++-- .../infra/DefaultKitchenridersClient.java | 15 ++++++++ .../kitchenpos/infra/KitchenridersClient.java | 10 ++--- .../application/FakeKitchenridersClient.java | 13 +++++++ .../application/InMemoryOrderRepository.java | 36 ++++++++++++++++++ .../InMemoryOrderTableRepository.java | 27 ++++++++++++++ .../application/OrderServiceTest.java | 28 ++++++-------- .../application/OrderTableServiceTest.java | 37 ++++++++++--------- 11 files changed, 162 insertions(+), 45 deletions(-) create mode 100644 src/main/java/kitchenpos/domain/JpaOrderRepository.java create mode 100644 src/main/java/kitchenpos/domain/JpaOrderTableRepository.java create mode 100644 src/main/java/kitchenpos/infra/DefaultKitchenridersClient.java create mode 100644 src/test/java/kitchenpos/application/FakeKitchenridersClient.java create mode 100644 src/test/java/kitchenpos/application/InMemoryOrderRepository.java create mode 100644 src/test/java/kitchenpos/application/InMemoryOrderTableRepository.java diff --git a/src/main/java/kitchenpos/domain/JpaOrderRepository.java b/src/main/java/kitchenpos/domain/JpaOrderRepository.java new file mode 100644 index 000000000..d67a85ecc --- /dev/null +++ b/src/main/java/kitchenpos/domain/JpaOrderRepository.java @@ -0,0 +1,9 @@ +package kitchenpos.domain; + +import org.springframework.data.jpa.repository.JpaRepository; + +import java.util.UUID; + +public interface JpaOrderRepository extends OrderRepository, JpaRepository { + boolean existsByOrderTableAndStatusNot(OrderTable orderTable, OrderStatus status); +} diff --git a/src/main/java/kitchenpos/domain/JpaOrderTableRepository.java b/src/main/java/kitchenpos/domain/JpaOrderTableRepository.java new file mode 100644 index 000000000..4de7441cc --- /dev/null +++ b/src/main/java/kitchenpos/domain/JpaOrderTableRepository.java @@ -0,0 +1,8 @@ +package kitchenpos.domain; + +import org.springframework.data.jpa.repository.JpaRepository; + +import java.util.UUID; + +public interface JpaOrderTableRepository extends OrderTableRepository, JpaRepository { +} diff --git a/src/main/java/kitchenpos/domain/OrderRepository.java b/src/main/java/kitchenpos/domain/OrderRepository.java index d3c51d32c..0e5780390 100644 --- a/src/main/java/kitchenpos/domain/OrderRepository.java +++ b/src/main/java/kitchenpos/domain/OrderRepository.java @@ -1,9 +1,16 @@ package kitchenpos.domain; -import org.springframework.data.jpa.repository.JpaRepository; - +import java.util.List; +import java.util.Optional; import java.util.UUID; -public interface OrderRepository extends JpaRepository { +public interface OrderRepository { + Order save(Order order); + + Optional findById(UUID id); + + List findAll(); + boolean existsByOrderTableAndStatusNot(OrderTable orderTable, OrderStatus status); } + diff --git a/src/main/java/kitchenpos/domain/OrderTableRepository.java b/src/main/java/kitchenpos/domain/OrderTableRepository.java index 0e732b0fc..3cefe042a 100644 --- a/src/main/java/kitchenpos/domain/OrderTableRepository.java +++ b/src/main/java/kitchenpos/domain/OrderTableRepository.java @@ -1,8 +1,13 @@ package kitchenpos.domain; -import org.springframework.data.jpa.repository.JpaRepository; - +import java.util.List; +import java.util.Optional; import java.util.UUID; -public interface OrderTableRepository extends JpaRepository { +public interface OrderTableRepository { + OrderTable save(OrderTable orderTable); + + Optional findById(UUID id); + + List findAll(); } diff --git a/src/main/java/kitchenpos/infra/DefaultKitchenridersClient.java b/src/main/java/kitchenpos/infra/DefaultKitchenridersClient.java new file mode 100644 index 000000000..f633964c6 --- /dev/null +++ b/src/main/java/kitchenpos/infra/DefaultKitchenridersClient.java @@ -0,0 +1,15 @@ +package kitchenpos.infra; + +import org.springframework.stereotype.Component; + +import java.math.BigDecimal; +import java.util.UUID; + +@Component +public class DefaultKitchenridersClient implements KitchenridersClient { + + @Override + public void requestDelivery(UUID orderId, BigDecimal amount, String deliveryAddress) { + + } +} diff --git a/src/main/java/kitchenpos/infra/KitchenridersClient.java b/src/main/java/kitchenpos/infra/KitchenridersClient.java index 88bf78fb1..f876de0d8 100644 --- a/src/main/java/kitchenpos/infra/KitchenridersClient.java +++ b/src/main/java/kitchenpos/infra/KitchenridersClient.java @@ -1,12 +1,10 @@ package kitchenpos.infra; -import org.springframework.stereotype.Component; - import java.math.BigDecimal; import java.util.UUID; -@Component -public class KitchenridersClient { - public void requestDelivery(final UUID orderId, final BigDecimal amount, final String deliveryAddress) { - } + +public interface KitchenridersClient { + public void requestDelivery(final UUID orderId, final BigDecimal amount, final String deliveryAddress); } + diff --git a/src/test/java/kitchenpos/application/FakeKitchenridersClient.java b/src/test/java/kitchenpos/application/FakeKitchenridersClient.java new file mode 100644 index 000000000..e1d6adb10 --- /dev/null +++ b/src/test/java/kitchenpos/application/FakeKitchenridersClient.java @@ -0,0 +1,13 @@ +package kitchenpos.application; + +import kitchenpos.infra.KitchenridersClient; + +import java.math.BigDecimal; +import java.util.UUID; + +public class FakeKitchenridersClient implements KitchenridersClient { + @Override + public void requestDelivery(UUID orderId, BigDecimal amount, String deliveryAddress) { + + } +} diff --git a/src/test/java/kitchenpos/application/InMemoryOrderRepository.java b/src/test/java/kitchenpos/application/InMemoryOrderRepository.java new file mode 100644 index 000000000..2e5c5ef26 --- /dev/null +++ b/src/test/java/kitchenpos/application/InMemoryOrderRepository.java @@ -0,0 +1,36 @@ +package kitchenpos.application; + +import kitchenpos.domain.Order; +import kitchenpos.domain.OrderRepository; +import kitchenpos.domain.OrderStatus; +import kitchenpos.domain.OrderTable; + +import java.util.*; +import java.util.concurrent.ConcurrentHashMap; + +public class InMemoryOrderRepository implements OrderRepository { + private Map orders = new ConcurrentHashMap<>(); + + @Override + public Order save(Order order) { + orders.put(order.getId(), order); + return order; + } + + @Override + public Optional findById(UUID id) { + return Optional.ofNullable(orders.get(id)); + } + + @Override + public List findAll() { + return new ArrayList<>(orders.values()); + } + + @Override + public boolean existsByOrderTableAndStatusNot(OrderTable orderTable, OrderStatus status) { + return orders.values() + .stream() + .anyMatch(order -> order.getOrderTable().equals(orderTable) && order.getStatus() != status); + } +} diff --git a/src/test/java/kitchenpos/application/InMemoryOrderTableRepository.java b/src/test/java/kitchenpos/application/InMemoryOrderTableRepository.java new file mode 100644 index 000000000..c3d012b87 --- /dev/null +++ b/src/test/java/kitchenpos/application/InMemoryOrderTableRepository.java @@ -0,0 +1,27 @@ +package kitchenpos.application; + +import kitchenpos.domain.OrderTable; +import kitchenpos.domain.OrderTableRepository; + +import java.util.*; +import java.util.concurrent.ConcurrentHashMap; + +public class InMemoryOrderTableRepository implements OrderTableRepository { + private Map orderTables = new ConcurrentHashMap<>(); + + @Override + public OrderTable save(OrderTable orderTable) { + orderTables.put(orderTable.getId(), orderTable); + return orderTable; + } + + @Override + public Optional findById(UUID id) { + return Optional.ofNullable(orderTables.get(id)); + } + + @Override + public List findAll() { + return new ArrayList<>(orderTables.values()); + } +} diff --git a/src/test/java/kitchenpos/application/OrderServiceTest.java b/src/test/java/kitchenpos/application/OrderServiceTest.java index 41203f411..7e9961091 100644 --- a/src/test/java/kitchenpos/application/OrderServiceTest.java +++ b/src/test/java/kitchenpos/application/OrderServiceTest.java @@ -2,6 +2,7 @@ import kitchenpos.application.fixture.*; import kitchenpos.domain.*; +import kitchenpos.infra.KitchenridersClient; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Nested; @@ -11,10 +12,7 @@ import org.junit.jupiter.params.provider.MethodSource; import org.junit.jupiter.params.provider.NullAndEmptySource; import org.junit.jupiter.params.provider.NullSource; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; import org.springframework.test.util.ReflectionTestUtils; -import org.springframework.transaction.annotation.Transactional; import java.math.BigDecimal; import java.time.LocalDateTime; @@ -27,32 +25,30 @@ import static org.assertj.core.api.Assertions.*; import static org.junit.jupiter.api.Assertions.assertAll; -@Transactional -@SpringBootTest class OrderServiceTest { private static final UUID DISPLAY_MENU_ID = UUID.randomUUID(); private static final UUID UNDISPLAYED_MENU_ID = UUID.randomUUID(); private static final UUID ORDER_TABLE_ID = UUID.randomUUID(); - @Autowired - private ProductRepository productRepository; - - @Autowired + private OrderRepository orderRepository; private MenuRepository menuRepository; - - @Autowired private MenuGroupRepository menuGroupRepository; - - @Autowired + private ProductRepository productRepository; private OrderTableRepository orderTableRepository; - - @Autowired + private KitchenridersClient kitchenridersClient; private OrderService orderService; - @BeforeEach void setUp() { + this.orderRepository = new InMemoryOrderRepository(); + this.menuRepository = new InMemoryMenuRepository(); + this.menuGroupRepository = new InMemoryMenuGroupRepository(); + this.productRepository = new InMemoryProductRepository(); + this.orderTableRepository = new InMemoryOrderTableRepository(); + this.kitchenridersClient = new FakeKitchenridersClient(); + this.orderService = new OrderService(orderRepository, menuRepository, orderTableRepository, kitchenridersClient); + Product product1 = productRepository.save(ProductFixture.createProduct(UUID.randomUUID(), "전시", new BigDecimal(25000))); Product product2 = productRepository.save(ProductFixture.createProduct(UUID.randomUUID(), "비전시", new BigDecimal(7000))); diff --git a/src/test/java/kitchenpos/application/OrderTableServiceTest.java b/src/test/java/kitchenpos/application/OrderTableServiceTest.java index cb27f6288..ac165a81e 100644 --- a/src/test/java/kitchenpos/application/OrderTableServiceTest.java +++ b/src/test/java/kitchenpos/application/OrderTableServiceTest.java @@ -2,16 +2,15 @@ import kitchenpos.application.fixture.*; import kitchenpos.domain.*; +import kitchenpos.infra.KitchenridersClient; +import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.EnumSource; import org.junit.jupiter.params.provider.NullAndEmptySource; -import org.springframework.beans.factory.annotation.Autowired; -import org.springframework.boot.test.context.SpringBootTest; import org.springframework.test.util.ReflectionTestUtils; -import org.springframework.transaction.annotation.Transactional; import java.math.BigDecimal; import java.time.LocalDateTime; @@ -20,24 +19,28 @@ import static org.assertj.core.api.Assertions.*; -@Transactional -@SpringBootTest class OrderTableServiceTest { - @Autowired - private OrderTableService orderTableService; - - @Autowired - private OrderService orderService; - - @Autowired - private ProductRepository productRepository; - - @Autowired + private OrderRepository orderRepository; private MenuRepository menuRepository; - - @Autowired private MenuGroupRepository menuGroupRepository; + private ProductRepository productRepository; + private OrderTableRepository orderTableRepository; + private KitchenridersClient kitchenridersClient; + private OrderService orderService; + private OrderTableService orderTableService; + + @BeforeEach + void setUp() { + this.orderRepository = new InMemoryOrderRepository(); + this.menuRepository = new InMemoryMenuRepository(); + this.menuGroupRepository = new InMemoryMenuGroupRepository(); + this.productRepository = new InMemoryProductRepository(); + this.orderTableRepository = new InMemoryOrderTableRepository(); + this.kitchenridersClient = new FakeKitchenridersClient(); + this.orderService = new OrderService(orderRepository, menuRepository, orderTableRepository, kitchenridersClient); + this.orderTableService = new OrderTableService(orderTableRepository, orderRepository); + } @DisplayName("주문 테이블을 등록할 수 있다") @Nested From 0ef38a09f17726b7caabcbfc51ef69f1dc6f54dc Mon Sep 17 00:00:00 2001 From: skdev0619 Date: Thu, 6 Feb 2025 10:42:22 +0900 Subject: [PATCH 21/29] =?UTF-8?q?Fake=20=ED=81=B4=EB=9E=98=EC=8A=A4=20?= =?UTF-8?q?=ED=8C=A8=ED=82=A4=EC=A7=80=20=EB=B3=80=EA=B2=BD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/test/java/kitchenpos/application/OrderServiceTest.java | 1 + .../java/kitchenpos/application/OrderTableServiceTest.java | 1 + src/test/java/kitchenpos/application/ProductServiceTest.java | 1 + .../{application => infra}/FakeKitchenridersClient.java | 4 +--- .../{application => infra}/FakePurgomalumClient.java | 4 +--- 5 files changed, 5 insertions(+), 6 deletions(-) rename src/test/java/kitchenpos/{application => infra}/FakeKitchenridersClient.java (75%) rename src/test/java/kitchenpos/{application => infra}/FakePurgomalumClient.java (84%) diff --git a/src/test/java/kitchenpos/application/OrderServiceTest.java b/src/test/java/kitchenpos/application/OrderServiceTest.java index 7e9961091..c13c060c0 100644 --- a/src/test/java/kitchenpos/application/OrderServiceTest.java +++ b/src/test/java/kitchenpos/application/OrderServiceTest.java @@ -2,6 +2,7 @@ import kitchenpos.application.fixture.*; import kitchenpos.domain.*; +import kitchenpos.infra.FakeKitchenridersClient; import kitchenpos.infra.KitchenridersClient; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; diff --git a/src/test/java/kitchenpos/application/OrderTableServiceTest.java b/src/test/java/kitchenpos/application/OrderTableServiceTest.java index ac165a81e..f3e20915f 100644 --- a/src/test/java/kitchenpos/application/OrderTableServiceTest.java +++ b/src/test/java/kitchenpos/application/OrderTableServiceTest.java @@ -2,6 +2,7 @@ import kitchenpos.application.fixture.*; import kitchenpos.domain.*; +import kitchenpos.infra.FakeKitchenridersClient; import kitchenpos.infra.KitchenridersClient; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.DisplayName; diff --git a/src/test/java/kitchenpos/application/ProductServiceTest.java b/src/test/java/kitchenpos/application/ProductServiceTest.java index d74f0f4d6..354312965 100644 --- a/src/test/java/kitchenpos/application/ProductServiceTest.java +++ b/src/test/java/kitchenpos/application/ProductServiceTest.java @@ -5,6 +5,7 @@ import kitchenpos.application.fixture.MenuProductFixture; import kitchenpos.application.fixture.ProductFixture; import kitchenpos.domain.*; +import kitchenpos.infra.FakePurgomalumClient; import kitchenpos.infra.PurgomalumClient; import org.assertj.core.groups.Tuple; import org.junit.jupiter.api.BeforeEach; diff --git a/src/test/java/kitchenpos/application/FakeKitchenridersClient.java b/src/test/java/kitchenpos/infra/FakeKitchenridersClient.java similarity index 75% rename from src/test/java/kitchenpos/application/FakeKitchenridersClient.java rename to src/test/java/kitchenpos/infra/FakeKitchenridersClient.java index e1d6adb10..15d03ece7 100644 --- a/src/test/java/kitchenpos/application/FakeKitchenridersClient.java +++ b/src/test/java/kitchenpos/infra/FakeKitchenridersClient.java @@ -1,6 +1,4 @@ -package kitchenpos.application; - -import kitchenpos.infra.KitchenridersClient; +package kitchenpos.infra; import java.math.BigDecimal; import java.util.UUID; diff --git a/src/test/java/kitchenpos/application/FakePurgomalumClient.java b/src/test/java/kitchenpos/infra/FakePurgomalumClient.java similarity index 84% rename from src/test/java/kitchenpos/application/FakePurgomalumClient.java rename to src/test/java/kitchenpos/infra/FakePurgomalumClient.java index b5e794fe4..fe3fc55f8 100644 --- a/src/test/java/kitchenpos/application/FakePurgomalumClient.java +++ b/src/test/java/kitchenpos/infra/FakePurgomalumClient.java @@ -1,6 +1,4 @@ -package kitchenpos.application; - -import kitchenpos.infra.PurgomalumClient; +package kitchenpos.infra; import java.util.List; From cf594ca8b2003bc6a3e63cbcfdbee6e08a1eff7a Mon Sep 17 00:00:00 2001 From: skdev0619 Date: Thu, 6 Feb 2025 10:43:41 +0900 Subject: [PATCH 22/29] =?UTF-8?q?=EB=A9=94=EB=89=B4=20=EC=9A=94=EA=B5=AC?= =?UTF-8?q?=EC=82=AC=ED=95=AD=20=ED=86=B5=ED=95=A9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 2 +- .../application/MenuServiceTest.java | 20 ++----------------- 2 files changed, 3 insertions(+), 19 deletions(-) diff --git a/README.md b/README.md index fa4a0505c..d8dceda31 100644 --- a/README.md +++ b/README.md @@ -47,7 +47,7 @@ ex) > 새우버거 > 새우버거세트 > 사이다 > 치즈스틱 ``` - [x] 메뉴를 등록할 수 있다 - - [x] 단일 또는 여러 상품을 조합하여 메뉴를 만들 수 있다 + - [x] 메뉴는 1가지 이상의 상품으로 등록 가능하다 - [x] 각 메뉴를 구성하는 상품과 그 수량을 선택할 수 있다 - [x] 각 메뉴를 구성하는 상품의 수량은 0이상이어야 한다 - [x] 메뉴는 메뉴명, 가격, 메뉴판 전시 여부(전시 O/ 전시 X), 메뉴그룹을 가진다 diff --git a/src/test/java/kitchenpos/application/MenuServiceTest.java b/src/test/java/kitchenpos/application/MenuServiceTest.java index c5411691b..b6244fb53 100644 --- a/src/test/java/kitchenpos/application/MenuServiceTest.java +++ b/src/test/java/kitchenpos/application/MenuServiceTest.java @@ -5,6 +5,7 @@ import kitchenpos.application.fixture.MenuProductFixture; import kitchenpos.application.fixture.ProductFixture; import kitchenpos.domain.*; +import kitchenpos.infra.FakePurgomalumClient; import kitchenpos.infra.PurgomalumClient; import org.assertj.core.groups.Tuple; import org.junit.jupiter.api.BeforeEach; @@ -54,25 +55,8 @@ void setUp() { @DisplayName("메뉴를 생성할 수 있다") @Nested class MenuCreator { - @DisplayName("단일 상품으로 메뉴를 등록할 수 있다") - @Test - void createMenuByProduct() { - MenuProduct chickenBurger = MenuProductFixture.createMenuProduct(BURGER_PRODUCT_ID, 1); - Menu menu = MenuFixture.createMenu(MENU_GROUP_ID, "치킨버거", new BigDecimal(7000), List.of(chickenBurger)); - - Menu resultMenu = menuService.create(menu); - - assertAll( - () -> assertThat(resultMenu.getName()).isEqualTo("치킨버거"), - () -> assertThat(resultMenu.getPrice()).isEqualTo(new BigDecimal(7000)), - () -> assertThat(resultMenu.isDisplayed()).isFalse(), - () -> assertThat(resultMenu.getMenuProducts()).hasSize(1), - () -> assertThat(resultMenu.getMenuGroup()).isNotNull(), - () -> assertThat(resultMenu.getMenuGroup().getId()).isEqualTo(MENU_GROUP_ID) - ); - } - @DisplayName("여러 상품으로 조합하여 하나의 메뉴를 등록할 수 있다") + @DisplayName("메뉴는 1가지 이상의 상품으로 등록 가능하다") @Test void createMenuByProducts() { //given From 76f58e9275cd7a2c6b11744816aab77d1a71c83e Mon Sep 17 00:00:00 2001 From: skdev0619 Date: Thu, 6 Feb 2025 11:01:33 +0900 Subject: [PATCH 23/29] =?UTF-8?q?OrderTable=20ReflectionTestUtils=20?= =?UTF-8?q?=EC=A0=9C=EA=B1=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../application/OrderTableServiceTest.java | 31 +++++++------------ .../application/fixture/OrderFixture.java | 6 ++++ 2 files changed, 17 insertions(+), 20 deletions(-) diff --git a/src/test/java/kitchenpos/application/OrderTableServiceTest.java b/src/test/java/kitchenpos/application/OrderTableServiceTest.java index f3e20915f..57a2f7ba0 100644 --- a/src/test/java/kitchenpos/application/OrderTableServiceTest.java +++ b/src/test/java/kitchenpos/application/OrderTableServiceTest.java @@ -98,33 +98,24 @@ class TableCleaner { @DisplayName("테이블의 주문 상태가 완료가 아니면 정리할 수 없다") @EnumSource(value = OrderStatus.class, names = "COMPLETED", mode = EnumSource.Mode.EXCLUDE) @ParameterizedTest - void validateOrderStatus(OrderStatus status) { + void validateOrderStatus(OrderStatus orderStatus) { //given - OrderTable orderTable = orderTableService.create(OrderTableFixture.createOrderTable("1번테이블")); - orderTableService.sit(orderTable.getId()); - ReflectionTestUtils.setField(orderTable, "numberOfGuests", 4); - orderTableService.changeNumberOfGuests(orderTable.getId(), orderTable); - - Order order = createUnnamedOrder(orderTable.getId()); + OrderTable occupiedOrderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(UUID.randomUUID(), "1번테이블", true, 4)); + Order order = createUnnamedOrder(occupiedOrderTable.getId(), orderStatus); //when, then - ReflectionTestUtils.setField(order, "status", status); assertThatIllegalStateException() - .isThrownBy(() -> orderTableService.clear(orderTable.getId())); + .isThrownBy(() -> orderTableService.clear(occupiedOrderTable.getId())); } @DisplayName("테이블 정리하면 손님의 수 0명, 테이블 사용유무 안함으로 변경된다") @Test void clear() { //given - OrderTable orderTable = orderTableService.create(OrderTableFixture.createOrderTable("1번테이블")); - orderTableService.sit(orderTable.getId()); - ReflectionTestUtils.setField(orderTable, "numberOfGuests", 4); - orderTableService.changeNumberOfGuests(orderTable.getId(), orderTable); - - Order order = createUnnamedOrder(orderTable.getId()); + OrderTable occupiedOrderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(UUID.randomUUID(), "1번테이블", true, 4)); + Order order = createUnnamedOrder(occupiedOrderTable.getId(), OrderStatus.COMPLETED); //when ReflectionTestUtils.setField(order, "status", OrderStatus.COMPLETED); - OrderTable clearOrder = orderTableService.clear(orderTable.getId()); + OrderTable clearOrder = orderTableService.clear(occupiedOrderTable.getId()); //then assertThat(clearOrder.getNumberOfGuests()).isZero(); assertThat(clearOrder.isOccupied()).isFalse(); @@ -177,17 +168,17 @@ void findAll() { } //endregion - private Order createEatInOrder(List orderLineItems, UUID orderTableId, LocalDateTime orderDateTime) { - return OrderFixture.createOrder(OrderType.EAT_IN, orderLineItems, null, orderTableId, orderDateTime); + private Order createEatInOrder(List orderLineItems, UUID orderTableId, OrderStatus orderStatus, LocalDateTime orderDateTime) { + return OrderFixture.createOrder(OrderType.EAT_IN, orderLineItems, null, orderTableId, orderStatus, orderDateTime); } - private Order createUnnamedOrder(UUID orderTableId) { + private Order createUnnamedOrder(UUID orderTableId, OrderStatus orderStatus) { Product unnamedProduct = productRepository.save(ProductFixture.createProduct(UUID.randomUUID(), "unnamed", BigDecimal.ZERO)); MenuGroup menuGroup = menuGroupRepository.save(MenuGroupFixture.createMenuGroup(UUID.randomUUID(), "unnamed")); MenuProduct displayMenuProduct = MenuProductFixture.createMenuProduct(unnamedProduct, 1); Menu unknownMenu = menuRepository.save(MenuFixture.createMenu(UUID.randomUUID(), menuGroup, menuGroup.getId(), "unnamed", BigDecimal.ZERO, true, List.of(displayMenuProduct))); OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(unknownMenu.getId(), BigDecimal.ZERO, 1); - return orderService.create(createEatInOrder(List.of(orderLineItem), orderTableId, LocalDateTime.now())); + return orderService.create(createEatInOrder(List.of(orderLineItem), orderTableId, orderStatus, LocalDateTime.now())); } } \ No newline at end of file diff --git a/src/test/java/kitchenpos/application/fixture/OrderFixture.java b/src/test/java/kitchenpos/application/fixture/OrderFixture.java index 31726291e..1cbdc3f17 100644 --- a/src/test/java/kitchenpos/application/fixture/OrderFixture.java +++ b/src/test/java/kitchenpos/application/fixture/OrderFixture.java @@ -2,6 +2,7 @@ import kitchenpos.domain.Order; import kitchenpos.domain.OrderLineItem; +import kitchenpos.domain.OrderStatus; import kitchenpos.domain.OrderType; import java.math.BigDecimal; @@ -12,11 +13,16 @@ public class OrderFixture { public static Order createOrder(OrderType orderType, List orderLineItems, String deliveryAddress, UUID orderTableId, LocalDateTime orderDateTime) { + return createOrder(orderType, orderLineItems, deliveryAddress, orderTableId, null, orderDateTime); + } + + public static Order createOrder(OrderType orderType, List orderLineItems, String deliveryAddress, UUID orderTableId, OrderStatus orderStatus, LocalDateTime orderDateTime) { Order order = new Order(); order.setType(orderType); order.setOrderLineItems(orderLineItems); order.setDeliveryAddress(deliveryAddress); order.setOrderTableId(orderTableId); + order.setStatus(orderStatus); order.setOrderDateTime(orderDateTime); return order; } From da95afc418f3b305cfe741a3ea2f95662ed2301b Mon Sep 17 00:00:00 2001 From: skdev0619 Date: Thu, 6 Feb 2025 12:55:45 +0900 Subject: [PATCH 24/29] =?UTF-8?q?Order=20ReflectionTestUtils=20=EC=A0=9C?= =?UTF-8?q?=EA=B1=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../application/OrderServiceTest.java | 133 ++++++++---------- .../application/fixture/OrderFixture.java | 32 ++++- 2 files changed, 89 insertions(+), 76 deletions(-) diff --git a/src/test/java/kitchenpos/application/OrderServiceTest.java b/src/test/java/kitchenpos/application/OrderServiceTest.java index c13c060c0..101ead749 100644 --- a/src/test/java/kitchenpos/application/OrderServiceTest.java +++ b/src/test/java/kitchenpos/application/OrderServiceTest.java @@ -268,10 +268,8 @@ void acceptOrderStatus() { @ParameterizedTest void validateAcceptStatus(OrderStatus orderStatus) { OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); - Order takeOutOrder = orderService.create(takeOutRequest); + Order takeOutOrder = orderRepository.save(createTakeOutOrder(List.of(orderLineItem), orderStatus, LocalDateTime.now())); - ReflectionTestUtils.setField(takeOutOrder, "status", orderStatus); assertThatIllegalStateException() .isThrownBy(() -> orderService.accept(takeOutOrder.getId())); } @@ -282,30 +280,27 @@ void validateAcceptStatus(OrderStatus orderStatus) { @Nested class OrderServer { - @DisplayName("주문 상태를 음식 제공됨(SERVED)로 변경한다") - @Test - void served() { + @DisplayName("주문의 상태가 주문 수락(ACCEPTED)일 때, 음식 제공됨(SERVED)로 변경한다") + @EnumSource(value = OrderStatus.class, names = "ACCEPTED", mode = EnumSource.Mode.INCLUDE) + @ParameterizedTest + void served(OrderStatus orderStatus) { OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); - Order takeOutOrder = orderService.create(takeOutRequest); - Order acceptOrder = orderService.accept(takeOutOrder.getId()); + Order acceptOrder = orderRepository.save(createTakeOutOrder(List.of(orderLineItem), orderStatus, LocalDateTime.now())); Order servedOrder = orderService.serve(acceptOrder.getId()); assertThat(servedOrder.getStatus()).isEqualTo(OrderStatus.SERVED); } - @DisplayName("주문의 상태가 주문 수락(ACCEPTED)일 때 음식 제공 가능하다") + @DisplayName("주문의 상태가 주문 수락(ACCEPTED)이 아니면 예외가 발생한다") @EnumSource(value = OrderStatus.class, names = "ACCEPTED", mode = EnumSource.Mode.EXCLUDE) @ParameterizedTest void validateServedStatus(OrderStatus orderStatus) { OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); - Order takeOutOrder = orderService.create(takeOutRequest); + Order order = orderRepository.save(createTakeOutOrder(List.of(orderLineItem), orderStatus, LocalDateTime.now())); - ReflectionTestUtils.setField(takeOutOrder, "status", orderStatus); assertThatIllegalStateException() - .isThrownBy(() -> orderService.serve(takeOutOrder.getId())); + .isThrownBy(() -> orderService.serve(order.getId())); } } @@ -314,28 +309,25 @@ void validateServedStatus(OrderStatus orderStatus) { @Nested class DeliveryStarter { - @DisplayName("배달 주문의 경우 음식이 제공되면 주문 상태를 배달 중(DELIVERING)으로 변경한다") - @Test - void startDelivery() { + @DisplayName("주문 상태가 음식 제공됨(SERVED)인 경우, 주문 상태를 배달 중(DELIVERING)으로 변경한다") + @EnumSource(value = OrderStatus.class, names = "SERVED", mode = EnumSource.Mode.INCLUDE) + @ParameterizedTest + void startDelivery(OrderStatus orderStatus) { OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", LocalDateTime.now()); - Order order = orderService.create(deliveryOrderRequest); + Order order = orderRepository.save(createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", orderStatus, LocalDateTime.now())); - ReflectionTestUtils.setField(order, "status", OrderStatus.SERVED); Order deliveryStartorder = orderService.startDelivery(order.getId()); assertThat(deliveryStartorder.getStatus()).isEqualTo(OrderStatus.DELIVERING); } - @DisplayName("주문 상태가 음식 제공됨(SERVED)인 경우, 배달 시작이 가능하다") + @DisplayName("주문 상태가 음식 제공됨(SERVED)이 아니면 예외가 발생한다") @EnumSource(value = OrderStatus.class, names = "SERVED", mode = EnumSource.Mode.EXCLUDE) @ParameterizedTest void validateDeliveryStartStatus(OrderStatus orderStatus) { OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", LocalDateTime.now()); - Order order = orderService.create(deliveryOrderRequest); + Order order = orderRepository.save(createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", orderStatus, LocalDateTime.now())); - ReflectionTestUtils.setField(order, "status", orderStatus); assertThatIllegalStateException() .isThrownBy(() -> orderService.startDelivery(order.getId())); } @@ -345,28 +337,26 @@ void validateDeliveryStartStatus(OrderStatus orderStatus) { @Nested class DeliveryCompleter { - @DisplayName("배달 완료한 주문 상태를 배달완료(DELIVERED)로 변경한다") - @Test - void endDelivery() { + @DisplayName("주문 상태가 배달 중(DELIVERING)인 경우, 배달완료(DELIVERED)로 변경한다") + @ParameterizedTest + @EnumSource(value = OrderStatus.class, names = "DELIVERING", mode = EnumSource.Mode.INCLUDE) + void endDelivery(OrderStatus orderStatus) { OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", LocalDateTime.now()); - Order order = orderService.create(deliveryOrderRequest); + Order order = orderRepository.save(createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", orderStatus, LocalDateTime.now())); - ReflectionTestUtils.setField(order, "status", OrderStatus.DELIVERING); Order deliveryStartorder = orderService.completeDelivery(order.getId()); assertThat(deliveryStartorder.getStatus()).isEqualTo(OrderStatus.DELIVERED); } - @DisplayName("주문 상태가 배달 중(DELIVERING)인 경우, 배달완료(DELIVERED)로 변경 가능하다") + @DisplayName("주문 상태가 배달 중(DELIVERING)가 아니면 예외가 발생한다") @ParameterizedTest @EnumSource(value = OrderStatus.class, names = "DELIVERING", mode = EnumSource.Mode.EXCLUDE) void validateDeliveryEndStatus(OrderStatus orderStatus) { OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", LocalDateTime.now()); - Order order = orderService.create(deliveryOrderRequest); - ReflectionTestUtils.setField(order, "status", orderStatus); + Order order = orderService.create(createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", orderStatus, LocalDateTime.now())); + assertThatIllegalStateException() .isThrownBy(() -> orderService.completeDelivery(order.getId())); } @@ -376,52 +366,50 @@ void validateDeliveryEndStatus(OrderStatus orderStatus) { @Nested class OrderCompleter { - @DisplayName("배달 주문의 상태를 주문 완료로 변경한다") - @Test - void complete() { + @DisplayName("배달 주문의 경우, 주문의 상태가 배달 완료(DELIVERED)인 경우만, 주문의 상태를 주문 완료로 변경한다") + @EnumSource(value = OrderStatus.class, names = "DELIVERED", mode = EnumSource.Mode.INCLUDE) + @ParameterizedTest + void complete(OrderStatus orderStatus) { //given OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", LocalDateTime.now()); - Order order = createDeliveredOrder(deliveryOrderRequest); + Order order = orderRepository.save(createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", orderStatus, LocalDateTime.now())); //when Order complete = orderService.complete(order.getId()); //then assertThat(complete.getStatus()).isEqualTo(OrderStatus.COMPLETED); } - @DisplayName("배달 주문의 경우, 주문의 상태가 배달 완료(DELIVERED)인 경우만 주문을 완료할 수 있다") + @DisplayName("배달 주문의 경우, 주문의 상태가 배달 완료(DELIVERED)아니면 예외가 발생한다") @EnumSource(value = OrderStatus.class, names = "DELIVERED", mode = EnumSource.Mode.EXCLUDE) @ParameterizedTest void completeOrderByDelivery(OrderStatus orderStatus) { OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", LocalDateTime.now()); - Order order = orderService.create(deliveryOrderRequest); + Order order = orderRepository.save(createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", orderStatus, LocalDateTime.now())); - ReflectionTestUtils.setField(order, "status", orderStatus); assertThatIllegalStateException() .isThrownBy(() -> orderService.complete(order.getId())); } - @DisplayName("포장 주문의 상태를 주문 완료로 변경한다") - @Test - void completeByTakeOut() { + @DisplayName("포장 주문의 경우, 주문의 상태가(SERVED)인 경우만 상태를 주문 완료로 변경한다") + @EnumSource(value = OrderStatus.class, names = "SERVED", mode = EnumSource.Mode.INCLUDE) + @ParameterizedTest + void completeByTakeOut(OrderStatus orderStatus) { //given OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); - Order servedOrder = createServedOrder(takeOutRequest); + Order servedOrder = orderRepository.save(createTakeOutOrder(List.of(orderLineItem), orderStatus, LocalDateTime.now())); //when Order complete = orderService.complete(servedOrder.getId()); //then assertThat(complete.getStatus()).isEqualTo(OrderStatus.COMPLETED); } - @DisplayName("매장 내 취식 주문 상태를 주문 완료로 변경한다") - @Test - void completeByEatIn() { + @DisplayName("매장 내 취식의 경우, 주문의 상태가(SERVED)인 경우만 주문 상태를 주문 완료로 변경한다") + @EnumSource(value = OrderStatus.class, names = "SERVED", mode = EnumSource.Mode.INCLUDE) + @ParameterizedTest + void completeByEatIn(OrderStatus orderStatus) { OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); OrderTable orderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); - Order eatInRequest = createEatInOrder(List.of(orderLineItem), orderTable.getId(), LocalDateTime.now()); - Order servedOrder = createServedOrder(eatInRequest); + Order servedOrder = orderRepository.save(createEatInOrder(List.of(orderLineItem), orderTable, orderStatus, LocalDateTime.now())); //when Order complete = orderService.complete(servedOrder.getId()); //then @@ -459,10 +447,10 @@ void completeOrderByEatIn() { //given OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); OrderTable orderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); - Order eatInRequest = createEatInOrder(List.of(orderLineItem), orderTable.getId(), LocalDateTime.now()); + //주문 상태가 SERVED인 주문1,2 생성 - Order servedOrder1 = createServedOrder(eatInRequest); - Order servedOrder2 = createServedOrder(eatInRequest); + Order servedOrder1 = orderRepository.save(createEatInOrder(List.of(orderLineItem), orderTable, OrderStatus.SERVED, LocalDateTime.now())); + Order servedOrder2 = orderRepository.save(createEatInOrder(List.of(orderLineItem), orderTable, OrderStatus.SERVED, LocalDateTime.now())); //when Order complete = orderService.complete(servedOrder1.getId()); @@ -481,10 +469,9 @@ void clearOrderTable() { //given OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); OrderTable orderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); - Order eatInRequest = createEatInOrder(List.of(orderLineItem), orderTable.getId(), LocalDateTime.now()); - Order servedOrder1 = createServedOrder(eatInRequest); - Order servedOrder2 = createServedOrder(eatInRequest); + Order servedOrder1 = orderRepository.save(createEatInOrder(List.of(orderLineItem), orderTable, OrderStatus.SERVED, LocalDateTime.now())); + Order servedOrder2 = orderRepository.save(createEatInOrder(List.of(orderLineItem), orderTable, OrderStatus.SERVED, LocalDateTime.now())); //when Order complete1 = orderService.complete(servedOrder1.getId()); @@ -527,28 +514,30 @@ void findAll() { private Order createTakeOutOrder(List orderLineItems, LocalDateTime orderDateTime) { - return OrderFixture.createOrder(OrderType.TAKEOUT, orderLineItems, null, null, orderDateTime); + return createTakeOutOrder(orderLineItems, null, orderDateTime); } private Order createDeliveryOrder(List orderLineItems, String deliveryAddress, LocalDateTime orderDateTime) { - return OrderFixture.createOrder(OrderType.DELIVERY, orderLineItems, deliveryAddress, null, orderDateTime); + return createDeliveryOrder(orderLineItems, deliveryAddress, null, orderDateTime); } private Order createEatInOrder(List orderLineItems, UUID orderTableId, LocalDateTime orderDateTime) { - return OrderFixture.createOrder(OrderType.EAT_IN, orderLineItems, null, orderTableId, orderDateTime); + return createEatInOrder(orderLineItems, orderTableId, null, orderDateTime); + } + + private Order createTakeOutOrder(List orderLineItems, OrderStatus orderStatus, LocalDateTime orderDateTime) { + return OrderFixture.createOrder(OrderType.TAKEOUT, orderLineItems, null, null, orderStatus, orderDateTime); + } + + private Order createDeliveryOrder(List orderLineItems, String deliveryAddress, OrderStatus orderStatus, LocalDateTime orderDateTime) { + return OrderFixture.createOrder(OrderType.DELIVERY, orderLineItems, deliveryAddress, null, orderStatus, orderDateTime); } - private Order createDeliveredOrder(Order deliveryOrder) { - Order order = orderService.create(deliveryOrder); - Order accept = orderService.accept(order.getId()); - Order serve = orderService.serve(accept.getId()); - Order startDelivery = orderService.startDelivery(serve.getId()); - return orderService.completeDelivery(startDelivery.getId()); + private Order createEatInOrder(List orderLineItems, OrderTable orderTable, OrderStatus orderStatus, LocalDateTime orderDateTime) { + return OrderFixture.createOrder(OrderType.EAT_IN, orderLineItems, orderTable, orderStatus, orderDateTime); } - private Order createServedOrder(Order orderRequest) { - Order takeOutOrder = orderService.create(orderRequest); - Order accept = orderService.accept(takeOutOrder.getId()); - return orderService.serve(accept.getId()); + private Order createEatInOrder(List orderLineItems, UUID orderTableId, OrderStatus orderStatus, LocalDateTime orderDateTime) { + return OrderFixture.createOrder(OrderType.EAT_IN, orderLineItems, orderTableId, orderStatus, orderDateTime); } } diff --git a/src/test/java/kitchenpos/application/fixture/OrderFixture.java b/src/test/java/kitchenpos/application/fixture/OrderFixture.java index 1cbdc3f17..afcbe5836 100644 --- a/src/test/java/kitchenpos/application/fixture/OrderFixture.java +++ b/src/test/java/kitchenpos/application/fixture/OrderFixture.java @@ -1,9 +1,6 @@ package kitchenpos.application.fixture; -import kitchenpos.domain.Order; -import kitchenpos.domain.OrderLineItem; -import kitchenpos.domain.OrderStatus; -import kitchenpos.domain.OrderType; +import kitchenpos.domain.*; import java.math.BigDecimal; import java.time.LocalDateTime; @@ -17,7 +14,34 @@ public static Order createOrder(OrderType orderType, List orderLi } public static Order createOrder(OrderType orderType, List orderLineItems, String deliveryAddress, UUID orderTableId, OrderStatus orderStatus, LocalDateTime orderDateTime) { + return createOrder(UUID.randomUUID(), orderType, orderLineItems, deliveryAddress, orderTableId, orderStatus, orderDateTime); + } + + public static Order createOrder(OrderType orderType, List orderLineItems, OrderTable orderTable, OrderStatus orderStatus, LocalDateTime orderDateTime) { + Order order = new Order(); + order.setId(UUID.randomUUID()); + order.setType(orderType); + order.setOrderLineItems(orderLineItems); + order.setOrderTable(orderTable); + order.setStatus(orderStatus); + order.setOrderDateTime(orderDateTime); + return order; + } + + public static Order createOrder(OrderType orderType, List orderLineItems, UUID orderTableId, OrderStatus orderStatus, LocalDateTime orderDateTime) { + Order order = new Order(); + order.setId(UUID.randomUUID()); + order.setType(orderType); + order.setOrderLineItems(orderLineItems); + order.setOrderTableId(orderTableId); + order.setStatus(orderStatus); + order.setOrderDateTime(orderDateTime); + return order; + } + + public static Order createOrder(UUID id, OrderType orderType, List orderLineItems, String deliveryAddress, UUID orderTableId, OrderStatus orderStatus, LocalDateTime orderDateTime) { Order order = new Order(); + order.setId(id); order.setType(orderType); order.setOrderLineItems(orderLineItems); order.setDeliveryAddress(deliveryAddress); From ad64f0884101e9462e574c3ebca6c119c627b526 Mon Sep 17 00:00:00 2001 From: skdev0619 Date: Fri, 7 Feb 2025 11:38:46 +0900 Subject: [PATCH 25/29] =?UTF-8?q?fake=20=ED=8C=A8=ED=82=A4=EC=A7=80=20?= =?UTF-8?q?=EC=83=9D=EC=84=B1?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/test/java/kitchenpos/application/MenuGroupServiceTest.java | 1 + src/test/java/kitchenpos/application/MenuServiceTest.java | 3 +++ src/test/java/kitchenpos/application/OrderServiceTest.java | 1 + .../java/kitchenpos/application/OrderTableServiceTest.java | 1 + src/test/java/kitchenpos/application/ProductServiceTest.java | 3 +++ .../application/{ => fake}/InMemoryMenuGroupRepository.java | 2 +- .../application/{ => fake}/InMemoryMenuRepository.java | 2 +- .../application/{ => fake}/InMemoryOrderRepository.java | 2 +- .../application/{ => fake}/InMemoryOrderTableRepository.java | 2 +- .../application/{ => fake}/InMemoryProductRepository.java | 2 +- 10 files changed, 14 insertions(+), 5 deletions(-) rename src/test/java/kitchenpos/application/{ => fake}/InMemoryMenuGroupRepository.java (94%) rename src/test/java/kitchenpos/application/{ => fake}/InMemoryMenuRepository.java (96%) rename src/test/java/kitchenpos/application/{ => fake}/InMemoryOrderRepository.java (96%) rename src/test/java/kitchenpos/application/{ => fake}/InMemoryOrderTableRepository.java (95%) rename src/test/java/kitchenpos/application/{ => fake}/InMemoryProductRepository.java (95%) diff --git a/src/test/java/kitchenpos/application/MenuGroupServiceTest.java b/src/test/java/kitchenpos/application/MenuGroupServiceTest.java index f4bdc4156..8a1c245a9 100644 --- a/src/test/java/kitchenpos/application/MenuGroupServiceTest.java +++ b/src/test/java/kitchenpos/application/MenuGroupServiceTest.java @@ -1,5 +1,6 @@ package kitchenpos.application; +import kitchenpos.application.fake.InMemoryMenuGroupRepository; import kitchenpos.application.fixture.MenuGroupFixture; import kitchenpos.domain.MenuGroup; import kitchenpos.domain.MenuGroupRepository; diff --git a/src/test/java/kitchenpos/application/MenuServiceTest.java b/src/test/java/kitchenpos/application/MenuServiceTest.java index b6244fb53..71ba168e9 100644 --- a/src/test/java/kitchenpos/application/MenuServiceTest.java +++ b/src/test/java/kitchenpos/application/MenuServiceTest.java @@ -1,5 +1,8 @@ package kitchenpos.application; +import kitchenpos.application.fake.InMemoryMenuGroupRepository; +import kitchenpos.application.fake.InMemoryMenuRepository; +import kitchenpos.application.fake.InMemoryProductRepository; import kitchenpos.application.fixture.MenuFixture; import kitchenpos.application.fixture.MenuGroupFixture; import kitchenpos.application.fixture.MenuProductFixture; diff --git a/src/test/java/kitchenpos/application/OrderServiceTest.java b/src/test/java/kitchenpos/application/OrderServiceTest.java index 101ead749..d0e6b593f 100644 --- a/src/test/java/kitchenpos/application/OrderServiceTest.java +++ b/src/test/java/kitchenpos/application/OrderServiceTest.java @@ -1,5 +1,6 @@ package kitchenpos.application; +import kitchenpos.application.fake.*; import kitchenpos.application.fixture.*; import kitchenpos.domain.*; import kitchenpos.infra.FakeKitchenridersClient; diff --git a/src/test/java/kitchenpos/application/OrderTableServiceTest.java b/src/test/java/kitchenpos/application/OrderTableServiceTest.java index 57a2f7ba0..95c0b1054 100644 --- a/src/test/java/kitchenpos/application/OrderTableServiceTest.java +++ b/src/test/java/kitchenpos/application/OrderTableServiceTest.java @@ -1,5 +1,6 @@ package kitchenpos.application; +import kitchenpos.application.fake.*; import kitchenpos.application.fixture.*; import kitchenpos.domain.*; import kitchenpos.infra.FakeKitchenridersClient; diff --git a/src/test/java/kitchenpos/application/ProductServiceTest.java b/src/test/java/kitchenpos/application/ProductServiceTest.java index 354312965..4d518bacd 100644 --- a/src/test/java/kitchenpos/application/ProductServiceTest.java +++ b/src/test/java/kitchenpos/application/ProductServiceTest.java @@ -1,5 +1,8 @@ package kitchenpos.application; +import kitchenpos.application.fake.InMemoryMenuGroupRepository; +import kitchenpos.application.fake.InMemoryMenuRepository; +import kitchenpos.application.fake.InMemoryProductRepository; import kitchenpos.application.fixture.MenuFixture; import kitchenpos.application.fixture.MenuGroupFixture; import kitchenpos.application.fixture.MenuProductFixture; diff --git a/src/test/java/kitchenpos/application/InMemoryMenuGroupRepository.java b/src/test/java/kitchenpos/application/fake/InMemoryMenuGroupRepository.java similarity index 94% rename from src/test/java/kitchenpos/application/InMemoryMenuGroupRepository.java rename to src/test/java/kitchenpos/application/fake/InMemoryMenuGroupRepository.java index f587340a2..0ae304796 100644 --- a/src/test/java/kitchenpos/application/InMemoryMenuGroupRepository.java +++ b/src/test/java/kitchenpos/application/fake/InMemoryMenuGroupRepository.java @@ -1,4 +1,4 @@ -package kitchenpos.application; +package kitchenpos.application.fake; import kitchenpos.domain.MenuGroup; import kitchenpos.domain.MenuGroupRepository; diff --git a/src/test/java/kitchenpos/application/InMemoryMenuRepository.java b/src/test/java/kitchenpos/application/fake/InMemoryMenuRepository.java similarity index 96% rename from src/test/java/kitchenpos/application/InMemoryMenuRepository.java rename to src/test/java/kitchenpos/application/fake/InMemoryMenuRepository.java index 79fa169e0..2c396ad2a 100644 --- a/src/test/java/kitchenpos/application/InMemoryMenuRepository.java +++ b/src/test/java/kitchenpos/application/fake/InMemoryMenuRepository.java @@ -1,4 +1,4 @@ -package kitchenpos.application; +package kitchenpos.application.fake; import kitchenpos.domain.Menu; import kitchenpos.domain.MenuRepository; diff --git a/src/test/java/kitchenpos/application/InMemoryOrderRepository.java b/src/test/java/kitchenpos/application/fake/InMemoryOrderRepository.java similarity index 96% rename from src/test/java/kitchenpos/application/InMemoryOrderRepository.java rename to src/test/java/kitchenpos/application/fake/InMemoryOrderRepository.java index 2e5c5ef26..8359ec6b7 100644 --- a/src/test/java/kitchenpos/application/InMemoryOrderRepository.java +++ b/src/test/java/kitchenpos/application/fake/InMemoryOrderRepository.java @@ -1,4 +1,4 @@ -package kitchenpos.application; +package kitchenpos.application.fake; import kitchenpos.domain.Order; import kitchenpos.domain.OrderRepository; diff --git a/src/test/java/kitchenpos/application/InMemoryOrderTableRepository.java b/src/test/java/kitchenpos/application/fake/InMemoryOrderTableRepository.java similarity index 95% rename from src/test/java/kitchenpos/application/InMemoryOrderTableRepository.java rename to src/test/java/kitchenpos/application/fake/InMemoryOrderTableRepository.java index c3d012b87..58a70a30a 100644 --- a/src/test/java/kitchenpos/application/InMemoryOrderTableRepository.java +++ b/src/test/java/kitchenpos/application/fake/InMemoryOrderTableRepository.java @@ -1,4 +1,4 @@ -package kitchenpos.application; +package kitchenpos.application.fake; import kitchenpos.domain.OrderTable; import kitchenpos.domain.OrderTableRepository; diff --git a/src/test/java/kitchenpos/application/InMemoryProductRepository.java b/src/test/java/kitchenpos/application/fake/InMemoryProductRepository.java similarity index 95% rename from src/test/java/kitchenpos/application/InMemoryProductRepository.java rename to src/test/java/kitchenpos/application/fake/InMemoryProductRepository.java index 5604f1a08..e336b7328 100644 --- a/src/test/java/kitchenpos/application/InMemoryProductRepository.java +++ b/src/test/java/kitchenpos/application/fake/InMemoryProductRepository.java @@ -1,4 +1,4 @@ -package kitchenpos.application; +package kitchenpos.application.fake; import kitchenpos.domain.Product; import kitchenpos.domain.ProductRepository; From 6ea560e9b047f917bd707a6422935b7f3a97bd36 Mon Sep 17 00:00:00 2001 From: skdev0619 Date: Fri, 7 Feb 2025 12:01:07 +0900 Subject: [PATCH 26/29] =?UTF-8?q?Fixture=20setter=20=EC=A0=9C=EA=B1=B0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../application/fixture/MenuFixture.java | 21 ++++++++++--------- .../application/fixture/MenuGroupFixture.java | 5 +++-- .../fixture/MenuProductFixture.java | 11 +++++----- .../fixture/OrderTableFixture.java | 9 ++++---- .../application/fixture/ProductFixture.java | 7 ++++--- 5 files changed, 29 insertions(+), 24 deletions(-) diff --git a/src/test/java/kitchenpos/application/fixture/MenuFixture.java b/src/test/java/kitchenpos/application/fixture/MenuFixture.java index 5c3f4401e..5b838231a 100644 --- a/src/test/java/kitchenpos/application/fixture/MenuFixture.java +++ b/src/test/java/kitchenpos/application/fixture/MenuFixture.java @@ -3,6 +3,7 @@ import kitchenpos.domain.Menu; import kitchenpos.domain.MenuGroup; import kitchenpos.domain.MenuProduct; +import org.springframework.test.util.ReflectionTestUtils; import java.math.BigDecimal; import java.util.List; @@ -10,19 +11,19 @@ public class MenuFixture { - public static Menu createMenu(UUID menuGroupId, String name, BigDecimal price, List products) { - return createMenu(null, null, menuGroupId, name, price, false, products); + public static Menu createMenu(UUID menuGroupId, String name, BigDecimal price, List menuProducts) { + return createMenu(null, null, menuGroupId, name, price, false, menuProducts); } - public static Menu createMenu(UUID id, MenuGroup menuGroup, UUID menuGroupId, String name, BigDecimal price, boolean displayed, List products) { + public static Menu createMenu(UUID id, MenuGroup menuGroup, UUID menuGroupId, String name, BigDecimal price, boolean displayed, List menuProducts) { Menu menu = new Menu(); - menu.setId(id); - menu.setMenuGroup(menuGroup); - menu.setMenuGroupId(menuGroupId); - menu.setName(name); - menu.setPrice(price); - menu.setDisplayed(displayed); - menu.setMenuProducts(products); + ReflectionTestUtils.setField(menu, "id", id); + ReflectionTestUtils.setField(menu, "menuGroup", menuGroup); + ReflectionTestUtils.setField(menu, "menuGroupId", menuGroupId); + ReflectionTestUtils.setField(menu, "name", name); + ReflectionTestUtils.setField(menu, "price", price); + ReflectionTestUtils.setField(menu, "displayed", displayed); + ReflectionTestUtils.setField(menu, "menuProducts", menuProducts); return menu; } diff --git a/src/test/java/kitchenpos/application/fixture/MenuGroupFixture.java b/src/test/java/kitchenpos/application/fixture/MenuGroupFixture.java index f5054d3a2..cf02f1d50 100644 --- a/src/test/java/kitchenpos/application/fixture/MenuGroupFixture.java +++ b/src/test/java/kitchenpos/application/fixture/MenuGroupFixture.java @@ -1,6 +1,7 @@ package kitchenpos.application.fixture; import kitchenpos.domain.MenuGroup; +import org.springframework.test.util.ReflectionTestUtils; import java.util.UUID; @@ -12,8 +13,8 @@ public static MenuGroup createMenuGroup(String name) { public static MenuGroup createMenuGroup(UUID id, String name) { MenuGroup menuGroup = new MenuGroup(); - menuGroup.setId(id); - menuGroup.setName(name); + ReflectionTestUtils.setField(menuGroup, "id", id); + ReflectionTestUtils.setField(menuGroup, "name", name); return menuGroup; } diff --git a/src/test/java/kitchenpos/application/fixture/MenuProductFixture.java b/src/test/java/kitchenpos/application/fixture/MenuProductFixture.java index f08f0c2ce..3b89f0b80 100644 --- a/src/test/java/kitchenpos/application/fixture/MenuProductFixture.java +++ b/src/test/java/kitchenpos/application/fixture/MenuProductFixture.java @@ -2,6 +2,7 @@ import kitchenpos.domain.MenuProduct; import kitchenpos.domain.Product; +import org.springframework.test.util.ReflectionTestUtils; import java.util.UUID; @@ -9,16 +10,16 @@ public class MenuProductFixture { public static MenuProduct createMenuProduct(UUID productId, int quantity) { MenuProduct menuProduct = new MenuProduct(); - menuProduct.setProductId(productId); - menuProduct.setQuantity(quantity); + ReflectionTestUtils.setField(menuProduct, "productId", productId); + ReflectionTestUtils.setField(menuProduct, "quantity", quantity); return menuProduct; } public static MenuProduct createMenuProduct(Product product, int quantity) { MenuProduct menuProduct = new MenuProduct(); - menuProduct.setProduct(product); - menuProduct.setProductId(product.getId()); - menuProduct.setQuantity(quantity); + ReflectionTestUtils.setField(menuProduct, "product", product); + ReflectionTestUtils.setField(menuProduct, "productId", product.getId()); + ReflectionTestUtils.setField(menuProduct, "quantity", quantity); return menuProduct; } diff --git a/src/test/java/kitchenpos/application/fixture/OrderTableFixture.java b/src/test/java/kitchenpos/application/fixture/OrderTableFixture.java index 37a36db48..99e9d02df 100644 --- a/src/test/java/kitchenpos/application/fixture/OrderTableFixture.java +++ b/src/test/java/kitchenpos/application/fixture/OrderTableFixture.java @@ -1,6 +1,7 @@ package kitchenpos.application.fixture; import kitchenpos.domain.OrderTable; +import org.springframework.test.util.ReflectionTestUtils; import java.util.UUID; @@ -16,10 +17,10 @@ public static OrderTable createOrderTable(UUID id, String name, int numberOfGues public static OrderTable createOrderTable(UUID id, String name, boolean occupied, int numberOfGuests) { OrderTable orderTable = new OrderTable(); - orderTable.setId(id); - orderTable.setName(name); - orderTable.setOccupied(occupied); - orderTable.setNumberOfGuests(numberOfGuests); + ReflectionTestUtils.setField(orderTable, "id", id); + ReflectionTestUtils.setField(orderTable, "name", name); + ReflectionTestUtils.setField(orderTable, "occupied", occupied); + ReflectionTestUtils.setField(orderTable, "numberOfGuests", numberOfGuests); return orderTable; } diff --git a/src/test/java/kitchenpos/application/fixture/ProductFixture.java b/src/test/java/kitchenpos/application/fixture/ProductFixture.java index 35890e582..510930162 100644 --- a/src/test/java/kitchenpos/application/fixture/ProductFixture.java +++ b/src/test/java/kitchenpos/application/fixture/ProductFixture.java @@ -1,6 +1,7 @@ package kitchenpos.application.fixture; import kitchenpos.domain.Product; +import org.springframework.test.util.ReflectionTestUtils; import java.math.BigDecimal; import java.util.UUID; @@ -13,9 +14,9 @@ public static Product createProduct(String name, BigDecimal price) { public static Product createProduct(UUID id, String name, BigDecimal price) { Product product = new Product(); - product.setId(id); - product.setName(name); - product.setPrice(price); + ReflectionTestUtils.setField(product, "id", id); + ReflectionTestUtils.setField(product, "name", name); + ReflectionTestUtils.setField(product, "price", price); return product; } From c0344aaabffd88809f21839d1e6ce34609dbef60 Mon Sep 17 00:00:00 2001 From: skdev0619 Date: Fri, 7 Feb 2025 12:10:47 +0900 Subject: [PATCH 27/29] =?UTF-8?q?=EB=A9=94=EB=89=B4=EB=A5=BC=20=EB=B9=88?= =?UTF-8?q?=20=EC=83=81=ED=92=88=20=EB=98=90=EB=8A=94=20=EC=83=81=ED=92=88?= =?UTF-8?q?=20=EC=97=86=EC=9D=B4=20=EB=93=B1=EB=A1=9D=ED=95=98=EB=A9=B4=20?= =?UTF-8?q?=EC=98=88=EC=99=B8=EA=B0=80=20=EB=B0=9C=EC=83=9D=ED=95=9C?= =?UTF-8?q?=EB=8B=A4?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../kitchenpos/application/MenuServiceTest.java | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/src/test/java/kitchenpos/application/MenuServiceTest.java b/src/test/java/kitchenpos/application/MenuServiceTest.java index 71ba168e9..08e0eb452 100644 --- a/src/test/java/kitchenpos/application/MenuServiceTest.java +++ b/src/test/java/kitchenpos/application/MenuServiceTest.java @@ -16,6 +16,7 @@ import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.NullAndEmptySource; import org.junit.jupiter.params.provider.NullSource; import org.junit.jupiter.params.provider.ValueSource; import org.springframework.test.util.ReflectionTestUtils; @@ -85,6 +86,22 @@ void createMenuByProducts() { ); } + @DisplayName("메뉴를 빈 상품 또는 상품 없이 등록하면 예외가 발생한다") + @NullAndEmptySource + @ParameterizedTest + void emptyOrNullProduct(List menuProducts) { + //given + Menu menu = MenuFixture.createMenu( + MENU_GROUP_ID, + "치킨버거세트", + new BigDecimal(10000), + menuProducts + ); + //when, then + assertThatIllegalArgumentException() + .isThrownBy(() -> menuService.create(menu)); + } + @DisplayName("각 메뉴를 구성하는 상품의 수량은 0이상이어야 한다") @Test void validateMenuProductQuantity() { From 46a206bd5648b052ca601a89c91d9bd08028a3c6 Mon Sep 17 00:00:00 2001 From: skdev0619 Date: Fri, 7 Feb 2025 13:08:43 +0900 Subject: [PATCH 28/29] =?UTF-8?q?orderTableId=20=EC=82=AC=EC=9A=A9?= =?UTF-8?q?=ED=95=98=EC=A7=80=20=EC=95=8A=EB=8F=84=EB=A1=9D=20=EB=B3=80?= =?UTF-8?q?=EA=B2=BD=20&=20OrderFixture=20=EC=88=98=EC=A0=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../application/OrderServiceTest.java | 35 ++++++------ .../application/OrderTableServiceTest.java | 12 ++--- .../application/fixture/OrderFixture.java | 53 +++++++------------ 3 files changed, 40 insertions(+), 60 deletions(-) diff --git a/src/test/java/kitchenpos/application/OrderServiceTest.java b/src/test/java/kitchenpos/application/OrderServiceTest.java index d0e6b593f..e9023ce8a 100644 --- a/src/test/java/kitchenpos/application/OrderServiceTest.java +++ b/src/test/java/kitchenpos/application/OrderServiceTest.java @@ -71,10 +71,9 @@ class OrderCreator { @DisplayName("주문의 종류는 반드시 입력해야 한다") @NullSource @ParameterizedTest - void orderType(OrderType status) { + void orderType(OrderType orderType) { OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal("25000"), 1); - Order nullOrderTypeRequest = OrderFixture.createOrder(status, List.of(orderLineItem), "", null, null); - + Order nullOrderTypeRequest = OrderFixture.createOrder(orderType, List.of(orderLineItem), "", null, null, null, LocalDateTime.now()); assertThatIllegalArgumentException() .isThrownBy(() -> orderService.create(nullOrderTypeRequest)); } @@ -121,7 +120,7 @@ void eatInOrder() { OrderTable orderTable = orderTableRepository.save(request); OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal("25000"), 1); - Order orderRequest = createEatInOrder(List.of(orderLineItem), orderTable.getId(), LocalDateTime.now()); + Order orderRequest = createEatInOrder(List.of(orderLineItem), orderTable, LocalDateTime.now()); Order orderResult = orderService.create(orderRequest); @@ -141,7 +140,7 @@ void notNullOrderLineItems(List orderLineItems) { Order takeOutRequest = createTakeOutOrder(orderLineItems, LocalDateTime.now()); Order deliveryOrderRequest = createDeliveryOrder(orderLineItems, "경기도 고양시..XX동 XX호", LocalDateTime.now()); OrderTable orderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); - Order eatInOrderRequest = createEatInOrder(orderLineItems, orderTable.getId(), LocalDateTime.now()); + Order eatInOrderRequest = createEatInOrder(orderLineItems, orderTable, LocalDateTime.now()); assertAll( () -> assertThatIllegalArgumentException() @@ -180,7 +179,7 @@ void validateMenuOrder() { Order takeOutRequest = createTakeOutOrder(List.of(undisplayMenuOrderItem), LocalDateTime.now()); Order deliveryOrderRequest = createDeliveryOrder(List.of(undisplayMenuOrderItem), "경기도 고양시..XX동 XX호", LocalDateTime.now()); OrderTable orderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); - Order eatInOrderRequest = createEatInOrder(List.of(undisplayMenuOrderItem), orderTable.getId(), LocalDateTime.now()); + Order eatInOrderRequest = createEatInOrder(List.of(undisplayMenuOrderItem), orderTable, LocalDateTime.now()); assertAll( () -> assertThatIllegalStateException() @@ -201,7 +200,7 @@ void validateOrderPrice() { Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XX호", LocalDateTime.now()); OrderTable orderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); - Order eatInOrderRequest = createEatInOrder(List.of(orderLineItem), orderTable.getId(), LocalDateTime.now()); + Order eatInOrderRequest = createEatInOrder(List.of(orderLineItem), orderTable, LocalDateTime.now()); assertAll( () -> assertThatIllegalArgumentException() @@ -227,9 +226,9 @@ void notNullOrNotEmpty(String deliveryAddress) { @DisplayName("매장 내 취식일 경우, 고객에게 배정된 주문 테이블이 있어야 한다") @Test void validateOrderTable() { - UUID unknownTableId = UUID.randomUUID(); + OrderTable unknownTable = OrderTableFixture.createOrderTable(UUID.randomUUID(), "1번테이블", 0); OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - Order eatInOrderRequest = createEatInOrder(List.of(orderLineItem), unknownTableId, LocalDateTime.now()); + Order eatInOrderRequest = createEatInOrder(List.of(orderLineItem), unknownTable, LocalDateTime.now()); assertThatThrownBy(() -> orderService.create(eatInOrderRequest)) .isInstanceOf(NoSuchElementException.class); @@ -241,7 +240,7 @@ void validateOrderTableStatus() { boolean tableOccupied = false; OrderTable orderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(ORDER_TABLE_ID, "1번테이블", tableOccupied, 0)); OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - Order eatInOrderRequest = createEatInOrder(List.of(orderLineItem), orderTable.getId(), LocalDateTime.now()); + Order eatInOrderRequest = createEatInOrder(List.of(orderLineItem), orderTable, LocalDateTime.now()); assertThatIllegalStateException() .isThrownBy(() -> orderService.create(eatInOrderRequest)); @@ -501,7 +500,7 @@ void findAll() { Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); Order deliveryRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XX호", LocalDateTime.now()); - Order eatInOrderRequest = createEatInOrder(List.of(orderLineItem), orderTable.getId(), LocalDateTime.now()); + Order eatInOrderRequest = createEatInOrder(List.of(orderLineItem), orderTable, LocalDateTime.now()); Order takeOutOrder = orderService.create(takeOutRequest); Order deliveryOrder = orderService.create(deliveryRequest); @@ -513,7 +512,6 @@ void findAll() { } //endregion - private Order createTakeOutOrder(List orderLineItems, LocalDateTime orderDateTime) { return createTakeOutOrder(orderLineItems, null, orderDateTime); } @@ -522,23 +520,20 @@ private Order createDeliveryOrder(List orderLineItems, String del return createDeliveryOrder(orderLineItems, deliveryAddress, null, orderDateTime); } - private Order createEatInOrder(List orderLineItems, UUID orderTableId, LocalDateTime orderDateTime) { - return createEatInOrder(orderLineItems, orderTableId, null, orderDateTime); + private Order createEatInOrder(List orderLineItems, OrderTable orderTable, LocalDateTime orderDateTime) { + return createEatInOrder(orderLineItems, orderTable, null, orderDateTime); } private Order createTakeOutOrder(List orderLineItems, OrderStatus orderStatus, LocalDateTime orderDateTime) { - return OrderFixture.createOrder(OrderType.TAKEOUT, orderLineItems, null, null, orderStatus, orderDateTime); + return OrderFixture.creatTakeOutOrder(orderLineItems, orderStatus, orderDateTime); } private Order createDeliveryOrder(List orderLineItems, String deliveryAddress, OrderStatus orderStatus, LocalDateTime orderDateTime) { - return OrderFixture.createOrder(OrderType.DELIVERY, orderLineItems, deliveryAddress, null, orderStatus, orderDateTime); + return OrderFixture.createDeliveryOrder(orderLineItems, deliveryAddress, orderStatus, orderDateTime); } private Order createEatInOrder(List orderLineItems, OrderTable orderTable, OrderStatus orderStatus, LocalDateTime orderDateTime) { - return OrderFixture.createOrder(OrderType.EAT_IN, orderLineItems, orderTable, orderStatus, orderDateTime); + return OrderFixture.createEatInOrder(orderLineItems, orderTable, orderStatus, orderDateTime); } - private Order createEatInOrder(List orderLineItems, UUID orderTableId, OrderStatus orderStatus, LocalDateTime orderDateTime) { - return OrderFixture.createOrder(OrderType.EAT_IN, orderLineItems, orderTableId, orderStatus, orderDateTime); - } } diff --git a/src/test/java/kitchenpos/application/OrderTableServiceTest.java b/src/test/java/kitchenpos/application/OrderTableServiceTest.java index 95c0b1054..dc1da89e9 100644 --- a/src/test/java/kitchenpos/application/OrderTableServiceTest.java +++ b/src/test/java/kitchenpos/application/OrderTableServiceTest.java @@ -102,7 +102,7 @@ class TableCleaner { void validateOrderStatus(OrderStatus orderStatus) { //given OrderTable occupiedOrderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(UUID.randomUUID(), "1번테이블", true, 4)); - Order order = createUnnamedOrder(occupiedOrderTable.getId(), orderStatus); + Order order = createUnnamedOrder(occupiedOrderTable, orderStatus); //when, then assertThatIllegalStateException() .isThrownBy(() -> orderTableService.clear(occupiedOrderTable.getId())); @@ -113,7 +113,7 @@ void validateOrderStatus(OrderStatus orderStatus) { void clear() { //given OrderTable occupiedOrderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(UUID.randomUUID(), "1번테이블", true, 4)); - Order order = createUnnamedOrder(occupiedOrderTable.getId(), OrderStatus.COMPLETED); + Order order = createUnnamedOrder(occupiedOrderTable, OrderStatus.COMPLETED); //when ReflectionTestUtils.setField(order, "status", OrderStatus.COMPLETED); OrderTable clearOrder = orderTableService.clear(occupiedOrderTable.getId()); @@ -169,17 +169,17 @@ void findAll() { } //endregion - private Order createEatInOrder(List orderLineItems, UUID orderTableId, OrderStatus orderStatus, LocalDateTime orderDateTime) { - return OrderFixture.createOrder(OrderType.EAT_IN, orderLineItems, null, orderTableId, orderStatus, orderDateTime); + private Order createEatInOrder(List orderLineItems, OrderTable orderTable, OrderStatus orderStatus, LocalDateTime orderDateTime) { + return OrderFixture.createEatInOrder(orderLineItems, orderTable, orderStatus, orderDateTime); } - private Order createUnnamedOrder(UUID orderTableId, OrderStatus orderStatus) { + private Order createUnnamedOrder(OrderTable orderTable, OrderStatus orderStatus) { Product unnamedProduct = productRepository.save(ProductFixture.createProduct(UUID.randomUUID(), "unnamed", BigDecimal.ZERO)); MenuGroup menuGroup = menuGroupRepository.save(MenuGroupFixture.createMenuGroup(UUID.randomUUID(), "unnamed")); MenuProduct displayMenuProduct = MenuProductFixture.createMenuProduct(unnamedProduct, 1); Menu unknownMenu = menuRepository.save(MenuFixture.createMenu(UUID.randomUUID(), menuGroup, menuGroup.getId(), "unnamed", BigDecimal.ZERO, true, List.of(displayMenuProduct))); OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(unknownMenu.getId(), BigDecimal.ZERO, 1); - return orderService.create(createEatInOrder(List.of(orderLineItem), orderTableId, orderStatus, LocalDateTime.now())); + return orderService.create(createEatInOrder(List.of(orderLineItem), orderTable, orderStatus, LocalDateTime.now())); } } \ No newline at end of file diff --git a/src/test/java/kitchenpos/application/fixture/OrderFixture.java b/src/test/java/kitchenpos/application/fixture/OrderFixture.java index afcbe5836..693ed3296 100644 --- a/src/test/java/kitchenpos/application/fixture/OrderFixture.java +++ b/src/test/java/kitchenpos/application/fixture/OrderFixture.java @@ -1,6 +1,7 @@ package kitchenpos.application.fixture; import kitchenpos.domain.*; +import org.springframework.test.util.ReflectionTestUtils; import java.math.BigDecimal; import java.time.LocalDateTime; @@ -9,53 +10,37 @@ public class OrderFixture { - public static Order createOrder(OrderType orderType, List orderLineItems, String deliveryAddress, UUID orderTableId, LocalDateTime orderDateTime) { - return createOrder(orderType, orderLineItems, deliveryAddress, orderTableId, null, orderDateTime); + public static Order createDeliveryOrder(List orderLineItems, String deliveryAddress, OrderStatus orderStatus, LocalDateTime orderDateTime) { + return createOrder(OrderType.DELIVERY, orderLineItems, deliveryAddress, null, null, orderStatus, orderDateTime); } - public static Order createOrder(OrderType orderType, List orderLineItems, String deliveryAddress, UUID orderTableId, OrderStatus orderStatus, LocalDateTime orderDateTime) { - return createOrder(UUID.randomUUID(), orderType, orderLineItems, deliveryAddress, orderTableId, orderStatus, orderDateTime); + public static Order createEatInOrder(List orderLineItems, OrderTable orderTable, OrderStatus orderStatus, LocalDateTime orderDateTime) { + return createOrder(OrderType.EAT_IN, orderLineItems, null, orderTable.getId(), orderTable, orderStatus, orderDateTime); } - public static Order createOrder(OrderType orderType, List orderLineItems, OrderTable orderTable, OrderStatus orderStatus, LocalDateTime orderDateTime) { - Order order = new Order(); - order.setId(UUID.randomUUID()); - order.setType(orderType); - order.setOrderLineItems(orderLineItems); - order.setOrderTable(orderTable); - order.setStatus(orderStatus); - order.setOrderDateTime(orderDateTime); - return order; + public static Order creatTakeOutOrder(List orderLineItems, OrderStatus orderStatus, LocalDateTime orderDateTime) { + return createOrder(OrderType.TAKEOUT, orderLineItems, null, null, null, orderStatus, orderDateTime); } - public static Order createOrder(OrderType orderType, List orderLineItems, UUID orderTableId, OrderStatus orderStatus, LocalDateTime orderDateTime) { + public static Order createOrder(OrderType orderType, List orderLineItems, String deliveryAddress, UUID orderTableId, OrderTable orderTable, OrderStatus orderStatus, LocalDateTime orderDateTime) { Order order = new Order(); - order.setId(UUID.randomUUID()); - order.setType(orderType); - order.setOrderLineItems(orderLineItems); - order.setOrderTableId(orderTableId); - order.setStatus(orderStatus); - order.setOrderDateTime(orderDateTime); - return order; - } + ReflectionTestUtils.setField(order, "id", UUID.randomUUID()); + ReflectionTestUtils.setField(order, "orderType", orderType); + ReflectionTestUtils.setField(order, "orderLineItems", orderLineItems); + ReflectionTestUtils.setField(order, "deliveryAddress", deliveryAddress); + ReflectionTestUtils.setField(order, "orderTable", orderTable); + ReflectionTestUtils.setField(order, "orderTableId", orderTableId); + ReflectionTestUtils.setField(order, "orderStatus", orderStatus); + ReflectionTestUtils.setField(order, "orderDateTime", orderDateTime); - public static Order createOrder(UUID id, OrderType orderType, List orderLineItems, String deliveryAddress, UUID orderTableId, OrderStatus orderStatus, LocalDateTime orderDateTime) { - Order order = new Order(); - order.setId(id); - order.setType(orderType); - order.setOrderLineItems(orderLineItems); - order.setDeliveryAddress(deliveryAddress); - order.setOrderTableId(orderTableId); - order.setStatus(orderStatus); - order.setOrderDateTime(orderDateTime); return order; } public static OrderLineItem createOrderLineItem(UUID menuId, BigDecimal price, int quantity) { OrderLineItem orderLineItem = new OrderLineItem(); - orderLineItem.setMenuId(menuId); - orderLineItem.setPrice(price); - orderLineItem.setQuantity(quantity); + ReflectionTestUtils.setField(orderLineItem, "menuId", menuId); + ReflectionTestUtils.setField(orderLineItem, "price", price); + ReflectionTestUtils.setField(orderLineItem, "quantity", quantity); return orderLineItem; } From 5b12cefd4df058aae72d4403784de0da5fc37549 Mon Sep 17 00:00:00 2001 From: skdev0619 Date: Mon, 10 Feb 2025 10:47:22 +0900 Subject: [PATCH 29/29] =?UTF-8?q?OrderFixture=20=EC=A0=95=EB=A6=AC=20?= =?UTF-8?q?=EB=B0=8F=20=EC=A0=81=EC=9A=A9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../application/OrderServiceTest.java | 121 +++++++----------- .../application/OrderTableServiceTest.java | 6 +- .../application/fixture/OrderFixture.java | 37 ++++-- 3 files changed, 73 insertions(+), 91 deletions(-) diff --git a/src/test/java/kitchenpos/application/OrderServiceTest.java b/src/test/java/kitchenpos/application/OrderServiceTest.java index e9023ce8a..836e81ba6 100644 --- a/src/test/java/kitchenpos/application/OrderServiceTest.java +++ b/src/test/java/kitchenpos/application/OrderServiceTest.java @@ -14,7 +14,6 @@ import org.junit.jupiter.params.provider.MethodSource; import org.junit.jupiter.params.provider.NullAndEmptySource; import org.junit.jupiter.params.provider.NullSource; -import org.springframework.test.util.ReflectionTestUtils; import java.math.BigDecimal; import java.time.LocalDateTime; @@ -74,6 +73,7 @@ class OrderCreator { void orderType(OrderType orderType) { OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal("25000"), 1); Order nullOrderTypeRequest = OrderFixture.createOrder(orderType, List.of(orderLineItem), "", null, null, null, LocalDateTime.now()); + assertThatIllegalArgumentException() .isThrownBy(() -> orderService.create(nullOrderTypeRequest)); } @@ -82,7 +82,7 @@ void orderType(OrderType orderType) { @Test void takeOutOrder() { OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal("25000"), 1); - Order orderRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); + Order orderRequest = OrderFixture.TakeOut.initializeOrder(List.of(orderLineItem), LocalDateTime.now()); Order orderResult = orderService.create(orderRequest); @@ -99,7 +99,7 @@ void takeOutOrder() { @Test void deliveryOrder() { OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal("25000"), 1); - Order orderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XX호", LocalDateTime.now()); + Order orderRequest = OrderFixture.Delivery.initializeOrder(List.of(orderLineItem), "경기도 고양시..XX동 XX호", LocalDateTime.now()); Order orderResult = orderService.create(orderRequest); @@ -120,7 +120,7 @@ void eatInOrder() { OrderTable orderTable = orderTableRepository.save(request); OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal("25000"), 1); - Order orderRequest = createEatInOrder(List.of(orderLineItem), orderTable, LocalDateTime.now()); + Order orderRequest = OrderFixture.EatIn.initializeOrder(List.of(orderLineItem), orderTable, LocalDateTime.now()); Order orderResult = orderService.create(orderRequest); @@ -137,10 +137,10 @@ void eatInOrder() { @ParameterizedTest @MethodSource("nullOrEmptyList") void notNullOrderLineItems(List orderLineItems) { - Order takeOutRequest = createTakeOutOrder(orderLineItems, LocalDateTime.now()); - Order deliveryOrderRequest = createDeliveryOrder(orderLineItems, "경기도 고양시..XX동 XX호", LocalDateTime.now()); + Order takeOutRequest = OrderFixture.TakeOut.initializeOrder(orderLineItems, LocalDateTime.now()); + Order deliveryOrderRequest = OrderFixture.Delivery.initializeOrder(orderLineItems, "경기도 고양시..XX동 XX호", LocalDateTime.now()); OrderTable orderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); - Order eatInOrderRequest = createEatInOrder(orderLineItems, orderTable, LocalDateTime.now()); + Order eatInOrderRequest = OrderFixture.EatIn.initializeOrder(orderLineItems, orderTable, LocalDateTime.now()); assertAll( () -> assertThatIllegalArgumentException() @@ -161,8 +161,8 @@ private static Stream nullOrEmptyList() { void validateQuantity() { int negativeQuantity = -1; OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal("25000"), negativeQuantity); - Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); - Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XX호", LocalDateTime.now()); + Order takeOutRequest = OrderFixture.TakeOut.initializeOrder(List.of(orderLineItem), LocalDateTime.now()); + Order deliveryOrderRequest = OrderFixture.Delivery.initializeOrder(List.of(orderLineItem), "경기도 고양시..XX동 XX호", LocalDateTime.now()); assertAll( () -> assertThatIllegalArgumentException() @@ -175,11 +175,11 @@ void validateQuantity() { @DisplayName("메뉴판에 전시하지 않은 메뉴는 주문할 수 없다") @Test void validateMenuOrder() { - OrderLineItem undisplayMenuOrderItem = OrderFixture.createOrderLineItem(UNDISPLAYED_MENU_ID, new BigDecimal("25000"), 1); - Order takeOutRequest = createTakeOutOrder(List.of(undisplayMenuOrderItem), LocalDateTime.now()); - Order deliveryOrderRequest = createDeliveryOrder(List.of(undisplayMenuOrderItem), "경기도 고양시..XX동 XX호", LocalDateTime.now()); + OrderLineItem unDisplayMenuOrderItem = OrderFixture.createOrderLineItem(UNDISPLAYED_MENU_ID, new BigDecimal("25000"), 1); + Order takeOutRequest = OrderFixture.TakeOut.initializeOrder(List.of(unDisplayMenuOrderItem), LocalDateTime.now()); + Order deliveryOrderRequest = OrderFixture.Delivery.initializeOrder(List.of(unDisplayMenuOrderItem), "경기도 고양시..XX동 XX호", LocalDateTime.now()); OrderTable orderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); - Order eatInOrderRequest = createEatInOrder(List.of(undisplayMenuOrderItem), orderTable, LocalDateTime.now()); + Order eatInOrderRequest = OrderFixture.EatIn.initializeOrder(List.of(unDisplayMenuOrderItem), orderTable, LocalDateTime.now()); assertAll( () -> assertThatIllegalStateException() @@ -197,10 +197,10 @@ void validateOrderPrice() { BigDecimal menuPrice = menuRepository.findById(DISPLAY_MENU_ID).get().getPrice(); OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, menuPrice.add(BigDecimal.ONE), 1); - Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); - Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XX호", LocalDateTime.now()); + Order takeOutRequest = OrderFixture.TakeOut.initializeOrder(List.of(orderLineItem), LocalDateTime.now()); + Order deliveryOrderRequest = OrderFixture.Delivery.initializeOrder(List.of(orderLineItem), "경기도 고양시..XX동 XX호", LocalDateTime.now()); OrderTable orderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); - Order eatInOrderRequest = createEatInOrder(List.of(orderLineItem), orderTable, LocalDateTime.now()); + Order eatInOrderRequest = OrderFixture.EatIn.initializeOrder(List.of(orderLineItem), orderTable, LocalDateTime.now()); assertAll( () -> assertThatIllegalArgumentException() @@ -217,7 +217,7 @@ void validateOrderPrice() { @NullAndEmptySource void notNullOrNotEmpty(String deliveryAddress) { OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - Order deliveryOrderRequest = createDeliveryOrder(List.of(orderLineItem), deliveryAddress, LocalDateTime.now()); + Order deliveryOrderRequest = OrderFixture.Delivery.initializeOrder(List.of(orderLineItem), deliveryAddress, LocalDateTime.now()); assertThatIllegalArgumentException() .isThrownBy(() -> orderService.create(deliveryOrderRequest)); @@ -228,7 +228,7 @@ void notNullOrNotEmpty(String deliveryAddress) { void validateOrderTable() { OrderTable unknownTable = OrderTableFixture.createOrderTable(UUID.randomUUID(), "1번테이블", 0); OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - Order eatInOrderRequest = createEatInOrder(List.of(orderLineItem), unknownTable, LocalDateTime.now()); + Order eatInOrderRequest = OrderFixture.EatIn.initializeOrder(List.of(orderLineItem), unknownTable, LocalDateTime.now()); assertThatThrownBy(() -> orderService.create(eatInOrderRequest)) .isInstanceOf(NoSuchElementException.class); @@ -240,7 +240,7 @@ void validateOrderTableStatus() { boolean tableOccupied = false; OrderTable orderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(ORDER_TABLE_ID, "1번테이블", tableOccupied, 0)); OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - Order eatInOrderRequest = createEatInOrder(List.of(orderLineItem), orderTable, LocalDateTime.now()); + Order eatInOrderRequest = OrderFixture.EatIn.initializeOrder(List.of(orderLineItem), orderTable, LocalDateTime.now()); assertThatIllegalStateException() .isThrownBy(() -> orderService.create(eatInOrderRequest)); @@ -252,11 +252,11 @@ void validateOrderTableStatus() { @Nested class OrderAccepter { @DisplayName("대기 중인 주문을 수락한다") - @Test - void acceptOrderStatus() { + @EnumSource(value = OrderStatus.class, names = "WAITING", mode = EnumSource.Mode.INCLUDE) + @ParameterizedTest + void acceptOrderStatus(OrderStatus orderStatus) { OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); - Order takeOutOrder = orderService.create(takeOutRequest); + Order takeOutOrder = orderRepository.save(OrderFixture.TakeOut.createOrderByStatus(List.of(orderLineItem), orderStatus, LocalDateTime.now())); Order acceptOrder = orderService.accept(takeOutOrder.getId()); @@ -268,7 +268,7 @@ void acceptOrderStatus() { @ParameterizedTest void validateAcceptStatus(OrderStatus orderStatus) { OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - Order takeOutOrder = orderRepository.save(createTakeOutOrder(List.of(orderLineItem), orderStatus, LocalDateTime.now())); + Order takeOutOrder = orderRepository.save(OrderFixture.TakeOut.createOrderByStatus(List.of(orderLineItem), orderStatus, LocalDateTime.now())); assertThatIllegalStateException() .isThrownBy(() -> orderService.accept(takeOutOrder.getId())); @@ -285,7 +285,7 @@ class OrderServer { @ParameterizedTest void served(OrderStatus orderStatus) { OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - Order acceptOrder = orderRepository.save(createTakeOutOrder(List.of(orderLineItem), orderStatus, LocalDateTime.now())); + Order acceptOrder = orderRepository.save(OrderFixture.TakeOut.createOrderByStatus(List.of(orderLineItem), orderStatus, LocalDateTime.now())); Order servedOrder = orderService.serve(acceptOrder.getId()); @@ -297,7 +297,7 @@ void served(OrderStatus orderStatus) { @ParameterizedTest void validateServedStatus(OrderStatus orderStatus) { OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - Order order = orderRepository.save(createTakeOutOrder(List.of(orderLineItem), orderStatus, LocalDateTime.now())); + Order order = orderRepository.save(OrderFixture.TakeOut.createOrderByStatus(List.of(orderLineItem), orderStatus, LocalDateTime.now())); assertThatIllegalStateException() .isThrownBy(() -> orderService.serve(order.getId())); @@ -314,7 +314,7 @@ class DeliveryStarter { @ParameterizedTest void startDelivery(OrderStatus orderStatus) { OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - Order order = orderRepository.save(createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", orderStatus, LocalDateTime.now())); + Order order = orderRepository.save(OrderFixture.Delivery.createOrderByStatus(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", orderStatus, LocalDateTime.now())); Order deliveryStartorder = orderService.startDelivery(order.getId()); @@ -326,7 +326,7 @@ void startDelivery(OrderStatus orderStatus) { @ParameterizedTest void validateDeliveryStartStatus(OrderStatus orderStatus) { OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - Order order = orderRepository.save(createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", orderStatus, LocalDateTime.now())); + Order order = orderRepository.save(OrderFixture.Delivery.createOrderByStatus(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", orderStatus, LocalDateTime.now())); assertThatIllegalStateException() .isThrownBy(() -> orderService.startDelivery(order.getId())); @@ -342,7 +342,7 @@ class DeliveryCompleter { @EnumSource(value = OrderStatus.class, names = "DELIVERING", mode = EnumSource.Mode.INCLUDE) void endDelivery(OrderStatus orderStatus) { OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - Order order = orderRepository.save(createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", orderStatus, LocalDateTime.now())); + Order order = orderRepository.save(OrderFixture.Delivery.createOrderByStatus(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", orderStatus, LocalDateTime.now())); Order deliveryStartorder = orderService.completeDelivery(order.getId()); @@ -355,7 +355,7 @@ void endDelivery(OrderStatus orderStatus) { void validateDeliveryEndStatus(OrderStatus orderStatus) { OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - Order order = orderService.create(createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", orderStatus, LocalDateTime.now())); + Order order = orderService.create(OrderFixture.Delivery.createOrderByStatus(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", orderStatus, LocalDateTime.now())); assertThatIllegalStateException() .isThrownBy(() -> orderService.completeDelivery(order.getId())); @@ -372,7 +372,7 @@ class OrderCompleter { void complete(OrderStatus orderStatus) { //given OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - Order order = orderRepository.save(createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", orderStatus, LocalDateTime.now())); + Order order = orderRepository.save(OrderFixture.Delivery.createOrderByStatus(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", orderStatus, LocalDateTime.now())); //when Order complete = orderService.complete(order.getId()); //then @@ -384,7 +384,7 @@ void complete(OrderStatus orderStatus) { @ParameterizedTest void completeOrderByDelivery(OrderStatus orderStatus) { OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - Order order = orderRepository.save(createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", orderStatus, LocalDateTime.now())); + Order order = orderRepository.save(OrderFixture.Delivery.createOrderByStatus(List.of(orderLineItem), "경기도 고양시..XX동 XXX호", orderStatus, LocalDateTime.now())); assertThatIllegalStateException() .isThrownBy(() -> orderService.complete(order.getId())); @@ -396,7 +396,7 @@ void completeOrderByDelivery(OrderStatus orderStatus) { void completeByTakeOut(OrderStatus orderStatus) { //given OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - Order servedOrder = orderRepository.save(createTakeOutOrder(List.of(orderLineItem), orderStatus, LocalDateTime.now())); + Order servedOrder = orderRepository.save(OrderFixture.TakeOut.createOrderByStatus(List.of(orderLineItem), orderStatus, LocalDateTime.now())); //when Order complete = orderService.complete(servedOrder.getId()); //then @@ -409,7 +409,7 @@ void completeByTakeOut(OrderStatus orderStatus) { void completeByEatIn(OrderStatus orderStatus) { OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); OrderTable orderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); - Order servedOrder = orderRepository.save(createEatInOrder(List.of(orderLineItem), orderTable, orderStatus, LocalDateTime.now())); + Order servedOrder = orderRepository.save(OrderFixture.EatIn.createOrderByStatus(List.of(orderLineItem), orderTable, orderStatus, LocalDateTime.now())); //when Order complete = orderService.complete(servedOrder.getId()); //then @@ -422,17 +422,12 @@ void completeByEatIn(OrderStatus orderStatus) { void completeOrderByEatInOrTakeOut(OrderStatus orderStatus) { //given OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); - Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); + Order takeoutOrder = orderRepository.save(OrderFixture.TakeOut.createOrderByStatus(List.of(orderLineItem), orderStatus, LocalDateTime.now())); OrderTable orderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); - Order eatInRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); + Order eatInOrder = orderRepository.save(OrderFixture.EatIn.createOrderByStatus(List.of(orderLineItem), orderTable, orderStatus, LocalDateTime.now())); - Order takeoutOrder = orderService.create(takeOutRequest); - Order eatInOrder = orderService.create(eatInRequest); - //when - ReflectionTestUtils.setField(takeoutOrder, "status", orderStatus); - ReflectionTestUtils.setField(eatInOrder, "status", orderStatus); - //then + //when, then assertAll( () -> assertThatIllegalStateException() .isThrownBy(() -> orderService.complete(takeoutOrder.getId())), @@ -449,8 +444,8 @@ void completeOrderByEatIn() { OrderTable orderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); //주문 상태가 SERVED인 주문1,2 생성 - Order servedOrder1 = orderRepository.save(createEatInOrder(List.of(orderLineItem), orderTable, OrderStatus.SERVED, LocalDateTime.now())); - Order servedOrder2 = orderRepository.save(createEatInOrder(List.of(orderLineItem), orderTable, OrderStatus.SERVED, LocalDateTime.now())); + Order servedOrder1 = orderRepository.save(OrderFixture.EatIn.createOrderByStatus(List.of(orderLineItem), orderTable, OrderStatus.SERVED, LocalDateTime.now())); + Order servedOrder2 = orderRepository.save(OrderFixture.EatIn.createOrderByStatus(List.of(orderLineItem), orderTable, OrderStatus.SERVED, LocalDateTime.now())); //when Order complete = orderService.complete(servedOrder1.getId()); @@ -470,8 +465,8 @@ void clearOrderTable() { OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); OrderTable orderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(ORDER_TABLE_ID, "1번테이블", true, 4)); - Order servedOrder1 = orderRepository.save(createEatInOrder(List.of(orderLineItem), orderTable, OrderStatus.SERVED, LocalDateTime.now())); - Order servedOrder2 = orderRepository.save(createEatInOrder(List.of(orderLineItem), orderTable, OrderStatus.SERVED, LocalDateTime.now())); + Order servedOrder1 = orderRepository.save(OrderFixture.EatIn.createOrderByStatus(List.of(orderLineItem), orderTable, OrderStatus.SERVED, LocalDateTime.now())); + Order servedOrder2 = orderRepository.save(OrderFixture.EatIn.createOrderByStatus(List.of(orderLineItem), orderTable, OrderStatus.SERVED, LocalDateTime.now())); //when Order complete1 = orderService.complete(servedOrder1.getId()); @@ -498,13 +493,9 @@ void findAll() { OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(DISPLAY_MENU_ID, new BigDecimal(25000), 1); OrderTable orderTable = orderTableRepository.save(OrderTableFixture.createOrderTable(UUID.randomUUID(), "1번테이블", true, 4)); - Order takeOutRequest = createTakeOutOrder(List.of(orderLineItem), LocalDateTime.now()); - Order deliveryRequest = createDeliveryOrder(List.of(orderLineItem), "경기도 고양시..XX동 XX호", LocalDateTime.now()); - Order eatInOrderRequest = createEatInOrder(List.of(orderLineItem), orderTable, LocalDateTime.now()); - - Order takeOutOrder = orderService.create(takeOutRequest); - Order deliveryOrder = orderService.create(deliveryRequest); - Order eatInOrder = orderService.create(eatInOrderRequest); + orderRepository.save(OrderFixture.TakeOut.initializeOrder(List.of(orderLineItem), LocalDateTime.now())); + orderRepository.save(OrderFixture.Delivery.initializeOrder(List.of(orderLineItem), "경기도 고양시..XX동 XX호", LocalDateTime.now())); + orderRepository.save(OrderFixture.EatIn.initializeOrder(List.of(orderLineItem), orderTable, LocalDateTime.now())); //when List orders = orderService.findAll(); //then @@ -512,28 +503,4 @@ void findAll() { } //endregion - private Order createTakeOutOrder(List orderLineItems, LocalDateTime orderDateTime) { - return createTakeOutOrder(orderLineItems, null, orderDateTime); - } - - private Order createDeliveryOrder(List orderLineItems, String deliveryAddress, LocalDateTime orderDateTime) { - return createDeliveryOrder(orderLineItems, deliveryAddress, null, orderDateTime); - } - - private Order createEatInOrder(List orderLineItems, OrderTable orderTable, LocalDateTime orderDateTime) { - return createEatInOrder(orderLineItems, orderTable, null, orderDateTime); - } - - private Order createTakeOutOrder(List orderLineItems, OrderStatus orderStatus, LocalDateTime orderDateTime) { - return OrderFixture.creatTakeOutOrder(orderLineItems, orderStatus, orderDateTime); - } - - private Order createDeliveryOrder(List orderLineItems, String deliveryAddress, OrderStatus orderStatus, LocalDateTime orderDateTime) { - return OrderFixture.createDeliveryOrder(orderLineItems, deliveryAddress, orderStatus, orderDateTime); - } - - private Order createEatInOrder(List orderLineItems, OrderTable orderTable, OrderStatus orderStatus, LocalDateTime orderDateTime) { - return OrderFixture.createEatInOrder(orderLineItems, orderTable, orderStatus, orderDateTime); - } - } diff --git a/src/test/java/kitchenpos/application/OrderTableServiceTest.java b/src/test/java/kitchenpos/application/OrderTableServiceTest.java index dc1da89e9..17bfe8473 100644 --- a/src/test/java/kitchenpos/application/OrderTableServiceTest.java +++ b/src/test/java/kitchenpos/application/OrderTableServiceTest.java @@ -169,10 +169,6 @@ void findAll() { } //endregion - private Order createEatInOrder(List orderLineItems, OrderTable orderTable, OrderStatus orderStatus, LocalDateTime orderDateTime) { - return OrderFixture.createEatInOrder(orderLineItems, orderTable, orderStatus, orderDateTime); - } - private Order createUnnamedOrder(OrderTable orderTable, OrderStatus orderStatus) { Product unnamedProduct = productRepository.save(ProductFixture.createProduct(UUID.randomUUID(), "unnamed", BigDecimal.ZERO)); MenuGroup menuGroup = menuGroupRepository.save(MenuGroupFixture.createMenuGroup(UUID.randomUUID(), "unnamed")); @@ -180,6 +176,6 @@ private Order createUnnamedOrder(OrderTable orderTable, OrderStatus orderStatus) Menu unknownMenu = menuRepository.save(MenuFixture.createMenu(UUID.randomUUID(), menuGroup, menuGroup.getId(), "unnamed", BigDecimal.ZERO, true, List.of(displayMenuProduct))); OrderLineItem orderLineItem = OrderFixture.createOrderLineItem(unknownMenu.getId(), BigDecimal.ZERO, 1); - return orderService.create(createEatInOrder(List.of(orderLineItem), orderTable, orderStatus, LocalDateTime.now())); + return orderService.create(OrderFixture.EatIn.createOrderByStatus(List.of(orderLineItem), orderTable, orderStatus, LocalDateTime.now())); } } \ No newline at end of file diff --git a/src/test/java/kitchenpos/application/fixture/OrderFixture.java b/src/test/java/kitchenpos/application/fixture/OrderFixture.java index 693ed3296..804b8c0e8 100644 --- a/src/test/java/kitchenpos/application/fixture/OrderFixture.java +++ b/src/test/java/kitchenpos/application/fixture/OrderFixture.java @@ -10,27 +10,46 @@ public class OrderFixture { - public static Order createDeliveryOrder(List orderLineItems, String deliveryAddress, OrderStatus orderStatus, LocalDateTime orderDateTime) { - return createOrder(OrderType.DELIVERY, orderLineItems, deliveryAddress, null, null, orderStatus, orderDateTime); + public static class Delivery { + + public static Order initializeOrder(List orderLineItems, String deliveryAddress, LocalDateTime orderDateTime) { + return createOrder(OrderType.DELIVERY, orderLineItems, deliveryAddress, null, null, null, orderDateTime); + } + + public static Order createOrderByStatus(List orderLineItems, String deliveryAddress, OrderStatus orderStatus, LocalDateTime orderDateTime) { + return createOrder(OrderType.DELIVERY, orderLineItems, deliveryAddress, null, null, orderStatus, orderDateTime); + } } - public static Order createEatInOrder(List orderLineItems, OrderTable orderTable, OrderStatus orderStatus, LocalDateTime orderDateTime) { - return createOrder(OrderType.EAT_IN, orderLineItems, null, orderTable.getId(), orderTable, orderStatus, orderDateTime); + public static class EatIn { + public static Order initializeOrder(List orderLineItems, OrderTable orderTable, LocalDateTime orderDateTime) { + return createOrder(OrderType.EAT_IN, orderLineItems, null, orderTable.getId(), orderTable, null, orderDateTime); + } + + public static Order createOrderByStatus(List orderLineItems, OrderTable orderTable, OrderStatus orderStatus, LocalDateTime orderDateTime) { + return createOrder(OrderType.EAT_IN, orderLineItems, null, orderTable.getId(), orderTable, orderStatus, orderDateTime); + } } - public static Order creatTakeOutOrder(List orderLineItems, OrderStatus orderStatus, LocalDateTime orderDateTime) { - return createOrder(OrderType.TAKEOUT, orderLineItems, null, null, null, orderStatus, orderDateTime); + public static class TakeOut { + public static Order initializeOrder(List orderLineItems, LocalDateTime orderDateTime) { + return createOrder(OrderType.TAKEOUT, orderLineItems, null, null, null, null, orderDateTime); + } + + public static Order createOrderByStatus(List orderLineItems, OrderStatus orderStatus, LocalDateTime orderDateTime) { + return createOrder(OrderType.TAKEOUT, orderLineItems, null, null, null, orderStatus, orderDateTime); + } } - public static Order createOrder(OrderType orderType, List orderLineItems, String deliveryAddress, UUID orderTableId, OrderTable orderTable, OrderStatus orderStatus, LocalDateTime orderDateTime) { + public static Order createOrder(OrderType type, List orderLineItems, String deliveryAddress, UUID orderTableId, OrderTable orderTable, OrderStatus status, LocalDateTime orderDateTime) { Order order = new Order(); ReflectionTestUtils.setField(order, "id", UUID.randomUUID()); - ReflectionTestUtils.setField(order, "orderType", orderType); + ReflectionTestUtils.setField(order, "type", type); ReflectionTestUtils.setField(order, "orderLineItems", orderLineItems); ReflectionTestUtils.setField(order, "deliveryAddress", deliveryAddress); ReflectionTestUtils.setField(order, "orderTable", orderTable); ReflectionTestUtils.setField(order, "orderTableId", orderTableId); - ReflectionTestUtils.setField(order, "orderStatus", orderStatus); + ReflectionTestUtils.setField(order, "status", status); ReflectionTestUtils.setField(order, "orderDateTime", orderDateTime); return order;