diff --git a/docs/README.md b/docs/README.md
index e69de29..336b510 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -0,0 +1,614 @@
+# 🎅 크리스마스 프로모션
+
+### [ 목차 ]
+
+#### 1. [ 비즈니스팀 전달사항 ](#비즈니스-팀-전달사항)
+
+- [프로그램 기능 설명](#프로그램-기능-설명)
+    - [예약 날짜 입력](#예약-날짜-입력)
+    - [주문 내역 입력](#주문-내역-입력)
+    - [실행 결과 예시](#실행-결과-예시)
+
+#### 2. [ 개발팀 전달사항 ](#개발팀-전달사항)
+
+- [기능 목록](#기능-목록)
+- [프로그램 패키지 구조](#패키지-구조)
+- [프로젝트 아키텍처](#프로젝트-아키텍처)
+- [추후 확장 및 코드 재사용 시 참고사항](#추후-확장-및-코드-재사용-시-참고사항)
+
+#### 3. [ 공통 전달 사항 ]
+
+- [1주일 뒤 개발 회의에서 논의하면 좋을 사항](#1주일-뒤-개발-회의에서-논의하면-좋을-사항)
+
+---
+
+## 비즈니스 팀 전달사항
+
+> ### 프로그램 기능 설명
+
+#### 예약 날짜 입력
+
+#### 1-1. 예약 날짜 입력 ( 유효하지 않은 입력값 )
+
+```bash
+안녕하세요! 우테코 식당 12월 이벤트 플래너입니다.
+12월 중 식당 방문 날짜는 언제인가요? (숫자만 입력해 주세요!)
+> 
+[ERROR] 유효하지 않은 날짜입니다. 다시 입력해 주세요.
+12월 중 식당 방문 날짜는 언제인가요? (숫자만 입력해 주세요!)
+>a
+[ERROR] 유효하지 않은 날짜입니다. 다시 입력해 주세요.
+12월 중 식당 방문 날짜는 언제인가요? (숫자만 입력해 주세요!)
+>40
+[ERROR] 유효하지 않은 날짜입니다. 다시 입력해 주세요.
+12월 중 식당 방문 날짜는 언제인가요? (숫자만 입력해 주세요!)
+>-5
+[ERROR] 유효하지 않은 날짜입니다. 다시 입력해 주세요.
+12월 중 식당 방문 날짜는 언제인가요? (숫자만 입력해 주세요!)
+```
+
+#### 유효하지 않은 예약날짜 입력 기준
+
+- 예약 날짜 입력에 다음과 같은 값을 입력할 시,
+  <br> 에러가 발생하고 예약 날짜를 다시 입력받습니다.
+    - 비어있는 값
+    - 숫자 형식이 아닌 입력 값
+    - 1부터 31 사이가 아닌 값
+    - 0보다 작은 숫자 값
+    - 공백 포함 2000글자 이상인 값
+    - 공백 제거 후 3글자 이상인 값
+
+#### 1-2. 예약 날짜 입력 ( 올바른 입력 값 + 공백을 포함한 입력 값 )
+
+```bash
+12월 중 식당 방문 날짜는 언제인가요? (숫자만 입력해 주세요!)
+>24
+주문하실 메뉴를 메뉴와 개수를 알려 주세요. (e.g. 해산물파스타-2,레드와인-1,초코케이크-1)
+>
+```
+
+```bash
+12월 중 식당 방문 날짜는 언제인가요? (숫자만 입력해 주세요!)
+>31
+주문하실 메뉴를 메뉴와 개수를 알려 주세요. (e.g. 해산물파스타-2,레드와인-1,초코케이크-1)
+>
+```
+
+```bash
+12월 중 식당 방문 날짜는 언제인가요? (숫자만 입력해 주세요!)
+>2 1
+주문하실 메뉴를 메뉴와 개수를 알려 주세요. (e.g. 해산물파스타-2,레드와인-1,초코케이크-1)
+> 
+```
+
+```bash
+12월 중 식당 방문 날짜는 언제인가요? (숫자만 입력해 주세요!)
+>   3      1
+주문하실 메뉴를 메뉴와 개수를 알려 주세요. (e.g. 해산물파스타-2,레드와인-1,초코케이크-1)
+> 
+```
+
+- 예약 날짜 입력이 공백을 포함하더라도<br>
+  [유효하지 않은 값](#유효하지-않은-예약날짜-입력-기준)이 아닌 형식의 입력이면 에러가 발생하지 않습니다.
+
+#### 주문 내역 입력
+
+#### 2-1. 주문 내역 입력 ( 유효하지 않은 입력값 )
+
+```bash
+안녕하세요! 우테코 식당 12월 이벤트 플래너입니다.
+12월 중 식당 방문 날짜는 언제인가요? (숫자만 입력해 주세요!)
+>1
+주문하실 메뉴를 메뉴와 개수를 알려 주세요. (e.g. 해산물파스타-2,레드와인-1,초코케이크-1)
+>
+[ERROR] 유효하지 않은 주문입니다. 다시 입력해 주세요.
+주문하실 메뉴를 메뉴와 개수를 알려 주세요. (e.g. 해산물파스타-2,레드와인-1,초코케이크-1)
+>타파스-
+[ERROR] 유효하지 않은 주문입니다. 다시 입력해 주세요.
+주문하실 메뉴를 메뉴와 개수를 알려 주세요. (e.g. 해산물파스타-2,레드와인-1,초코케이크-1)
+>-3
+[ERROR] 유효하지 않은 주문입니다. 다시 입력해 주세요.
+주문하실 메뉴를 메뉴와 개수를 알려 주세요. (e.g. 해산물파스타-2,레드와인-1,초코케이크-1)
+>타파스-a
+[ERROR] 유효하지 않은 주문입니다. 다시 입력해 주세요.
+주문하실 메뉴를 메뉴와 개수를 알려 주세요. (e.g. 해산물파스타-2,레드와인-1,초코케이크-1)
+>허니갈릭치킨-1
+[ERROR] 유효하지 않은 주문입니다. 다시 입력해 주세요.
+주문하실 메뉴를 메뉴와 개수를 알려 주세요. (e.g. 해산물파스타-2,레드와인-1,초코케이크-1)
+>시저샐러드-2,타파스-3,티본스테이크-5,제로콜라-10,해산물파스타-5
+[ERROR] 유효하지 않은 주문입니다. 다시 입력해 주세요.
+주문하실 메뉴를 메뉴와 개수를 알려 주세요. (e.g. 해산물파스타-2,레드와인-1,초코케이크-1)
+>제로콜라-3,레드와인-2,샴페인-1
+[ERROR] 유효하지 않은 주문입니다. 다시 입력해 주세요.
+주문하실 메뉴를 메뉴와 개수를 알려 주세요. (e.g. 해산물파스타-2,레드와인-1,초코케이크-1)
+> 타파스-1,시저샐러드-,티본스테이크-3
+[ERROR] 유효하지 않은 주문입니다. 다시 입력해 주세요.
+주문하실 메뉴를 메뉴와 개수를 알려 주세요. (e.g. 해산물파스타-2,레드와인-1,초코케이크-1)
+> 아이스크림-1,-3,초코케이크-1
+[ERROR] 유효하지 않은 주문입니다. 다시 입력해 주세요.
+주문하실 메뉴를 메뉴와 개수를 알려 주세요. (e.g. 해산물파스타-2,레드와인-1,초코케이크-1)
+> 시저샐러드-1,초코케이크-1,시저샐러드-1
+[ERROR] 유효하지 않은 주문입니다. 다시 입력해 주세요.
+주문하실 메뉴를 메뉴와 개수를 알려 주세요. (e.g. 해산물파스타-2,레드와인-1,초코케이크-1)
+>
+```
+
+#### 유효하지 않은 주문내역 입력 기준
+
+- 주문 내역에 다음과 같은 값을 입력할 시,
+  <br> 에러가 발생하고 주문 내역을 다시 입력받습니다.
+    - 비어있는 값
+    - 메뉴 이름이 비어있는 값
+    - 메뉴 개수가 비어있는 값
+    - 메뉴 개수가 숫자 형식이 아닌 값
+    - 메뉴 이름이 30글자 초과인 값
+    - 메뉴 개수가 3글자 초과인 값
+    - 판매중인 메뉴가 아닌 메뉴 이름을 포함한 값
+    - 각 주문의 메뉴 개수 합이 20개를 초과하는 값
+    - 메뉴 이름이 음료만으로 이루어진 값
+    - 메뉴 이름과 메뉴 개수를 나누는 구분자(-)가 포함되지 않는 값
+    - 구분자(-)로 끝나는 값
+    - 공백 포함 2000글자 초과인 값
+    - 공백 제거 후 1000글자 초과인 값
+
+#### 2-2. 주문 내역 입력 ( 올바른 입력값 + 공백을 포함한 입력값 )
+
+```bash
+안녕하세요! 우테코 식당 12월 이벤트 플래너입니다.
+12월 중 식당 방문 날짜는 언제인가요? (숫자만 입력해 주세요!)
+>31
+주문하실 메뉴를 메뉴와 개수를 알려 주세요. (e.g. 해산물파스타-2,레드와인-1,초코케이크-1)
+>타파스-1,티본스테이크-1,바비큐립-1,아이스크림-1,초코케이크-1,샴페인-1,레드와인-1
+12월 31일에 우테코 식당에서 받을 이벤트 혜택 미리 보기!
+...
+```
+
+```bash
+안녕하세요! 우테코 식당 12월 이벤트 플래너입니다.
+12월 중 식당 방문 날짜는 언제인가요? (숫자만 입력해 주세요!)
+>25
+주문하실 메뉴를 메뉴와 개수를 알려 주세요. (e.g. 해산물파스타-2,레드와인-1,초코케이크-1)
+>양  송이 수  프 -  1, 티 본스테이크-1,바비큐 립-1, 초코 케이크-1, 크리스마스 파스타 -1, 레드 와인-1
+12월 25일에 우테코 식당에서 받을 이벤트 혜택 미리 보기!
+...
+```
+
+- 주문 내역 입력이 공백을 포함하더라도<br>
+  [유효하지 않은 값](#유효하지-않은-주문내역-입력-기준)이 아닌 형식의 입력이면 에러가 발생하지 않습니다.
+
+#### 실행 결과 예시
+
+- 다음은 이해를 돕기 위한 몇가지 예시 프로그램 실행 결과입니다.
+
+#### 3-1. 주문 금액이 10000원 미만, 이벤트 적용 대상이 아닌 주문
+
+```bash
+안녕하세요! 우테코 식당 12월 이벤트 플래너입니다.
+12월 중 식당 방문 날짜는 언제인가요? (숫자만 입력해 주세요!)
+>1
+주문하실 메뉴를 메뉴와 개수를 알려 주세요. (e.g. 해산물파스타-2,레드와인-1,초코케이크-1)
+>타파스-1,제로콜라-1
+12월 1일에 우테코 식당에서 받을 이벤트 혜택 미리 보기!
+
+<주문 메뉴>
+제로콜라 1개
+타파스 1개
+
+<할인 전 총주문 금액>
+8,500원
+
+<증정 메뉴>
+없음
+
+<혜택 내역>
+없음
+
+<총혜택 금액>
+0원
+
+<할인 후 예상 결제 금액>
+8,500원
+
+<12월 이벤트 배지>
+없음
+```
+
+#### 3-2. 크리스마스 디데이 할인, 평일 할인 적용 주문 예시
+
+```bash
+안녕하세요! 우테코 식당 12월 이벤트 플래너입니다.
+12월 중 식당 방문 날짜는 언제인가요? (숫자만 입력해 주세요!)
+>13
+주문하실 메뉴를 메뉴와 개수를 알려 주세요. (e.g. 해산물파스타-2,레드와인-1,초코케이크-1)
+>타파스-1,시저샐러드-1,티본스테이크-1,초코케이크-1,제로콜라-1
+12월 13일에 우테코 식당에서 받을 이벤트 혜택 미리 보기!
+
+<주문 메뉴>
+초코케이크 1개
+제로콜라 1개
+타파스 1개
+티본스테이크 1개
+시저샐러드 1개
+
+<할인 전 총주문 금액>
+86,500원
+
+<증정 메뉴>
+없음
+
+<혜택 내역>
+크리스마스 디데이 할인: -2,200원
+평일 할인: -2,023원
+
+<총혜택 금액>
+-4,223원
+
+<할인 후 예상 결제 금액>
+82,277원
+
+<12월 이벤트 배지>
+없음
+```
+
+#### 3-3. 크리스마스 디데이 할인, 주말 할인, 증정 이벤트 적용 주문 예시
+
+```bash
+안녕하세요! 우테코 식당 12월 이벤트 플래너입니다.
+12월 중 식당 방문 날짜는 언제인가요? (숫자만 입력해 주세요!)
+>23
+주문하실 메뉴를 메뉴와 개수를 알려 주세요. (e.g. 해산물파스타-2,레드와인-1,초코케이크-1)
+>타파스-2,티본스테이크-1,해산물파스타-2,레드와인-1
+12월 23일에 우테코 식당에서 받을 이벤트 혜택 미리 보기!
+
+<주문 메뉴>
+타파스 2개
+티본스테이크 1개
+해산물파스타 2개
+레드와인 1개
+
+<할인 전 총주문 금액>
+196,000원
+
+<증정 메뉴>
+샴페인 1개
+
+<혜택 내역>
+크리스마스 디데이 할인: -3,200원
+주말 할인: -6,069원
+증정 이벤트: -25,000원
+
+<총혜택 금액>
+-34,269원
+
+<할인 후 예상 결제 금액>
+186,731원
+
+<12월 이벤트 배지>
+산타
+```
+
+#### 3-4. 평일 할인만 적용된 주문 예시
+
+```bash
+안녕하세요! 우테코 식당 12월 이벤트 플래너입니다.
+12월 중 식당 방문 날짜는 언제인가요? (숫자만 입력해 주세요!)
+>28
+주문하실 메뉴를 메뉴와 개수를 알려 주세요. (e.g. 해산물파스타-2,레드와인-1,초코케이크-1)
+>타파스-1,아이스크림-3,제로콜라-1
+12월 28일에 우테코 식당에서 받을 이벤트 혜택 미리 보기!
+
+<주문 메뉴>
+제로콜라 1개
+타파스 1개
+아이스크림 3개
+
+<할인 전 총주문 금액>
+23,500원
+
+<증정 메뉴>
+없음
+
+<혜택 내역>
+평일 할인: -6,069원
+
+<총혜택 금액>
+-6,069원
+
+<할인 후 예상 결제 금액>
+17,431원
+
+<12월 이벤트 배지>
+별
+```
+
+---
+
+## 개발팀 전달사항
+
+## 👨‍💻기능 목록
+
+## 💻 [ 입력 및 입력값 검증 기능 ]
+
+> ### 🎯 모든 종류 입력값에 대한 검증
+
+- [x] 모든 사용자 입력값은 공백 포함 길이 2000글자 이하로 한다.
+    - [x] 위 경우를 만족시키지 못하는 경우 `BasicInputException`을 발생시키고,<br>
+      입력 종류에 따라 "[ERROR] 유효하지 않은 날짜입니다. 다시 입력해 주세요." 또는 <br>"[ERROR] 유효하지 않은 주문입니다. 다시 입력해 주세요."라는 메시지를 내보낸다.<br>이후 다시
+      해당 입력
+      종류(날짜 혹은 주문)을 받는다.
+
+> ### 🗓 예약 날짜 입력 및 입력값 검증
+
+- [x] `예약 날짜` 입력 요청 문구를 출력한다.
+- [x] 사용자에게 `예약 날짜`를 입력받는다.
+    - [x] 날짜가 비어있는 값이 아님을 확인한다.
+    - [x] 날짜에 공백이 포함되어 있는지 확인한다.
+        - [x] 공백이 앞 뒤에 포함되어 있을 경우, 공백을 제거한다.
+        - [x] 공백이 글자 중간에 포함되어 있을 경우, 공백을 제거해 공백 사이를 이어준다.
+    - [x] 공백 제거 후 글자 길이가 2 이하인지 확인한다.
+    - [x] 예약 날짜가 숫자 형식인지 확인한다.
+    - [x] 예약 날짜가 양수인지 확인한다.
+- [x] 위 경우를 만족하지 못하는 경우 `DayInputException`을 발생시키고,<br>
+  "[ERROR] 유효하지 않은 날짜입니다. 다시 입력해 주세요."라는 메시지를 내보낸다.<br>이후 다시 `예약 날짜` 입력을 받는다.
+
+> ### 🔖 주문 내역 입력 및 입력값 검증
+
+- [x] `주문 내역` 입력 요청 문구를 출력한다.
+- [x] 사용자에게 `주문 내역`을 입력받는다.
+    - [x] `주문 내역`이 비어있지 않은지 확인한다.
+    - [x] `주문 내역`이 1000글자 이하인지 확인한다.
+        - [x] 위 경우를 만족시키지 못하는 경우 `BasicInputException`을 발생시키고,<br>
+          "[ERROR] 유효하지 않은 주문입니다. 다시 입력해 주세요."라는 메시지를 내보낸다.<br>이후 다시 `주문 내역`을 입력을 받는다.
+    - [x] 주문 내역에 공백이 포함되어 있는지 확인한다.
+        - [x] 공백이 앞 뒤에 포함되어 있을 경우, 공백을 제거한다.
+        - [x] 공백이 글자 중간에 포함되어 있을 경우, 공백을 제거해 공백 사이를 이어준다.
+    - [x] `주문`은 `메뉴 이름`과 `메뉴 개수`로 이루어진다.
+    - [x] `주문`은 쉼표(,)를 기준으로 구분한다.
+        - [x] `메뉴 이름`와 `메뉴 개수`는 대시(-)를 기준으로 구분한다.
+
+> #### i) 🙋`주문`에 대한 입력값 검증
+
+- [x] `주문`이 비어있는 값이 아님을 확인한다.
+- [x] `주문`이 50글자 이하인지 확인한다.
+    - [x] 위 경우를 만족시키지 못하는 경우 `BasicInputException`을 발생시키고,<br>
+      "[ERROR] 유효하지 않은 주문입니다. 다시 입력해 주세요."라는 메시지를 내보낸다.<br>이후 다시 `주문 내역`을 입력을 받는다.
+- [x] `주문`이 대시(-)를 포함하는지 확인한다.
+- [x] `주문` 앞 뒤에 공백이 존재하는지 확인한다.
+    - [x] 공백이 앞뒤에 포함되어 있을 경우, 공백을 제거한다.
+    - [x] 공백이 글자 중간에 포함되어 있을 경우, 공백을 제거해 공백 사이를 이어준다.
+- [x] 위 경우를 만족시키지 못하는 경우 `OrdersInputException`을 발생시키고,<br>
+  "[ERROR] 유효하지 않은 주문입니다. 다시 입력해 주세요."라는 메시지를 내보낸다.<br>이후 다시 `주문 내역`을 입력을 받는다.
+
+> #### ii) ✉️`메뉴 이름`에 대한 입력값 검증
+
+- [x] `메뉴 이름`이 비어있는 값이 아님을 확인한다.
+- [x] `메뉴 이름`이 30글자 이하인지 확인한다.
+    - [x] 위 경우를 만족시키지 못하는 경우 `BasicInputException`을 발생시키고,<br>
+      "[ERROR] 유효하지 않은 주문입니다. 다시 입력해 주세요."라는 메시지를 내보낸다.<br>이후 다시 `주문 내역`을 입력을 받는다.
+- [x] `메뉴 이름`이 메뉴판에 있는 메뉴인지 확인한다.
+    - [x] 위 경우를 만족시키지 못하는 경우 `InvalidOrdersException`을 발생시키고,<br>
+      "[ERROR] 유효하지 않은 주문입니다. 다시 입력해 주세요." 라는 메시지를 내보낸다.<br>이후 다시 `주문 내역`을 입력을 받는다.
+
+> #### iii) `메뉴 개수`에 대한 입력값 검증
+
+- [x] `메뉴 개수`가 비어있는 값이 아님을 확인한다.
+- [x] `메뉴 개수`가 2글자 이하인지 확인한다.
+    - [x] 위 경우를 만족시키지 못하는 경우 `BasicInputException`을 발생시키고,<br>
+      "[ERROR] 유효하지 않은 주문입니다. 다시 입력해 주세요."라는 메시지를 내보낸다.<br>이후 다시 `주문 내역`을 입력을 받는다.
+- [x] `메뉴 개수`가 숫자 형식인지 확인한다.
+- [x] `메뉴 개수`가 1 이상 정수 인지 확인한다.
+    - [x] 위 경우를 만족시키지 못하는 경우 `OrdersInputException`을 발생시키고,<br>
+      "[ERROR] 유효하지 않은 주문입니다. 다시 입력해 주세요."라는 메시지를 내보낸다.<br>이후 다시 `주문 내역`을 입력을 받는다.
+
+> #### 🔖 iv) `주문 내역` 입력값 재검증
+
+- [x] `주문 내역`을 취합했을 때, 중복 메뉴가 존재하는지 확인한다.
+    - [x] 위 경우를 만족시키지 못하는 경우 `OrdersInputException`을 발생시키고,<br>
+      "[ERROR] 유효하지 않은 주문입니다. 다시 입력해 주세요."라는 메시지를 내보낸다.<br>이후 다시 `주문 내역`을 입력을 받는다.
+
+## 🧩 [ 비즈니스 로직 관련 기능 ]
+
+> ### 🗓 날짜에 대한 적용 가능한 이벤트 판단 도메인 로직
+
+- 사용자에게 입력받은 날짜에 대해
+    - [x] 날짜가 1 이상 31 이하의 숫자인지 확인한다.
+        - [x] 1 이상 31 이하의 숫자가 아닌 경우, `InvalidDayException`을 발생시키고, <br> "[ERROR] 유효하지 않은 날짜입니다. 다시 입력해 주세요."라는 메시지를
+          출력한다.
+    - [x] 해당 날짜가 크리스마스 D-Day 프로모션 대상 날짜인지 확인한다.
+    - [x] 평일 할인 대상 날짜인지 확인한다.
+    - [x] 주말 할인 대상 날짜인지 확인한다.
+    - [x] 특별 할인 대상 날짜인지 확인한다.
+
+> ### 🔖 주문 내역에 따른 이벤트 적용 여부 판단 도메인 로직
+
+- 사용자에게 입력받은 주문 내역( 메뉴 이름과 수량 )에 대해
+    - [x] `주문 내역`을 취합했을 때, `메뉴 개수`가 `20개`가 넘어가는지 확인한다.
+    - [x] `주문 내역`을 취합했을 때, `주문 내역`에 음료수만 있는지 확인한다.
+        - [x] 위 경우를 만족시키지 못하는 경우 `InvalidOrdersException`을 발생시키고,<br>
+          "[ERROR] 유효하지 않은 주문입니다. 다시 입력해 주세요."라는 메시지를 내보낸다.<br>이후 다시 `주문 내역`을 입력을 받는다.
+    - [x] 주문 내역을 취합했을 때, 주문 금액이 `10000원` 이하이면, 할인 이벤트 적용 대상에서 제외시킨다.
+    - [x] 주문 내역을 취합했을 때, 주문 금액이 `12만원 이상`일 시, `샴페인 1개` 를 증정한다.
+    - [x] 주문 내역을 이용해서 `할인 전 총 주문 금액`을 계산할 수 있다.
+
+> ### 🎄 주문 내역에 대한 이벤트 적용 결과 산출 도메인 로직
+
+- [x] 주문 내역과 날짜를 비교해서, `혜택 내역`을 생산한다.
+    - [x] 주문 내역에 날짜에 따른 할인 여부를 적용해서, `할인 금액`을 계산한다.
+    - [x] 혜택 내역의 금액을 합쳐서, `총 혜택 금액`을 계산한다.
+        - [x] 주문 내역에 증정 이벤트가 포함되어 있을 시, 증정품의 가격까지 `총 혜택 금액`에 포함시킨다.
+    - [x] 총 혜택 금액을 기반으로 12월 이벤트 배지를 발급한다.
+        - [x] 혜택 금액이 `5000원` 이상일 시, `별`
+          <br> 혜택 금액이 `1만원` 이상일 시, `트리`
+          <br> 혜택 금액이 `2만원` 이상일 시, `산타`
+    - [x] `할인 전 총 주문 금액` 에서 `할인 금액`을 빼서 `할인 후 예상 결제 금액`을 계산한다.
+
+## 🖨 [ 출력 기능 ]
+
+> ### 🎙️ 이벤트 혜택 미리 보기 알림 출력
+
+- [x] 입력받은 날짜에 해당하는 이벤트 혜택 미리보기 알림 문구를 출력한다.
+
+> ### 🙋‍♂️ 주문 메뉴 출력
+
+- [x] 주문 메뉴를 나타내는 문구를 출력한다.
+- [x] 주문 메뉴는 `${메뉴이름} ${메뉴개수} 개`  형식으로 출력한다.
+- [x] 주문한 메뉴 전체를 위와 같은 형식으로 출력한다.
+- [x] 출력 순서는 자유롭게 한다.
+
+> ### 💰 할인 전 총 주문 금액 출력
+
+- [x] 할인 전 총 주문 금액을 나타내는 문구를 출력한다.
+- [x] `할인 전 총 주문 금액`을 나타낸다.
+    - [x] 금액의 세자리 수마다 `,`을 붙이는 형식으로 출력한다.
+
+> ### 🎁 증정 메뉴 출력
+
+- [x] 증정 메뉴를 나타내는 문구를 출력한다.
+- [x] 증정 메뉴가 있는 경우 `${증정 메뉴 이름} ${증정 메뉴 개수}개`  형식으로 출력한다.
+- [x] 증정 메뉴가 없는 경우 `없음`으로 출력한다.
+
+> ### 👍 혜택 내역 출력
+
+- [x] 혜택 내역을 나타내는 문구를 출력한다.
+- [x] 적용되는 할인 이벤트별 이름 및 혜택 금액을 정리해서 나타낸다.
+    - [x] `${적용 혜택 이벤트 이름}: -${혜택 금액}원` 형식으로 출력한다.
+        - [x] `혜택 금액`의 세자리 수마다 `,`을 붙이는 형식으로 출력한다.
+    - [x] 적용된 혜택이 없으면 `없음`으로 출력한다.
+- [x] 여러 개의 이벤트가 적용되었으면, 출력 순서는 자유롭게 한다.
+
+> ### 📉 총 혜택 금액 출력
+
+- [x] 총 혜택 금액을 나타내는 문구를 출력한다.
+- [x] `총 혜택 금액`은 `혜택 내역`에 적용된 혜택 금액을 모두 더한 값을 출력한다.
+    - [x] `-${혜택 금액}원` 형식으로 출력한다.
+        - [x] `혜택 금액`의 세자리 수마다 `,`를 붙이는 형식으로 출력한다.
+- [x] `총 혜택 금액`이 0원이면 `0원`으로 출력한다.
+
+> ### 💵 할인 후 예상 결제 금액 출력
+
+- [x] 할인 후 예상 결제 금액을 나타내는 문구를 출력한다.
+- [x] `할인 후 예상 결제 금액`은 `할인 전 총 주문 금액`에서 `총 혜택 금액`을 뺀 값을 출력한다.
+    - [x] `${할인 후 예상 결제 금액}원` 형식으로 출력한다.
+        - [x] `할인 후 예상 결제 금액`의 세자리 수마다 `,`를 붙이는 형식으로 출력한다.
+
+> ### ⭐🎄🎅 12월 이벤트 배지 출력
+
+- [x] 12월 이벤트 배지를 나타내는 문구를 출력한다.
+- [x] `배지 이름` 의 형식으로 출력한다.
+    - [x] `12월 이벤트 배지`는 `총 혜택 금액`의 값에 따라 다르게 값을 다르게 출력한다.
+        - [x] 5000원 이상은 `별`, 10000원 이상은 `트리`, 20000원 이상은 `산타`로 출력한다.
+- [x] 이벤트 배지가 부여되지 않으면 `없음`을 출력한다.
+
+---
+
+## 🎒패키지 구조
+
+```bash
+christmas
+    ├── Application.java
+    ├── EventPlanner.java
+    ├── controller
+    │   ├── OrdersController.java
+    │   └── ReservationDayController.java
+    ├── domain
+    │   ├── DayPerMonth.java
+    │   ├── EventManager.java
+    │   ├── Order.java
+    │   ├── Orders.java
+    │   ├── ReservationDay.java
+    │   ├── constant
+    │   │   ├── event
+    │   │   │   ├── ChristmasPromotion.java
+    │   │   │   ├── EventBadge.java
+    │   │   │   ├── EventNumberConstant.java
+    │   │   │   ├── EventSymbolConstant.java
+    │   │   │   └── Promotion.java
+    │   │   ├── orders
+    │   │   │   ├── FoodType.java
+    │   │   │   ├── Menu.java
+    │   │   │   └── OrdersConstant.java
+    │   │   └── reservationday
+    │   │       └── ReservationDayConstant.java
+    │   └── exception
+    │       ├── InvalidOrdersException.java
+    │       ├── InvalidReservationDayException.java
+    │       └── message
+    │           ├── InvalidOrdersExceptionMessage.java
+    │           └── InvalidReservationDayExceptionMessage.java
+    ├── dto
+    │   ├── BenefitsDetailsDto.java
+    │   ├── EstimatedAmountWithDiscountDto.java
+    │   ├── EventBadgeDto.java
+    │   ├── EventBenefitsPreviewDto.java
+    │   ├── GiftDto.java
+    │   ├── OrderedMenusDto.java
+    │   ├── TotalAmountWithNoDiscountDto.java
+    │   └── TotalBenefitedAmountDto.java
+    ├── global
+    │   └── ApplicationConstant.java
+    ├── service
+    │   ├── EventManagerService.java
+    │   ├── OrdersService.java
+    │   └── ReservationDayService.java
+    └── view
+        ├── input
+        │   ├── InputView.java
+        │   ├── constant
+        │   │   ├── InputNumberConstant.java
+        │   │   └── InputSymbolConstant.java
+        │   ├── exception
+        │   │   ├── BasicInputException.java
+        │   │   ├── DayInputException.java
+        │   │   ├── OrdersInputException.java
+        │   │   └── message
+        │   │       ├── BasicInputExceptionMessageFormat.java
+        │   │       ├── DayInputExceptionMessage.java
+        │   │       └── OrdersInputExceptionMessage.java
+        │   ├── parser
+        │   │   └── InputParser.java
+        │   └── validator
+        │       ├── BasicValidator.java
+        │       ├── DayInputValidator.java
+        │       ├── MenuCountInputValidator.java
+        │       ├── MenuNameInputValidator.java
+        │       ├── OrderInputValidator.java
+        │       ├── OrdersInputValidator.java
+        │       └── PositiveIntegerCheckable.java
+        └── output
+            ├── OutputView.java
+            └── constant
+                ├── OutputFormatConstant.java
+                ├── OutputMessageConstant.java
+                └── OutputSymbolConstant.java
+```
+
+## 프로젝트 아키텍처
+
+<img width="80%" src="https://github.com/junslog/java-christmas-6-junslog/assets/30232340/094d051a-f37b-47a6-bcc4-f947bc3ddde5"/>
+
+## 추후 확장 및 코드 재사용 시 참고사항
+
+- `global/ApplicationConstant` 클래스의 <br>
+  `CURRENT_PROMOTION_MONTH`는 이벤트가 시행되는 월(month)을 의미합니다.
+  <br><br>
+- `ReservationDay` 클래스는 12월의 날짜 값과 12월 이벤트 도메인 로직을 처리하는 클래스입니다.<br>
+  해당 클래스는 `DayPerMonth`라는 추상 클래스를 상속받으며, 이 클래스는 유효 날짜 검증 로직을 가집니다.<br>
+  예를 들어, 다음 달 1월 이벤트를 위해 코드를 재사용 하신다면, 다음과 같은 순서로 진행하시면 됩니다.<br><br>
+    1. `domain.constant.reservationday.ReservationDayConstant` 클래스에서,<br>
+       `JANUARY_FIRST_DAY`, `JANUARY_LAST_DAY` 값을 추가합니다.<br><br>
+    2. `ReservationDay` 클래스의 `isInAppropriateRange`메서드의 DECEMBER 관련 상수 값을 1에서 생성한 상수 값으로 대체해줍니다.<br><br>
+    3. `ReservationDay` 클래스의 12월 관련 도메인 로직을 제거하고,<br> 1월 이벤트에 맞는 도메인 로직으로 클래스를 구성합니다.<br><br>
+    4. `EventManager` 클래스는 이벤트 관련 도메인 로직을 <br>예약 날짜와 주문 내역을 통해 해결하는 클래스입니다.<br><br>
+    5. `ReservationDay`클래스의 도메인 변경에 따른 `EventManager`도메인 로직을 수정해주시면 됩니다.이 때, `christmas.domain.constant.event` 폴더의
+       이벤트 변수 값을 변경 또는 활용해주시면 됩니다.
+
+---
+
+### 1주일 뒤 개발 회의에서 논의하면 좋을 사항
+
+- 평일 할인 날에 아이스크림만 많이 시켜먹는 손님이 오면 매출에 불리할 것 같습니다.<br>
+  이에 대한 대응책이 필요하지 않을까요?<br><br>
+- 30일과 31일은 연말이라 손님이 많이 몰릴 시기인데, 이를 유인할만한 이벤트가 다소 부족한 것 같습니다.<br>
+  연말 이벤트를 추가하는 방안은 어떨까요?<br><br>
+- 증정 이벤트가 샴페인만 제공해주는 것 같아, 아이들과 함께 오는 부모님들에게는 그다지 유인책이 되지 않을 것 같습니다.
+  <br>고객을 유인하기 위해 샴페인을 제공하는 것인데, 오히려 아이들 앞에서 음주 장려(?)를 하는 것 같아 저희 식당을 이용하지 않을 수도 있을 거 같습니다.증정품을 다양화하는 것은 어떻게 생각하시나요?
\ No newline at end of file
diff --git a/src/main/java/christmas/Application.java b/src/main/java/christmas/Application.java
index b9ba6a2..579e42e 100644
--- a/src/main/java/christmas/Application.java
+++ b/src/main/java/christmas/Application.java
@@ -1,7 +1,11 @@
 package christmas;
 
+import christmas.view.input.InputView;
+import christmas.view.output.OutputView;
+
 public class Application {
     public static void main(String[] args) {
-        // TODO: 프로그램 구현
+        EventPlanner eventPlanner = new EventPlanner(new InputView(), new OutputView());
+        eventPlanner.execute();
     }
-}
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/EventPlanner.java b/src/main/java/christmas/EventPlanner.java
new file mode 100644
index 0000000..d5b1d48
--- /dev/null
+++ b/src/main/java/christmas/EventPlanner.java
@@ -0,0 +1,82 @@
+package christmas;
+
+import camp.nextstep.edu.missionutils.Console;
+import christmas.controller.OrdersController;
+import christmas.controller.ReservationDayController;
+import christmas.domain.EventManager;
+import christmas.domain.Orders;
+import christmas.domain.ReservationDay;
+import christmas.service.EventManagerService;
+import christmas.view.input.InputView;
+import christmas.view.output.OutputView;
+
+public class EventPlanner {
+    private final OutputView outputView;
+    private final ReservationDayController reservationDayController;
+    private final OrdersController ordersController;
+    private final EventManagerService eventManagerService;
+
+    public EventPlanner(InputView inputView, OutputView outputView) {
+        this.outputView = outputView;
+        reservationDayController = new ReservationDayController(inputView, outputView);
+        ordersController = new OrdersController(inputView, outputView);
+        eventManagerService = new EventManagerService();
+        outputView.printGreetingMessage();
+    }
+
+    public void execute() {
+        ReservationDay reservationDay = reservationDayController.insertReservationDay();
+        Orders orders = ordersController.insertOrders();
+        EventManager eventManager = EventManager.of(reservationDay, orders);
+        printResult(reservationDay, orders, eventManager);
+        terminatePlanner();
+    }
+
+    private void printResult(ReservationDay reservationDay, Orders orders, EventManager eventManager) {
+        printIntroMessage(reservationDay);
+        printOrderedMenus(orders);
+        printTotalAmountWithNoDiscount(orders);
+        printGiftMenu(orders);
+        printBenefitsDetails(eventManager);
+        printTotalBenefitedAmount(eventManager);
+        printEstimatedAmountWithDiscount(eventManager);
+        printEventBadge(eventManager);
+    }
+
+    private void printIntroMessage(ReservationDay reservationDay) {
+        outputView.printIntroMessage(reservationDayController.createEventBenefitsPreviousDto(reservationDay));
+    }
+
+    private void printOrderedMenus(Orders orders) {
+        outputView.printOrderedMenus(ordersController.createOrderedMenusDto(orders));
+    }
+
+    private void printTotalAmountWithNoDiscount(Orders orders) {
+        outputView.printTotalAmountWithNoDiscount(ordersController.createTotalAmountWithNoDiscountDto(orders));
+    }
+
+    private void printGiftMenu(Orders orders) {
+        outputView.printGiftMenu(eventManagerService.createGiftDto(orders));
+    }
+
+    private void printBenefitsDetails(EventManager eventManager) {
+        outputView.printBenefitsDetails(eventManagerService.createBenefitsDetailsDto(eventManager));
+    }
+
+    private void printTotalBenefitedAmount(EventManager eventManager) {
+        outputView.printTotalBenefitedAmount(eventManagerService.createTotalBenefitedAmountDto(eventManager));
+    }
+
+    private void printEstimatedAmountWithDiscount(EventManager eventManager) {
+        outputView.printEstimatedAmountWithDiscount(
+                eventManagerService.createEstimatedAmountWithDiscountDto(eventManager));
+    }
+
+    private void printEventBadge(EventManager eventManager) {
+        outputView.printEventBadge(eventManagerService.createEventBadgeDto(eventManager));
+    }
+
+    private void terminatePlanner() {
+        Console.close();
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/controller/OrdersController.java b/src/main/java/christmas/controller/OrdersController.java
new file mode 100644
index 0000000..fa8a313
--- /dev/null
+++ b/src/main/java/christmas/controller/OrdersController.java
@@ -0,0 +1,47 @@
+package christmas.controller;
+
+import christmas.domain.Orders;
+import christmas.domain.exception.InvalidOrdersException;
+import christmas.dto.OrderedMenusDto;
+import christmas.dto.TotalAmountWithNoDiscountDto;
+import christmas.service.OrdersService;
+import christmas.view.input.InputView;
+import christmas.view.input.exception.BasicInputException;
+import christmas.view.input.exception.OrdersInputException;
+import christmas.view.output.OutputView;
+import java.util.Map;
+
+public class OrdersController {
+    private final InputView inputView;
+    private final OutputView outputView;
+    private final OrdersService ordersService;
+
+    public OrdersController(InputView inputView, OutputView outputView) {
+        this.inputView = inputView;
+        this.outputView = outputView;
+        ordersService = new OrdersService();
+    }
+
+    public Orders insertOrders() {
+        try {
+            Map<String, Integer> orders = askToInsertOrders();
+            return ordersService.createOrders(orders);
+        } catch (BasicInputException | OrdersInputException | InvalidOrdersException e) {
+            outputView.printErrorMessage(e.getMessage());
+            return insertOrders();
+        }
+    }
+
+    private Map<String, Integer> askToInsertOrders() throws BasicInputException, OrdersInputException {
+        outputView.askToInsertOrders();
+        return inputView.getOrders();
+    }
+
+    public OrderedMenusDto createOrderedMenusDto(Orders orders) {
+        return ordersService.createOrdersHistoryDto(orders);
+    }
+
+    public TotalAmountWithNoDiscountDto createTotalAmountWithNoDiscountDto(Orders orders) {
+        return ordersService.createTotalAmountWithNoDiscountDto(orders);
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/controller/ReservationDayController.java b/src/main/java/christmas/controller/ReservationDayController.java
new file mode 100644
index 0000000..f10378c
--- /dev/null
+++ b/src/main/java/christmas/controller/ReservationDayController.java
@@ -0,0 +1,41 @@
+package christmas.controller;
+
+import christmas.domain.ReservationDay;
+import christmas.domain.exception.InvalidReservationDayException;
+import christmas.dto.EventBenefitsPreviewDto;
+import christmas.service.ReservationDayService;
+import christmas.view.input.InputView;
+import christmas.view.input.exception.BasicInputException;
+import christmas.view.input.exception.DayInputException;
+import christmas.view.output.OutputView;
+
+public class ReservationDayController {
+    private final InputView inputView;
+    private final OutputView outputView;
+    private final ReservationDayService reservationDayService;
+
+    public ReservationDayController(InputView inputView, OutputView outputView) {
+        this.inputView = inputView;
+        this.outputView = outputView;
+        reservationDayService = new ReservationDayService();
+    }
+
+    public ReservationDay insertReservationDay() {
+        try {
+            int reservationDay = askToInsertReservationDay();
+            return reservationDayService.createReservationDay(reservationDay);
+        } catch (BasicInputException | DayInputException | InvalidReservationDayException e) {
+            outputView.printErrorMessage(e.getMessage());
+            return insertReservationDay();
+        }
+    }
+
+    private int askToInsertReservationDay() throws BasicInputException, DayInputException {
+        outputView.askToInsertReservationDay();
+        return inputView.getReservationDay();
+    }
+
+    public EventBenefitsPreviewDto createEventBenefitsPreviousDto(ReservationDay reservationDay) {
+        return reservationDayService.createEventBenefitsPreviewDto(reservationDay);
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/domain/DayPerMonth.java b/src/main/java/christmas/domain/DayPerMonth.java
new file mode 100644
index 0000000..28e4d7a
--- /dev/null
+++ b/src/main/java/christmas/domain/DayPerMonth.java
@@ -0,0 +1,22 @@
+package christmas.domain;
+
+import static christmas.domain.constant.reservationday.ReservationDayConstant.DECEMBER_LAST_DAY;
+import static christmas.domain.constant.reservationday.ReservationDayConstant.DEFAULT_FIRST_DAY;
+import static christmas.domain.exception.message.InvalidReservationDayExceptionMessage.NOT_IN_APPROPRIATE_RANGE;
+
+import christmas.domain.exception.InvalidReservationDayException;
+
+public abstract class DayPerMonth {
+    public DayPerMonth() {
+    }
+
+    protected void validate(final int day) {
+        if (!isInAppropriateRange(day)) {
+            throw InvalidReservationDayException.of(NOT_IN_APPROPRIATE_RANGE.getMessage());
+        }
+    }
+
+    protected boolean isInAppropriateRange(final int day) {
+        return day >= DEFAULT_FIRST_DAY.getValue() && day <= DECEMBER_LAST_DAY.getValue();
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/domain/EventManager.java b/src/main/java/christmas/domain/EventManager.java
new file mode 100644
index 0000000..faccf98
--- /dev/null
+++ b/src/main/java/christmas/domain/EventManager.java
@@ -0,0 +1,138 @@
+package christmas.domain;
+
+import static christmas.domain.constant.event.ChristmasPromotion.CHRISTMAS_D_DAY_PROMOTION;
+import static christmas.domain.constant.event.EventNumberConstant.NONE_PROMOTION_APPLIED_AMOUNT;
+import static christmas.domain.constant.event.Promotion.GIFT_PROMOTION;
+import static christmas.domain.constant.event.Promotion.SPECIAL_PROMOTION;
+import static christmas.domain.constant.event.Promotion.WEEKDAY_PROMOTION;
+import static christmas.domain.constant.event.Promotion.WEEKEND_PROMOTION;
+
+import christmas.domain.constant.event.EventBadge;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+public class EventManager {
+    private final ReservationDay reservationDay;
+    private final Orders orders;
+
+    private EventManager(ReservationDay reservationDay, Orders orders) {
+        this.reservationDay = reservationDay;
+        this.orders = orders;
+    }
+
+    public static EventManager of(ReservationDay reservationDay, Orders orders) {
+        return new EventManager(reservationDay, orders);
+    }
+
+    public Map<String, Integer> createBenefitsDetails() {
+        Map<String, Integer> benefitsDetails = new LinkedHashMap<>();
+        if (orders.isEventApplicable()) {
+            return makeBenefitsDetails(benefitsDetails);
+        }
+        return Collections.unmodifiableMap(benefitsDetails);
+    }
+
+    private Map<String, Integer> makeBenefitsDetails(Map<String, Integer> benefitsDetails) {
+        addChristmasPromotionDetails(benefitsDetails);
+        addWeekdayPromotionDetails(benefitsDetails);
+        addWeekendPromotionDetails(benefitsDetails);
+        addSpecialPromotionDetails(benefitsDetails);
+        addGiftPromotionDetails(benefitsDetails);
+        return Collections.unmodifiableMap(benefitsDetails);
+    }
+
+    private void addChristmasPromotionDetails(Map<String, Integer> benefitsDetails) {
+        if (reservationDay.isChristmasPromotionApplicable()) {
+            benefitsDetails.put(CHRISTMAS_D_DAY_PROMOTION.getName(),
+                    calculateChristmasPromotionBenefitAmount());
+        }
+    }
+
+    private int calculateChristmasPromotionBenefitAmount() {
+        return CHRISTMAS_D_DAY_PROMOTION.getBenefitAmount(reservationDay.getDay());
+    }
+
+    private void addWeekdayPromotionDetails(Map<String, Integer> benefitsDetails) {
+        if (canAddWeekdayPromotion()) {
+            benefitsDetails.put(WEEKDAY_PROMOTION.getName(),
+                    calculateWeekdayPromotionBenefitAmount());
+        }
+    }
+
+    private boolean canAddWeekdayPromotion() {
+        return reservationDay.isWeekdayPromotionApplicable()
+                && calculateWeekdayPromotionBenefitAmount()
+                > NONE_PROMOTION_APPLIED_AMOUNT.getValue();
+    }
+
+    private int calculateWeekdayPromotionBenefitAmount() {
+        int count = orders.getOrders().stream()
+                .filter(Order::isWeekdayPromotionApplicable)
+                .mapToInt(Order::getMenuCount)
+                .sum();
+        return WEEKDAY_PROMOTION.getBenefitAmount() * count;
+    }
+
+    private void addWeekendPromotionDetails(Map<String, Integer> benefitsDetails) {
+        if (canAddWeekendPromotion()) {
+            benefitsDetails.put(WEEKEND_PROMOTION.getName(),
+                    calculateWeekendPromotionBenefitAmount());
+        }
+    }
+
+    private boolean canAddWeekendPromotion() {
+        return reservationDay.isWeekendPromotionApplicable()
+                && calculateWeekendPromotionBenefitAmount()
+                > NONE_PROMOTION_APPLIED_AMOUNT.getValue();
+    }
+
+    private int calculateWeekendPromotionBenefitAmount() {
+        int count = orders.getOrders().stream()
+                .filter(Order::isWeekendPromotionApplicable)
+                .mapToInt(Order::getMenuCount)
+                .sum();
+        return WEEKEND_PROMOTION.getBenefitAmount() * count;
+    }
+
+    private void addSpecialPromotionDetails(Map<String, Integer> benefitsDetails) {
+        if (reservationDay.isSpecialPromotionApplicable()) {
+            benefitsDetails.put(SPECIAL_PROMOTION.getName(), calculateSpecialPromotionBenefitAmount());
+        }
+    }
+
+    private int calculateSpecialPromotionBenefitAmount() {
+        return SPECIAL_PROMOTION.getBenefitAmount();
+    }
+
+    private void addGiftPromotionDetails(Map<String, Integer> benefitsDetails) {
+        if (orders.isGiftEventApplicable()) {
+            benefitsDetails.put(GIFT_PROMOTION.getName(), calculateGiftPromotionBenefitAmount());
+        }
+    }
+
+    private int calculateGiftPromotionBenefitAmount() {
+        return GIFT_PROMOTION.getBenefitAmount();
+    }
+
+    public int calculateTotalBenefitedAmount() {
+        return createBenefitsDetails().values().stream()
+                .mapToInt(Integer::intValue)
+                .sum();
+    }
+
+    public int calculateEstimatedOrdersAmountWithDiscount() {
+        return orders.calculateTotalAmountWithNoDiscount() - calculateTotalDiscountedAmount();
+    }
+
+    private int calculateTotalDiscountedAmount() {
+        if (orders.isGiftEventApplicable()) {
+            return calculateTotalBenefitedAmount() - calculateGiftPromotionBenefitAmount();
+        }
+        return calculateTotalBenefitedAmount();
+    }
+
+    public String issueEventBadge() {
+        return EventBadge.getBadgeNameByBenefitedPrice(calculateTotalBenefitedAmount());
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/domain/Order.java b/src/main/java/christmas/domain/Order.java
new file mode 100644
index 0000000..0d1b0b5
--- /dev/null
+++ b/src/main/java/christmas/domain/Order.java
@@ -0,0 +1,43 @@
+package christmas.domain;
+
+import christmas.domain.constant.orders.FoodType;
+import christmas.domain.constant.orders.Menu;
+import christmas.domain.exception.InvalidOrdersException;
+
+public class Order {
+    private final Menu menu;
+    private final int count;
+
+    private Order(Menu menu, final int count) {
+        this.menu = menu;
+        this.count = count;
+    }
+
+    public static Order of(final String menuName, final int count) throws InvalidOrdersException {
+        return new Order(Menu.searchByName(menuName), count);
+    }
+
+    public String getMenuName() {
+        return menu.getName();
+    }
+
+    public int getMenuCount() {
+        return count;
+    }
+
+    public FoodType getFoodType() {
+        return menu.getFoodType();
+    }
+
+    public boolean isWeekdayPromotionApplicable() {
+        return menu.isWeekDayPromotionApplicable();
+    }
+
+    public boolean isWeekendPromotionApplicable() {
+        return menu.isWeekendPromotionApplicable();
+    }
+
+    public int getTotalPrice() {
+        return menu.getPrice() * count;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/domain/Orders.java b/src/main/java/christmas/domain/Orders.java
new file mode 100644
index 0000000..5aa333e
--- /dev/null
+++ b/src/main/java/christmas/domain/Orders.java
@@ -0,0 +1,71 @@
+package christmas.domain;
+
+import static christmas.domain.constant.event.EventNumberConstant.EVENT_APPLICABLE_AMOUNT;
+import static christmas.domain.constant.event.EventNumberConstant.GIFT_EVENT_APPLICABLE_AMOUNT;
+import static christmas.domain.constant.orders.OrdersConstant.MAX_MENU_COUNTS;
+import static christmas.domain.exception.message.InvalidOrdersExceptionMessage.EXCEED_MENU_COUNTS_UPPER_LIMIT;
+import static christmas.domain.exception.message.InvalidOrdersExceptionMessage.MENUS_ONLY_CONTAIN_BEVERAGE;
+
+import christmas.domain.constant.orders.FoodType;
+import christmas.domain.exception.InvalidOrdersException;
+import java.util.Collections;
+import java.util.List;
+
+public class Orders {
+    private final List<Order> orders;
+
+    private Orders(List<Order> orders) {
+        this.orders = orders;
+    }
+
+    public static Orders from(List<Order> orders) {
+        validate(orders);
+        return new Orders(orders);
+    }
+
+    private static void validate(List<Order> orders) {
+        validateSumOfMenuCountsNotExceedUpperLimit(orders);
+        validateOrderedMenusNotOnlyContainBeverage(orders);
+    }
+
+    private static void validateSumOfMenuCountsNotExceedUpperLimit(List<Order> orders) {
+        if (sumOfMenuCountsExceedUpperLimit(orders)) {
+            throw InvalidOrdersException.of(EXCEED_MENU_COUNTS_UPPER_LIMIT.getMessage());
+        }
+    }
+
+    private static boolean sumOfMenuCountsExceedUpperLimit(List<Order> orders) {
+        return orders.stream()
+                .mapToInt(Order::getMenuCount)
+                .sum() > MAX_MENU_COUNTS.getValue();
+    }
+
+    private static void validateOrderedMenusNotOnlyContainBeverage(List<Order> orders) {
+        if (orderedMenusOnlyContainBeverage(orders)) {
+            throw InvalidOrdersException.of(MENUS_ONLY_CONTAIN_BEVERAGE.getMessage());
+        }
+    }
+
+    private static boolean orderedMenusOnlyContainBeverage(List<Order> orders) {
+        return orders.stream()
+                .allMatch(order -> order.getFoodType() == FoodType.BEVERAGE);
+    }
+
+    public int calculateTotalAmountWithNoDiscount() {
+        return orders.stream()
+                .mapToInt(Order::getTotalPrice)
+                .sum();
+    }
+
+    public boolean isEventApplicable() {
+        return calculateTotalAmountWithNoDiscount() >= EVENT_APPLICABLE_AMOUNT.getValue();
+    }
+
+    public boolean isGiftEventApplicable() {
+        return calculateTotalAmountWithNoDiscount() >= GIFT_EVENT_APPLICABLE_AMOUNT.getValue();
+    }
+
+    public List<Order> getOrders() {
+        return Collections.unmodifiableList(orders);
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/domain/ReservationDay.java b/src/main/java/christmas/domain/ReservationDay.java
new file mode 100644
index 0000000..1888dc0
--- /dev/null
+++ b/src/main/java/christmas/domain/ReservationDay.java
@@ -0,0 +1,54 @@
+package christmas.domain;
+
+import static christmas.domain.constant.reservationday.ReservationDayConstant.DECEMBER_CHRISTMAS_DAY;
+import static christmas.domain.constant.reservationday.ReservationDayConstant.DECEMBER_FIRST_DAY;
+import static christmas.domain.constant.reservationday.ReservationDayConstant.DECEMBER_LAST_DAY;
+import static christmas.domain.constant.reservationday.ReservationDayConstant.FRIDAY_VALUE;
+import static christmas.domain.constant.reservationday.ReservationDayConstant.SATURDAY_VALUE;
+import static christmas.domain.constant.reservationday.ReservationDayConstant.SUNDAY_VALUE;
+import static christmas.domain.constant.reservationday.ReservationDayConstant.WEEKDAY_LENGTH;
+
+import christmas.domain.exception.InvalidReservationDayException;
+
+public class ReservationDay extends DayPerMonth {
+    private final int day;
+
+    private ReservationDay(final int day) throws InvalidReservationDayException {
+        validate(day);
+        this.day = day;
+    }
+
+    public static ReservationDay from(final int day) throws InvalidReservationDayException {
+        return new ReservationDay(day);
+    }
+
+    public boolean isChristmasPromotionApplicable() {
+        return day >= DECEMBER_FIRST_DAY.getValue() && day <= DECEMBER_CHRISTMAS_DAY.getValue();
+    }
+
+    public boolean isWeekdayPromotionApplicable() {
+        return !isWeekend();
+    }
+
+    public boolean isWeekendPromotionApplicable() {
+        return isWeekend();
+    }
+
+    private boolean isWeekend() {
+        return day % WEEKDAY_LENGTH.getValue() == FRIDAY_VALUE.getValue()
+                || day % WEEKDAY_LENGTH.getValue() == SATURDAY_VALUE.getValue();
+    }
+
+    public boolean isSpecialPromotionApplicable() {
+        return day % WEEKDAY_LENGTH.getValue() == SUNDAY_VALUE.getValue() || day == DECEMBER_CHRISTMAS_DAY.getValue();
+    }
+
+    public int getDay() {
+        return day;
+    }
+
+    @Override
+    protected boolean isInAppropriateRange(final int day) {
+        return day >= DECEMBER_FIRST_DAY.getValue() && day <= DECEMBER_LAST_DAY.getValue();
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/domain/constant/event/ChristmasPromotion.java b/src/main/java/christmas/domain/constant/event/ChristmasPromotion.java
new file mode 100644
index 0000000..3e50d44
--- /dev/null
+++ b/src/main/java/christmas/domain/constant/event/ChristmasPromotion.java
@@ -0,0 +1,23 @@
+package christmas.domain.constant.event;
+
+import static christmas.domain.constant.event.EventNumberConstant.CHRISTMAS_PROMOTION_INCREASING_AMOUNT;
+
+public enum ChristmasPromotion {
+    CHRISTMAS_D_DAY_PROMOTION("크리스마스 디데이 할인", 900);
+
+    private final String name;
+    private final int startBenefitAmount;
+
+    ChristmasPromotion(final String name, final int startBenefitAmount) {
+        this.name = name;
+        this.startBenefitAmount = startBenefitAmount;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public int getBenefitAmount(final int day) {
+        return startBenefitAmount + day * CHRISTMAS_PROMOTION_INCREASING_AMOUNT.getValue();
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/domain/constant/event/EventBadge.java b/src/main/java/christmas/domain/constant/event/EventBadge.java
new file mode 100644
index 0000000..bac6c4c
--- /dev/null
+++ b/src/main/java/christmas/domain/constant/event/EventBadge.java
@@ -0,0 +1,44 @@
+package christmas.domain.constant.event;
+
+import static christmas.domain.constant.event.EventSymbolConstant.NO_BADGE_SYMBOL;
+
+public enum EventBadge {
+    STAR("별", 5_000),
+    TREE("트리", 10_000),
+    SANTA("산타", 20_000);
+
+    private final String name;
+    private final int minimumTotalBenefitedPrice;
+
+    EventBadge(final String name, final int minimumTotalBenefitedPrice) {
+        this.name = name;
+        this.minimumTotalBenefitedPrice = minimumTotalBenefitedPrice;
+    }
+
+    public static String getBadgeNameByBenefitedPrice(final int totalBenefitedPrice) {
+        if (isStar(totalBenefitedPrice)) {
+            return STAR.name;
+        }
+        if (isTree(totalBenefitedPrice)) {
+            return TREE.name;
+        }
+        if (isSanta(totalBenefitedPrice)) {
+            return SANTA.name;
+        }
+        return NO_BADGE_SYMBOL.getSymbol();
+    }
+
+    private static boolean isStar(final int totalBenefitedPrice) {
+        return totalBenefitedPrice >= STAR.minimumTotalBenefitedPrice
+                && totalBenefitedPrice < TREE.minimumTotalBenefitedPrice;
+    }
+
+    private static boolean isTree(final int totalBenefitedPrice) {
+        return totalBenefitedPrice >= TREE.minimumTotalBenefitedPrice
+                && totalBenefitedPrice < SANTA.minimumTotalBenefitedPrice;
+    }
+
+    private static boolean isSanta(final int totalBenefitedPrice) {
+        return totalBenefitedPrice >= SANTA.minimumTotalBenefitedPrice;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/domain/constant/event/EventNumberConstant.java b/src/main/java/christmas/domain/constant/event/EventNumberConstant.java
new file mode 100644
index 0000000..12cecd3
--- /dev/null
+++ b/src/main/java/christmas/domain/constant/event/EventNumberConstant.java
@@ -0,0 +1,19 @@
+package christmas.domain.constant.event;
+
+public enum EventNumberConstant {
+    EVENT_APPLICABLE_AMOUNT(10_000),
+    GIFT_EVENT_APPLICABLE_AMOUNT(120_000),
+    GIFT_CHAMPAGNE_COUNT(1),
+    CHRISTMAS_PROMOTION_INCREASING_AMOUNT(100),
+    NONE_PROMOTION_APPLIED_AMOUNT(0);
+
+    private final int value;
+
+    EventNumberConstant(final int value) {
+        this.value = value;
+    }
+
+    public int getValue() {
+        return value;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/domain/constant/event/EventSymbolConstant.java b/src/main/java/christmas/domain/constant/event/EventSymbolConstant.java
new file mode 100644
index 0000000..e7fc013
--- /dev/null
+++ b/src/main/java/christmas/domain/constant/event/EventSymbolConstant.java
@@ -0,0 +1,14 @@
+package christmas.domain.constant.event;
+
+public enum EventSymbolConstant {
+    NO_BADGE_SYMBOL("");
+    private final String symbol;
+
+    EventSymbolConstant(final String symbol) {
+        this.symbol = symbol;
+    }
+
+    public String getSymbol() {
+        return symbol;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/domain/constant/event/Promotion.java b/src/main/java/christmas/domain/constant/event/Promotion.java
new file mode 100644
index 0000000..898c630
--- /dev/null
+++ b/src/main/java/christmas/domain/constant/event/Promotion.java
@@ -0,0 +1,24 @@
+package christmas.domain.constant.event;
+
+public enum Promotion {
+    WEEKDAY_PROMOTION("평일 할인", 2_023),
+    WEEKEND_PROMOTION("주말 할인", 2_023),
+    SPECIAL_PROMOTION("특별 할인", 1_000),
+    GIFT_PROMOTION("증정 이벤트", 25_000);
+
+    private final String name;
+    private final int benefitAmount;
+
+    Promotion(final String name, final int benefitAmount) {
+        this.name = name;
+        this.benefitAmount = benefitAmount;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public int getBenefitAmount() {
+        return benefitAmount;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/domain/constant/orders/FoodType.java b/src/main/java/christmas/domain/constant/orders/FoodType.java
new file mode 100644
index 0000000..4679658
--- /dev/null
+++ b/src/main/java/christmas/domain/constant/orders/FoodType.java
@@ -0,0 +1,25 @@
+package christmas.domain.constant.orders;
+
+public enum FoodType {
+
+    APPETIZER(false, false),
+    MAIN(false, true),
+    DESSERT(true, false),
+    BEVERAGE(false, false);
+
+    private final boolean isWeekdayPromotionApplicable;
+    private final boolean isWeekendPromotionApplicable;
+
+    FoodType(final boolean isWeekdayPromotionApplicable, final boolean isWeekendPromotionApplicable) {
+        this.isWeekdayPromotionApplicable = isWeekdayPromotionApplicable;
+        this.isWeekendPromotionApplicable = isWeekendPromotionApplicable;
+    }
+
+    public boolean isWeekdayPromotionApplicable() {
+        return isWeekdayPromotionApplicable;
+    }
+
+    public boolean isWeekendPromotionApplicable() {
+        return isWeekendPromotionApplicable;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/domain/constant/orders/Menu.java b/src/main/java/christmas/domain/constant/orders/Menu.java
new file mode 100644
index 0000000..223997c
--- /dev/null
+++ b/src/main/java/christmas/domain/constant/orders/Menu.java
@@ -0,0 +1,65 @@
+package christmas.domain.constant.orders;
+
+import static christmas.domain.constant.orders.FoodType.APPETIZER;
+import static christmas.domain.constant.orders.FoodType.BEVERAGE;
+import static christmas.domain.constant.orders.FoodType.DESSERT;
+import static christmas.domain.constant.orders.FoodType.MAIN;
+import static christmas.domain.exception.message.InvalidOrdersExceptionMessage.NOT_EXISTING_MENU;
+
+import christmas.domain.exception.InvalidOrdersException;
+import java.util.Arrays;
+
+public enum Menu {
+    MUSHROOM_SOUP("양송이수프", 6_000, APPETIZER),
+    TAPAS("타파스", 5_500, APPETIZER),
+    CAESAR_SALAD("시저샐러드", 8_000, APPETIZER),
+
+    T_BONE_STAKE("티본스테이크", 55_000, MAIN),
+    BARBECUE_RIB("바비큐립", 54_000, MAIN),
+    SEAFOOD_PASTA("해산물파스타", 35_000, MAIN),
+    CHRISTMAS_PASTA("크리스마스파스타", 25_000, MAIN),
+
+    CHOCOLATE_CAKE("초코케이크", 15_000, DESSERT),
+    ICE_CREAM("아이스크림", 5_000, DESSERT),
+
+    ZERO_COKE("제로콜라", 3_000, BEVERAGE),
+    RED_WINE("레드와인", 60_000, BEVERAGE),
+    CHAMPAGNE("샴페인", 25_000, BEVERAGE);
+
+    private final String name;
+    private final int price;
+    private final FoodType foodType;
+
+    Menu(final String name, final int price, final FoodType foodType) {
+        this.name = name;
+        this.price = price;
+        this.foodType = foodType;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public int getPrice() {
+        return price;
+    }
+
+    public FoodType getFoodType() {
+        return foodType;
+    }
+
+    public boolean isWeekDayPromotionApplicable() {
+        return foodType.isWeekdayPromotionApplicable();
+    }
+
+    public boolean isWeekendPromotionApplicable() {
+        return foodType.isWeekendPromotionApplicable();
+    }
+
+    public static Menu searchByName(final String name) {
+        return Arrays.stream(Menu.values())
+                .filter(menu -> menu.name.equalsIgnoreCase(name))
+                .findFirst()
+                .orElseThrow(() -> InvalidOrdersException.of(NOT_EXISTING_MENU.getMessage()));
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/domain/constant/orders/OrdersConstant.java b/src/main/java/christmas/domain/constant/orders/OrdersConstant.java
new file mode 100644
index 0000000..df44a44
--- /dev/null
+++ b/src/main/java/christmas/domain/constant/orders/OrdersConstant.java
@@ -0,0 +1,15 @@
+package christmas.domain.constant.orders;
+
+public enum OrdersConstant {
+    MAX_MENU_COUNTS(20);
+
+    private final int value;
+
+    OrdersConstant(final int value) {
+        this.value = value;
+    }
+
+    public int getValue() {
+        return value;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/domain/constant/reservationday/ReservationDayConstant.java b/src/main/java/christmas/domain/constant/reservationday/ReservationDayConstant.java
new file mode 100644
index 0000000..66e9fbc
--- /dev/null
+++ b/src/main/java/christmas/domain/constant/reservationday/ReservationDayConstant.java
@@ -0,0 +1,23 @@
+package christmas.domain.constant.reservationday;
+
+public enum ReservationDayConstant {
+    DEFAULT_FIRST_DAY(1),
+    DEFAULT_LAST_DAY(30),
+    DECEMBER_FIRST_DAY(1),
+    DECEMBER_LAST_DAY(31),
+    DECEMBER_CHRISTMAS_DAY(25),
+    WEEKDAY_LENGTH(7),
+    FRIDAY_VALUE(1),
+    SATURDAY_VALUE(2),
+    SUNDAY_VALUE(3);
+
+    private final int value;
+
+    ReservationDayConstant(final int value) {
+        this.value = value;
+    }
+
+    public int getValue() {
+        return value;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/domain/exception/InvalidOrdersException.java b/src/main/java/christmas/domain/exception/InvalidOrdersException.java
new file mode 100644
index 0000000..e0e25ae
--- /dev/null
+++ b/src/main/java/christmas/domain/exception/InvalidOrdersException.java
@@ -0,0 +1,11 @@
+package christmas.domain.exception;
+
+public class InvalidOrdersException extends IllegalArgumentException {
+    private InvalidOrdersException(final String invalidMenuExceptionMessage) {
+        super(invalidMenuExceptionMessage);
+    }
+
+    public static InvalidOrdersException of(final String invalidMenuExceptionMessage) {
+        return new InvalidOrdersException(invalidMenuExceptionMessage);
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/domain/exception/InvalidReservationDayException.java b/src/main/java/christmas/domain/exception/InvalidReservationDayException.java
new file mode 100644
index 0000000..e4ff894
--- /dev/null
+++ b/src/main/java/christmas/domain/exception/InvalidReservationDayException.java
@@ -0,0 +1,11 @@
+package christmas.domain.exception;
+
+public class InvalidReservationDayException extends IllegalArgumentException {
+    private InvalidReservationDayException(final String invalidDayExceptionMessage) {
+        super(invalidDayExceptionMessage);
+    }
+
+    public static InvalidReservationDayException of(final String invalidDayExceptionMessage) {
+        return new InvalidReservationDayException(invalidDayExceptionMessage);
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/domain/exception/message/InvalidOrdersExceptionMessage.java b/src/main/java/christmas/domain/exception/message/InvalidOrdersExceptionMessage.java
new file mode 100644
index 0000000..b479cb4
--- /dev/null
+++ b/src/main/java/christmas/domain/exception/message/InvalidOrdersExceptionMessage.java
@@ -0,0 +1,19 @@
+package christmas.domain.exception.message;
+
+import static christmas.global.ApplicationConstant.ERROR_PREFIX;
+
+public enum InvalidOrdersExceptionMessage {
+    NOT_EXISTING_MENU("유효하지 않은 주문입니다. 다시 입력해 주세요."),
+    EXCEED_MENU_COUNTS_UPPER_LIMIT("유효하지 않은 주문입니다. 다시 입력해 주세요."),
+    MENUS_ONLY_CONTAIN_BEVERAGE("유효하지 않은 주문입니다. 다시 입력해 주세요.");
+
+    private final String message;
+
+    InvalidOrdersExceptionMessage(final String message) {
+        this.message = message;
+    }
+
+    public String getMessage() {
+        return ERROR_PREFIX + message;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/domain/exception/message/InvalidReservationDayExceptionMessage.java b/src/main/java/christmas/domain/exception/message/InvalidReservationDayExceptionMessage.java
new file mode 100644
index 0000000..23b0f05
--- /dev/null
+++ b/src/main/java/christmas/domain/exception/message/InvalidReservationDayExceptionMessage.java
@@ -0,0 +1,17 @@
+package christmas.domain.exception.message;
+
+import static christmas.global.ApplicationConstant.ERROR_PREFIX;
+
+public enum InvalidReservationDayExceptionMessage {
+    NOT_IN_APPROPRIATE_RANGE("유효하지 않은 날짜입니다. 다시 입력해 주세요.");
+
+    private final String message;
+
+    InvalidReservationDayExceptionMessage(final String message) {
+        this.message = message;
+    }
+
+    public String getMessage() {
+        return ERROR_PREFIX + message;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/dto/BenefitsDetailsDto.java b/src/main/java/christmas/dto/BenefitsDetailsDto.java
new file mode 100644
index 0000000..44d606f
--- /dev/null
+++ b/src/main/java/christmas/dto/BenefitsDetailsDto.java
@@ -0,0 +1,24 @@
+package christmas.dto;
+
+import java.util.Collections;
+import java.util.Map;
+
+public class BenefitsDetailsDto {
+    private final Map<String, Integer> benefitsDetails;
+
+    private BenefitsDetailsDto(Map<String, Integer> benefitsDetails) {
+        this.benefitsDetails = benefitsDetails;
+    }
+
+    public static BenefitsDetailsDto from(Map<String, Integer> benefitsDetails) {
+        return new BenefitsDetailsDto(benefitsDetails);
+    }
+
+    public Map<String, Integer> getBenefitsDetails() {
+        return Collections.unmodifiableMap(benefitsDetails);
+    }
+
+    public boolean isEmpty() {
+        return benefitsDetails.isEmpty();
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/dto/EstimatedAmountWithDiscountDto.java b/src/main/java/christmas/dto/EstimatedAmountWithDiscountDto.java
new file mode 100644
index 0000000..6e459e7
--- /dev/null
+++ b/src/main/java/christmas/dto/EstimatedAmountWithDiscountDto.java
@@ -0,0 +1,17 @@
+package christmas.dto;
+
+public class EstimatedAmountWithDiscountDto {
+    private final int amount;
+
+    public EstimatedAmountWithDiscountDto(final int amount) {
+        this.amount = amount;
+    }
+
+    public static EstimatedAmountWithDiscountDto from(final int amount) {
+        return new EstimatedAmountWithDiscountDto(amount);
+    }
+
+    public int getAmount() {
+        return amount;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/dto/EventBadgeDto.java b/src/main/java/christmas/dto/EventBadgeDto.java
new file mode 100644
index 0000000..038140b
--- /dev/null
+++ b/src/main/java/christmas/dto/EventBadgeDto.java
@@ -0,0 +1,21 @@
+package christmas.dto;
+
+public class EventBadgeDto {
+    private final String badgeName;
+
+    public EventBadgeDto(final String badgeName) {
+        this.badgeName = badgeName;
+    }
+
+    public static EventBadgeDto from(final String badgeName) {
+        return new EventBadgeDto(badgeName);
+    }
+
+    public String getBadgeName() {
+        return badgeName;
+    }
+
+    public boolean isEmpty() {
+        return badgeName.isEmpty();
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/dto/EventBenefitsPreviewDto.java b/src/main/java/christmas/dto/EventBenefitsPreviewDto.java
new file mode 100644
index 0000000..9fc1315
--- /dev/null
+++ b/src/main/java/christmas/dto/EventBenefitsPreviewDto.java
@@ -0,0 +1,17 @@
+package christmas.dto;
+
+public class EventBenefitsPreviewDto {
+    private final int day;
+
+    public EventBenefitsPreviewDto(final int day) {
+        this.day = day;
+    }
+
+    public static EventBenefitsPreviewDto from(final int day) {
+        return new EventBenefitsPreviewDto(day);
+    }
+
+    public int getDay() {
+        return day;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/dto/GiftDto.java b/src/main/java/christmas/dto/GiftDto.java
new file mode 100644
index 0000000..6ffd78a
--- /dev/null
+++ b/src/main/java/christmas/dto/GiftDto.java
@@ -0,0 +1,24 @@
+package christmas.dto;
+
+import java.util.Collections;
+import java.util.Map;
+
+public class GiftDto {
+    private final Map<String, Integer> gift;
+
+    private GiftDto(Map<String, Integer> gift) {
+        this.gift = gift;
+    }
+
+    public static GiftDto from(Map<String, Integer> gift) {
+        return new GiftDto(gift);
+    }
+
+    public Map<String, Integer> getGift() {
+        return Collections.unmodifiableMap(gift);
+    }
+
+    public boolean isEmpty() {
+        return gift.isEmpty();
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/dto/OrderedMenusDto.java b/src/main/java/christmas/dto/OrderedMenusDto.java
new file mode 100644
index 0000000..4b79253
--- /dev/null
+++ b/src/main/java/christmas/dto/OrderedMenusDto.java
@@ -0,0 +1,20 @@
+package christmas.dto;
+
+import java.util.Collections;
+import java.util.Map;
+
+public class OrderedMenusDto {
+    private final Map<String, Integer> orders;
+
+    public OrderedMenusDto(Map<String, Integer> orders) {
+        this.orders = orders;
+    }
+
+    public static OrderedMenusDto from(Map<String, Integer> orders) {
+        return new OrderedMenusDto(orders);
+    }
+
+    public Map<String, Integer> getOrders() {
+        return Collections.unmodifiableMap(orders);
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/dto/TotalAmountWithNoDiscountDto.java b/src/main/java/christmas/dto/TotalAmountWithNoDiscountDto.java
new file mode 100644
index 0000000..5cabde5
--- /dev/null
+++ b/src/main/java/christmas/dto/TotalAmountWithNoDiscountDto.java
@@ -0,0 +1,17 @@
+package christmas.dto;
+
+public class TotalAmountWithNoDiscountDto {
+    private final int amount;
+
+    public TotalAmountWithNoDiscountDto(final int amount) {
+        this.amount = amount;
+    }
+
+    public static TotalAmountWithNoDiscountDto from(final int amount) {
+        return new TotalAmountWithNoDiscountDto(amount);
+    }
+
+    public int getAmount() {
+        return amount;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/dto/TotalBenefitedAmountDto.java b/src/main/java/christmas/dto/TotalBenefitedAmountDto.java
new file mode 100644
index 0000000..5cbbbbd
--- /dev/null
+++ b/src/main/java/christmas/dto/TotalBenefitedAmountDto.java
@@ -0,0 +1,17 @@
+package christmas.dto;
+
+public class TotalBenefitedAmountDto {
+    private final int amount;
+
+    public TotalBenefitedAmountDto(final int amount) {
+        this.amount = amount;
+    }
+
+    public static TotalBenefitedAmountDto from(final int amount) {
+        return new TotalBenefitedAmountDto(amount);
+    }
+
+    public int getAmount() {
+        return amount;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/global/ApplicationConstant.java b/src/main/java/christmas/global/ApplicationConstant.java
new file mode 100644
index 0000000..d544ca2
--- /dev/null
+++ b/src/main/java/christmas/global/ApplicationConstant.java
@@ -0,0 +1,9 @@
+package christmas.global;
+
+public class ApplicationConstant {
+    public static final int CURRENT_PROMOTION_MONTH = 12;
+    public static final String ERROR_PREFIX = "[ERROR] ";
+
+    private ApplicationConstant() {
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/service/EventManagerService.java b/src/main/java/christmas/service/EventManagerService.java
new file mode 100644
index 0000000..b3e3808
--- /dev/null
+++ b/src/main/java/christmas/service/EventManagerService.java
@@ -0,0 +1,45 @@
+package christmas.service;
+
+
+import static christmas.domain.constant.event.EventNumberConstant.GIFT_CHAMPAGNE_COUNT;
+
+import christmas.domain.EventManager;
+import christmas.domain.Orders;
+import christmas.domain.constant.orders.Menu;
+import christmas.dto.BenefitsDetailsDto;
+import christmas.dto.EstimatedAmountWithDiscountDto;
+import christmas.dto.EventBadgeDto;
+import christmas.dto.GiftDto;
+import christmas.dto.TotalBenefitedAmountDto;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+public class EventManagerService {
+    public GiftDto createGiftDto(Orders orders) {
+        Map<String, Integer> gifts = new LinkedHashMap<>();
+        if (orders.isGiftEventApplicable()) {
+            makeGifts(gifts);
+        }
+        return GiftDto.from(gifts);
+    }
+
+    private void makeGifts(Map<String, Integer> gifts) {
+        gifts.put(Menu.CHAMPAGNE.getName(), GIFT_CHAMPAGNE_COUNT.getValue());
+    }
+
+    public BenefitsDetailsDto createBenefitsDetailsDto(EventManager eventManager) {
+        return BenefitsDetailsDto.from(eventManager.createBenefitsDetails());
+    }
+
+    public TotalBenefitedAmountDto createTotalBenefitedAmountDto(EventManager eventManager) {
+        return TotalBenefitedAmountDto.from(eventManager.calculateTotalBenefitedAmount());
+    }
+
+    public EstimatedAmountWithDiscountDto createEstimatedAmountWithDiscountDto(EventManager eventManager) {
+        return EstimatedAmountWithDiscountDto.from(eventManager.calculateEstimatedOrdersAmountWithDiscount());
+    }
+
+    public EventBadgeDto createEventBadgeDto(EventManager eventManager) {
+        return EventBadgeDto.from(eventManager.issueEventBadge());
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/service/OrdersService.java b/src/main/java/christmas/service/OrdersService.java
new file mode 100644
index 0000000..447ce0f
--- /dev/null
+++ b/src/main/java/christmas/service/OrdersService.java
@@ -0,0 +1,42 @@
+package christmas.service;
+
+import christmas.domain.Order;
+import christmas.domain.Orders;
+import christmas.domain.exception.InvalidOrdersException;
+import christmas.dto.OrderedMenusDto;
+import christmas.dto.TotalAmountWithNoDiscountDto;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public class OrdersService {
+    public Orders createOrders(Map<String, Integer> orders) throws InvalidOrdersException {
+        return Orders.from(makeOrders(orders));
+    }
+
+    private List<Order> makeOrders(Map<String, Integer> orders) throws InvalidOrdersException {
+        return orders.entrySet().stream()
+                .map(order -> createOrder(order.getKey(), order.getValue()))
+                .toList();
+    }
+
+    private Order createOrder(final String menuName, final int menuCount) throws InvalidOrdersException {
+        return Order.of(menuName, menuCount);
+    }
+
+    public OrderedMenusDto createOrdersHistoryDto(Orders orders) {
+        return OrderedMenusDto.from(makeOrdersHistory(orders));
+    }
+
+    private Map<String, Integer> makeOrdersHistory(Orders orders) {
+        return orders.getOrders().stream()
+                .collect(Collectors.toUnmodifiableMap(
+                        Order::getMenuName,
+                        Order::getMenuCount
+                ));
+    }
+
+    public TotalAmountWithNoDiscountDto createTotalAmountWithNoDiscountDto(Orders orders) {
+        return TotalAmountWithNoDiscountDto.from(orders.calculateTotalAmountWithNoDiscount());
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/service/ReservationDayService.java b/src/main/java/christmas/service/ReservationDayService.java
new file mode 100644
index 0000000..c2a7cf7
--- /dev/null
+++ b/src/main/java/christmas/service/ReservationDayService.java
@@ -0,0 +1,15 @@
+package christmas.service;
+
+import christmas.domain.ReservationDay;
+import christmas.domain.exception.InvalidReservationDayException;
+import christmas.dto.EventBenefitsPreviewDto;
+
+public class ReservationDayService {
+    public ReservationDay createReservationDay(final int day) throws InvalidReservationDayException {
+        return ReservationDay.from(day);
+    }
+
+    public EventBenefitsPreviewDto createEventBenefitsPreviewDto(ReservationDay day) {
+        return EventBenefitsPreviewDto.from(day.getDay());
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/view/input/InputView.java b/src/main/java/christmas/view/input/InputView.java
new file mode 100644
index 0000000..9901e42
--- /dev/null
+++ b/src/main/java/christmas/view/input/InputView.java
@@ -0,0 +1,28 @@
+package christmas.view.input;
+
+import camp.nextstep.edu.missionutils.Console;
+import christmas.view.input.exception.BasicInputException;
+import christmas.view.input.exception.DayInputException;
+import christmas.view.input.exception.OrdersInputException;
+import christmas.view.input.parser.InputParser;
+import java.util.Map;
+
+public class InputView {
+    private final InputParser inputParser;
+
+    public InputView() {
+        inputParser = new InputParser();
+    }
+
+    public int getReservationDay() throws BasicInputException, DayInputException {
+        return inputParser.parseReservationDay(readLine());
+    }
+
+    public Map<String, Integer> getOrders() throws BasicInputException, OrdersInputException {
+        return inputParser.parseOrders(readLine());
+    }
+
+    private String readLine() {
+        return Console.readLine();
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/view/input/constant/InputNumberConstant.java b/src/main/java/christmas/view/input/constant/InputNumberConstant.java
new file mode 100644
index 0000000..d9d8df0
--- /dev/null
+++ b/src/main/java/christmas/view/input/constant/InputNumberConstant.java
@@ -0,0 +1,23 @@
+package christmas.view.input.constant;
+
+public enum InputNumberConstant {
+    APPLICATION_MAX_INPUT_LENGTH(2000),
+    ORDERS_MAX_INPUT_LENGTH(1000),
+    ORDER_MAX_INPUT_LENGTH(33),
+    MENU_NAME_MAX_INPUT_LENGTH(30),
+    MENU_COUNT_MAX_INPUT_LENGTH(2),
+    DAY_MAX_INPUT_LENGTH(2),
+    MENU_NAME_INDEX(0),
+    MENU_COUNT_INDEX(1),
+    POSITIVE_BOUNDARY_VALUE(0);
+
+    private final int value;
+
+    InputNumberConstant(final int value) {
+        this.value = value;
+    }
+
+    public int getValue() {
+        return value;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/view/input/constant/InputSymbolConstant.java b/src/main/java/christmas/view/input/constant/InputSymbolConstant.java
new file mode 100644
index 0000000..f7b9bee
--- /dev/null
+++ b/src/main/java/christmas/view/input/constant/InputSymbolConstant.java
@@ -0,0 +1,20 @@
+package christmas.view.input.constant;
+
+public enum InputSymbolConstant {
+    BLANK(" "),
+    VOID(""),
+    ORDERS_DELIMITER(","),
+    ORDER_DELIMITER("-"),
+    DAY_SYMBOL("날짜"),
+    ORDER_SYMBOL("주문");
+
+    private final String symbol;
+
+    InputSymbolConstant(final String symbol) {
+        this.symbol = symbol;
+    }
+
+    public String getSymbol() {
+        return symbol;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/view/input/exception/BasicInputException.java b/src/main/java/christmas/view/input/exception/BasicInputException.java
new file mode 100644
index 0000000..23d5a58
--- /dev/null
+++ b/src/main/java/christmas/view/input/exception/BasicInputException.java
@@ -0,0 +1,11 @@
+package christmas.view.input.exception;
+
+public class BasicInputException extends IllegalArgumentException {
+    private BasicInputException(final String invalidDayExceptionMessage) {
+        super(invalidDayExceptionMessage);
+    }
+
+    public static BasicInputException of(final String basicInputExceptionMessage) {
+        return new BasicInputException(basicInputExceptionMessage);
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/view/input/exception/DayInputException.java b/src/main/java/christmas/view/input/exception/DayInputException.java
new file mode 100644
index 0000000..6820be7
--- /dev/null
+++ b/src/main/java/christmas/view/input/exception/DayInputException.java
@@ -0,0 +1,11 @@
+package christmas.view.input.exception;
+
+public class DayInputException extends IllegalArgumentException {
+    private DayInputException(final String dayInputExceptionMessage) {
+        super(dayInputExceptionMessage);
+    }
+
+    public static DayInputException of(final String dayInputExceptionMessage) {
+        return new DayInputException(dayInputExceptionMessage);
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/view/input/exception/OrdersInputException.java b/src/main/java/christmas/view/input/exception/OrdersInputException.java
new file mode 100644
index 0000000..3c94983
--- /dev/null
+++ b/src/main/java/christmas/view/input/exception/OrdersInputException.java
@@ -0,0 +1,11 @@
+package christmas.view.input.exception;
+
+public class OrdersInputException extends IllegalArgumentException {
+    private OrdersInputException(final String ordersInputExceptionMessage) {
+        super(ordersInputExceptionMessage);
+    }
+
+    public static OrdersInputException of(final String ordersInputExceptionMessage) {
+        return new OrdersInputException(ordersInputExceptionMessage);
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/view/input/exception/message/BasicInputExceptionMessageFormat.java b/src/main/java/christmas/view/input/exception/message/BasicInputExceptionMessageFormat.java
new file mode 100644
index 0000000..26444fc
--- /dev/null
+++ b/src/main/java/christmas/view/input/exception/message/BasicInputExceptionMessageFormat.java
@@ -0,0 +1,19 @@
+package christmas.view.input.exception.message;
+
+import static christmas.global.ApplicationConstant.ERROR_PREFIX;
+
+public enum BasicInputExceptionMessageFormat {
+    TOO_LONG_WITH_BLANKS_FORMAT("유효하지 않은 %s입니다. 다시 입력해 주세요."),
+    EMPTY_FORMAT("유효하지 않은 %s입니다. 다시 입력해 주세요."),
+    TOO_LONG_FORMAT("유효하지 않은 %s입니다. 다시 입력해 주세요.");
+
+    private final String format;
+
+    BasicInputExceptionMessageFormat(final String format) {
+        this.format = format;
+    }
+
+    public String getFormat() {
+        return ERROR_PREFIX + format;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/view/input/exception/message/DayInputExceptionMessage.java b/src/main/java/christmas/view/input/exception/message/DayInputExceptionMessage.java
new file mode 100644
index 0000000..cb12a99
--- /dev/null
+++ b/src/main/java/christmas/view/input/exception/message/DayInputExceptionMessage.java
@@ -0,0 +1,18 @@
+package christmas.view.input.exception.message;
+
+import static christmas.global.ApplicationConstant.ERROR_PREFIX;
+
+public enum DayInputExceptionMessage {
+    NOT_NUMERIC_TYPE("유효하지 않은 날짜입니다. 다시 입력해 주세요."),
+    NOT_POSITIVE("유효하지 않은 날짜입니다. 다시 입력해 주세요.");
+
+    private final String message;
+
+    DayInputExceptionMessage(final String message) {
+        this.message = message;
+    }
+
+    public String getMessage() {
+        return ERROR_PREFIX + message;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/view/input/exception/message/OrdersInputExceptionMessage.java b/src/main/java/christmas/view/input/exception/message/OrdersInputExceptionMessage.java
new file mode 100644
index 0000000..322b140
--- /dev/null
+++ b/src/main/java/christmas/view/input/exception/message/OrdersInputExceptionMessage.java
@@ -0,0 +1,21 @@
+package christmas.view.input.exception.message;
+
+import static christmas.global.ApplicationConstant.ERROR_PREFIX;
+
+public enum OrdersInputExceptionMessage {
+    INVALID_ORDER_FORMAT("유효하지 않은 주문입니다. 다시 입력해 주세요."),
+    EMPTY_MENU_COUNT("유효하지 않은 주문입니다. 다시 입력해 주세요."),
+    NOT_NUMERIC_TYPE("유효하지 않은 주문입니다. 다시 입력해 주세요."),
+    NOT_POSITIVE("유효하지 않은 주문입니다. 다시 입력해 주세요."),
+    DUPLICATED_MENUS("유효하지 않은 주문입니다. 다시 입력해 주세요.");
+
+    private final String message;
+
+    OrdersInputExceptionMessage(final String message) {
+        this.message = message;
+    }
+
+    public String getMessage() {
+        return ERROR_PREFIX + message;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/view/input/parser/InputParser.java b/src/main/java/christmas/view/input/parser/InputParser.java
new file mode 100644
index 0000000..75e925a
--- /dev/null
+++ b/src/main/java/christmas/view/input/parser/InputParser.java
@@ -0,0 +1,89 @@
+package christmas.view.input.parser;
+
+import static christmas.view.input.constant.InputNumberConstant.APPLICATION_MAX_INPUT_LENGTH;
+import static christmas.view.input.constant.InputNumberConstant.MENU_COUNT_INDEX;
+import static christmas.view.input.constant.InputNumberConstant.MENU_NAME_INDEX;
+import static christmas.view.input.constant.InputSymbolConstant.BLANK;
+import static christmas.view.input.constant.InputSymbolConstant.DAY_SYMBOL;
+import static christmas.view.input.constant.InputSymbolConstant.ORDERS_DELIMITER;
+import static christmas.view.input.constant.InputSymbolConstant.ORDER_DELIMITER;
+import static christmas.view.input.constant.InputSymbolConstant.ORDER_SYMBOL;
+import static christmas.view.input.constant.InputSymbolConstant.VOID;
+import static christmas.view.input.exception.message.BasicInputExceptionMessageFormat.TOO_LONG_WITH_BLANKS_FORMAT;
+
+import christmas.view.input.exception.BasicInputException;
+import christmas.view.input.exception.DayInputException;
+import christmas.view.input.exception.OrdersInputException;
+import christmas.view.input.validator.DayInputValidator;
+import christmas.view.input.validator.OrderInputValidator;
+import christmas.view.input.validator.OrdersInputValidator;
+import java.util.Arrays;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public class InputParser {
+    private final DayInputValidator dayInputValidator;
+    private final OrdersInputValidator ordersInputValidator;
+    private final OrderInputValidator orderInputValidator;
+
+    public InputParser() {
+        this.dayInputValidator = new DayInputValidator();
+        this.ordersInputValidator = new OrdersInputValidator();
+        this.orderInputValidator = new OrderInputValidator();
+    }
+
+    public int parseReservationDay(String userInput) throws BasicInputException, DayInputException {
+        checkDayLengthIsUnderUpperLimit(userInput);
+        userInput = removeBlank(userInput);
+        dayInputValidator.validate(userInput);
+        return parseToInt(userInput);
+    }
+
+    public Map<String, Integer> parseOrders(String userInput) throws BasicInputException, OrdersInputException {
+        checkOrdersLengthIsUnderUpperLimit(userInput);
+        userInput = removeBlank(userInput);
+        ordersInputValidator.preValidate(userInput);
+        validateEachOrder(userInput);
+        ordersInputValidator.postValidate(userInput);
+        return parseToOrderMap(userInput);
+    }
+
+    private void checkDayLengthIsUnderUpperLimit(final String userInput) {
+        if (userInput.length() > APPLICATION_MAX_INPUT_LENGTH.getValue()) {
+            throw BasicInputException.of(
+                    String.format(TOO_LONG_WITH_BLANKS_FORMAT.getFormat(), DAY_SYMBOL.getSymbol()));
+        }
+    }
+
+    private void checkOrdersLengthIsUnderUpperLimit(final String userInput) {
+        if (userInput.length() > APPLICATION_MAX_INPUT_LENGTH.getValue()) {
+            throw BasicInputException.of(
+                    String.format(TOO_LONG_WITH_BLANKS_FORMAT.getFormat(), ORDER_SYMBOL.getSymbol()));
+        }
+    }
+
+    private int parseToInt(String userInput) {
+        return Integer.parseInt(userInput);
+    }
+
+    private String removeBlank(String userInput) {
+        if (userInput.contains(BLANK.getSymbol())) {
+            userInput = userInput.replace(BLANK.getSymbol(), VOID.getSymbol());
+        }
+        return userInput;
+    }
+
+    private void validateEachOrder(final String userInput) throws BasicInputException, OrdersInputException {
+        Arrays.stream(userInput.split(ORDERS_DELIMITER.getSymbol()))
+                .forEach(orderInputValidator::validate);
+    }
+
+    private Map<String, Integer> parseToOrderMap(final String userInput) {
+        return Arrays.stream(userInput.split(ORDERS_DELIMITER.getSymbol()))
+                .map(orders -> orders.split(ORDER_DELIMITER.getSymbol()))
+                .collect(Collectors.toUnmodifiableMap(
+                        order -> order[MENU_NAME_INDEX.getValue()],
+                        order -> parseToInt(order[MENU_COUNT_INDEX.getValue()])
+                ));
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/view/input/validator/BasicValidator.java b/src/main/java/christmas/view/input/validator/BasicValidator.java
new file mode 100644
index 0000000..16d834d
--- /dev/null
+++ b/src/main/java/christmas/view/input/validator/BasicValidator.java
@@ -0,0 +1,27 @@
+package christmas.view.input.validator;
+
+import christmas.view.input.exception.BasicInputException;
+import christmas.view.input.exception.message.BasicInputExceptionMessageFormat;
+
+public abstract class BasicValidator {
+
+    protected void validate(final String userInput, final String inputType, final int maxLength)
+            throws BasicInputException {
+        validateNotEmpty(userInput, inputType);
+        validateLengthUnderMaxLength(userInput, inputType, maxLength);
+    }
+
+    protected void validateNotEmpty(final String userInput, final String inputType) {
+        if (userInput.isEmpty()) {
+            throw BasicInputException.of(
+                    String.format(BasicInputExceptionMessageFormat.EMPTY_FORMAT.getFormat(), inputType));
+        }
+    }
+
+    protected void validateLengthUnderMaxLength(final String userInput, final String inputType, final int maxLength) {
+        if (userInput.length() > maxLength) {
+            throw BasicInputException.of(
+                    String.format(BasicInputExceptionMessageFormat.TOO_LONG_FORMAT.getFormat(), inputType));
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/view/input/validator/DayInputValidator.java b/src/main/java/christmas/view/input/validator/DayInputValidator.java
new file mode 100644
index 0000000..a5b2f30
--- /dev/null
+++ b/src/main/java/christmas/view/input/validator/DayInputValidator.java
@@ -0,0 +1,39 @@
+package christmas.view.input.validator;
+
+import static christmas.view.input.constant.InputNumberConstant.DAY_MAX_INPUT_LENGTH;
+import static christmas.view.input.constant.InputNumberConstant.POSITIVE_BOUNDARY_VALUE;
+import static christmas.view.input.constant.InputSymbolConstant.DAY_SYMBOL;
+import static christmas.view.input.exception.message.DayInputExceptionMessage.NOT_NUMERIC_TYPE;
+import static christmas.view.input.exception.message.DayInputExceptionMessage.NOT_POSITIVE;
+
+import christmas.view.input.exception.BasicInputException;
+import christmas.view.input.exception.DayInputException;
+
+public class DayInputValidator extends BasicValidator implements PositiveIntegerCheckable {
+    public void validate(final String dayInput) throws BasicInputException, DayInputException {
+        super.validate(dayInput, DAY_SYMBOL.getSymbol(), DAY_MAX_INPUT_LENGTH.getValue());
+        validateNumeric(dayInput);
+        validatePositive(dayInput);
+    }
+
+    @Override
+    public void validateNumeric(final String dayInput) {
+        try {
+            parseToInt(dayInput);
+        } catch (NumberFormatException e) {
+            throw DayInputException.of(NOT_NUMERIC_TYPE.getMessage());
+        }
+    }
+
+    @Override
+    public void validatePositive(final String dayInput) {
+        int day = parseToInt(dayInput);
+        if (day < POSITIVE_BOUNDARY_VALUE.getValue()) {
+            throw DayInputException.of(NOT_POSITIVE.getMessage());
+        }
+    }
+
+    private int parseToInt(final String dayInput) {
+        return Integer.parseInt(dayInput);
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/view/input/validator/MenuCountInputValidator.java b/src/main/java/christmas/view/input/validator/MenuCountInputValidator.java
new file mode 100644
index 0000000..cee80cf
--- /dev/null
+++ b/src/main/java/christmas/view/input/validator/MenuCountInputValidator.java
@@ -0,0 +1,38 @@
+package christmas.view.input.validator;
+
+import static christmas.view.input.constant.InputNumberConstant.MENU_COUNT_MAX_INPUT_LENGTH;
+import static christmas.view.input.constant.InputNumberConstant.POSITIVE_BOUNDARY_VALUE;
+import static christmas.view.input.constant.InputSymbolConstant.ORDER_SYMBOL;
+import static christmas.view.input.exception.message.OrdersInputExceptionMessage.NOT_NUMERIC_TYPE;
+import static christmas.view.input.exception.message.OrdersInputExceptionMessage.NOT_POSITIVE;
+
+import christmas.view.input.exception.OrdersInputException;
+
+public class MenuCountInputValidator extends BasicValidator implements PositiveIntegerCheckable {
+    public void validate(final String menuCountInput) throws OrdersInputException {
+        super.validate(menuCountInput, ORDER_SYMBOL.getSymbol(), MENU_COUNT_MAX_INPUT_LENGTH.getValue());
+        validateNumeric(menuCountInput);
+        validatePositive(menuCountInput);
+    }
+
+    @Override
+    public void validateNumeric(final String menuCountInput) {
+        try {
+            parseToInt(menuCountInput);
+        } catch (NumberFormatException e) {
+            throw OrdersInputException.of(NOT_NUMERIC_TYPE.getMessage());
+        }
+    }
+
+    @Override
+    public void validatePositive(final String menuCountInput) {
+        int menuCount = parseToInt(menuCountInput);
+        if (menuCount < POSITIVE_BOUNDARY_VALUE.getValue()) {
+            throw OrdersInputException.of(NOT_POSITIVE.getMessage());
+        }
+    }
+
+    private int parseToInt(final String menuCountInput) {
+        return Integer.parseInt(menuCountInput);
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/view/input/validator/MenuNameInputValidator.java b/src/main/java/christmas/view/input/validator/MenuNameInputValidator.java
new file mode 100644
index 0000000..9f7e071
--- /dev/null
+++ b/src/main/java/christmas/view/input/validator/MenuNameInputValidator.java
@@ -0,0 +1,12 @@
+package christmas.view.input.validator;
+
+import static christmas.view.input.constant.InputNumberConstant.MENU_NAME_MAX_INPUT_LENGTH;
+import static christmas.view.input.constant.InputSymbolConstant.ORDER_SYMBOL;
+
+import christmas.view.input.exception.BasicInputException;
+
+public class MenuNameInputValidator extends BasicValidator {
+    public void validate(final String menuNameInput) throws BasicInputException {
+        super.validate(menuNameInput, ORDER_SYMBOL.getSymbol(), MENU_NAME_MAX_INPUT_LENGTH.getValue());
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/view/input/validator/OrderInputValidator.java b/src/main/java/christmas/view/input/validator/OrderInputValidator.java
new file mode 100644
index 0000000..684bcdd
--- /dev/null
+++ b/src/main/java/christmas/view/input/validator/OrderInputValidator.java
@@ -0,0 +1,61 @@
+package christmas.view.input.validator;
+
+import static christmas.view.input.constant.InputNumberConstant.MENU_COUNT_INDEX;
+import static christmas.view.input.constant.InputNumberConstant.MENU_NAME_INDEX;
+import static christmas.view.input.constant.InputNumberConstant.ORDER_MAX_INPUT_LENGTH;
+import static christmas.view.input.constant.InputSymbolConstant.ORDER_DELIMITER;
+import static christmas.view.input.constant.InputSymbolConstant.ORDER_SYMBOL;
+import static christmas.view.input.exception.message.OrdersInputExceptionMessage.EMPTY_MENU_COUNT;
+import static christmas.view.input.exception.message.OrdersInputExceptionMessage.INVALID_ORDER_FORMAT;
+
+import christmas.view.input.exception.BasicInputException;
+import christmas.view.input.exception.OrdersInputException;
+import java.util.Arrays;
+import java.util.List;
+
+public class OrderInputValidator extends BasicValidator {
+    private final MenuNameInputValidator menuNameInputValidator;
+    private final MenuCountInputValidator menuCountInputValidator;
+
+    public OrderInputValidator() {
+        this.menuNameInputValidator = new MenuNameInputValidator();
+        this.menuCountInputValidator = new MenuCountInputValidator();
+    }
+
+    public void validate(final String orderInput) throws BasicInputException, OrdersInputException {
+        super.validate(orderInput, ORDER_SYMBOL.getSymbol(), ORDER_MAX_INPUT_LENGTH.getValue());
+        validateContainingDelimiter(orderInput);
+        validateNotEndsWithDelimiter(orderInput);
+        validateMenu(splitToMenuInput(orderInput));
+    }
+
+    private void validateContainingDelimiter(final String orderInput) {
+        if (!containsDelimiter(orderInput)) {
+            throw OrdersInputException.of(INVALID_ORDER_FORMAT.getMessage());
+        }
+    }
+
+    private boolean containsDelimiter(final String orderInput) {
+        return orderInput.contains(ORDER_DELIMITER.getSymbol());
+    }
+
+    private void validateNotEndsWithDelimiter(final String orderInput) {
+        if (endsWithDelimiter(orderInput)) {
+            throw OrdersInputException.of(EMPTY_MENU_COUNT.getMessage());
+        }
+    }
+
+    private boolean endsWithDelimiter(final String orderInput) {
+        return orderInput.endsWith(ORDER_DELIMITER.getSymbol());
+    }
+
+    private List<String> splitToMenuInput(final String orderInput) {
+        return Arrays.stream(orderInput.split(ORDER_DELIMITER.getSymbol()))
+                .toList();
+    }
+
+    private void validateMenu(List<String> menuInput) throws BasicInputException, OrdersInputException {
+        menuNameInputValidator.validate(menuInput.get(MENU_NAME_INDEX.getValue()));
+        menuCountInputValidator.validate(menuInput.get(MENU_COUNT_INDEX.getValue()));
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/view/input/validator/OrdersInputValidator.java b/src/main/java/christmas/view/input/validator/OrdersInputValidator.java
new file mode 100644
index 0000000..31c3054
--- /dev/null
+++ b/src/main/java/christmas/view/input/validator/OrdersInputValidator.java
@@ -0,0 +1,41 @@
+package christmas.view.input.validator;
+
+import static christmas.view.input.constant.InputNumberConstant.MENU_NAME_INDEX;
+import static christmas.view.input.constant.InputNumberConstant.ORDERS_MAX_INPUT_LENGTH;
+import static christmas.view.input.constant.InputSymbolConstant.ORDERS_DELIMITER;
+import static christmas.view.input.constant.InputSymbolConstant.ORDER_DELIMITER;
+import static christmas.view.input.constant.InputSymbolConstant.ORDER_SYMBOL;
+import static christmas.view.input.exception.message.OrdersInputExceptionMessage.DUPLICATED_MENUS;
+
+import christmas.view.input.exception.BasicInputException;
+import christmas.view.input.exception.OrdersInputException;
+import java.util.Arrays;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class OrdersInputValidator extends BasicValidator {
+    public void preValidate(final String ordersInput) throws BasicInputException {
+        super.validate(ordersInput, ORDER_SYMBOL.getSymbol(), ORDERS_MAX_INPUT_LENGTH.getValue());
+    }
+
+    public void postValidate(final String ordersInput) throws OrdersInputException {
+        validateNotExistDuplicatedMenus(ordersInput);
+    }
+
+    private void validateNotExistDuplicatedMenus(final String ordersInput) {
+        Set<String> uniqueMenuNames = makeUniqueMenuNames(ordersInput);
+        if (haveDuplicatedMenus(ordersInput, uniqueMenuNames)) {
+            throw OrdersInputException.of(DUPLICATED_MENUS.getMessage());
+        }
+    }
+
+    private Set<String> makeUniqueMenuNames(final String ordersInput) {
+        return Arrays.stream(ordersInput.split(ORDERS_DELIMITER.getSymbol()))
+                .map(order -> order.split(ORDER_DELIMITER.getSymbol())[MENU_NAME_INDEX.getValue()])
+                .collect(Collectors.toUnmodifiableSet());
+    }
+
+    private boolean haveDuplicatedMenus(final String ordersInput, Set<String> uniqueMenuNames) {
+        return uniqueMenuNames.size() < ordersInput.split(ORDERS_DELIMITER.getSymbol()).length;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/view/input/validator/PositiveIntegerCheckable.java b/src/main/java/christmas/view/input/validator/PositiveIntegerCheckable.java
new file mode 100644
index 0000000..e203f43
--- /dev/null
+++ b/src/main/java/christmas/view/input/validator/PositiveIntegerCheckable.java
@@ -0,0 +1,7 @@
+package christmas.view.input.validator;
+
+public interface PositiveIntegerCheckable {
+    void validateNumeric(final String userInput);
+
+    void validatePositive(final String userInput);
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/view/output/OutputView.java b/src/main/java/christmas/view/output/OutputView.java
new file mode 100644
index 0000000..c3313ee
--- /dev/null
+++ b/src/main/java/christmas/view/output/OutputView.java
@@ -0,0 +1,171 @@
+package christmas.view.output;
+
+import static christmas.view.output.constant.OutputFormatConstant.BENEFITS_DETAILS_PRINT_FORMAT;
+import static christmas.view.output.constant.OutputFormatConstant.ESTIMATED_AMOUNT_WITH_DISCOUNT_PRINT_FORMAT;
+import static christmas.view.output.constant.OutputFormatConstant.GIFT_PRINT_FORMAT;
+import static christmas.view.output.constant.OutputFormatConstant.ORDERED_MENUS_PRINT_FORMAT;
+import static christmas.view.output.constant.OutputFormatConstant.PRICE_FORMAT_STYLE;
+import static christmas.view.output.constant.OutputFormatConstant.SHOW_RESULT_INTRO_FORMAT;
+import static christmas.view.output.constant.OutputFormatConstant.TOTAL_AMOUNT_WITH_NO_DISCOUNT_PRINT_FORMAT;
+import static christmas.view.output.constant.OutputFormatConstant.TOTAL_BENEFITED_AMOUNT_PRINT_FORMAT;
+import static christmas.view.output.constant.OutputMessageConstant.GREETING;
+import static christmas.view.output.constant.OutputMessageConstant.INSERT_ORDERS;
+import static christmas.view.output.constant.OutputMessageConstant.INSERT_RESERVATION_DAY;
+import static christmas.view.output.constant.OutputSymbolConstant.BENEFITS_DETAILS;
+import static christmas.view.output.constant.OutputSymbolConstant.ESTIMATED_AMOUNT_WITH_DISCOUNT;
+import static christmas.view.output.constant.OutputSymbolConstant.EVENT_BADGE;
+import static christmas.view.output.constant.OutputSymbolConstant.GIFT_MENU;
+import static christmas.view.output.constant.OutputSymbolConstant.NEW_LINE;
+import static christmas.view.output.constant.OutputSymbolConstant.NO_BENEFITS;
+import static christmas.view.output.constant.OutputSymbolConstant.NO_EVENT_BADGE;
+import static christmas.view.output.constant.OutputSymbolConstant.NO_GIFT;
+import static christmas.view.output.constant.OutputSymbolConstant.ORDERED_MENUS;
+import static christmas.view.output.constant.OutputSymbolConstant.TOTAL_AMOUNT_WITH_NO_DISCOUNT;
+import static christmas.view.output.constant.OutputSymbolConstant.TOTAL_BENEFITED_AMOUNT;
+
+import christmas.dto.BenefitsDetailsDto;
+import christmas.dto.EstimatedAmountWithDiscountDto;
+import christmas.dto.EventBadgeDto;
+import christmas.dto.EventBenefitsPreviewDto;
+import christmas.dto.GiftDto;
+import christmas.dto.OrderedMenusDto;
+import christmas.dto.TotalAmountWithNoDiscountDto;
+import christmas.dto.TotalBenefitedAmountDto;
+import java.text.DecimalFormat;
+
+public class OutputView {
+    public void printGreetingMessage() {
+        print(GREETING.getMessage());
+        printLine();
+    }
+
+    public void askToInsertReservationDay() {
+        print(INSERT_RESERVATION_DAY.getMessage());
+        printLine();
+    }
+
+    public void askToInsertOrders() {
+        print(INSERT_ORDERS.getMessage());
+        printLine();
+    }
+
+    public void printIntroMessage(EventBenefitsPreviewDto eventBenefitsPreviewDto) {
+        printFormatted(SHOW_RESULT_INTRO_FORMAT.getFormat(), eventBenefitsPreviewDto.getDay());
+        printLine();
+        printLine();
+    }
+
+    public void printOrderedMenus(OrderedMenusDto orderedMenusDto) {
+        print(ORDERED_MENUS.getSymbol());
+        printLine();
+        orderedMenusDto.getOrders().forEach(this::printOrderedMenu);
+    }
+
+    private void printOrderedMenu(final String menuName, final int menuCount) {
+        printFormatted(ORDERED_MENUS_PRINT_FORMAT.getFormat(), menuName, menuCount);
+        printLine();
+    }
+
+    public void printTotalAmountWithNoDiscount(TotalAmountWithNoDiscountDto totalAmountWithNoDiscountDto) {
+        printLine();
+        print(TOTAL_AMOUNT_WITH_NO_DISCOUNT.getSymbol());
+        printLine();
+        printFormatted(TOTAL_AMOUNT_WITH_NO_DISCOUNT_PRINT_FORMAT.getFormat(),
+                formatPrice(totalAmountWithNoDiscountDto.getAmount()));
+        printLine();
+    }
+
+    public void printGiftMenu(GiftDto giftDto) {
+        printLine();
+        print(GIFT_MENU.getSymbol());
+        printLine();
+        printGift(giftDto);
+    }
+
+    private void printGift(GiftDto giftDto) {
+        if (giftDto.isEmpty()) {
+            print(NO_GIFT.getSymbol());
+            printLine();
+        }
+        giftDto.getGift().forEach((giftName, giftCount) -> {
+                    printFormatted(GIFT_PRINT_FORMAT.getFormat(), giftName, giftCount);
+                    printLine();
+                }
+        );
+    }
+
+    public void printBenefitsDetails(BenefitsDetailsDto benefitsDetailsDto) {
+        printLine();
+        print(BENEFITS_DETAILS.getSymbol());
+        printLine();
+        printBenefitNamesAndAmount(benefitsDetailsDto);
+    }
+
+    private void printBenefitNamesAndAmount(BenefitsDetailsDto benefitsDetailsDto) {
+        if (benefitsDetailsDto.isEmpty()) {
+            print(NO_BENEFITS.getSymbol());
+            printLine();
+        }
+        benefitsDetailsDto.getBenefitsDetails().forEach((benefitName, benefitAmount) -> {
+                    printFormatted(BENEFITS_DETAILS_PRINT_FORMAT.getFormat(), benefitName, formatPrice(benefitAmount));
+                    printLine();
+                }
+        );
+    }
+
+    public void printTotalBenefitedAmount(TotalBenefitedAmountDto totalBenefitedAmountDto) {
+        printLine();
+        print(TOTAL_BENEFITED_AMOUNT.getSymbol());
+        printLine();
+        printFormatted(TOTAL_BENEFITED_AMOUNT_PRINT_FORMAT.getFormat(),
+                formatPrice(-totalBenefitedAmountDto.getAmount()));
+        printLine();
+    }
+
+    public void printEstimatedAmountWithDiscount(EstimatedAmountWithDiscountDto estimatedAmountWithDiscountDto) {
+        printLine();
+        print(ESTIMATED_AMOUNT_WITH_DISCOUNT.getSymbol());
+        printLine();
+        printFormatted(ESTIMATED_AMOUNT_WITH_DISCOUNT_PRINT_FORMAT.getFormat(),
+                formatPrice(estimatedAmountWithDiscountDto.getAmount()));
+        printLine();
+    }
+
+    public void printEventBadge(EventBadgeDto eventBadgeDto) {
+        printLine();
+        print(EVENT_BADGE.getSymbol());
+        printLine();
+        printEventBadgeName(eventBadgeDto);
+    }
+
+    private void printEventBadgeName(EventBadgeDto eventBadgeDto) {
+        if (eventBadgeDto.isEmpty()) {
+            print(NO_EVENT_BADGE.getSymbol());
+        }
+        if (!eventBadgeDto.isEmpty()) {
+            print(eventBadgeDto.getBadgeName());
+        }
+    }
+
+    public void printErrorMessage(final String message) {
+        print(message);
+        printLine();
+    }
+
+    private void print(final String message) {
+        System.out.print(message);
+    }
+
+    private void printLine() {
+        System.out.print(NEW_LINE.getSymbol());
+    }
+
+    private void printFormatted(final String format, final Object... args) {
+        print(String.format(format, args));
+    }
+
+    private String formatPrice(final int price) {
+        return new DecimalFormat(PRICE_FORMAT_STYLE.getFormat())
+                .format(price);
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/view/output/constant/OutputFormatConstant.java b/src/main/java/christmas/view/output/constant/OutputFormatConstant.java
new file mode 100644
index 0000000..47d4b07
--- /dev/null
+++ b/src/main/java/christmas/view/output/constant/OutputFormatConstant.java
@@ -0,0 +1,24 @@
+package christmas.view.output.constant;
+
+import static christmas.global.ApplicationConstant.CURRENT_PROMOTION_MONTH;
+
+public enum OutputFormatConstant {
+    SHOW_RESULT_INTRO_FORMAT(CURRENT_PROMOTION_MONTH + "월 %d일에 우테코 식당에서 받을 이벤트 혜택 미리 보기!"),
+    ORDERED_MENUS_PRINT_FORMAT("%s %d개"),
+    TOTAL_AMOUNT_WITH_NO_DISCOUNT_PRINT_FORMAT("%s원"),
+    PRICE_FORMAT_STYLE("###,###"),
+    GIFT_PRINT_FORMAT("%s %d개"),
+    BENEFITS_DETAILS_PRINT_FORMAT("%s: -%s원"),
+    TOTAL_BENEFITED_AMOUNT_PRINT_FORMAT("%s원"),
+    ESTIMATED_AMOUNT_WITH_DISCOUNT_PRINT_FORMAT("%s원");
+
+    private final String format;
+
+    OutputFormatConstant(final String format) {
+        this.format = format;
+    }
+
+    public String getFormat() {
+        return format;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/view/output/constant/OutputMessageConstant.java b/src/main/java/christmas/view/output/constant/OutputMessageConstant.java
new file mode 100644
index 0000000..5c825ba
--- /dev/null
+++ b/src/main/java/christmas/view/output/constant/OutputMessageConstant.java
@@ -0,0 +1,19 @@
+package christmas.view.output.constant;
+
+import static christmas.global.ApplicationConstant.CURRENT_PROMOTION_MONTH;
+
+public enum OutputMessageConstant {
+    GREETING("안녕하세요! 우테코 식당 " + CURRENT_PROMOTION_MONTH + "월 이벤트 플래너입니다."),
+    INSERT_RESERVATION_DAY(CURRENT_PROMOTION_MONTH + "월 중 식당 방문 날짜는 언제인가요? (숫자만 입력해 주세요!)"),
+    INSERT_ORDERS("주문하실 메뉴를 메뉴와 개수를 알려 주세요. (e.g. 해산물파스타-2,레드와인-1,초코케이크-1)");
+
+    private final String message;
+
+    OutputMessageConstant(final String message) {
+        this.message = message;
+    }
+
+    public String getMessage() {
+        return message;
+    }
+}
\ No newline at end of file
diff --git a/src/main/java/christmas/view/output/constant/OutputSymbolConstant.java b/src/main/java/christmas/view/output/constant/OutputSymbolConstant.java
new file mode 100644
index 0000000..5849c15
--- /dev/null
+++ b/src/main/java/christmas/view/output/constant/OutputSymbolConstant.java
@@ -0,0 +1,24 @@
+package christmas.view.output.constant;
+
+public enum OutputSymbolConstant {
+    NEW_LINE(System.lineSeparator()),
+    ORDERED_MENUS("<주문 메뉴>"),
+    TOTAL_AMOUNT_WITH_NO_DISCOUNT("<할인 전 총주문 금액>"),
+    GIFT_MENU("<증정 메뉴>"),
+    BENEFITS_DETAILS("<혜택 내역>"),
+    TOTAL_BENEFITED_AMOUNT("<총혜택 금액>"),
+    ESTIMATED_AMOUNT_WITH_DISCOUNT("<할인 후 예상 결제 금액>"),
+    EVENT_BADGE("<12월 이벤트 배지>"),
+    NO_GIFT("없음"),
+    NO_BENEFITS("없음"),
+    NO_EVENT_BADGE("없음");
+    private final String symbol;
+
+    OutputSymbolConstant(final String symbol) {
+        this.symbol = symbol;
+    }
+
+    public String getSymbol() {
+        return symbol;
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/christmas/domain/ChristmasPromotionTest.java b/src/test/java/christmas/domain/ChristmasPromotionTest.java
new file mode 100644
index 0000000..08a6da6
--- /dev/null
+++ b/src/test/java/christmas/domain/ChristmasPromotionTest.java
@@ -0,0 +1,21 @@
+package christmas.domain;
+
+import static christmas.domain.constant.event.ChristmasPromotion.CHRISTMAS_D_DAY_PROMOTION;
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+
+public class ChristmasPromotionTest {
+    @DisplayName("25일 이전의 날짜가 입력되면, 해당하는 크리스마스 디데이 프로모션 금액을 계산한다.")
+    @ParameterizedTest
+    @CsvSource(value = {
+            "1:1000", "2:1100", "3:1200", "25:3400", "24:3300", "23:3200",
+            "15:2400", "16:2500", "19:2800", "7:1600", "11:2000", "13:2200"
+    }, delimiter = ':')
+    void 날짜가_입력되면_해당하는_크리스마스_디데이_프로모션_금액을_계산(int day, int expectedBenefitAmount) {
+        assertThat(CHRISTMAS_D_DAY_PROMOTION.getBenefitAmount(day))
+                .isEqualTo(expectedBenefitAmount);
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/christmas/domain/EventBadgeTest.java b/src/test/java/christmas/domain/EventBadgeTest.java
new file mode 100644
index 0000000..40f9d14
--- /dev/null
+++ b/src/test/java/christmas/domain/EventBadgeTest.java
@@ -0,0 +1,21 @@
+package christmas.domain;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import christmas.domain.constant.event.EventBadge;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+
+public class EventBadgeTest {
+    @DisplayName("혜택 금액에 따라 이벤트 배지를 발급한다.")
+    @ParameterizedTest
+    @CsvSource(value = {
+            "1000:''", "4999:''", "5000:별", "8230:별", "9999:별", "10000:트리", "13200:트리",
+            "14999:트리", "15000:트리", "19999:트리", "20000:산타", "20001:산타", "83000:산타"
+    }, delimiter = ':')
+    void 혜택_금액에_따라_이벤트_배지_발급(int totalBenefitedAmount, String eventBadgeName) {
+        assertThat(EventBadge.getBadgeNameByBenefitedPrice(totalBenefitedAmount))
+                .isEqualTo(eventBadgeName);
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/christmas/domain/EventManagerTest.java b/src/test/java/christmas/domain/EventManagerTest.java
new file mode 100644
index 0000000..b45fd57
--- /dev/null
+++ b/src/test/java/christmas/domain/EventManagerTest.java
@@ -0,0 +1,101 @@
+package christmas.domain;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+
+public class EventManagerTest {
+    @DisplayName("주문 내역과 날짜를 비교해서, 혜택 내역을 생산한다.")
+    @ParameterizedTest
+    @CsvSource({
+            "4, '시저샐러드,3|제로콜라,2|레드와인,1|티본스테이크,3|초코케이크,4','평일 할인,8092|크리스마스 디데이 할인,1300|증정 이벤트,25000'",
+            "3,'티본스테이크,1|바비큐립,1|초코케이크,2|제로콜라,1','크리스마스 디데이 할인,1200|평일 할인,4046|특별 할인,1000|증정 이벤트,25000'",
+            "25,'타파스,1|티본스테이크,1|아이스크림,3|제로콜라,3','크리스마스 디데이 할인,3400|평일 할인,6069|특별 할인,1000'"
+    })
+    void 주문_내역과_날짜를_비교해서_혜택_내역을_생산(int day, String menuAndCounts, String expectedBenefitDetails) {
+        // given
+        EventManager eventManager = createEventManager(day, menuAndCounts);
+        // when
+        Map<String, Integer> benefitsDetails = eventManager.createBenefitsDetails();
+        // then
+        for (String benefit : expectedBenefitDetails.split("\\|")) {
+            String[] parts = benefit.split(",");
+            String benefitName = parts[0];
+            int expectedAmount = Integer.parseInt(parts[1]);
+            assertThat(benefitsDetails.get(benefitName)).isEqualTo(expectedAmount);
+        }
+    }
+
+    @DisplayName("주문 내역에 날짜에 따른 할인 여부를 적용해서, 할인 금액을 계산한다.")
+    @ParameterizedTest
+    @CsvSource({
+            "4, '시저샐러드,3|제로콜라,2|레드와인,1|티본스테이크,3|초코케이크,4','9392'",
+            "3,'티본스테이크,1|바비큐립,1|초코케이크,2|제로콜라,1','6246'",
+            "25,'타파스,1|티본스테이크,1|아이스크림,3|제로콜라,3','10469'"
+    })
+    void 주문_내역에_날짜에_따른_할인_여부를_적용해서_할인_금액_계산(int day, String menuAndCounts, int expectedDiscountAmount) {
+        // given
+        Orders orders = Orders.from(parseMenuAndCounts(menuAndCounts));
+        EventManager eventManager = createEventManager(day, menuAndCounts);
+        // when
+        int discountAmount =
+                orders.calculateTotalAmountWithNoDiscount() - eventManager.calculateEstimatedOrdersAmountWithDiscount();
+        // then
+        assertThat(discountAmount).isEqualTo(expectedDiscountAmount);
+    }
+
+    @DisplayName("혜택 내역의 금액을 합쳐서, 총 혜택 금액을 계산한다.")
+    @ParameterizedTest
+    @CsvSource({
+            "4, '시저샐러드,3|제로콜라,2|레드와인,1|티본스테이크,3|초코케이크,4','34392'",
+            "3,'티본스테이크,1|바비큐립,1|초코케이크,2|제로콜라,1','31246'",
+            "25,'타파스,1|티본스테이크,1|아이스크림,3|제로콜라,3','10469'"
+    })
+    void 혜택_내역의_금액을_합쳐서_총_혜택_금액을_계산(int day, String menuAndCounts, int expectedDiscountAmount) {
+        // given
+        EventManager eventManager = createEventManager(day, menuAndCounts);
+        // when
+        int discountAmount = eventManager.calculateTotalBenefitedAmount();
+        // then
+        assertThat(discountAmount).isEqualTo(expectedDiscountAmount);
+    }
+
+    @DisplayName("총 혜택 금액을 기반으로 12월 이벤트 배지를 발급한다.")
+    @ParameterizedTest
+    @CsvSource({
+            "4, '시저샐러드,3|제로콜라,2|레드와인,1|티본스테이크,3|초코케이크,4','산타'",
+            "3,'티본스테이크,1|바비큐립,1|초코케이크,2|제로콜라,1','산타'",
+            "25,'타파스,1|티본스테이크,1|아이스크림,3|제로콜라,3','트리'",
+            "26,'타파스,1|크리스마스파스타,1|아이스크림,3|','별'",
+            "26,'양송이수프,3|크리스마스파스타,1|아이스크림,1|',''"
+    })
+    void 총_혜택_금액을_기반으로_12월_이벤트_배지를_발급(int day, String menuAndCounts, String expectedEventBadge) {
+        // given
+        EventManager eventManager = createEventManager(day, menuAndCounts);
+        // when
+        String eventBadge = eventManager.issueEventBadge();
+        // then
+        assertThat(eventBadge).isEqualTo(expectedEventBadge);
+    }
+
+    private EventManager createEventManager(int day, String menuAndCounts) {
+        ReservationDay reservationDay = ReservationDay.from(day);
+        Orders orders = Orders.from(parseMenuAndCounts(menuAndCounts));
+        return EventManager.of(reservationDay, orders);
+    }
+
+    private List<Order> parseMenuAndCounts(String menuAndCounts) {
+        List<Order> orders = new ArrayList<>();
+        String[] splitedMenusAndCounts = menuAndCounts.split("\\|");
+        for (String splitedMenusAndCount : splitedMenusAndCounts) {
+            String[] menuNameAndCount = splitedMenusAndCount.split(",");
+            orders.add(Order.of(menuNameAndCount[0], Integer.parseInt(menuNameAndCount[1])));
+        }
+        return orders;
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/christmas/domain/MenuTest.java b/src/test/java/christmas/domain/MenuTest.java
new file mode 100644
index 0000000..05b602d
--- /dev/null
+++ b/src/test/java/christmas/domain/MenuTest.java
@@ -0,0 +1,34 @@
+package christmas.domain;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import christmas.domain.constant.orders.Menu;
+import christmas.domain.exception.InvalidOrdersException;
+import christmas.domain.exception.message.InvalidOrdersExceptionMessage;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+public class MenuTest {
+    @DisplayName("메뉴 이름이 메뉴판에 없으면 예외가 발생한다.")
+    @ParameterizedTest
+    @ValueSource(strings = {"시츄샐러드", "동양송이수프", "물파스", "백퍼콜라", "와이본스테이크", "바비큐치킨", "크림", "당근케이크"})
+    void 메뉴_이름이_메뉴판에_없으면_예외_발생(String menuName) {
+        assertThatThrownBy(() -> Menu.searchByName(menuName))
+                .isInstanceOf(InvalidOrdersException.class)
+                .hasMessageContaining(InvalidOrdersExceptionMessage.NOT_EXISTING_MENU.getMessage());
+    }
+
+    @DisplayName("메뉴 이름이 메뉴판에 있으면, 메뉴가 올바르게 반환된다.")
+    @ParameterizedTest
+    @ValueSource(strings = {"시저샐러드", "타파스", "양송이수프", "티본스테이크", "바비큐립", "해산물파스타", "크리스마스파스타", "초코케이크", "아이스크림", "제로콜라",
+            "레드와인", "샴페인"})
+    void 메뉴_이름이_메뉴판에_있으면_메뉴를_올바르게_반환(String menuName) {
+        // given, when
+        Menu menu = Menu.searchByName(menuName);
+        // then
+        assertThat(menu).isInstanceOf(Menu.class);
+        assertThat(menu.getName()).isEqualTo(menuName);
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/christmas/domain/OrderTest.java b/src/test/java/christmas/domain/OrderTest.java
new file mode 100644
index 0000000..88f000e
--- /dev/null
+++ b/src/test/java/christmas/domain/OrderTest.java
@@ -0,0 +1,31 @@
+package christmas.domain;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import christmas.domain.exception.InvalidOrdersException;
+import christmas.domain.exception.message.InvalidOrdersExceptionMessage;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+
+public class OrderTest {
+    @DisplayName("메뉴판에 있는 메뉴 이름과 수량을 주문하면 주문이 생성된다.")
+    @ParameterizedTest
+    @CsvSource(value = {"양송이수프-10", "타파스-3", "레드와인-5", "제로콜라-3", "샴페인-7", "바비큐립-10"}, delimiter = '-')
+    void 메뉴판에_있는_메뉴_이름과_수량을_주문시_주문_생성(String menuName, int count) {
+        // given, when
+        Order order = Order.of(menuName, count);
+        // then
+        assertThat(order).isInstanceOf(Order.class);
+    }
+
+    @DisplayName("메뉴판에 없는 메뉴를 주문하면 예외가 발생한다.")
+    @ParameterizedTest
+    @CsvSource(value = {"시져샐러드-10", "티스테이크-3", "산나물파스타-2", "논알콜콜라-3", "단오파스타-7", "연근케이크-10"}, delimiter = '-')
+    void 메뉴판에_없는_메뉴이름으로_주문시_예외_발생(String menuName, int count) {
+        assertThatThrownBy(() -> Order.of(menuName, count))
+                .isInstanceOf(InvalidOrdersException.class)
+                .hasMessageContaining(InvalidOrdersExceptionMessage.NOT_EXISTING_MENU.getMessage());
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/christmas/domain/OrdersTest.java b/src/test/java/christmas/domain/OrdersTest.java
new file mode 100644
index 0000000..9f77ad6
--- /dev/null
+++ b/src/test/java/christmas/domain/OrdersTest.java
@@ -0,0 +1,114 @@
+package christmas.domain;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import christmas.domain.exception.InvalidOrdersException;
+import christmas.domain.exception.message.InvalidOrdersExceptionMessage;
+import java.util.List;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+public class OrdersTest {
+
+    @DisplayName("주문 내역을 취합했을 때, 메뉴 개수가 20개가 넘어가면 예외가 발생한다.")
+    @Test
+    public void 주문_내역을_취합했을때_메뉴_개수가_20개가_넘어가면_예외_발생() {
+        // given
+        List<Order> orders = List.of(
+                Order.of("시저샐러드", 3),
+                Order.of("제로콜라", 10),
+                Order.of("타파스", 2),
+                Order.of("티본스테이크", 3),
+                Order.of("초코케이크", 4)
+        );
+        // when, then
+        assertThatThrownBy(() -> Orders.from(orders))
+                .isInstanceOf(InvalidOrdersException.class)
+                .hasMessageContaining(InvalidOrdersExceptionMessage.EXCEED_MENU_COUNTS_UPPER_LIMIT.getMessage());
+    }
+
+    @DisplayName("주문 내역을 취합했을 때, 주문 내역에 음료수만 있으면 예외가 발생한다.")
+    @Test
+    public void 주문_내역을_취합했을때_주문_내역에_음료수만_있으면_예외_발생() {
+        // given
+        List<Order> orders = List.of(
+                Order.of("레드와인", 3),
+                Order.of("제로콜라", 4),
+                Order.of("샴페인", 5)
+        );
+        // when, then
+        assertThatThrownBy(() -> Orders.from(orders))
+                .isInstanceOf(InvalidOrdersException.class)
+                .hasMessageContaining(InvalidOrdersExceptionMessage.MENUS_ONLY_CONTAIN_BEVERAGE.getMessage());
+    }
+
+    @DisplayName("주문 내역을 취합했을 때, 주문 금액이 10000원 이하면 모든 이벤트 적용 대상에서 제외된다.")
+    @Test
+    public void 주문_내역을_취합했을때_주문_금액이_10000원_이하면_모든_이벤트_적용_대상에서_제외() {
+        // given
+        List<Order> orders = List.of(
+                Order.of("양송이수프", 1),
+                Order.of("제로콜라", 1)
+        );
+        // when, then
+        assertThat(Orders.from(orders).isEventApplicable()).isEqualTo(false);
+    }
+
+    @DisplayName("주문 내역을 취합했을 때, 주문 금액이 10000원 초과면 이벤트 적용 대상에 포함한다.")
+    @Test
+    public void 주문_내역을_취합했을때_주문_금액이_10000원_초과면_이벤트_적용_대상에_포함() {
+        // given
+        List<Order> orders = List.of(
+                Order.of("시저샐러드", 2),
+                Order.of("티본스테이크", 3)
+        );
+        // when, then
+        assertThat(Orders.from(orders).isEventApplicable()).isEqualTo(true);
+    }
+
+    @DisplayName("주문 내역을 취합했을 때, 주문 금액이 12만원 미만이면 증정 이벤트 적용 대상에 제외된다.")
+    @Test
+    public void 주문_내역을_취합했을때_주문_금액이_12만원_미만이면_증정_이벤트_적용_대상에_포함() {
+        // given
+        List<Order> orders = List.of(
+                Order.of("시저샐러드", 1),
+                Order.of("크리스마스파스타", 1),
+                Order.of("아이스크림", 1),
+                Order.of("제로콜라", 1)
+        );
+        // when, then
+        assertThat(Orders.from(orders).isGiftEventApplicable()).isEqualTo(false);
+    }
+
+
+    @DisplayName("주문 내역을 취합했을 때, 주문 금액이 12만원 이상이면 증정 이벤트 적용 대상에 포함한다.")
+    @Test
+    public void 주문_내역을_취합했을때_주문_금액이_12만원_이상이면_증정_이벤트_적용_대상에_포함() {
+        // given
+        List<Order> orders = List.of(
+                Order.of("시저샐러드", 2),
+                Order.of("바비큐립", 2),
+                Order.of("티본스테이크", 1),
+                Order.of("초코케이크", 1),
+                Order.of("레드와인", 1)
+        );
+        // when, then
+        assertThat(Orders.from(orders).isGiftEventApplicable()).isEqualTo(true);
+    }
+
+    @DisplayName("주문 내역을 이용해서 할인 전 총 주문 금액을 계산한다.")
+    @Test
+    public void 주문_내역을_이용해서_할인_전_총_주문_금액을_계산() {
+        // given
+        List<Order> orders = List.of(
+                Order.of("시저샐러드", 1),
+                Order.of("티본스테이크", 1),
+                Order.of("아이스크림", 1),
+                Order.of("초코케이크", 1),
+                Order.of("레드와인", 1)
+        );
+        // when, then
+        assertThat(Orders.from(orders).calculateTotalAmountWithNoDiscount()).isEqualTo(143000);
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/christmas/domain/ReservationDayTest.java b/src/test/java/christmas/domain/ReservationDayTest.java
new file mode 100644
index 0000000..275520a
--- /dev/null
+++ b/src/test/java/christmas/domain/ReservationDayTest.java
@@ -0,0 +1,65 @@
+package christmas.domain;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import christmas.domain.exception.InvalidReservationDayException;
+import christmas.domain.exception.message.InvalidReservationDayExceptionMessage;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+import org.junit.jupiter.params.provider.ValueSource;
+
+public class ReservationDayTest {
+    @DisplayName("유효하지 않은 날짜 ( 1 ~ 31 사이의 숫자가 아닌 숫자 )를 입력하면 예외를 발생시킨다.")
+    @ParameterizedTest
+    @ValueSource(ints = {0, -1, -10, 300, 350, 500, 32})
+    void 유효하지_않은_날짜_입력시_예외_발생(int day) {
+        assertThatThrownBy(() -> ReservationDay.from(day))
+                .isInstanceOf(InvalidReservationDayException.class)
+                .hasMessageContaining(InvalidReservationDayExceptionMessage.NOT_IN_APPROPRIATE_RANGE.getMessage());
+    }
+
+    @DisplayName("날짜를 입력하면 크리스마스 D-Day 프로모션이 적용 가능한지 여부를 판단 가능하다.")
+    @ParameterizedTest
+    @CsvSource(value = {"1:true", "10:true", "24:true", "31:false", "25:true", "26:false"}, delimiter = ':')
+    void 날짜_입력시_크리스마스_디데이_프로모션_적용_가능_여부_판단_가능(int day, boolean expected) {
+        // given, when
+        ReservationDay reservationDay = ReservationDay.from(day);
+        // then
+        assertThat(reservationDay.isChristmasPromotionApplicable()).isEqualTo(expected);
+    }
+
+    @DisplayName("날짜를 입력하면 평일 할인이 적용 가능한지 여부를 판단 가능하다.")
+    @ParameterizedTest
+    @CsvSource(value = {"5:true", "6:true", "7:true", "8:false", "25:true", "29:false", "30:false",
+            "31:true"}, delimiter = ':')
+    void 날짜_입력시_평일_할인_적용_가능_여부_판단_가능(int day, boolean expected) {
+        // given, when
+        ReservationDay reservationDay = ReservationDay.from(day);
+        // then
+        assertThat(reservationDay.isWeekdayPromotionApplicable()).isEqualTo(expected);
+    }
+
+    @DisplayName("날짜를 입력하면 주말 할인이 적용 가능한지 여부를 판단 가능하다.")
+    @ParameterizedTest
+    @CsvSource(value = {"1:true", "9:true", "15:true", "24:false", "30:true", "28:false", "31:false",
+            "23:true"}, delimiter = ':')
+    void 날짜_입력시_주말_할인_적용_가능_여부_판단_가능(int day, boolean expected) {
+        // given, when
+        ReservationDay reservationDay = ReservationDay.from(day);
+        // then
+        assertThat(reservationDay.isWeekendPromotionApplicable()).isEqualTo(expected);
+    }
+
+    @DisplayName("날짜를 입력하면 특별 할인이 적용 가능한지 여부를 판단 가능하다.")
+    @ParameterizedTest
+    @CsvSource(value = {"3:true", "10:true", "24:true", "26:false", "25:true", "27:false", "14:false",
+            "17:true", "31:true"}, delimiter = ':')
+    void 날짜_입력시_특별_할인_적용_가능_여부_판단_가능(int day, boolean expected) {
+        // given, when
+        ReservationDay reservationDay = ReservationDay.from(day);
+        // then
+        assertThat(reservationDay.isSpecialPromotionApplicable()).isEqualTo(expected);
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/christmas/parser/InputParserTest.java b/src/test/java/christmas/parser/InputParserTest.java
new file mode 100644
index 0000000..6a6d205
--- /dev/null
+++ b/src/test/java/christmas/parser/InputParserTest.java
@@ -0,0 +1,65 @@
+package christmas.parser;
+
+import static christmas.view.input.constant.InputSymbolConstant.DAY_SYMBOL;
+import static christmas.view.input.constant.InputSymbolConstant.ORDER_SYMBOL;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import christmas.view.input.exception.BasicInputException;
+import christmas.view.input.exception.message.BasicInputExceptionMessageFormat;
+import christmas.view.input.parser.InputParser;
+import java.util.Collections;
+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.CsvSource;
+
+public class InputParserTest {
+    private InputParser inputParser;
+
+    @BeforeEach
+    void setUp() {
+        inputParser = new InputParser();
+    }
+
+    @DisplayName("예약 날짜에 공백이 포함된 경우, 공백을 제거한 값을 숫자 형식으로 바꾸어 돌려준다.")
+    @ParameterizedTest
+    @CsvSource(value = {"1             0:10", "2    3:23", "   1   7:17", "3     1:31", "     1    :1",
+            " 3 0 :30"}, delimiter = ':')
+    void 예약_날짜에_공백이_포함된_경우_공백을_제거한_숫자로_반환(String userInput, int expected) {
+        assertThat(inputParser.parseReservationDay(userInput)).isEqualTo(expected);
+    }
+
+    @DisplayName("주문 내역에 공백이 포함된 경우, 공백을 제거한 값을 Map형식으로 바꾸어 돌려준다.")
+    @ParameterizedTest
+    @CsvSource(value = {"타   파 스 - 1,타파스,1", " 티  본  스테  이 크 - 2,티본스테이크,2", "제로 콜  라-10,제로콜라,10"}, delimiter = ',')
+    void 주문_내역에_공백이_포함된_경우_공백을_제거한_값을_맵으로_반환(String userInput, String menuName, int menuCount) {
+        assertThat(inputParser.parseOrders(userInput))
+                .isEqualTo(Collections.singletonMap(menuName, menuCount));
+    }
+
+    @DisplayName("공백 포함 날짜 입력값의 길이가 2000글자 이상이면, 예외가 발생한다.")
+    @Test
+    void 공백_포함_날짜_입력값이_2000글자_이상이면_예외_발생() {
+        String safeDayInput = "1" + " ".repeat(1000);
+        String illegalDayInput = "1" + " ".repeat(2000);
+        assertThat(inputParser.parseReservationDay(safeDayInput)).isEqualTo(1);
+        assertThatThrownBy(() -> inputParser.parseReservationDay(illegalDayInput))
+                .isInstanceOf(BasicInputException.class)
+                .hasMessageContaining(
+                        String.format(BasicInputExceptionMessageFormat.TOO_LONG_WITH_BLANKS_FORMAT.getFormat(),
+                                DAY_SYMBOL.getSymbol()));
+    }
+
+    @DisplayName("공백 포함 주문내역 입력값의 길이가 2000글자 이상이면, 예외가 발생한다.")
+    @Test
+    void 공백_포함_주문내역_입력값이_2000글자_이상이면_예외_발생() {
+        String userInput = "타파스-1" + " ".repeat(2000);
+        assertThatThrownBy(() -> inputParser.parseOrders(userInput))
+                .isInstanceOf(BasicInputException.class)
+                .hasMessageContaining(
+                        String.format(BasicInputExceptionMessageFormat.TOO_LONG_WITH_BLANKS_FORMAT.getFormat(),
+                                ORDER_SYMBOL.getSymbol()));
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/christmas/validator/DayInputValidatorTest.java b/src/test/java/christmas/validator/DayInputValidatorTest.java
new file mode 100644
index 0000000..b61452d
--- /dev/null
+++ b/src/test/java/christmas/validator/DayInputValidatorTest.java
@@ -0,0 +1,62 @@
+package christmas.validator;
+
+import static christmas.view.input.constant.InputSymbolConstant.DAY_SYMBOL;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import christmas.view.input.exception.BasicInputException;
+import christmas.view.input.exception.DayInputException;
+import christmas.view.input.exception.message.BasicInputExceptionMessageFormat;
+import christmas.view.input.exception.message.DayInputExceptionMessage;
+import christmas.view.input.validator.DayInputValidator;
+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.CsvSource;
+
+public class DayInputValidatorTest {
+    private DayInputValidator dayInputValidator;
+
+    @BeforeEach
+    void setUp() {
+        dayInputValidator = new DayInputValidator();
+    }
+
+    @DisplayName("예약 날짜가 비어있는 입력값일 때 예외가 발생한다.")
+    @Test
+    void 예약_날짜가_비어있는_값일때_예외_발생() {
+        assertThatThrownBy(() -> dayInputValidator.validate(""))
+                .isInstanceOf(BasicInputException.class)
+                .hasMessageContaining(String.format(BasicInputExceptionMessageFormat.EMPTY_FORMAT.getFormat(),
+                        DAY_SYMBOL.getSymbol()));
+    }
+
+    @DisplayName("공백 제거 후 날짜 길이가 3글자 이상이면, 예외가 발생한다.")
+    @ParameterizedTest
+    @CsvSource(value = {" 0    3    0 ", "0 0   2", "0 0   0  0 4"})
+    void 공백_제거_후_예약_날짜_입력값이_3글자_이상이면_예외_발생(String userInput) {
+        assertThatThrownBy(() -> dayInputValidator.validate(userInput))
+                .isInstanceOf(BasicInputException.class)
+                .hasMessageContaining(
+                        String.format(BasicInputExceptionMessageFormat.TOO_LONG_FORMAT.getFormat(),
+                                DAY_SYMBOL.getSymbol()));
+    }
+
+    @DisplayName("예약 날짜가 숫자형식이 아닌 입력값일 때 예외가 발생한다.")
+    @ParameterizedTest
+    @CsvSource(value = {"1a", "1s", "kw", "@!", "-", "a-", "dy", "!a"})
+    void 예약_날짜가_숫자_형식이_아닌_입력값이면_예외_발생(String userInput) {
+        assertThatThrownBy(() -> dayInputValidator.validate(userInput))
+                .isInstanceOf(DayInputException.class)
+                .hasMessageContaining(DayInputExceptionMessage.NOT_NUMERIC_TYPE.getMessage());
+    }
+
+    @DisplayName("예약 날짜가 양수가 아닌 숫자일 때 예외가 발생한다.")
+    @ParameterizedTest
+    @CsvSource(value = {"-1", "-2", "-5", "-7", "-9", "-8", "-3", "-4"})
+    void 예약_날짜가_양수가_아닌_숫자이면_예외_발생(String userInput) {
+        assertThatThrownBy(() -> dayInputValidator.validate(userInput))
+                .isInstanceOf(DayInputException.class)
+                .hasMessageContaining(DayInputExceptionMessage.NOT_POSITIVE.getMessage());
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/christmas/validator/MenuCountInputValidatorTest.java b/src/test/java/christmas/validator/MenuCountInputValidatorTest.java
new file mode 100644
index 0000000..3d6c818
--- /dev/null
+++ b/src/test/java/christmas/validator/MenuCountInputValidatorTest.java
@@ -0,0 +1,62 @@
+package christmas.validator;
+
+import static christmas.view.input.constant.InputSymbolConstant.ORDER_SYMBOL;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import christmas.view.input.exception.BasicInputException;
+import christmas.view.input.exception.OrdersInputException;
+import christmas.view.input.exception.message.BasicInputExceptionMessageFormat;
+import christmas.view.input.exception.message.OrdersInputExceptionMessage;
+import christmas.view.input.validator.MenuCountInputValidator;
+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.CsvSource;
+
+public class MenuCountInputValidatorTest {
+    private MenuCountInputValidator menuCountInputValidator;
+
+    @BeforeEach
+    void setUp() {
+        menuCountInputValidator = new MenuCountInputValidator();
+    }
+
+    @DisplayName("메뉴 개수가 비어있는 입력값일 때 예외가 발생한다.")
+    @Test
+    void 메뉴_개수가_비어있는_값일때_예외_발생() {
+        assertThatThrownBy(() -> menuCountInputValidator.validate(""))
+                .isInstanceOf(BasicInputException.class)
+                .hasMessageContaining(String.format(BasicInputExceptionMessageFormat.EMPTY_FORMAT.getFormat(),
+                        ORDER_SYMBOL.getSymbol()));
+    }
+
+    @DisplayName("공백 제거 후 메뉴 개수가 3글자 이상이면, 예외가 발생한다.")
+    @ParameterizedTest
+    @CsvSource(value = {" 1    3    2 ", "4 3   2", "2 5   3  7 4"})
+    void 공백_제거_후_메뉴_개수_입력값이_3글자_이상이면_예외_발생(String userInput) {
+        assertThatThrownBy(() -> menuCountInputValidator.validate(userInput))
+                .isInstanceOf(BasicInputException.class)
+                .hasMessageContaining(
+                        String.format(BasicInputExceptionMessageFormat.TOO_LONG_FORMAT.getFormat(),
+                                ORDER_SYMBOL.getSymbol()));
+    }
+
+    @DisplayName("메뉴 개수가 숫자형식이 아닌 입력값일 때 예외가 발생한다.")
+    @ParameterizedTest
+    @CsvSource(value = {"a1", "s1", "wk", "!@", "-/", "-a", "yd", "a!"})
+    void 메뉴_개수가_숫자_형식이_아닌_입력값이면_예외_발생(String userInput) {
+        assertThatThrownBy(() -> menuCountInputValidator.validate(userInput))
+                .isInstanceOf(OrdersInputException.class)
+                .hasMessageContaining(OrdersInputExceptionMessage.NOT_NUMERIC_TYPE.getMessage());
+    }
+
+    @DisplayName("메뉴 개수가 양수가 아닌 숫자일 때 예외가 발생한다.")
+    @ParameterizedTest
+    @CsvSource(value = {"-1", "-2", "-5", "-7", "-9", "-8", "-3", "-4"})
+    void 메뉴_개수가_양수가_아닌_숫자이면_예외_발생(String userInput) {
+        assertThatThrownBy(() -> menuCountInputValidator.validate(userInput))
+                .isInstanceOf(OrdersInputException.class)
+                .hasMessageContaining(OrdersInputExceptionMessage.NOT_POSITIVE.getMessage());
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/christmas/validator/MenuNameInputValidatorTest.java b/src/test/java/christmas/validator/MenuNameInputValidatorTest.java
new file mode 100644
index 0000000..ee7878a
--- /dev/null
+++ b/src/test/java/christmas/validator/MenuNameInputValidatorTest.java
@@ -0,0 +1,44 @@
+package christmas.validator;
+
+import static christmas.view.input.constant.InputSymbolConstant.ORDER_SYMBOL;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import christmas.view.input.exception.BasicInputException;
+import christmas.view.input.exception.message.BasicInputExceptionMessageFormat;
+import christmas.view.input.validator.MenuNameInputValidator;
+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.ValueSource;
+
+public class MenuNameInputValidatorTest {
+    private MenuNameInputValidator menuNameInputValidator;
+
+    @BeforeEach
+    void setUp() {
+        menuNameInputValidator = new MenuNameInputValidator();
+    }
+
+    @DisplayName("메뉴 이름이 비어있는 입력값일 때 예외가 발생한다.")
+    @Test
+    void 메뉴_이름이_비어있는_값일때_예외_발생() {
+        assertThatThrownBy(() -> menuNameInputValidator.validate(""))
+                .isInstanceOf(BasicInputException.class)
+                .hasMessageContaining(String.format(BasicInputExceptionMessageFormat.EMPTY_FORMAT.getFormat(),
+                        ORDER_SYMBOL.getSymbol()));
+    }
+
+    @DisplayName("공백 제거 후 메뉴 이름 길이가 31글자 이상이면, 예외가 발생한다.")
+    @ParameterizedTest
+    @ValueSource(strings = {"타파스 타파스 타파스 타파스 타파스 타파스 타파스 타파스 타파스 타파스 타파스 타파스 타파스 타파스 타파스  ",
+            "티본스테이크 티본스테이크 티본스테이크 티본스테이크 티본스테이크 티본스테이크 티본스테이크 "
+            , "레드와인 레드와인 레드와인 레드와인 레드와인 레드와인 레드와인 레드와인 "})
+    void 공백_제거_후_메뉴_이름_길이가_31글자_이상이면_예외_발생(String userInput) {
+        assertThatThrownBy(() -> menuNameInputValidator.validate(userInput))
+                .isInstanceOf(BasicInputException.class)
+                .hasMessageContaining(
+                        String.format(BasicInputExceptionMessageFormat.TOO_LONG_FORMAT.getFormat(),
+                                ORDER_SYMBOL.getSymbol()));
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/christmas/validator/OrderInputValidatorTest.java b/src/test/java/christmas/validator/OrderInputValidatorTest.java
new file mode 100644
index 0000000..19c1d3a
--- /dev/null
+++ b/src/test/java/christmas/validator/OrderInputValidatorTest.java
@@ -0,0 +1,65 @@
+package christmas.validator;
+
+import static christmas.view.input.constant.InputSymbolConstant.ORDER_SYMBOL;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import christmas.view.input.exception.BasicInputException;
+import christmas.view.input.exception.OrdersInputException;
+import christmas.view.input.exception.message.BasicInputExceptionMessageFormat;
+import christmas.view.input.exception.message.OrdersInputExceptionMessage;
+import christmas.view.input.validator.OrderInputValidator;
+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.CsvSource;
+import org.junit.jupiter.params.provider.ValueSource;
+
+public class OrderInputValidatorTest {
+    private OrderInputValidator orderInputValidator;
+
+    @BeforeEach
+    void setUp() {
+        orderInputValidator = new OrderInputValidator();
+    }
+
+    @DisplayName("주문이 비어있는 입력값일 때 예외가 발생한다.")
+    @Test
+    void 주문이_비어있는_값일때_예외_발생() {
+        assertThatThrownBy(() -> orderInputValidator.validate(""))
+                .isInstanceOf(BasicInputException.class)
+                .hasMessageContaining(String.format(BasicInputExceptionMessageFormat.EMPTY_FORMAT.getFormat(),
+                        ORDER_SYMBOL.getSymbol()));
+    }
+
+    @DisplayName("공백 제거 후 주문 길이가 34글자 이상이면, 예외가 발생한다.")
+    @ParameterizedTest
+    @CsvSource(value = {"타파스타파스타파스타파스타파스타파스타파스타파스타파스타파스타파스타파스타파스타파스타파스-13",
+            "티본스테이크티본스테이크티본스테이크티본스테이크티본스테이크티본스테이크-14",
+            "아이스크림아이스크림아이스크림아이스크림아이스크림아이스크림아이스크림아이스크림-11"})
+    void 공백_제거_후_주문_입력값이_34글자_이상이면_예외_발생(String userInput) {
+        assertThatThrownBy(() -> orderInputValidator.validate(userInput))
+                .isInstanceOf(BasicInputException.class)
+                .hasMessageContaining(
+                        String.format(BasicInputExceptionMessageFormat.TOO_LONG_FORMAT.getFormat(),
+                                ORDER_SYMBOL.getSymbol()));
+    }
+
+    @DisplayName("주문에 구분자(-)가 포함되어 있지 않으면 에외가 발생한다.")
+    @ParameterizedTest
+    @ValueSource(strings = {"타파스1", "티본스테이크~2", "바비큐립@12", "아이스크림", "시저샐러드#3", "초코케이크*4", "제로콜라!!", "레드와인$3"})
+    void 주문_입력값에_구분자가_포함되어_있지_않으면_예외_발생(String userInput) {
+        assertThatThrownBy(() -> orderInputValidator.validate(userInput))
+                .isInstanceOf(OrdersInputException.class)
+                .hasMessageContaining(OrdersInputExceptionMessage.INVALID_ORDER_FORMAT.getMessage());
+    }
+
+    @DisplayName("주문의 마지막 단어가 구분자(-)인 경우 예외가 발생한다.")
+    @ParameterizedTest
+    @ValueSource(strings = {"타파스1-", "티본스테이크-", "티본스테이크-1-", "시저샐러드-", "초코-케이크-"})
+    void 주문_입력값의_마지막_단어가_구분자_이면_예외_발생(String userInput) {
+        assertThatThrownBy(() -> orderInputValidator.validate(userInput))
+                .isInstanceOf(OrdersInputException.class)
+                .hasMessageContaining(OrdersInputExceptionMessage.EMPTY_MENU_COUNT.getMessage());
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/christmas/validator/OrdersInputValidatorTest.java b/src/test/java/christmas/validator/OrdersInputValidatorTest.java
new file mode 100644
index 0000000..c24df9d
--- /dev/null
+++ b/src/test/java/christmas/validator/OrdersInputValidatorTest.java
@@ -0,0 +1,57 @@
+package christmas.validator;
+
+import static christmas.view.input.constant.InputSymbolConstant.ORDER_SYMBOL;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import christmas.view.input.exception.BasicInputException;
+import christmas.view.input.exception.OrdersInputException;
+import christmas.view.input.exception.message.BasicInputExceptionMessageFormat;
+import christmas.view.input.exception.message.OrdersInputExceptionMessage;
+import christmas.view.input.validator.OrdersInputValidator;
+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.ValueSource;
+
+public class OrdersInputValidatorTest {
+    private OrdersInputValidator ordersInputValidator;
+
+    @BeforeEach
+    void setUp() {
+        ordersInputValidator = new OrdersInputValidator();
+    }
+
+    @DisplayName("주문 내역이 비어있는 입력값일 때 예외가 발생한다.")
+    @Test
+    void 주문_내역이_비어있는_값일때_예외_발생() {
+        assertThatThrownBy(() -> ordersInputValidator.preValidate(""))
+                .isInstanceOf(BasicInputException.class)
+                .hasMessageContaining(String.format(BasicInputExceptionMessageFormat.EMPTY_FORMAT.getFormat(),
+                        ORDER_SYMBOL.getSymbol()));
+    }
+
+    @DisplayName("공백 제거 후 주문 내역 길이가 1000글자 이상이면, 예외가 발생한다.")
+    @Test
+    void 공백_제거_후_주문내역_입력값이_1000글자_이상이면_예외_발생() {
+        String illegalOrdersInput = "시저샐러드-1,".repeat(200);
+        assertThatThrownBy(() -> ordersInputValidator.preValidate(illegalOrdersInput))
+                .isInstanceOf(BasicInputException.class)
+                .hasMessageContaining(
+                        BasicInputExceptionMessageFormat.TOO_LONG_FORMAT.getFormat(), ORDER_SYMBOL.getSymbol());
+    }
+
+    @DisplayName("주문 내역을 취합했을 때, 중복된 주문 메뉴가 존재하면 예외가 발생한다.")
+    @ParameterizedTest
+    @ValueSource(strings = {
+            "타파스-1,타파스-4",
+            "타파스-1,초코케이크-2,레드와인-1,샴페인-1,아이스크림-2,티본스테이크-1,초코케이크-1",
+            "초코케이크-1,초코케이크-1,초코케이크-1,초코케이크-1,초코케이크-1,초코케이크-1",
+            "시저샐러드-1,양송이수프-1,제로콜라-1,샴페인-1,크리스마스파스타-2,해산물파스타-1,시저샐러드-4"
+    })
+    void 중복_주문_메뉴_존재_시_예외_발생(String userInput) {
+        assertThatThrownBy(() -> ordersInputValidator.postValidate(userInput))
+                .isInstanceOf(OrdersInputException.class)
+                .hasMessageContaining(OrdersInputExceptionMessage.DUPLICATED_MENUS.getMessage());
+    }
+}
\ No newline at end of file