[레거시 코드 리팩터링 - 2단계] 현구막(최현구) 미션 제출합니다. (#170)

* docs: 컨트롤러 메서드를 통한 요구사항 정리

* docs: 서비스 메서드를 통한 요구사항 정리

* chore: gitignore에 bin 디렉토리 추가

* test: JdbcTemplateProductDao 테스트 작성

* refactor: JdbcTemplateDao 테스트 중복설정 추상화

* test: JdbcTemplateTableGroup 테스트 작성

* refactor: 엔티티 저장 테스트 검증 변경

* test: JdbcTemplateOrderTableDao 테스트 작성

* test: JdbcTemplateOrderDao 테스트 작성

* test: JdbcTemplateMenuGroupDao 테스트 작성

* test: JdbcTemplateMenuDao 테스트 작성

* test: JdbcTemplateMenuProductDao 테스트 작성

* test: JdbcTemplateOrderLineItemDao 테스트 작성

* refactor: Order가 생성될 때 필요한 orderTableId 값을 임의의 값이 아닌 실제 값을 사용하도록 변경

* test: MenuGroupService 테스트 작성

* test: ProductService 테스트 작성

* test: MenuGroupService DisplayName 추가

* test: TableService 테스트 작성

* test: TableGroupService 테스트 작성

* test: MenuService 테스트 작성

* refactor: ProductService 전체 조회 테스트 수정

* test: OrderService 테스트 작성

* chore: rest-assured 의존성 추가

* test: MenuGroup 인수 테스트 작성

* test: Menu 인수 테스트 작성

* refactor: Menu 인수 테스트가 Dao가 아닌 Http 요청에 의존하도록 변경

OrderService 테스트 오타 수정

* test: Order 인수 테스트 작성

* refactor: HttpPost, HttpPut 요청 메서드 추상화

* refactor: OrderService 테스트 예시값 수정

* test: Product 인수 테스트 작성

* refactor: HTTP 요청을 이용한 데이터생성 메서드의 이름 변경

* test: TableGroup 인수 테스트 작성

* test: Table 인수 테스트 작성

* docs: README.md 완료사항 반영

* refactor: Product 관련 기능 JPA 도입, 비즈니스 로직 도메인으로 이동

* feat: Exception 핸들러 추가

* refactor: MenuGroup 관련 기능 JPA 도입, 비즈니스 검증 로직 도메인으로 이동

* refactor: Menu, MenuProduct 관련 기능 JPA 도입, 비즈니스 검증 로직 도메인 이동

* refactor: 개행 추가, 불필요한 import 제거

* refactor: 엔티티 단위 테스트 보완

Menu
MenuGroup
MenuProduct
MenuProducts
Product
Price

* refactor: 추가 엔티티 단위 테스트 보완

Order
Orders
OrderLineItem
OrderLineItems
OrderTable
OrderTables

* refactor: 불필요한 Dao, DaoTest 제거

* refactor: MenuGroup 테스트 수정, 컨트롤러 Valid 어노테이션 추가

* refactor: Menu 테스트 수정, 메서드명 변경, 컨트롤러 Valid 어노테이션 추가

* refactor: Order, OrderLineItem 서비스계층 리팩토링, 테스트코드 수정

* refactor: Product 인수테스트명 변경, 컨트롤러 Valid 어노테이션 추가

* refactor: OrderTable, TableGroup 인수 테스트명 변경, 컨트롤러 Valid 어노테이션 추가, 서비스 계층 리팩토링

* refactor: 불필요한 생성자, 사용되지 않는 setter 제거

* refactor: 순환참조를 방지하기 위해 Service계층간 Repository를 의존하도록 변경

* refactor: 스프링 프로필 파일 변경

* refactor: 브랜치 병합 이후 불필요하게 추가된 테스트, 클래스 제거

* refactor: 메뉴상품 총 금액 메서드 추상화

* refactor: 불필요한 import, 사용되지 않는 메서드 제거

* refactor: 이름(Name) 관련 값 객체로 포장

* refactor: 가격(Price) 관련 값 객체로 포장

* refactor: 수량(Quantity) 관련 값 객체로 포장

* refactor:  손님수(NumberOfGuests) 관련 값 객체로 포장

Author: Hyeon9mak

README.md

@@ -5,6 +5,7 @@
 ### MenuGroups
 - [x] `POST /api/menu-groups` 요청을 통해 MenuGroup을 추가할 수 있다.
     - [x] MenuGroup을 DB에 저장한다.
+    - [x] MenuGroup의 이름은 Null 이어서는 안된다.
 
 - [x] `GET /api/menu-groups` 요청을 통해 MenuGroup 목록을 조회할 수 있다.
     - [x] MenuGroup 리스트를 DB에서 찾아 반환한다.
@@ -106,3 +107,61 @@
 | 단체 지정 | table group | 통합 계산을 위해 개별 주문 테이블을 그룹화하는 기능 |
 | 주문 항목 | order line item | 주문에 속하는 수량이 있는 메뉴 |
 | 매장 식사 | eat in | 포장하지 않고 매장에서 식사하는 것 |
+
+<br>
+
+## 엔티티 단위 테스트
+- [x] Menu
+  - [x] name null, blank
+  - [x] price null, negative
+  - [x] MenuGroup null
+- [x] MenuGroup
+  - [x] name null, blank
+- [x] MenuProduct
+  - [x] menu null
+  - [x] product null
+  - [x] quantity null, negative
+- [x] MenuProducts
+  - [x] menu.price > all(product.price * quantity)
+- [x] Product
+  - [x] name null, blank
+  - [x] price null, negative
+- [x] Price
+  - [x] value null, negative
+- [x] Order
+  - [x] orderTable null
+  - [x] already completion
+- [x] Orders
+  - [x] completed status
+- [x] OrderLineItem
+  - [x] order null
+  - [x] menu null
+  - [x] quantity null, negative
+- [x] OrderLineItems
+  - [x] empty
+  - [x] menu duplicate
+- [x] OrderTable
+  - [x] numberOfGuests negative
+  - [x] groupBy status
+  - [x] ungroup status
+  - [x] changeNumberOfGuests
+    - [x] negative
+    - [x] orderTable status empty
+  - [x] changeEmpty nonNull tableGroup
+- [x] OrderTables
+  - [x] orderTable count < 2
+  - [x] orderTable already not empty or grouped
+  - [x] groupBy
+- [x] TableGroup
+
+## 추가 리팩토링
+- [x] 커스텀 Exception 추가
+- [x] 인수테스트 DisplayName 변경하기
+- [x] 엔티티 원시값 포장
+  - [x] quantity
+  - [x] price
+  - [x] name
+  - [x] numberOfGuests
+- [x] DTO getter 디미터 법칙
+- [ ] OrderTable에서 TableGroup 값에 따라 empty 설정을 해야하는가 고민
+- [x] 서비스 계층 의존 -> 최초의 순환참조 경험 -> Repository 계층 의존하도록 변경

build.gradle

@@ -16,8 +16,12 @@ dependencies {
     implementation 'org.springframework.boot:spring-boot-starter-actuator'
     implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
     implementation 'org.springframework.boot:spring-boot-starter-web'
+
     implementation 'org.flywaydb:flyway-core'
     runtimeOnly 'com.h2database:h2'
+
+    implementation 'org.springframework.boot:spring-boot-starter-validation'
+
     testImplementation 'io.rest-assured:rest-assured'
     testImplementation('org.springframework.boot:spring-boot-starter-test') {
         exclude group: 'org.junit.vintage', module: 'junit-vintage-engine'

src/main/java/kitchenpos/application/MenuGroupService.java

@@ -1,26 +1,33 @@
 package kitchenpos.application;
 
-import kitchenpos.dao.MenuGroupDao;
+import java.util.List;
 import kitchenpos.domain.MenuGroup;
+import kitchenpos.repository.MenuGroupRepository;
+import kitchenpos.ui.request.MenuGroupRequest;
+import kitchenpos.ui.response.MenuGroupResponse;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
-import java.util.List;
-
+@Transactional(readOnly = true)
 @Service
 public class MenuGroupService {
-    private final MenuGroupDao menuGroupDao;
 
-    public MenuGroupService(final MenuGroupDao menuGroupDao) {
-        this.menuGroupDao = menuGroupDao;
+    private final MenuGroupRepository menuGroupRepository;
+
+    public MenuGroupService(MenuGroupRepository menuGroupRepository) {
+        this.menuGroupRepository = menuGroupRepository;
     }
 
     @Transactional
-    public MenuGroup create(final MenuGroup menuGroup) {
-        return menuGroupDao.save(menuGroup);
+    public MenuGroupResponse create(final MenuGroupRequest request) {
+        MenuGroup menuGroup = menuGroupRepository.save(request.toEntity());
+
+        return MenuGroupResponse.from(menuGroup);
     }
 
-    public List<MenuGroup> list() {
-        return menuGroupDao.findAll();
+    public List<MenuGroupResponse> list() {
+        List<MenuGroup> menuGroups = menuGroupRepository.findAll();
+
+        return MenuGroupResponse.of(menuGroups);
     }
 }

src/main/java/kitchenpos/application/MenuService.java

@@ -1,84 +1,90 @@
 package kitchenpos.application;
 
-import kitchenpos.dao.MenuDao;
-import kitchenpos.dao.MenuGroupDao;
-import kitchenpos.dao.MenuProductDao;
-import kitchenpos.dao.ProductDao;
+import java.util.ArrayList;
+import java.util.List;
 import kitchenpos.domain.Menu;
+import kitchenpos.domain.MenuGroup;
 import kitchenpos.domain.MenuProduct;
+import kitchenpos.domain.MenuProducts;
+import kitchenpos.domain.Price;
 import kitchenpos.domain.Product;
+import kitchenpos.exception.MenuGroupNotFoundException;
+import kitchenpos.exception.ProductNotFoundException;
+import kitchenpos.repository.MenuGroupRepository;
+import kitchenpos.repository.MenuProductRepository;
+import kitchenpos.repository.MenuRepository;
+import kitchenpos.repository.ProductRepository;
+import kitchenpos.ui.request.MenuProductRequest;
+import kitchenpos.ui.request.MenuRequest;
+import kitchenpos.ui.response.MenuResponse;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
-import java.math.BigDecimal;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Objects;
-
+@Transactional(readOnly = true)
 @Service
 public class MenuService {
-    private final MenuDao menuDao;
-    private final MenuGroupDao menuGroupDao;
-    private final MenuProductDao menuProductDao;
-    private final ProductDao productDao;
+
+    private final MenuRepository menuRepository;
+    private final MenuProductRepository menuProductRepository;
+    private final MenuGroupRepository menuGroupRepository;
+    private final ProductRepository productRepository;
 
     public MenuService(
-            final MenuDao menuDao,
-            final MenuGroupDao menuGroupDao,
-            final MenuProductDao menuProductDao,
-            final ProductDao productDao
+        MenuRepository menuRepository,
+        MenuProductRepository menuProductRepository,
+        MenuGroupRepository menuGroupRepository,
+        ProductRepository productRepository
     ) {
-        this.menuDao = menuDao;
-        this.menuGroupDao = menuGroupDao;
-        this.menuProductDao = menuProductDao;
-        this.productDao = productDao;
+        this.menuRepository = menuRepository;
+        this.menuProductRepository = menuProductRepository;
+        this.menuGroupRepository = menuGroupRepository;
+        this.productRepository = productRepository;
     }
 
     @Transactional
-    public Menu create(final Menu menu) {
-        final BigDecimal price = menu.getPrice();
-
-        if (Objects.isNull(price) || price.compareTo(BigDecimal.ZERO) < 0) {
-            throw new IllegalArgumentException();
-        }
+    public MenuResponse create(final MenuRequest request) {
+        MenuGroup menuGroup = findMenuGroupById(request.getMenuGroup());
+        Menu menu = menuRepository.save(new Menu(request.getName(), request.getPrice(), menuGroup));
+        MenuProducts menuProducts = generateMenuProducts(menu, request.getMenuProducts());
+        menuProducts.validateMenuPrice(new Price(request.getPrice()));
 
-        if (!menuGroupDao.existsById(menu.getMenuGroupId())) {
-            throw new IllegalArgumentException();
-        }
+        return MenuResponse.from(menu, menuProducts.toList());
+    }
 
-        final List<MenuProduct> menuProducts = menu.getMenuProducts();
+    private MenuProducts generateMenuProducts(Menu menu, List<MenuProductRequest> menuProductRequests) {
+        List<MenuProduct> menuProducts = new ArrayList<>();
 
-        BigDecimal sum = BigDecimal.ZERO;
-        for (final MenuProduct menuProduct : menuProducts) {
-            final Product product = productDao.findById(menuProduct.getProductId())
-                    .orElseThrow(IllegalArgumentException::new);
-            sum = sum.add(product.getPrice().multiply(BigDecimal.valueOf(menuProduct.getQuantity())));
+        for (MenuProductRequest request : menuProductRequests) {
+            Product product = findProductById(request.getProductId());
+            MenuProduct menuProduct = new MenuProduct(menu, product, request.getQuantity());
+            menuProducts.add(menuProductRepository.save(menuProduct));
         }
 
-        if (price.compareTo(sum) > 0) {
-            throw new IllegalArgumentException();
-        }
+        return new MenuProducts(menuProducts);
+    }
 
-        final Menu savedMenu = menuDao.save(menu);
+    public List<MenuResponse> list() {
+        List<MenuResponse> menuResponses = new ArrayList<>();
 
-        final Long menuId = savedMenu.getId();
-        final List<MenuProduct> savedMenuProducts = new ArrayList<>();
-        for (final MenuProduct menuProduct : menuProducts) {
-            menuProduct.setMenuId(menuId);
-            savedMenuProducts.add(menuProductDao.save(menuProduct));
+        for (Menu menu : menuRepository.findAll()) {
+            List<MenuProduct> menuProducts = menuProductRepository.findAllByMenu(menu);
+            menuResponses.add(MenuResponse.from(menu, menuProducts));
         }
-        savedMenu.setMenuProducts(savedMenuProducts);
 
-        return savedMenu;
+        return menuResponses;
     }
 
-    public List<Menu> list() {
-        final List<Menu> menus = menuDao.findAll();
-
-        for (final Menu menu : menus) {
-            menu.setMenuProducts(menuProductDao.findAllByMenuId(menu.getId()));
-        }
+    private MenuGroup findMenuGroupById(Long menuGroupId) {
+        return menuGroupRepository.findById(menuGroupId)
+            .orElseThrow(() -> new MenuGroupNotFoundException(
+                String.format("%d ID를 가진 MenuGroup이 존재하지 않습니다.", menuGroupId)
+            ));
+    }
 
-        return menus;
+    private Product findProductById(Long productId) {
+        return productRepository.findById(productId)
+            .orElseThrow(() -> new ProductNotFoundException(
+                String.format("%d ID를 가진 Product가 존재하지 않습니다.", productId))
+            );
     }
 }