diff --git a/docs/README.md b/docs/README.md
index e69de29..5baaf77 100644
--- a/docs/README.md
+++ b/docs/README.md
@@ -0,0 +1,279 @@
+### 🖥️ 프로그램 소개
+주문을 받아서 이벤트 적용 내역을 출력하는 프로그램입니다.
+
+### 💡 핵심 기능
+적용 가능한 이벤트 혜택 내역 계산
+
+### 📌 주요 포인트
+- 할인 이벤트와 선물 이벤트를 <b>인터페이스</b>와 <b>추상 클래스</b>로 분리와 동시에 공통 로직 통합
+- 여러 종류의 이벤트를 <b>Enum</b>과 <b>함수형 인터페이스</b>로 관리
+- MVC 패턴에 <b>Service</b>, <b>Repository</b>를 추가하여 역할 분리
+- <b>Enum</b>과 <b>EnumMap</b>으로 불필요 클래스 제거 및 통합 관리
+- <b>계층형 Dto</b>를 활용한 View와 Domain 의존성 분리
+
+### 📉 런타임 의존관계도
+![asso](https://github.com/Arachneee/java-christmas-6-Arachneee/assets/66822642/e94eb329-5991-41f3-9e21-23978a98377e)
+
+### 📊 UML
+![promotion_uml](https://github.com/Arachneee/java-christmas-6-Arachneee/assets/66822642/f085deea-f1fc-4475-bf5d-9318d445565e)
+
+### ⚒️ 클래스 역할
+<div align="center">
+<table>
+    <tr>
+        <th align="center">📁 Package</th>
+        <th align="center">📚 Class</th>
+        <th align="center">✏️ Description</th>
+    </tr>
+    <tr>
+        <td rowspan="1">🗓️ <b>config</b></td>
+        <td><b>PlannerConfig</b></td>
+        <td>의존관계 설정</td>
+    </tr>
+<tr><td colspan="3"></td></tr>
+    <tr>
+        <td rowspan="2">⚙️ <b>controller</b></td>
+        <td><b>OrderController</b></td>
+        <td>주문 입출력(View), 주문(Service) 연결</td>
+    </tr>
+    <tr>
+        <td><b>OrderConverter</b></td>
+        <td>View 입력값 Order 인스턴스 변수로 변환</td>
+    </tr>
+    <tr><td colspan="3"></td></tr>
+    <tr>
+        <td rowspan="2">📐 <b>domain</b><br>&rAarr; order</td>
+        <td><b>Order</b></td>
+        <td>주문 일자와 메뉴 수량을 갖는 클래스</td>
+    </tr>
+    <tr>
+        <td><b>Day</b></td>
+        <td>12월의 일자 원시타입 포장 클래스</td>
+    </tr>
+    <tr>
+        <td rowspan="5"><b>domain</b><br>&rAarr; order<br>&rAarr; constant</td>
+        <td><b>Category</b></td>
+        <td>메뉴의 카테고리 Enum</td>
+    </tr>
+    <tr>
+        <td><b>DayOfWeek</b></td>
+        <td>요일 Enum</td>
+    </tr>
+    <tr>
+        <td><b>December</b></td>
+        <td>12월 Enum</td>
+    </tr>
+    <tr>
+        <td><b>Menu</b></td>
+        <td>메뉴 Enum</td>
+    </tr>
+    <tr>
+        <td><b>Week</b></td>
+        <td>평일/주말 Enum</td>
+    </tr>
+    <tr>
+        <td rowspan="3"><b>domain</b><br>&rAarr; event</td>
+        <td>📗 <b>Event</b></td>
+        <td>이벤트 혜택 계산 인터페이스</td>
+    </tr>
+    <tr>
+        <td>📗 <b>EventRepository</b></td>
+        <td>이벤트 혜택 결과 저장 추상 클래스</td>
+    </tr>
+    <tr>
+        <td><b>Badge</b></td>
+        <td>배지 Enum</td>
+    </tr>
+    <tr>
+        <td rowspan="2"><b>domain</b><br>&rAarr; event<br>&rAarr; discount</td>
+        <td>🎁 <b>DiscountEventType</b></td>
+        <td>Event 인터페이스 구현, 할인 이벤트 통합 관리 Enum</td>
+    </tr>
+    <tr>
+        <td>💾 <b>DiscountRepository</b></td>
+        <td>EventRepository 구현, 할인 이벤트 결과 EnumMap 저장</td>
+    </tr>
+    <tr>
+        <td rowspan="2"><b>domain</b><br>&rAarr; event<br>&rAarr; gift</td>
+        <td>🎁 <b>GiftEventType</b></td>
+        <td>Event 인터페이스 구현, 선물 이벤트 통합 관리 Enum</td>
+    </tr>
+    <tr>
+        <td>💾 <b>GiftRepository</b></td>
+        <td>EventRepository 구현, 선물 이벤트 결과 EnumMap 저장</td>
+    </tr>
+    <tr><td colspan="3"></td></tr>
+    <tr>
+        <td rowspan="1">🕹️ <b>service</b><br>&rAarr; order</td>
+        <td><b>OrderService</b></td>
+        <td>주문 생성 및 주문 결과 요약</td>
+    </tr>
+    <tr>
+        <td rowspan="4"><b>service</b><br>&rAarr; event</td>
+        <td><b>EventDetailService</b></td>
+        <td>이벤트 적용 상세 결과 요약</td>
+    </tr>
+    <tr>
+        <td>📗 <b>EventService</b></td>
+        <td>이벤트 혜택 결과 계산 추상 클래스</td>
+    </tr>
+    <tr>
+        <td><b>DiscountService</b></td>
+        <td>EventService 구현, 할인 해택 적용</td>
+    </tr>
+    <tr>
+        <td><b>GiftService</b></td>
+        <td>EventService 구현, 선물 해택 적용</td>
+    </tr>
+    <tr><td colspan="3"></td></tr>
+    <tr>
+        <td rowspan="2">⏰ <b>exception</b></td>
+        <td><b>OrderException</b></td>
+        <td>주문 생성 예외 발생</td>
+    </tr>
+    <tr>
+        <td><b>ErrorMessage</b></td>
+        <td>예외 메시지 Enum</td>
+    </tr>
+    <tr><td colspan="3"></td></tr>
+    <tr>
+        <td rowspan="6">📬 <b>response</b></td>
+        <td><b>OrderSummaryResponse</b></td>
+        <td>주문 결과 요약 DTO</td>
+    </tr>
+    <tr>
+        <td><b>OrderResponse</b></td>
+        <td>주문 항목 DTO</td>
+    </tr>
+    <tr>
+        <td><b>MenuCountResponse</b></td>
+        <td>주문 메뉴 수량 DTO</td>
+    </tr>
+    <tr>
+        <td><b>EventDetailResponse</b></td>
+        <td>이벤트 적용 상세 내역 DTO</td>
+    </tr>
+    <tr>
+        <td><b>EventResponse</b></td>
+        <td>이벤트 적용 내역 DTO</td>
+    </tr>
+    <tr>
+        <td><b>GiftMenuResponse</b></td>
+        <td>선물 메뉴 수량 DTO</td>
+    </tr>
+    <tr><td colspan="3"></td></tr>
+    <tr>
+        <td rowspan="4">🖥️ <b>view</b></td>
+        <td><b>InputView</b></td>
+        <td>입력 요청 View</td>
+    </tr>
+    <tr>
+        <td><b>OutputView</b></td>
+        <td>결과 출력 View</td>
+    </tr>
+    <tr>
+        <td>📗 <b>Reader</b></td>
+        <td>입력 인터페이스</td>
+    </tr>
+    <tr>
+        <td>📗 <b>Writer</b></td>
+        <td>출력 인터페이스</td>
+    </tr>
+    <tr>
+        <td rowspan="2"><b>view</b><br>&rAarr; io</td>
+        <td><b>ConsoleReader</b></td>
+        <td>콘솔 입력</td>
+    </tr>
+    <tr>
+        <td><b>ConsoleWriter</b></td>
+        <td>콘솔 출력</td>
+    </tr>
+    
+
+</table>
+</div>
+
+<br>
+
+### 🗂️ 구현 기능 목록
+#### ⚙️ Controller
+- #### OrderController
+- [x] 입력 오류시 반복 요청
+- #### OrderConverter
+- [x] 입력 날짜 숫자 검증
+- [x] 입력 날짜 숫자 변환
+- [x] 중복 메뉴 검증
+- [x] 개수 숫자 검증
+- [x] 개수 숫자 변환
+- [x] 메뉴 개수 포맷 검증
+#### 📐 Domail
+- #### Day
+- [x] 입력 날짜 범위 검증 (1 ~ 31)
+- [x] 날짜 차이 계산
+- [x] 날짜 대소비교 기능
+- #### Order
+- [x] 메뉴 개수 범위 검증 (1이상)
+- [x] 총 주문 메뉴 개수 검증 (20이하)
+- [x] 음료만 주문 검증
+- [x] 카테고리별 수량 계산
+- [x] 할인 전 총주문 금액 계산
+- #### Menu
+- [x] 메뉴 유무 검증
+- #### Week
+- [x] 평일/주말 구분
+- [x] 평일/주말 할인 카테고리 선택
+- #### DayOfWeek
+- [x] 요일 구분
+- #### December
+- [x] 크리스마스 확인
+- [x] 12월 날짜 확인
+- #### DiscountEventType
+- [x] 전체 할인 적용 가능 판별
+- [x] 전체 할인 이벤트 적용하기
+- [x] 총주문 금액 10,000 이상 확인
+- [x] 크리스마스 디데이 할인 적용 여부 확인
+- [x] 크리스마스 디데이 할인 금액 계산
+- [x] 평일/주말 할인 적용 여부 확인
+- [x] 평일 할인 적용 금액 계산
+- [x] 주말 할인 적용 금액 계산
+- [x] 특별 할인 적용 금액 계산
+- [x] 특별 할인 적용 여부 확인
+- #### GiftEventType
+- [x] 전체 선물 이벤트 적용 가능 판별
+- [x] 전체 선물 이벤트 적용하기
+- [x] 증정 이벤트 적용 여부 확인
+- [x] 증정 이벤트 적용 금액 계산
+- #### DiscountRepository
+- [x] 할인 이벤트 결과 저장
+- [x] 할인 이벤트 전체 이익 계산
+- #### GiftRepository
+- [x] 선물 이벤트 결과 저장
+- [x] 선물 이벤트 전체 이익 계산
+- [x] 선물 메뉴 항목, 수량 계산
+- #### Badge
+- [x] 12월 이벤트 배지 등급 계산
+#### 🕹️ Service
+- #### OrderService
+- [x] 주문 내역, 이벤트 적용 내역 요약하기
+- #### EventDetailService
+- [x] 이벤트 적용 내역 계신
+- [x] 총혜택 금액 계산
+- [x] 할인 후 예상 결제 금액 계산
+- #### DiscountService
+- [x] 전체 할인 이벤트 적용하기
+- #### GiftService
+- [x] 전체 선물 이벤트 적용하기
+#### 🖥️ View
+- #### InputView
+- [x] 방문 날짜 입력 받기
+- [x] 메뉴와 개수 입력 받기
+- #### OutputView
+- [x] Hello 헤더 출력
+- [x] 증정 메뉴 출력
+- [x] 이벤트 혜택 미리보기 출력
+- [x] 주문 메뉴 출력
+- [x] 할인 전 총주문 금액 출력
+- [x] 혜택 내역 출력
+- [x] 총혜택 금액 출력
+- [x] 할인 후 예상 결제 금액 출력
+- [x] 12월 이벤트 배지 출력
\ No newline at end of file
diff --git a/src/main/java/christmas/Application.java b/src/main/java/christmas/Application.java
index b9ba6a2..6faa6ba 100644
--- a/src/main/java/christmas/Application.java
+++ b/src/main/java/christmas/Application.java
@@ -1,7 +1,10 @@
 package christmas;
 
+import static christmas.config.PlannerConfig.orderController;
+
 public class Application {
+
     public static void main(String[] args) {
-        // TODO: 프로그램 구현
+        orderController().run();
     }
 }
diff --git a/src/main/java/christmas/config/PlannerConfig.java b/src/main/java/christmas/config/PlannerConfig.java
new file mode 100644
index 0000000..5b86512
--- /dev/null
+++ b/src/main/java/christmas/config/PlannerConfig.java
@@ -0,0 +1,47 @@
+package christmas.config;
+
+import christmas.controller.OrderController;
+import christmas.domain.event.discount.DiscountRepository;
+import christmas.domain.event.gift.GiftRepository;
+import christmas.service.event.DiscountService;
+import christmas.service.event.EventDetailService;
+import christmas.service.event.GiftService;
+import christmas.service.order.OrderService;
+import christmas.view.InputView;
+import christmas.view.OutputView;
+import christmas.view.io.ConsoleReader;
+import christmas.view.io.ConsoleWriter;
+
+public class PlannerConfig {
+
+    private PlannerConfig() {
+    }
+
+    public static OrderController orderController() {
+        return new OrderController(inputView(), outputView(), orderService());
+    }
+
+    private static InputView inputView() {
+        return new InputView(new ConsoleReader(), new ConsoleWriter());
+    }
+
+    private static OutputView outputView() {
+        return new OutputView(new ConsoleWriter());
+    }
+
+    private static OrderService orderService() {
+        return new OrderService(eventDetailService());
+    }
+
+    private static EventDetailService eventDetailService() {
+        return new EventDetailService(discountService(), giftService());
+    }
+
+    private static DiscountService discountService() {
+        return new DiscountService(new DiscountRepository());
+    }
+
+    private static GiftService giftService() {
+        return new GiftService(new GiftRepository());
+    }
+}
diff --git a/src/main/java/christmas/controller/OrderController.java b/src/main/java/christmas/controller/OrderController.java
new file mode 100644
index 0000000..105bca7
--- /dev/null
+++ b/src/main/java/christmas/controller/OrderController.java
@@ -0,0 +1,55 @@
+package christmas.controller;
+
+import christmas.controller.converter.OrderConverter;
+import christmas.domain.order.Day;
+import christmas.domain.order.Order;
+import christmas.response.OrderSummaryResponse;
+import christmas.service.order.OrderService;
+import christmas.view.InputView;
+import christmas.view.OutputView;
+import java.util.function.Supplier;
+
+public class OrderController {
+
+    private final InputView inputView;
+    private final OutputView outputView;
+    private final OrderService orderService;
+
+    public OrderController(final InputView inputView, final OutputView outputView, final OrderService orderService) {
+        this.inputView = inputView;
+        this.outputView = outputView;
+        this.orderService = orderService;
+    }
+
+    public void run() {
+        outputView.printHello();
+
+        final Day orderDay = createOrderDay();
+        final Order order = createOrder(orderDay);
+
+        final OrderSummaryResponse orderSummaryResponse = orderService.createOrderSummary(order);
+
+        outputView.printOrderSummary(orderSummaryResponse);
+
+        inputView.close();
+    }
+
+    private Day createOrderDay() {
+        return getByRoof(() -> OrderConverter.convertToDay(inputView.readDate()));
+    }
+
+    private Order createOrder(final Day day) {
+        return getByRoof(() -> Order.of(day, OrderConverter.convertToMenu(inputView.readMenuAndCount())));
+    }
+
+    private <T> T getByRoof(final Supplier<T> method) {
+        while (true) {
+            try {
+                return method.get();
+            } catch (IllegalArgumentException illegalArgumentException) {
+                outputView.printError(illegalArgumentException.getMessage());
+            }
+        }
+    }
+
+}
diff --git a/src/main/java/christmas/controller/converter/OrderConverter.java b/src/main/java/christmas/controller/converter/OrderConverter.java
new file mode 100644
index 0000000..b78c046
--- /dev/null
+++ b/src/main/java/christmas/controller/converter/OrderConverter.java
@@ -0,0 +1,81 @@
+package christmas.controller.converter;
+
+import static christmas.exception.ErrorMessage.INVALID_DAY;
+import static christmas.exception.ErrorMessage.INVALID_ORDER;
+import static java.util.regex.Pattern.compile;
+import static java.util.stream.Collectors.toMap;
+
+import christmas.domain.order.Day;
+import christmas.domain.order.constant.Menu;
+import christmas.exception.ErrorMessage;
+import christmas.exception.OrderException;
+import java.util.Arrays;
+import java.util.EnumMap;
+import java.util.function.BinaryOperator;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public final class OrderConverter {
+
+    private static final Pattern MENU_COUNT_PATTERN = compile("^[가-힣A-Za-z]+-\\d+(?:,[가-힣A-Za-z]+-\\d+)*$");
+    private static final String MENU_SPLIT_SIGNAL = ",";
+    private static final String COUNT_SPLIT_SIGNAL = "-";
+    private static final String INVALID_START = "0";
+    private static final int TITLE_INDEX = 0;
+    private static final int COUNT_INDEX = 1;
+
+    private OrderConverter() {
+    }
+
+    public static Day convertToDay(final String input) {
+        return Day.from(convertToInt(input, INVALID_DAY));
+    }
+
+    private static int convertToInt(final String input, final ErrorMessage errorMessage) {
+        validateStartZero(input, errorMessage);
+
+        try {
+            return Integer.parseInt(input);
+        } catch (NumberFormatException numberFormatException) {
+            throw OrderException.from(errorMessage);
+        }
+    }
+
+    private static void validateStartZero(final String input, final ErrorMessage errorMessage) {
+        if (input.startsWith(INVALID_START)) {
+            throw OrderException.from(errorMessage);
+        }
+    }
+
+    public static EnumMap<Menu, Integer> convertToMenu(final String input) {
+        validateMenuFormat(input);
+
+        return createMenuEnumMap(input);
+    }
+
+    private static void validateMenuFormat(final String input) {
+        final Matcher matcher = MENU_COUNT_PATTERN.matcher(input);
+
+        if (matcher.matches()) {
+            return;
+        }
+
+        throw OrderException.from(INVALID_ORDER);
+    }
+
+    private static EnumMap<Menu, Integer> createMenuEnumMap(final String input) {
+
+        return Arrays.stream(input.split(MENU_SPLIT_SIGNAL))
+                .map(menuCount -> menuCount.split(COUNT_SPLIT_SIGNAL))
+                .collect(toMap(menuCount -> Menu.from(menuCount[TITLE_INDEX]),
+                        menuCount -> convertToInt(menuCount[COUNT_INDEX], INVALID_ORDER),
+                        throwingDuplicateMenuException(),
+                        () -> new EnumMap<>(Menu.class)));
+    }
+
+    private static <T> BinaryOperator<T> throwingDuplicateMenuException() {
+        return (menu, other) -> {
+            throw OrderException.from(ErrorMessage.INVALID_ORDER);
+        };
+    }
+}
diff --git a/src/main/java/christmas/domain/event/Badge.java b/src/main/java/christmas/domain/event/Badge.java
new file mode 100644
index 0000000..1a9d669
--- /dev/null
+++ b/src/main/java/christmas/domain/event/Badge.java
@@ -0,0 +1,39 @@
+package christmas.domain.event;
+
+import java.util.Arrays;
+import java.util.Comparator;
+
+public enum Badge {
+    SANTA("산타", 20_000),
+    TREE("트리", 10_000),
+    STAR("별", 5_000),
+    NONE("", 0);
+
+    private final String title;
+    private final int minPrice;
+
+    Badge(final String title, final int minPrice) {
+        this.title = title;
+        this.minPrice = minPrice;
+    }
+
+    public static Badge from(final int totalDiscount) {
+        return Arrays.stream(values())
+                .sorted(Comparator.comparing(Badge::getMinPrice).reversed())
+                .filter(badge -> badge.isSatisfiedCondition(totalDiscount))
+                .findFirst()
+                .orElse(NONE);
+    }
+
+    private boolean isSatisfiedCondition(final int totalDiscount) {
+        return minPrice <= totalDiscount;
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public int getMinPrice() {
+        return minPrice;
+    }
+}
diff --git a/src/main/java/christmas/domain/event/Event.java b/src/main/java/christmas/domain/event/Event.java
new file mode 100644
index 0000000..e5fd52c
--- /dev/null
+++ b/src/main/java/christmas/domain/event/Event.java
@@ -0,0 +1,25 @@
+package christmas.domain.event;
+
+import christmas.domain.order.Order;
+import java.util.Arrays;
+import java.util.EnumMap;
+import java.util.stream.Collectors;
+
+
+public interface Event {
+
+    int calculateBenefits(final Order order);
+
+    String getTitle();
+
+    static <T extends Enum<T> & Event> EnumMap<T, Integer> applyAll(final Class<T> eventType, final Order order) {
+
+        return Arrays.stream(eventType.getEnumConstants())
+                .collect(Collectors.toMap(
+                        event -> event,
+                        event -> event.calculateBenefits(order),
+                        Integer::sum,
+                        () -> new EnumMap<>(eventType)
+                ));
+    }
+}
diff --git a/src/main/java/christmas/domain/event/EventRepository.java b/src/main/java/christmas/domain/event/EventRepository.java
new file mode 100644
index 0000000..3686a06
--- /dev/null
+++ b/src/main/java/christmas/domain/event/EventRepository.java
@@ -0,0 +1,35 @@
+package christmas.domain.event;
+
+import static java.util.stream.Collectors.toMap;
+
+import java.util.EnumMap;
+import java.util.Map;
+import java.util.Map.Entry;
+
+
+public abstract class EventRepository<T extends Enum<T> & Event> {
+
+    private static final int ZERO = 0;
+    protected EnumMap<T, Integer> eventAmounts;
+
+    public void init(final EnumMap<T, Integer> eventAmounts) {
+        this.eventAmounts = eventAmounts;
+    }
+
+    public int calculateTotal() {
+        return eventAmounts.values().stream().mapToInt(Integer::intValue).sum();
+    }
+
+    public Map<String, Integer> getActiveResult() {
+        return eventAmounts.entrySet().stream().filter(this::isActive)
+                .collect(toMap(this::getEventTitle, Entry::getValue));
+    }
+
+    protected boolean isActive(final Entry<T, Integer> entry) {
+        return entry.getValue() != ZERO;
+    }
+
+    private String getEventTitle(final Entry<T, Integer> entry) {
+        return entry.getKey().getTitle();
+    }
+}
diff --git a/src/main/java/christmas/domain/event/discount/DiscountEventType.java b/src/main/java/christmas/domain/event/discount/DiscountEventType.java
new file mode 100644
index 0000000..747f646
--- /dev/null
+++ b/src/main/java/christmas/domain/event/discount/DiscountEventType.java
@@ -0,0 +1,59 @@
+package christmas.domain.event.discount;
+
+import christmas.domain.event.Event;
+import christmas.domain.order.Order;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+public enum DiscountEventType implements Event {
+
+    CHRISTMAS_D_DAY_DISCOUNT("크리스마스 디데이 할인", Order::isAfterChristmas,
+            order -> order.countDayAfterFirstDay() * Amount.CHRISTMAS_ONCE.value + Amount.CHRISTMAS_OFFSET.value),
+    WEEKDAY_DISCOUNT("평일 할인", Order::isWeekend,
+            order -> order.countWeekEventMenu() * Amount.WEEKDAY_ONCE.value),
+    WEEKEND_DISCOUNT("주말 할인", Order::isWeekday,
+            order -> order.countWeekEventMenu() * Amount.WEEKEND_ONCE.value),
+    SPECIAL_DISCOUNT("특별 할인", order -> order.isNotSunDay() && order.isNotChristmasDay(),
+            order -> Amount.SPECIAL_ONCE.value);
+
+    private final String title;
+    private final Predicate<Order> unavailable;
+    private final Function<Order, Integer> calculate;
+
+    DiscountEventType(final String title, final Predicate<Order> unavailable,
+            final Function<Order, Integer> calculate) {
+        this.title = title;
+        this.unavailable = unavailable;
+        this.calculate = calculate;
+    }
+
+    @Override
+    public int calculateBenefits(final Order order) {
+        if (order.isTotalPriceUnder(Amount.BASE_MIN.value) || unavailable.test(order)) {
+            return Amount.ZERO.value;
+        }
+
+        return calculate.apply(order);
+    }
+
+    @Override
+    public String getTitle() {
+        return title;
+    }
+
+    private enum Amount {
+        CHRISTMAS_ONCE(100),
+        CHRISTMAS_OFFSET(1_000),
+        WEEKDAY_ONCE(2_023),
+        WEEKEND_ONCE(2_023),
+        SPECIAL_ONCE(1_000),
+        BASE_MIN(10_000),
+        ZERO(0);
+
+        private final int value;
+
+        Amount(final int value) {
+            this.value = value;
+        }
+    }
+}
diff --git a/src/main/java/christmas/domain/event/discount/DiscountRepository.java b/src/main/java/christmas/domain/event/discount/DiscountRepository.java
new file mode 100644
index 0000000..fefb20b
--- /dev/null
+++ b/src/main/java/christmas/domain/event/discount/DiscountRepository.java
@@ -0,0 +1,6 @@
+package christmas.domain.event.discount;
+
+import christmas.domain.event.EventRepository;
+
+public class DiscountRepository extends EventRepository<DiscountEventType> {
+}
diff --git a/src/main/java/christmas/domain/event/gift/GiftEventType.java b/src/main/java/christmas/domain/event/gift/GiftEventType.java
new file mode 100644
index 0000000..cb78fae
--- /dev/null
+++ b/src/main/java/christmas/domain/event/gift/GiftEventType.java
@@ -0,0 +1,61 @@
+package christmas.domain.event.gift;
+
+import christmas.domain.event.Event;
+import christmas.domain.order.Order;
+import christmas.domain.order.constant.Menu;
+import java.util.function.Predicate;
+
+public enum GiftEventType implements Event {
+    PRESENTATION("증정 이벤트", order -> order.isTotalPriceUnder(Amount.PRESENTATION_MIN.value),
+            Menu.CHAMPAGNE, 1);
+
+    private final String title;
+    private final Predicate<Order> unavailable;
+    private final Menu menu;
+    private final int count;
+
+    GiftEventType(final String title, final Predicate<Order> unavailable, final Menu menu, final int count) {
+        this.title = title;
+        this.unavailable = unavailable;
+        this.menu = menu;
+        this.count = count;
+    }
+
+    @Override
+    public int calculateBenefits(final Order order) {
+        if (unavailable.test(order)) {
+            return Amount.ZERO.value;
+        }
+
+        return calculateMenuTotalPrice();
+    }
+
+    private int calculateMenuTotalPrice() {
+        return menu.getPrice() * count;
+    }
+
+    @Override
+    public String getTitle() {
+        return title;
+    }
+
+    public String getMenuTitle() {
+        return menu.getTitle();
+    }
+
+    public int getCount() {
+        return count;
+    }
+
+    private enum Amount {
+        PRESENTATION_MIN(120_000),
+        ZERO(0);
+
+        private final int value;
+
+        Amount(final int value) {
+            this.value = value;
+        }
+    }
+
+}
diff --git a/src/main/java/christmas/domain/event/gift/GiftRepository.java b/src/main/java/christmas/domain/event/gift/GiftRepository.java
new file mode 100644
index 0000000..81c9bf3
--- /dev/null
+++ b/src/main/java/christmas/domain/event/gift/GiftRepository.java
@@ -0,0 +1,25 @@
+package christmas.domain.event.gift;
+
+import static java.util.stream.Collectors.toMap;
+
+import christmas.domain.event.EventRepository;
+import java.util.Map;
+import java.util.Map.Entry;
+
+public class GiftRepository extends EventRepository<GiftEventType> {
+
+    public Map<String, Integer> getActiveMenuCounts() {
+        return eventAmounts.entrySet().stream()
+                .filter(this::isActive)
+                .collect(toMap(this::getMenuTitle, this::getMenuCount));
+    }
+
+    private String getMenuTitle(final Entry<GiftEventType, Integer> entry) {
+        return entry.getKey().getMenuTitle();
+    }
+
+    private Integer getMenuCount(final Entry<GiftEventType, Integer> entry) {
+        return entry.getKey().getCount();
+    }
+
+}
diff --git a/src/main/java/christmas/domain/order/Day.java b/src/main/java/christmas/domain/order/Day.java
new file mode 100644
index 0000000..10b987e
--- /dev/null
+++ b/src/main/java/christmas/domain/order/Day.java
@@ -0,0 +1,88 @@
+package christmas.domain.order;
+
+import static christmas.domain.order.constant.December.START_DAY;
+import static christmas.exception.ErrorMessage.INVALID_DAY;
+
+import christmas.domain.order.constant.DayOfWeek;
+import christmas.domain.order.constant.December;
+import christmas.domain.order.constant.Week;
+import christmas.domain.order.constant.Category;
+import christmas.exception.OrderException;
+import java.util.Objects;
+
+public class Day {
+
+    private final int day;
+
+    private Day(final int day) {
+        this.day = day;
+    }
+
+    public static Day from(final int day) {
+        validate(day);
+        return new Day(day);
+    }
+
+    private static void validate(final int day) {
+        if (isOutOfRange(day)) {
+            throw OrderException.from(INVALID_DAY);
+        }
+    }
+
+    private static boolean isOutOfRange(final int day) {
+        return !December.isInRange(day);
+    }
+
+    public int gap(final Day other) {
+        return Math.abs(other.day - this.day);
+    }
+
+    public int gapFromStartDay() {
+        return this.gap(from(START_DAY.getDay()));
+    }
+
+    public Integer mod(final int weekCount) {
+        return day % weekCount;
+    }
+
+    public Category getTodayEventCategory() {
+        return Week.from(DayOfWeek.from(this)).getEventCategory();
+    }
+
+    public boolean isOverThan(final Day other) {
+        return this.day > other.day;
+    }
+
+    public boolean isChristmasDay() {
+        return December.isChristMas(day);
+    }
+
+    public boolean isSunDay() {
+        return DayOfWeek.from(this).isSunDay();
+    }
+
+    public boolean isWeekend() {
+        return DayOfWeek.from(this).isWeekend();
+    }
+
+    public int getValue() {
+        return day;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        Day day1 = (Day) o;
+        return day == day1.day;
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(day);
+    }
+}
diff --git a/src/main/java/christmas/domain/order/Order.java b/src/main/java/christmas/domain/order/Order.java
new file mode 100644
index 0000000..fe5b963
--- /dev/null
+++ b/src/main/java/christmas/domain/order/Order.java
@@ -0,0 +1,128 @@
+package christmas.domain.order;
+
+import static christmas.domain.order.constant.December.CHRISTMAS_DAY;
+import static christmas.domain.order.constant.December.START_DAY;
+
+import christmas.domain.order.constant.Category;
+import christmas.domain.order.constant.Menu;
+import christmas.exception.OrderException;
+import christmas.exception.ErrorMessage;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Set;
+
+public class Order {
+
+    private static final int TOTAL_COUNT_MAX = 20;
+    private static final int ONCE_COUNT_MIN = 1;
+    private final Day day;
+    private final Map<Menu, Integer> menuCount;
+
+    private Order(final Day day, final Map<Menu, Integer> menuCount) {
+        this.day = day;
+        this.menuCount = menuCount;
+    }
+
+    public static Order of(final Day day, final Map<Menu, Integer> menuCount) {
+        validate(menuCount);
+
+        return new Order(day, menuCount);
+    }
+
+    private static void validate(final Map<Menu, Integer> menuCount) {
+        validateCountRange(menuCount.values());
+        validateTotalCountMax(menuCount.values());
+        validateOnlyBeverage(menuCount.keySet());
+    }
+
+    private static void validateCountRange(final Collection<Integer> counts) {
+        if (isUnderThanMin(counts)) {
+            throw OrderException.from(ErrorMessage.INVALID_ORDER);
+        }
+
+    }
+
+    private static boolean isUnderThanMin(final Collection<Integer> counts) {
+        return counts.stream()
+                .anyMatch(count -> count < ONCE_COUNT_MIN);
+    }
+
+
+    private static void validateTotalCountMax(final Collection<Integer> counts) {
+        if (calculateTotalCount(counts) > TOTAL_COUNT_MAX) {
+            throw OrderException.from(ErrorMessage.INVALID_ORDER);
+        }
+    }
+
+    private static int calculateTotalCount(final Collection<Integer> counts) {
+        return counts.stream()
+                .mapToInt(Integer::intValue)
+                .sum();
+    }
+
+    private static void validateOnlyBeverage(final Set<Menu> menus) {
+        if (isOnlyBeverage(menus)) {
+            throw OrderException.from(ErrorMessage.INVALID_ORDER);
+        }
+    }
+
+    private static boolean isOnlyBeverage(final Set<Menu> menus) {
+        return menus.stream()
+                .map(Menu::getCategory)
+                .distinct()
+                .noneMatch(Category::isNotBeverage);
+    }
+
+    public int calculateTotalPrice() {
+        return menuCount.entrySet().stream()
+                .mapToInt(entry -> entry.getKey().getPrice() * entry.getValue())
+                .sum();
+    }
+
+    public int countDayAfterFirstDay() {
+        return this.day.gap(Day.from(START_DAY.getDay()));
+    }
+
+    public int countWeekEventMenu() {
+        final Category category = day.getTodayEventCategory();
+
+        return menuCount.entrySet().stream()
+                .filter(entry -> entry.getKey().isCategory(category))
+                .mapToInt(Entry::getValue)
+                .sum();
+    }
+
+    public boolean isTotalPriceUnder(final int price) {
+        return calculateTotalPrice() < price;
+    }
+
+    public boolean isAfterChristmas() {
+        return day.isOverThan(Day.from(CHRISTMAS_DAY.getDay()));
+    }
+
+    public boolean isWeekend() {
+        return day.isWeekend();
+    }
+
+    public boolean isWeekday() {
+        return !day.isWeekend();
+    }
+
+    public boolean isNotSunDay() {
+        return !day.isSunDay();
+    }
+
+    public boolean isNotChristmasDay() {
+        return !day.isChristmasDay();
+    }
+
+    public Map<Menu, Integer> getMenuCount() {
+        return Collections.unmodifiableMap(menuCount);
+    }
+
+    public int getDayInt() {
+        return day.getValue();
+    }
+}
diff --git a/src/main/java/christmas/domain/order/constant/Category.java b/src/main/java/christmas/domain/order/constant/Category.java
new file mode 100644
index 0000000..b4774c6
--- /dev/null
+++ b/src/main/java/christmas/domain/order/constant/Category.java
@@ -0,0 +1,9 @@
+package christmas.domain.order.constant;
+
+public enum Category {
+    APPETIZER, MAIN, DESSERT, BEVERAGE;
+
+    public boolean isNotBeverage() {
+        return !this.equals(BEVERAGE);
+    }
+}
diff --git a/src/main/java/christmas/domain/order/constant/DayOfWeek.java b/src/main/java/christmas/domain/order/constant/DayOfWeek.java
new file mode 100644
index 0000000..ac82c01
--- /dev/null
+++ b/src/main/java/christmas/domain/order/constant/DayOfWeek.java
@@ -0,0 +1,55 @@
+package christmas.domain.order.constant;
+
+import static christmas.domain.order.constant.December.START_DAY;
+import static christmas.domain.order.constant.Week.WEEKDAY;
+import static christmas.domain.order.constant.Week.WEEKEND;
+
+import christmas.domain.order.Day;
+import java.util.Arrays;
+
+public enum DayOfWeek {
+    MONDAY(0, WEEKDAY),
+    TUESDAY(1, WEEKDAY),
+    WEDNESDAY(2, WEEKDAY),
+    THURSDAY(3, WEEKDAY),
+    FRIDAY(4, WEEKEND),
+    SATURDAY(5, WEEKEND),
+    SUNDAY(6, WEEKDAY);
+
+    private static final int TOTAL_COUNT = (int) Arrays.stream(values()).count();
+    private final int sequence;
+    private final Week week;
+
+    DayOfWeek(final int sequence, final Week week) {
+        this.sequence = sequence;
+        this.week = week;
+    }
+
+    public static DayOfWeek from(final Day day) {
+        return START_DAY.getDayOfWeek().getAfterDay(day);
+    }
+
+    private DayOfWeek getAfterDay(final Day day) {
+        final int mod = day.gapFromStartDay() % TOTAL_COUNT;
+        return findDayOfWeekByMod(mod);
+    }
+
+    private DayOfWeek findDayOfWeekByMod(final int mod) {
+        return Arrays.stream(values())
+                .filter(dayOfWeek -> this.getGapMod(dayOfWeek.sequence) == mod)
+                .findFirst()
+                .orElseThrow();
+    }
+
+    private int getGapMod(final int mod) {
+        return (mod - this.sequence + TOTAL_COUNT) % TOTAL_COUNT;
+    }
+
+    public boolean isSunDay() {
+        return this.equals(SUNDAY);
+    }
+
+    public boolean isWeekend() {
+        return this.week.equals(WEEKEND);
+    }
+}
diff --git a/src/main/java/christmas/domain/order/constant/December.java b/src/main/java/christmas/domain/order/constant/December.java
new file mode 100644
index 0000000..59c2393
--- /dev/null
+++ b/src/main/java/christmas/domain/order/constant/December.java
@@ -0,0 +1,35 @@
+package christmas.domain.order.constant;
+
+import static christmas.domain.order.constant.DayOfWeek.FRIDAY;
+import static christmas.domain.order.constant.DayOfWeek.MONDAY;
+import static christmas.domain.order.constant.DayOfWeek.SUNDAY;
+
+public enum December {
+    START_DAY(1, FRIDAY),
+    CHRISTMAS_DAY(25, MONDAY),
+    END_DAY(31, SUNDAY);
+
+    private final int day;
+    private final DayOfWeek dayOfWeek;
+
+    December(final int day, final DayOfWeek dayOfWeek) {
+        this.day = day;
+        this.dayOfWeek = dayOfWeek;
+    }
+
+    public static boolean isInRange(final int day) {
+        return day >= START_DAY.getDay() && day <= END_DAY.getDay();
+    }
+
+    public static boolean isChristMas(final int day) {
+        return day == CHRISTMAS_DAY.getDay();
+    }
+
+    public int getDay() {
+        return day;
+    }
+
+    public DayOfWeek getDayOfWeek() {
+        return dayOfWeek;
+    }
+}
diff --git a/src/main/java/christmas/domain/order/constant/Menu.java b/src/main/java/christmas/domain/order/constant/Menu.java
new file mode 100644
index 0000000..f27adc7
--- /dev/null
+++ b/src/main/java/christmas/domain/order/constant/Menu.java
@@ -0,0 +1,63 @@
+package christmas.domain.order.constant;
+
+
+import static christmas.domain.order.constant.Category.APPETIZER;
+import static christmas.domain.order.constant.Category.BEVERAGE;
+import static christmas.domain.order.constant.Category.DESSERT;
+import static christmas.domain.order.constant.Category.MAIN;
+import static christmas.exception.ErrorMessage.INVALID_ORDER;
+import static java.util.stream.Collectors.toMap;
+
+import christmas.exception.OrderException;
+import java.util.Arrays;
+import java.util.Map;
+
+public enum Menu {
+
+    BUTTON_MUSHROOM_SOUP("양송이수프", APPETIZER, 6_000),
+    TAPAS("타파스", APPETIZER, 5_500),
+    CAESAR_SALAD("시저샐러드", APPETIZER, 8_000),
+    T_BONE_STEAK("티본스테이크", MAIN, 55_000),
+    BARBECUE_RIBS("바비큐립", MAIN, 54_000),
+    SEAFOOD_PASTA("해산물파스타", MAIN, 35_000),
+    CHRISTMAS_PASTA("크리스마스파스타", MAIN, 25_000),
+    CHOCOLATE_CAKE("초코케이크", DESSERT, 15_000),
+    ICE_CREAM("아이스크림", DESSERT, 5_000),
+    ZERO_COLA("제로콜라", BEVERAGE, 3_000),
+    RED_WINE("레드와인", BEVERAGE, 60_000),
+    CHAMPAGNE("샴페인", BEVERAGE, 25_000);
+
+    private static final Map<String, Menu> menus = Arrays.stream(values())
+            .collect(toMap(menu -> menu.title, menu -> menu));
+    private final String title;
+    private final Category category;
+    private final int price;
+
+    Menu(final String title, final Category category, final int price) {
+        this.title = title;
+        this.category = category;
+        this.price = price;
+    }
+
+    public static Menu from(final String title) {
+        return menus.computeIfAbsent(title, key -> {
+            throw OrderException.from(INVALID_ORDER);
+        });
+    }
+
+    public boolean isCategory(final Category category) {
+        return this.category.equals(category);
+    }
+
+    public String getTitle() {
+        return title;
+    }
+
+    public Category getCategory() {
+        return category;
+    }
+
+    public int getPrice() {
+        return price;
+    }
+}
diff --git a/src/main/java/christmas/domain/order/constant/Week.java b/src/main/java/christmas/domain/order/constant/Week.java
new file mode 100644
index 0000000..76fca89
--- /dev/null
+++ b/src/main/java/christmas/domain/order/constant/Week.java
@@ -0,0 +1,32 @@
+package christmas.domain.order.constant;
+
+import static christmas.domain.order.constant.Category.DESSERT;
+import static christmas.domain.order.constant.Category.MAIN;
+
+public enum Week {
+    WEEKDAY(DESSERT),
+    WEEKEND(MAIN);
+
+    private final Category eventCategory;
+
+
+    Week(final Category category) {
+        this.eventCategory = category;
+    }
+
+    public static Week from(final DayOfWeek dayOfWeek) {
+        if (dayOfWeek.isWeekend()) {
+            return WEEKEND;
+        }
+
+        return WEEKDAY;
+    }
+
+    public boolean isWeekend() {
+        return this.equals(WEEKEND);
+    }
+
+    public Category getEventCategory() {
+        return eventCategory;
+    }
+}
diff --git a/src/main/java/christmas/exception/ErrorMessage.java b/src/main/java/christmas/exception/ErrorMessage.java
new file mode 100644
index 0000000..d7281e8
--- /dev/null
+++ b/src/main/java/christmas/exception/ErrorMessage.java
@@ -0,0 +1,18 @@
+package christmas.exception;
+
+public enum ErrorMessage {
+
+    INVALID_DAY("유효하지 않은 날짜입니다. 다시 입력해 주세요."),
+    INVALID_ORDER("유효하지 않은 주문입니다. 다시 입력해 주세요.");
+
+    private static final String PREFIX = "[ERROR] ";
+    private final String message;
+
+    ErrorMessage(final String message) {
+        this.message = message;
+    }
+
+    public String getMessage() {
+        return PREFIX + message;
+    }
+}
diff --git a/src/main/java/christmas/exception/OrderException.java b/src/main/java/christmas/exception/OrderException.java
new file mode 100644
index 0000000..eef374c
--- /dev/null
+++ b/src/main/java/christmas/exception/OrderException.java
@@ -0,0 +1,14 @@
+package christmas.exception;
+
+public class OrderException extends IllegalArgumentException {
+
+    private OrderException(final ErrorMessage errorMessage) {
+        super(errorMessage.getMessage());
+    }
+
+    public static OrderException from(final ErrorMessage errorMessage) {
+        return new OrderException(errorMessage);
+    }
+
+
+}
diff --git a/src/main/java/christmas/response/EventDetailResponse.java b/src/main/java/christmas/response/EventDetailResponse.java
new file mode 100644
index 0000000..ef5ac7b
--- /dev/null
+++ b/src/main/java/christmas/response/EventDetailResponse.java
@@ -0,0 +1,62 @@
+package christmas.response;
+
+import java.util.List;
+
+public record EventDetailResponse(
+        int priceBeforeEvent,
+        List<GiftMenuResponse> giftMenuResponses,
+        List<EventResponse> activeEvents,
+        int totalBenefitsAmount,
+        int priceAfterEvent,
+        String badge
+) {
+
+    public static class EventDetailResponseBuilder {
+
+        int priceBeforeEvent;
+        List<GiftMenuResponse> giftMenuResponses;
+        List<EventResponse> activeEvents;
+        int totalBenefitsAmount;
+        int priceAfterEvent;
+        String badge;
+
+        public static EventDetailResponseBuilder builder() {
+            return new EventDetailResponseBuilder();
+        }
+
+        public EventDetailResponseBuilder priceBeforeEvent(final int priceBeforeEvent) {
+            this.priceBeforeEvent = priceBeforeEvent;
+            return this;
+        }
+
+        public EventDetailResponseBuilder giftMenuResponses(final List<GiftMenuResponse> giftMenuResponses) {
+            this.giftMenuResponses = giftMenuResponses;
+            return this;
+        }
+
+        public EventDetailResponseBuilder activeEvents(final List<EventResponse> activeEvents) {
+            this.activeEvents = activeEvents;
+            return this;
+        }
+
+        public EventDetailResponseBuilder totalBenefitsAmount(final int totalBenefitsAmount) {
+            this.totalBenefitsAmount = totalBenefitsAmount;
+            return this;
+        }
+
+        public EventDetailResponseBuilder priceAfterEvent(final int priceAfterEvent) {
+            this.priceAfterEvent = priceAfterEvent;
+            return this;
+        }
+
+        public EventDetailResponseBuilder badge(final String badge) {
+            this.badge = badge;
+            return this;
+        }
+
+        public EventDetailResponse build() {
+            return new EventDetailResponse(priceBeforeEvent, giftMenuResponses, activeEvents,
+                    totalBenefitsAmount, priceAfterEvent, badge);
+        }
+    }
+}
diff --git a/src/main/java/christmas/response/EventResponse.java b/src/main/java/christmas/response/EventResponse.java
new file mode 100644
index 0000000..63e99df
--- /dev/null
+++ b/src/main/java/christmas/response/EventResponse.java
@@ -0,0 +1,8 @@
+package christmas.response;
+
+public record EventResponse(String title, int amount) {
+
+    public static EventResponse of(final String title, final int amount) {
+        return new EventResponse(title, amount);
+    }
+}
diff --git a/src/main/java/christmas/response/GiftMenuResponse.java b/src/main/java/christmas/response/GiftMenuResponse.java
new file mode 100644
index 0000000..02e2457
--- /dev/null
+++ b/src/main/java/christmas/response/GiftMenuResponse.java
@@ -0,0 +1,8 @@
+package christmas.response;
+
+public record GiftMenuResponse(String title, int count) {
+
+    public static GiftMenuResponse of(final String title, final int count) {
+        return new GiftMenuResponse(title, count);
+    }
+}
diff --git a/src/main/java/christmas/response/MenuCountResponse.java b/src/main/java/christmas/response/MenuCountResponse.java
new file mode 100644
index 0000000..cdcbadb
--- /dev/null
+++ b/src/main/java/christmas/response/MenuCountResponse.java
@@ -0,0 +1,9 @@
+package christmas.response;
+
+public record MenuCountResponse(String title, int count) {
+
+    public static MenuCountResponse of(final String title, final int count) {
+        return new MenuCountResponse(title, count);
+    }
+
+}
diff --git a/src/main/java/christmas/response/OrderResponse.java b/src/main/java/christmas/response/OrderResponse.java
new file mode 100644
index 0000000..931a291
--- /dev/null
+++ b/src/main/java/christmas/response/OrderResponse.java
@@ -0,0 +1,11 @@
+package christmas.response;
+
+import java.util.List;
+
+public record OrderResponse(int day, List<MenuCountResponse> menuCount) {
+
+    public static OrderResponse of(final int day, final List<MenuCountResponse> menuCount) {
+        return new OrderResponse(day, menuCount);
+    }
+
+}
diff --git a/src/main/java/christmas/response/OrderSummaryResponse.java b/src/main/java/christmas/response/OrderSummaryResponse.java
new file mode 100644
index 0000000..5bb7842
--- /dev/null
+++ b/src/main/java/christmas/response/OrderSummaryResponse.java
@@ -0,0 +1,9 @@
+package christmas.response;
+
+public record OrderSummaryResponse(OrderResponse orderResponse, EventDetailResponse eventDetailResponse) {
+
+    public static OrderSummaryResponse of(final OrderResponse orderResponse,
+            final EventDetailResponse eventDetailResponse) {
+        return new OrderSummaryResponse(orderResponse, eventDetailResponse);
+    }
+}
diff --git a/src/main/java/christmas/service/event/DiscountService.java b/src/main/java/christmas/service/event/DiscountService.java
new file mode 100644
index 0000000..08eb918
--- /dev/null
+++ b/src/main/java/christmas/service/event/DiscountService.java
@@ -0,0 +1,11 @@
+package christmas.service.event;
+
+import christmas.domain.event.discount.DiscountEventType;
+import christmas.domain.event.discount.DiscountRepository;
+
+public class DiscountService extends EventService<DiscountEventType> {
+
+    public DiscountService(final DiscountRepository discountRepository) {
+        super(discountRepository);
+    }
+}
diff --git a/src/main/java/christmas/service/event/EventDetailService.java b/src/main/java/christmas/service/event/EventDetailService.java
new file mode 100644
index 0000000..5ea7f69
--- /dev/null
+++ b/src/main/java/christmas/service/event/EventDetailService.java
@@ -0,0 +1,68 @@
+package christmas.service.event;
+
+import christmas.domain.event.Badge;
+import christmas.domain.event.discount.DiscountEventType;
+import christmas.domain.event.gift.GiftEventType;
+import christmas.domain.order.Order;
+import christmas.response.EventDetailResponse;
+import christmas.response.EventDetailResponse.EventDetailResponseBuilder;
+import christmas.response.EventResponse;
+import java.util.List;
+import java.util.stream.Stream;
+
+public class EventDetailService {
+
+    private final DiscountService discountService;
+    private final GiftService giftService;
+
+    public EventDetailService(final DiscountService discountService, final GiftService giftService) {
+        this.discountService = discountService;
+        this.giftService = giftService;
+    }
+
+    public void applyEvent(final Order order) {
+        discountService.applyEventAll(DiscountEventType.class, order);
+        giftService.applyEventAll(GiftEventType.class, order);
+    }
+
+    public EventDetailResponse getEventDetail(final int priceBeforeDiscount) {
+        final int totalDiscountBenefits = discountService.calculateTotalBenefits();
+        final int totalGiftBenefits = giftService.calculateTotalBenefits();
+
+        final int totalBenefitsAmount = totalDiscountBenefits + totalGiftBenefits;
+
+        return buildEventDetailResponse(priceBeforeDiscount, totalBenefitsAmount, totalDiscountBenefits);
+    }
+
+    private EventDetailResponse buildEventDetailResponse(
+            final int priceBeforeDiscount,
+            final int totalBenefitsAmount,
+            final int totalDiscountBenefits
+    ) {
+
+        return EventDetailResponseBuilder.builder()
+                .priceBeforeEvent(priceBeforeDiscount)
+                .giftMenuResponses(giftService.getGiftMenuResponse())
+                .activeEvents(getAllActiveEvent())
+                .totalBenefitsAmount(totalBenefitsAmount)
+                .priceAfterEvent(calculatePriceAfterDiscount(priceBeforeDiscount, totalDiscountBenefits))
+                .badge(getBadgeTitle(totalBenefitsAmount))
+                .build();
+    }
+
+    private List<EventResponse> getAllActiveEvent() {
+        return Stream.concat(discountService.getActiveEventResult().stream(),
+                        giftService.getActiveEventResult().stream())
+                .toList();
+    }
+
+    private int calculatePriceAfterDiscount(final int priceBeforeDiscount, final int totalDiscountBenefits) {
+        return priceBeforeDiscount - totalDiscountBenefits;
+    }
+
+    private String getBadgeTitle(final int totalBenefitsAmount) {
+        return Badge.from(totalBenefitsAmount).getTitle();
+    }
+
+
+}
diff --git a/src/main/java/christmas/service/event/EventService.java b/src/main/java/christmas/service/event/EventService.java
new file mode 100644
index 0000000..9baf8ad
--- /dev/null
+++ b/src/main/java/christmas/service/event/EventService.java
@@ -0,0 +1,37 @@
+package christmas.service.event;
+
+import christmas.domain.event.Event;
+import christmas.domain.event.EventRepository;
+import christmas.domain.order.Order;
+import christmas.response.EventResponse;
+import java.util.EnumMap;
+import java.util.List;
+import java.util.Map.Entry;
+
+public abstract class EventService<T extends Enum<T> & Event> {
+
+    protected final EventRepository<T> eventRepository;
+
+    public EventService(final EventRepository<T> eventRepository) {
+        this.eventRepository = eventRepository;
+    }
+
+    public void applyEventAll(final Class<T> eventType, final Order order) {
+        final EnumMap<T, Integer> giftAmounts = Event.applyAll(eventType, order);
+        eventRepository.init(giftAmounts);
+    }
+
+    public List<EventResponse> getActiveEventResult() {
+        return eventRepository.getActiveResult().entrySet().stream()
+                .map(this::createEventResponse)
+                .toList();
+    }
+
+    private EventResponse createEventResponse(final Entry<String, Integer> entry) {
+        return EventResponse.of(entry.getKey(), entry.getValue());
+    }
+
+    public int calculateTotalBenefits() {
+        return eventRepository.calculateTotal();
+    }
+}
diff --git a/src/main/java/christmas/service/event/GiftService.java b/src/main/java/christmas/service/event/GiftService.java
new file mode 100644
index 0000000..d6a6f1b
--- /dev/null
+++ b/src/main/java/christmas/service/event/GiftService.java
@@ -0,0 +1,27 @@
+package christmas.service.event;
+
+import christmas.domain.event.gift.GiftEventType;
+import christmas.domain.event.gift.GiftRepository;
+import christmas.response.GiftMenuResponse;
+import java.util.List;
+import java.util.Map.Entry;
+
+public class GiftService extends EventService<GiftEventType> {
+
+    private final GiftRepository giftRepository;
+
+    public GiftService(final GiftRepository giftRepository) {
+        super(giftRepository);
+        this.giftRepository = giftRepository;
+    }
+
+    public List<GiftMenuResponse> getGiftMenuResponse() {
+        return giftRepository.getActiveMenuCounts().entrySet().stream()
+                .map(this::createGiftMenuResponse)
+                .toList();
+    }
+
+    private GiftMenuResponse createGiftMenuResponse(final Entry<String, Integer> entry) {
+        return GiftMenuResponse.of(entry.getKey(), entry.getValue());
+    }
+}
diff --git a/src/main/java/christmas/service/order/OrderService.java b/src/main/java/christmas/service/order/OrderService.java
new file mode 100644
index 0000000..b94d397
--- /dev/null
+++ b/src/main/java/christmas/service/order/OrderService.java
@@ -0,0 +1,50 @@
+package christmas.service.order;
+
+import christmas.domain.order.Order;
+import christmas.domain.order.constant.Menu;
+import christmas.response.EventDetailResponse;
+import christmas.response.MenuCountResponse;
+import christmas.response.OrderResponse;
+import christmas.response.OrderSummaryResponse;
+import christmas.service.event.EventDetailService;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+
+public class OrderService {
+
+    private final EventDetailService eventDetailService;
+
+    public OrderService(final EventDetailService eventDetailService) {
+        this.eventDetailService = eventDetailService;
+    }
+
+    public OrderSummaryResponse createOrderSummary(final Order order) {
+        eventDetailService.applyEvent(order);
+
+        final OrderResponse orderResponse = createOrderResponse(order);
+        final EventDetailResponse eventDetailResponse = createEventDetailResponse(order);
+
+        return OrderSummaryResponse.of(orderResponse, eventDetailResponse);
+    }
+
+    private OrderResponse createOrderResponse(final Order order) {
+        return OrderResponse.of(order.getDayInt(), convertMenuCounts(order.getMenuCount()));
+    }
+
+    private List<MenuCountResponse> convertMenuCounts(final Map<Menu, Integer> menuCount) {
+        return menuCount.entrySet().stream()
+                .map(this::createMenuCountResponse)
+                .toList();
+    }
+
+    private MenuCountResponse createMenuCountResponse(final Entry<Menu, Integer> entry) {
+        return MenuCountResponse.of(entry.getKey().getTitle(), entry.getValue());
+    }
+
+    private EventDetailResponse createEventDetailResponse(final Order order) {
+        final int priceBeforeDiscount = order.calculateTotalPrice();
+
+        return eventDetailService.getEventDetail(priceBeforeDiscount);
+    }
+}
diff --git a/src/main/java/christmas/view/InputView.java b/src/main/java/christmas/view/InputView.java
new file mode 100644
index 0000000..cab8b89
--- /dev/null
+++ b/src/main/java/christmas/view/InputView.java
@@ -0,0 +1,41 @@
+package christmas.view;
+
+import christmas.view.io.Reader;
+import christmas.view.io.Writer;
+
+public class InputView {
+
+    private final Reader reader;
+    private final Writer writer;
+
+    public InputView(final Reader reader, final Writer writer) {
+        this.reader = reader;
+        this.writer = writer;
+    }
+
+    public String readDate() {
+        writer.println(Request.VISIT_DAY.value);
+
+        return reader.readLine();
+    }
+
+    public String readMenuAndCount() {
+        writer.println(Request.MENU_AND_COUNT.value);
+
+        return reader.readLine();
+    }
+
+    public void close() {
+        reader.close();
+    }
+
+    private enum Request {
+        VISIT_DAY("12월 중 식당 예상 방문 날짜는 언제인가요? (숫자만 입력해 주세요!)"),
+        MENU_AND_COUNT("주문하실 메뉴를 메뉴와 개수를 알려 주세요. (e.g. 해산물파스타-2,레드와인-1,초코케이크-1)");
+        private final String value;
+
+        Request(final String value) {
+            this.value = value;
+        }
+    }
+}
diff --git a/src/main/java/christmas/view/OutputView.java b/src/main/java/christmas/view/OutputView.java
new file mode 100644
index 0000000..2f4c0b6
--- /dev/null
+++ b/src/main/java/christmas/view/OutputView.java
@@ -0,0 +1,169 @@
+package christmas.view;
+
+import static java.lang.System.lineSeparator;
+
+import christmas.response.EventDetailResponse;
+import christmas.response.EventResponse;
+import christmas.response.GiftMenuResponse;
+import christmas.response.MenuCountResponse;
+import christmas.response.OrderResponse;
+import christmas.response.OrderSummaryResponse;
+import christmas.view.io.Writer;
+import java.util.List;
+
+public class OutputView {
+
+    private static final int ZERO = 0;
+    private final Writer writer;
+
+    public OutputView(final Writer writer) {
+        this.writer = writer;
+    }
+
+    public void printHello() {
+        writer.println(Response.HELLO.value);
+    }
+
+    public void printError(final String message) {
+        writer.println(message);
+    }
+
+    public void printOrderSummary(final OrderSummaryResponse orderSummaryResponse) {
+        printOrder(orderSummaryResponse.orderResponse());
+        printDiscountDetail(orderSummaryResponse.eventDetailResponse());
+    }
+
+    private void printOrder(final OrderResponse orderResponse) {
+        printPreViewHeader(orderResponse.day());
+        printMenuCountAll(orderResponse.menuCount());
+    }
+
+    private void printDiscountDetail(final EventDetailResponse eventDetailResponse) {
+        printPriceBeforeEvent(eventDetailResponse.priceBeforeEvent());
+        printGiftCountAll(eventDetailResponse.giftMenuResponses());
+        printActiveEventAll(eventDetailResponse.activeEvents());
+        printTotalBenefitsAmount(eventDetailResponse.totalBenefitsAmount());
+        printPriceAfterEvent(eventDetailResponse.priceAfterEvent());
+        printBadge(eventDetailResponse.badge());
+    }
+
+    private void printPreViewHeader(final int day) {
+        writer.printf(Response.PREVIEW_EVENT.value + Response.ENTER.value, day);
+    }
+
+    private void printMenuCountAll(final List<MenuCountResponse> menuCountResponses) {
+        writer.println(Header.MENU.getValueWithEnter());
+
+        menuCountResponses.forEach(this::printMenuCount);
+    }
+
+    private void printMenuCount(final MenuCountResponse menuCountResponse) {
+        writer.printf(Response.MENU_COUNT.value + Response.ENTER.value,
+                menuCountResponse.title(), menuCountResponse.count());
+    }
+
+    private void printPriceBeforeEvent(final int totalPrice) {
+        writer.println(Header.BEFORE_TOTAL_PRICE.getValueWithEnter());
+        writer.printf(Response.POSITIVE_MONEY.value + Response.ENTER.value, totalPrice);
+    }
+
+    private void printGiftCountAll(final List<GiftMenuResponse> giftMenus) {
+        writer.println(Header.GIFT.getValueWithEnter());
+
+        if (giftMenus.isEmpty()) {
+            printNone();
+            return;
+        }
+
+        giftMenus.forEach(this::printGiftCount);
+    }
+
+    private void printGiftCount(final GiftMenuResponse giftMenu) {
+        writer.printf(Response.MENU_COUNT.value + Response.ENTER.value,
+                giftMenu.title(), giftMenu.count());
+    }
+
+    private void printActiveEventAll(final List<EventResponse> discounts) {
+        writer.println(Header.DISCOUNT.getValueWithEnter());
+
+        if (discounts.isEmpty()) {
+            printNone();
+            return;
+        }
+
+        discounts.forEach(this::printActiveEvent);
+    }
+
+    private void printActiveEvent(final EventResponse discount) {
+        writer.printf(Response.DISCOUNT_RESULT.value + Response.ENTER.value,
+                discount.title(), discount.amount());
+    }
+
+    private void printTotalBenefitsAmount(final int totalDiscountAmount) {
+        writer.println(Header.TOTAL_DISCOUNT.getValueWithEnter());
+
+        if (totalDiscountAmount == ZERO) {
+            writer.printf(Response.POSITIVE_MONEY.value + Response.ENTER.value, totalDiscountAmount);
+            return;
+        }
+
+        writer.printf(Response.NEGATIVE_MONEY.value + Response.ENTER.value, totalDiscountAmount);
+    }
+
+    private void printPriceAfterEvent(final int afterDiscountPayment) {
+        writer.println(Header.AFTER_PAYMENT.getValueWithEnter());
+        writer.printf(Response.POSITIVE_MONEY.value + Response.ENTER.value, afterDiscountPayment);
+    }
+
+    private void printBadge(final String badge) {
+        writer.println(Header.BADGE.getValueWithEnter());
+
+        if (badge.isBlank()) {
+            printNone();
+            return;
+        }
+
+        writer.println(badge);
+    }
+
+    private void printNone() {
+        writer.println(Response.NONE.value);
+    }
+
+    private enum Response {
+        HELLO("안녕하세요! 우테코 식당 12월 이벤트 플래너입니다."),
+        PREVIEW_EVENT("12월 %d일에 우테코 식당에서 받을 이벤트 혜택 미리 보기!"),
+        MENU_COUNT("%s %d개"),
+        DISCOUNT_RESULT("%s: -%,d원"),
+        POSITIVE_MONEY("%,d원"),
+        NEGATIVE_MONEY("-%,d원"),
+        NONE("없음"),
+        ENTER(lineSeparator());
+
+        private final String value;
+
+        Response(final String value) {
+            this.value = value;
+        }
+    }
+
+    private enum Header {
+        MENU("<주문 메뉴>"),
+        BEFORE_TOTAL_PRICE("<할인 전 총주문 금액>"),
+        GIFT("<증정 메뉴>"),
+        DISCOUNT("<혜택 내역>"),
+        TOTAL_DISCOUNT("<총혜택 금액>"),
+        AFTER_PAYMENT("<할인 후 예상 결제 금액>"),
+        BADGE("<12월 이벤트 배지>");
+
+        private final String value;
+
+        Header(final String value) {
+            this.value = value;
+        }
+
+        public String getValueWithEnter() {
+            return Response.ENTER.value + value;
+        }
+    }
+}
diff --git a/src/main/java/christmas/view/io/ConsoleReader.java b/src/main/java/christmas/view/io/ConsoleReader.java
new file mode 100644
index 0000000..4e1c528
--- /dev/null
+++ b/src/main/java/christmas/view/io/ConsoleReader.java
@@ -0,0 +1,16 @@
+package christmas.view.io;
+
+import camp.nextstep.edu.missionutils.Console;
+
+public class ConsoleReader implements Reader {
+
+    @Override
+    public String readLine() {
+        return Console.readLine();
+    }
+
+    @Override
+    public void close() {
+        Console.close();
+    }
+}
diff --git a/src/main/java/christmas/view/io/ConsoleWriter.java b/src/main/java/christmas/view/io/ConsoleWriter.java
new file mode 100644
index 0000000..c9aeefb
--- /dev/null
+++ b/src/main/java/christmas/view/io/ConsoleWriter.java
@@ -0,0 +1,14 @@
+package christmas.view.io;
+
+public class ConsoleWriter implements Writer {
+
+    @Override
+    public void println(final String input) {
+        System.out.println(input);
+    }
+
+    @Override
+    public void printf(final String format, final Object... args) {
+        System.out.printf(format, args);
+    }
+}
diff --git a/src/main/java/christmas/view/io/Reader.java b/src/main/java/christmas/view/io/Reader.java
new file mode 100644
index 0000000..00e3b58
--- /dev/null
+++ b/src/main/java/christmas/view/io/Reader.java
@@ -0,0 +1,9 @@
+package christmas.view.io;
+
+
+public interface Reader {
+
+    String readLine();
+
+    void close();
+}
diff --git a/src/main/java/christmas/view/io/Writer.java b/src/main/java/christmas/view/io/Writer.java
new file mode 100644
index 0000000..f909409
--- /dev/null
+++ b/src/main/java/christmas/view/io/Writer.java
@@ -0,0 +1,8 @@
+package christmas.view.io;
+
+public interface Writer {
+
+    void println(final String input);
+
+    void printf(final String format, final Object... args);
+}
diff --git a/src/test/java/christmas/ApplicationTest.java b/src/test/java/christmas/ApplicationTest.java
index 514a99e..ff23bde 100644
--- a/src/test/java/christmas/ApplicationTest.java
+++ b/src/test/java/christmas/ApplicationTest.java
@@ -7,6 +7,7 @@
 import org.junit.jupiter.api.Test;
 
 class ApplicationTest extends NsTest {
+
     private static final String LINE_SEPARATOR = System.lineSeparator();
 
     @Test
@@ -14,13 +15,13 @@ class ApplicationTest extends NsTest {
         assertSimpleTest(() -> {
             run("3", "티본스테이크-1,바비큐립-1,초코케이크-2,제로콜라-1");
             assertThat(output()).contains(
-                "<주문 메뉴>",
-                "<할인 전 총주문 금액>",
-                "<증정 메뉴>",
-                "<혜택 내역>",
-                "<총혜택 금액>",
-                "<할인 후 예상 결제 금액>",
-                "<12월 이벤트 배지>"
+                    "<주문 메뉴>",
+                    "<할인 전 총주문 금액>",
+                    "<증정 메뉴>",
+                    "<혜택 내역>",
+                    "<총혜택 금액>",
+                    "<할인 후 예상 결제 금액>",
+                    "<12월 이벤트 배지>"
             );
         });
     }
diff --git a/src/test/java/christmas/controller/OrderControllerTest.java b/src/test/java/christmas/controller/OrderControllerTest.java
new file mode 100644
index 0000000..6ef67c9
--- /dev/null
+++ b/src/test/java/christmas/controller/OrderControllerTest.java
@@ -0,0 +1,92 @@
+package christmas.controller;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import christmas.domain.event.discount.DiscountRepository;
+import christmas.domain.event.gift.GiftRepository;
+import christmas.service.event.DiscountService;
+import christmas.service.event.EventDetailService;
+import christmas.service.event.GiftService;
+import christmas.service.order.OrderService;
+import christmas.view.InputView;
+import christmas.view.OutputView;
+import christmas.view.io.Reader;
+import christmas.view.TestWriter;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+@DisplayName("주문 컨트롤러는")
+class OrderControllerTest {
+
+    OrderController orderController;
+    TestWriter writer;
+    TestQueueReader reader;
+
+    @BeforeEach
+    void setUp() {
+        writer = new TestWriter();
+        reader = new TestQueueReader();
+
+        InputView inputView = new InputView(reader, writer);
+        OutputView outputView = new OutputView(writer);
+        DiscountService discountService = new DiscountService(new DiscountRepository());
+        GiftService giftService = new GiftService(new GiftRepository());
+        EventDetailService eventDetailService = new EventDetailService(discountService, giftService);
+        OrderService orderService = new OrderService(eventDetailService);
+
+        orderController = new OrderController(inputView, outputView, orderService);
+    }
+
+    @DisplayName("정상적인 날짜가 입력될 때까지 재입력 받는다.")
+    @Test
+    void createDay() {
+        // given
+        reader.add("A", "01", "32", "-1", "12일", "12월1일", "", " 1", "25");
+        reader.add("해산물파스타-2,레드와인-1");
+
+        // when
+        orderController.run();
+
+        // then
+        assertThat(writer.getString())
+                .contains("12월 25일에 우테코 식당에서 받을 이벤트 혜택 미리 보기!");
+    }
+
+    @DisplayName("정상적인 메뉴가 입력될 때까지 재입력 받는다.")
+    @Test
+    void createMenuCount() {
+        // given
+        reader.add("25");
+        reader.add("티마스-2", "해산물파스타-2,,", "제로콜라-1", "해산물파스타-A", "해토파스칼-2,레드와인-1", "해산물파스타-2,레드와인-1");
+
+        // when
+        orderController.run();
+
+        // then
+        assertThat(writer.getString())
+                .contains("<주문 메뉴>\n해산물파스타 2개\n레드와인 1개");
+    }
+
+    static class TestQueueReader implements Reader {
+
+        private static final Queue<String> queue = new LinkedList<>();
+
+        public void add(String... args) {
+            queue.addAll(List.of(args));
+        }
+
+        @Override
+        public String readLine() {
+            return queue.poll();
+        }
+
+        @Override
+        public void close() {
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/src/test/java/christmas/controller/converter/OrderConverterTest.java b/src/test/java/christmas/controller/converter/OrderConverterTest.java
new file mode 100644
index 0000000..65c28e1
--- /dev/null
+++ b/src/test/java/christmas/controller/converter/OrderConverterTest.java
@@ -0,0 +1,139 @@
+package christmas.controller.converter;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.jupiter.params.provider.Arguments.arguments;
+
+import christmas.domain.order.Day;
+import christmas.domain.order.constant.Menu;
+import java.util.EnumMap;
+import java.util.Map;
+import java.util.stream.Stream;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.junit.jupiter.params.provider.ValueSource;
+
+@DisplayName("주문 변환기는")
+class OrderConverterTest {
+
+    @Nested
+    @DisplayName("날짜로 변환할 때")
+    class ConvertToDay {
+
+        @DisplayName("문자를 Day로 변환할 수 있다.")
+        @ParameterizedTest
+        @ValueSource(strings = {"1", "2", "3", "4", "10", "14", "19", "25", "29", "30", "31"})
+        void convertToDay(String input) {
+            // when
+            Day day = OrderConverter.convertToDay(input);
+
+            // then
+            assertThat(day).isEqualTo(Day.from(Integer.parseInt(input)));
+        }
+
+        @DisplayName("문자가 정수가 아니면 예외처리된다.")
+        @ParameterizedTest
+        @ValueSource(strings = {"1.0", "가", ",", "-", "abd", "1 1", " ", "/"})
+        void convertToDayNotInteger(String input) {
+            assertThatThrownBy(() -> OrderConverter.convertToDay(input))
+                    .isInstanceOf(IllegalArgumentException.class)
+                    .hasMessage("[ERROR] 유효하지 않은 날짜입니다. 다시 입력해 주세요.");
+        }
+
+        @DisplayName("문자가 정수이어도 0으로 시작하면 예외처리된다.")
+        @ParameterizedTest
+        @ValueSource(strings = {"01", "031", "0"})
+        void convertToDayZero(String input) {
+            assertThatThrownBy(() -> OrderConverter.convertToDay(input))
+                    .isInstanceOf(IllegalArgumentException.class)
+                    .hasMessage("[ERROR] 유효하지 않은 날짜입니다. 다시 입력해 주세요.");
+        }
+
+        @DisplayName("문자가 12월에 없으면 예외 처리된다.")
+        @ParameterizedTest
+        @ValueSource(strings = {"0", "32", "-1", "33"})
+        void convertToDayNotDecember(String input) {
+            assertThatThrownBy(() -> OrderConverter.convertToDay(input))
+                    .isInstanceOf(IllegalArgumentException.class)
+                    .hasMessage("[ERROR] 유효하지 않은 날짜입니다. 다시 입력해 주세요.");
+        }
+    }
+
+
+    @Nested
+    @DisplayName("메뉴 수량으로 변환할 때")
+    class ConvertMenu {
+
+        @DisplayName("문자를 MenuEnumMap으로 변환할 수 있다.")
+        @ParameterizedTest
+        @MethodSource("menuCountProvider")
+        void convertToMenu(String menuCount, Map<Menu, Integer> target) {
+            // when
+            EnumMap<Menu, Integer> convert = OrderConverter.convertToMenu(menuCount);
+
+            // then
+            assertThat(convert).containsExactlyInAnyOrderEntriesOf(target);
+        }
+
+        static Stream<Arguments> menuCountProvider() {
+            return Stream.of(
+                    arguments("티본스테이크-1,초코케이크-2",
+                            Map.of(Menu.T_BONE_STEAK, 1, Menu.CHOCOLATE_CAKE, 2)),
+                    arguments("티본스테이크-1",
+                            Map.of(Menu.T_BONE_STEAK, 1)),
+                    arguments("티본스테이크-1,초코케이크-19",
+                            Map.of(Menu.T_BONE_STEAK, 1, Menu.CHOCOLATE_CAKE, 19)),
+                    arguments("티본스테이크-1,초코케이크-2,아이스크림-1",
+                            Map.of(Menu.T_BONE_STEAK, 1, Menu.CHOCOLATE_CAKE, 2, Menu.ICE_CREAM, 1))
+            );
+        }
+
+        @DisplayName("중복된 메뉴가 있을 경우 예외가 발생한다.")
+        @Test
+        void throwingDuplicateOrderException() {
+            // given
+            String menuCount = "티본스테이크-1,초코케이크-2,티본스테이크-3";
+
+            assertThatThrownBy(() -> OrderConverter.convertToMenu(menuCount))
+                    .isInstanceOf(IllegalArgumentException.class)
+                    .hasMessage("[ERROR] 유효하지 않은 주문입니다. 다시 입력해 주세요.");
+        }
+
+        @DisplayName("입력 메뉴의 수가 숫자가 아닐 경우 예외가 발생한다.")
+        @Test
+        void convertCountToInt() {
+            // given
+            String menuCount = "티본스테이크-A";
+
+            assertThatThrownBy(() -> OrderConverter.convertToMenu(menuCount))
+                    .isInstanceOf(IllegalArgumentException.class)
+                    .hasMessage("[ERROR] 유효하지 않은 주문입니다. 다시 입력해 주세요.");
+        }
+
+        @DisplayName("입력 메뉴의 수가 0으로 시작하면 예외가 발생한다.")
+        @Test
+        void convertCountToIntZero() {
+            // given
+            String menuCount = "티본스테이크-01";
+
+            assertThatThrownBy(() -> OrderConverter.convertToMenu(menuCount))
+                    .isInstanceOf(IllegalArgumentException.class)
+                    .hasMessage("[ERROR] 유효하지 않은 주문입니다. 다시 입력해 주세요.");
+        }
+
+        @DisplayName("입력 메뉴가 형식에 맞지 않을 경우 예외가 발생한다.")
+        @ParameterizedTest
+        @ValueSource(strings = {"티본스테이크-1,초코케이크-2,", ",티본스테이크-1,초코케이크-2", "티본스테이크-1,,초코케이크-2",
+                "티본스테이크-1-3,초코케이크-2", "티본스테이크--1,초코케이크-2"})
+        void validateFormat(String menuCount) {
+            assertThatThrownBy(() -> OrderConverter.convertToMenu(menuCount))
+                    .isInstanceOf(IllegalArgumentException.class)
+                    .hasMessage("[ERROR] 유효하지 않은 주문입니다. 다시 입력해 주세요.");
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/src/test/java/christmas/domain/event/BadgeTest.java b/src/test/java/christmas/domain/event/BadgeTest.java
new file mode 100644
index 0000000..6d3ea4b
--- /dev/null
+++ b/src/test/java/christmas/domain/event/BadgeTest.java
@@ -0,0 +1,56 @@
+package christmas.domain.event;
+
+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.ValueSource;
+
+@DisplayName("배지는 ")
+class BadgeTest {
+
+    @DisplayName("혜택금액이 20000원 이상이면 산타등급이다.")
+    @ParameterizedTest
+    @ValueSource(ints = {20000, 30000, 100000})
+    void santa(int discount) {
+        // given // when
+        Badge badge = Badge.from(discount);
+
+        // then
+        assertThat(badge).isEqualByComparingTo(Badge.SANTA);
+    }
+
+    @DisplayName("혜택금액이 20000원 미만 10000원 이상이면 트리등급이다.")
+    @ParameterizedTest
+    @ValueSource(ints = {10000, 15000, 19999})
+    void tree(int discount) {
+        // given // when
+        Badge badge = Badge.from(discount);
+
+        // then
+        assertThat(badge).isEqualByComparingTo(Badge.TREE);
+    }
+
+    @DisplayName("혜택금액이 10000원 미만 5000원 이상이면 별등급이다.")
+    @ParameterizedTest
+    @ValueSource(ints = {5000, 8000, 9999})
+    void star(int discount) {
+        // given // when
+        Badge badge = Badge.from(discount);
+
+        // then
+        assertThat(badge).isEqualByComparingTo(Badge.STAR);
+    }
+
+    @DisplayName("혜택금액이 5000원 미만이면 등급이 없다.")
+    @ParameterizedTest
+    @ValueSource(ints = {0, 1000, 4999})
+    void none(int discount) {
+        // given // when
+        Badge badge = Badge.from(discount);
+
+        // then
+        assertThat(badge).isEqualByComparingTo(Badge.NONE);
+    }
+
+}
\ No newline at end of file
diff --git a/src/test/java/christmas/domain/event/discount/DiscountEventTypeTest.java b/src/test/java/christmas/domain/event/discount/DiscountEventTypeTest.java
new file mode 100644
index 0000000..260d345
--- /dev/null
+++ b/src/test/java/christmas/domain/event/discount/DiscountEventTypeTest.java
@@ -0,0 +1,298 @@
+package christmas.domain.event.discount;
+
+import static christmas.domain.event.discount.DiscountEventType.CHRISTMAS_D_DAY_DISCOUNT;
+import static christmas.domain.event.discount.DiscountEventType.SPECIAL_DISCOUNT;
+import static christmas.domain.event.discount.DiscountEventType.WEEKDAY_DISCOUNT;
+import static christmas.domain.event.discount.DiscountEventType.WEEKEND_DISCOUNT;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.params.provider.Arguments.arguments;
+
+import christmas.domain.event.Event;
+import christmas.domain.order.Day;
+import christmas.domain.order.Order;
+import christmas.domain.order.constant.Menu;
+import java.util.EnumMap;
+import java.util.Map;
+import java.util.stream.Stream;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.CsvSource;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.junit.jupiter.params.provider.ValueSource;
+
+@DisplayName("할인 이벤트 타입은")
+class DiscountEventTypeTest {
+
+    @Nested
+    @DisplayName("공통 적으로")
+    class Common {
+
+        @DisplayName("할인 정책을 중복 적용할 수 있다.")
+        @Test
+        void discountAll() {
+            // given
+            Order order = Order.of(Day.from(25),
+                    Map.of(Menu.T_BONE_STEAK, 1, Menu.ICE_CREAM, 2, Menu.BUTTON_MUSHROOM_SOUP, 1, Menu.CHRISTMAS_PASTA,
+                            2));
+
+            // when
+            EnumMap<DiscountEventType, Integer> discountEventTypeIntegerEnumMap = Event.applyAll(DiscountEventType.class, order);
+
+            // then
+            assertThat(discountEventTypeIntegerEnumMap)
+                    .containsExactlyInAnyOrderEntriesOf(Map.of(CHRISTMAS_D_DAY_DISCOUNT, 3400,
+                            WEEKDAY_DISCOUNT, 2023 * 2,
+                            WEEKEND_DISCOUNT, 0,
+                            SPECIAL_DISCOUNT, 1000));
+        }
+
+        @DisplayName("어떤 이벤트도 총 주문 금액이 10,000원이 넘지 않으면 할인이 적용되지 않는다.")
+        @ParameterizedTest
+        @MethodSource("eventProvider")
+        void calculateBenefits(DiscountEventType event, int day) {
+            // given
+            Order order = Order.of(Day.from(day), Map.of(Menu.ZERO_COLA, 1,
+                    Menu.ICE_CREAM, 1));
+
+            // when
+            int benefits = event.calculateBenefits(order);
+
+            // then
+            assertThat(benefits).isEqualTo(0);
+        }
+
+        static Stream<Arguments> eventProvider() {
+            return Stream.of(arguments(CHRISTMAS_D_DAY_DISCOUNT, 25),
+                    arguments(WEEKEND_DISCOUNT, 2),
+                    arguments(WEEKDAY_DISCOUNT, 24),
+                    arguments(SPECIAL_DISCOUNT, 25));
+        }
+    }
+
+    @Nested
+    @DisplayName("크리스마스 디데이 할인은")
+    class ChristmasDDayDiscount {
+
+        @DisplayName("날짜에 따른 할인 금액을 계산할 수 있다.")
+        @ParameterizedTest
+        @CsvSource(value = {"1,1000", "2,1100", "3,1200", "24,3300", "25,3400"}, delimiter = ',')
+        void calculateAmount(int day, int discountTarget) {
+            // given
+            Day orderDay = Day.from(day);
+            Order order = Order.of(orderDay, Map.of(Menu.T_BONE_STEAK, 1));
+
+            // when
+            int discountAmount = CHRISTMAS_D_DAY_DISCOUNT.calculateBenefits(order);
+
+            // then
+            assertThat(discountAmount).isEqualTo(discountTarget);
+        }
+
+        @DisplayName("주문 날짜가 25일 이내이면 할인이 적용된다.")
+        @ParameterizedTest
+        @ValueSource(ints = {1, 2, 3, 4, 5, 6, 7, 15, 20, 23, 24, 25})
+        void calculateBenefits(int day) {
+            // given
+            Day orderDay = Day.from(day);
+            Order order = Order.of(orderDay, Map.of(Menu.ICE_CREAM, 10));
+
+            // when
+            int discountAmount = CHRISTMAS_D_DAY_DISCOUNT.calculateBenefits(order);
+
+            // then
+            assertThat(discountAmount).isEqualTo((day - 1) * 100 + 1000);
+        }
+
+        @DisplayName("주문 날짜가 25일을 넘어가면 할인 적용이 안된다.")
+        @ParameterizedTest
+        @ValueSource(ints = {26, 27, 28, 29, 30, 31})
+        void calculateBenefitsOverDay(int day) {
+            // given
+            Day orderDay = Day.from(day);
+            Order order = Order.of(orderDay, Map.of(Menu.ICE_CREAM, 10));
+
+            // when
+            int discountAmount = CHRISTMAS_D_DAY_DISCOUNT.calculateBenefits(order);
+
+            // then
+            assertThat(discountAmount).isEqualTo(0);
+        }
+    }
+
+    @Nested
+    @DisplayName("평일 할인은")
+    class WeekdayDiscount {
+
+        @DisplayName("평일에 디저트 메뉴 1개당 2023원 할인 합계를 계산할 수 있다.")
+        @ParameterizedTest
+        @MethodSource("weekDayMenuProvider")
+        void calculateAmount(Map<Menu, Integer> menuCount, int discountTarget) {
+            // given
+            Day day = Day.from(3);
+            Order order = Order.of(day, menuCount);
+
+            // when
+            int discountAmount = WEEKDAY_DISCOUNT.calculateBenefits(order);
+
+            // then
+            assertThat(discountAmount).isEqualTo(discountTarget);
+
+        }
+
+        static Stream<Arguments> weekDayMenuProvider() {
+            return Stream.of(
+                    arguments(Map.of(Menu.ICE_CREAM, 1, Menu.T_BONE_STEAK, 1), 2023),
+                    arguments(Map.of(Menu.ICE_CREAM, 2), 2023 * 2),
+                    arguments(Map.of(Menu.TAPAS, 1), 0),
+                    arguments(Map.of(Menu.CAESAR_SALAD, 1, Menu.CHOCOLATE_CAKE, 10), 2023 * 10),
+                    arguments(Map.of(Menu.ICE_CREAM, 3, Menu.CHOCOLATE_CAKE, 5), 2023 * 8),
+                    arguments(Map.of(Menu.BUTTON_MUSHROOM_SOUP, 1, Menu.ZERO_COLA, 1), 0)
+            );
+        }
+
+        @DisplayName("평일에 할인이 적용된다.")
+        @ParameterizedTest
+        @ValueSource(ints = {3, 4, 5, 6, 7,
+                10, 11, 12, 13, 14,
+                17, 18, 19, 20, 21,
+                24, 25, 26, 27, 28,
+                31})
+        void calculateAmountWeekend(int day) {
+            // given
+            Day orderDay = Day.from(day);
+            Order order = Order.of(orderDay, Map.of(Menu.ICE_CREAM, 10));
+
+            // when
+            int discountAmount = WEEKDAY_DISCOUNT.calculateBenefits(order);
+
+            // then
+            assertThat(discountAmount).isEqualTo(2023 * 10);
+
+        }
+
+        @DisplayName("주말에 할인 적용이 불가능하다.")
+        @ParameterizedTest
+        @ValueSource(ints = {1, 2, 8, 9, 15, 16, 22, 23, 29, 30})
+        void calculateBenefitsWeekday(int day) {
+            // given
+            Day orderDay = Day.from(day);
+            Order order = Order.of(orderDay, Map.of(Menu.ICE_CREAM, 3));
+
+            // when
+            int discountAmount = WEEKDAY_DISCOUNT.calculateBenefits(order);
+
+            // then
+            assertThat(discountAmount).isEqualTo(0);
+        }
+    }
+
+    @Nested
+    @DisplayName("주말 할인은")
+    class WeekendDiscount {
+
+        @DisplayName("주말에 메인 메뉴 1개당 2023원 할인 합계를 계산할 수 있다.")
+        @ParameterizedTest
+        @MethodSource("weekendMenuProvider")
+        void calculateBenefits(Map<Menu, Integer> menuCount, int discountTarget) {
+            // given
+            Day day = Day.from(1);
+            Order order = Order.of(day, menuCount);
+
+            // when
+            int discountAmount = WEEKEND_DISCOUNT.calculateBenefits(order);
+
+            // then
+            assertThat(discountAmount).isEqualTo(discountTarget);
+
+        }
+
+        static Stream<Arguments> weekendMenuProvider() {
+            return Stream.of(
+                    arguments(Map.of(Menu.BARBECUE_RIBS, 1), 2023),
+                    arguments(Map.of(Menu.T_BONE_STEAK, 2), 2023 * 2),
+                    arguments(Map.of(Menu.ICE_CREAM, 1), 0),
+                    arguments(Map.of(Menu.ICE_CREAM, 1, Menu.BARBECUE_RIBS, 10), 2023 * 10),
+                    arguments(Map.of(Menu.BARBECUE_RIBS, 3, Menu.T_BONE_STEAK, 5), 2023 * 8),
+                    arguments(Map.of(Menu.BUTTON_MUSHROOM_SOUP, 1, Menu.ZERO_COLA, 1), 0)
+            );
+        }
+
+        @DisplayName("평일에 할인이 적용되지 않는다.")
+        @ParameterizedTest
+        @ValueSource(ints = {3, 4, 5, 6, 7,
+                10, 11, 12, 13, 14,
+                17, 18, 19, 20, 21,
+                24, 25, 26, 27, 28,
+                31})
+        void weekendInWeekday(int day) {
+            // given
+            Day orderDay = Day.from(day);
+            Order order = Order.of(orderDay, Map.of(Menu.T_BONE_STEAK, 10));
+
+            // when
+            int discountAmount = WEEKEND_DISCOUNT.calculateBenefits(order);
+
+            // then
+            assertThat(discountAmount).isEqualTo(0);
+
+        }
+
+        @DisplayName("주말에 할인 적용된다.")
+        @ParameterizedTest
+        @ValueSource(ints = {1, 2, 8, 9, 15, 16, 22, 23, 29, 30})
+        void weekendInWeekend(int day) {
+            // given
+            Day orderDay = Day.from(day);
+            Order order = Order.of(orderDay, Map.of(Menu.T_BONE_STEAK, 10));
+
+            // when
+            int discountAmount = WEEKEND_DISCOUNT.calculateBenefits(order);
+
+            // then
+            assertThat(discountAmount).isEqualTo(2023 * 10);
+        }
+    }
+
+    @Nested
+    @DisplayName("스페셜 할인은")
+    class SpecialDiscount {
+
+        @DisplayName("별이 있는 달에 1000원 할인된다.")
+        @ParameterizedTest
+        @ValueSource(ints = {3, 10, 17, 24, 25, 31})
+        void calculateBenefitsAtStarDay(int day) {
+            // given
+            Day orderDay = Day.from(day);
+            Order order = Order.of(orderDay, Map.of(Menu.T_BONE_STEAK, 1));
+
+            // when
+            int discount = SPECIAL_DISCOUNT.calculateBenefits(order);
+
+            // then
+            assertThat(discount).isEqualTo(1000);
+        }
+
+        @DisplayName("별이 없는 달에 할인 불가하다.")
+        @ParameterizedTest
+        @ValueSource(ints = {1, 2,
+                4, 5, 6, 7, 8, 9,
+                11, 12, 13, 14, 15, 16,
+                18, 19, 20, 21, 22, 23,
+                26, 27, 28, 29, 30})
+        void calculateBenefitsAtNonStarDay(int day) {
+            // given
+            Day orderDay = Day.from(day);
+            Order order = Order.of(orderDay, Map.of(Menu.T_BONE_STEAK, 1));
+
+            // when
+            int discount = SPECIAL_DISCOUNT.calculateBenefits(order);
+
+            // then
+            assertThat(discount).isEqualTo(0);
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/src/test/java/christmas/domain/event/discount/DiscountRepositoryTest.java b/src/test/java/christmas/domain/event/discount/DiscountRepositoryTest.java
new file mode 100644
index 0000000..9ac9c46
--- /dev/null
+++ b/src/test/java/christmas/domain/event/discount/DiscountRepositoryTest.java
@@ -0,0 +1,53 @@
+package christmas.domain.event.discount;
+
+import static christmas.domain.event.discount.DiscountEventType.CHRISTMAS_D_DAY_DISCOUNT;
+import static christmas.domain.event.discount.DiscountEventType.SPECIAL_DISCOUNT;
+import static christmas.domain.event.discount.DiscountEventType.WEEKDAY_DISCOUNT;
+import static christmas.domain.event.discount.DiscountEventType.WEEKEND_DISCOUNT;
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.EnumMap;
+import java.util.Map;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+@DisplayName("할인 저장소는")
+class DiscountRepositoryTest {
+
+    DiscountRepository discountRepository = new DiscountRepository();
+
+    @BeforeEach
+    void setUp() {
+        EnumMap<DiscountEventType, Integer> discountCounts = new EnumMap<>(DiscountEventType.class);
+        discountCounts.put(SPECIAL_DISCOUNT, 1_000);
+        discountCounts.put(CHRISTMAS_D_DAY_DISCOUNT, 2_400);
+        discountCounts.put(WEEKDAY_DISCOUNT, 2_023);
+        discountCounts.put(WEEKEND_DISCOUNT, 0);
+
+        discountRepository.init(discountCounts);
+    }
+
+    @DisplayName("전체 할인 금액을 계산할 수 있다.")
+    @Test
+    void calculateTotal() {
+        // given // when
+        int totalDiscount = discountRepository.calculateTotal();
+
+        // then
+        assertThat(totalDiscount).isEqualTo(1000 + 2400 + 2023);
+    }
+
+    @DisplayName("적용된 할인목록을 구할 수 있다.")
+    @Test
+    void getActiveResult() {
+        // given // when
+        Map<String, Integer> activeResult = discountRepository.getActiveResult();
+
+        // then
+        assertThat(activeResult)
+                .containsExactlyInAnyOrderEntriesOf(Map.of("특별 할인", 1_000,
+                        "크리스마스 디데이 할인", 2_400,
+                        "평일 할인", 2_023));
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/christmas/domain/event/gift/GiftEventTypeTest.java b/src/test/java/christmas/domain/event/gift/GiftEventTypeTest.java
new file mode 100644
index 0000000..6ba6133
--- /dev/null
+++ b/src/test/java/christmas/domain/event/gift/GiftEventTypeTest.java
@@ -0,0 +1,104 @@
+package christmas.domain.event.gift;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import christmas.domain.event.Event;
+import christmas.domain.order.Day;
+import christmas.domain.order.Order;
+import christmas.domain.order.constant.Menu;
+import java.util.EnumMap;
+import java.util.Map;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+@DisplayName("선물 이벤트 타입은")
+class GiftEventTypeTest {
+
+    @Nested
+    @DisplayName("공통적으로")
+    class Common {
+
+        @DisplayName("할인 정책을 중복 적용할 수 있다.")
+        @Test
+        void discountAll() {
+            // given
+            Order order = Order.of(Day.from(25),
+                    Map.of(Menu.T_BONE_STEAK, 2, Menu.ICE_CREAM, 2, Menu.BUTTON_MUSHROOM_SOUP, 1, Menu.CHRISTMAS_PASTA,
+                            2));
+
+            // when
+            EnumMap<GiftEventType, Integer> giftEventTypeResult = Event.applyAll(GiftEventType.class, order);
+
+            // then
+            assertThat(giftEventTypeResult)
+                    .containsExactlyInAnyOrderEntriesOf(Map.of(GiftEventType.PRESENTATION, 25000));
+        }
+
+        @DisplayName("혜택 금액을 계산 할 수 있다.")
+        @Test
+        void calculateBenefits() {
+            // given
+            Order order = Order.of(Day.from(1), Map.of(Menu.T_BONE_STEAK, 3));
+
+            // when
+            int benefits = GiftEventType.PRESENTATION.calculateBenefits(order);
+
+            // then
+            assertThat(benefits).isEqualTo(25_000);
+        }
+
+        @DisplayName("메뉴이름을 알 수 있다.")
+        @Test
+        void getMenuTitle() {
+            // given // when
+            String menuTitle = GiftEventType.PRESENTATION.getMenuTitle();
+
+            // then
+            assertThat(menuTitle).isEqualTo("샴페인");
+        }
+
+        @DisplayName("메뉴의 수량을 알 수 있다.")
+        @Test
+        void getCount() {
+            // given // when
+            int count = GiftEventType.PRESENTATION.getCount();
+
+            // then
+            assertThat(count).isEqualTo(1);
+        }
+    }
+
+    @Nested
+    @DisplayName("증정 이벤트는")
+    class PresentationEvent {
+
+        @DisplayName("할인 전 주문금액이 120,000이상일 때 적용된다.")
+        @Test
+        void calculateBenefitsTrue() {
+            // given
+            Order order = Order.of(Day.from(1), Map.of(Menu.T_BONE_STEAK, 3));
+
+            // when
+            int benefits = GiftEventType.PRESENTATION.calculateBenefits(order);
+
+            // then
+            assertThat(benefits).isEqualTo(25_000);
+        }
+
+        @DisplayName("할인 전 주문금액이 120,000이하면 적용되지 않는다.")
+        @Test
+        void calculateBenefitsFalse() {
+            // given
+            Order order = Order.of(Day.from(1), Map.of(Menu.T_BONE_STEAK, 2));
+
+            // when
+            int benefits = GiftEventType.PRESENTATION.calculateBenefits(order);
+
+            // then
+            assertThat(benefits).isEqualTo(0);
+        }
+    }
+
+
+}
\ No newline at end of file
diff --git a/src/test/java/christmas/domain/event/gift/GiftRepositoryTest.java b/src/test/java/christmas/domain/event/gift/GiftRepositoryTest.java
new file mode 100644
index 0000000..05b7f41
--- /dev/null
+++ b/src/test/java/christmas/domain/event/gift/GiftRepositoryTest.java
@@ -0,0 +1,56 @@
+package christmas.domain.event.gift;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.EnumMap;
+import java.util.Map;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+@DisplayName("선물 저장소는")
+class GiftRepositoryTest {
+
+    GiftRepository giftRepository = new GiftRepository();
+
+    @BeforeEach
+    void setUp() {
+        EnumMap<GiftEventType, Integer> giftCounts = new EnumMap<>(GiftEventType.class);
+        giftCounts.put(GiftEventType.PRESENTATION, 25_000);
+
+        giftRepository.init(giftCounts);
+    }
+
+    @DisplayName("전체 할인 금액을 계산할 수 있다.")
+    @Test
+    void calculateTotal() {
+        // given // when
+        int totalDiscount = giftRepository.calculateTotal();
+
+        // then
+        assertThat(totalDiscount).isEqualTo(25_000);
+    }
+
+    @DisplayName("적용된 할인 목록을 구할 수 있다.")
+    @Test
+    void getActiveResult() {
+        // given // when
+        Map<String, Integer> activeResult = giftRepository.getActiveResult();
+
+        // then
+        assertThat(activeResult)
+                .containsExactlyInAnyOrderEntriesOf(Map.of("증정 이벤트", 25_000));
+    }
+
+
+    @DisplayName("적용된 증정 메뉴의 이름과 수량을 알 수 있다.")
+    @Test
+    void getActiveMenuCounts() {
+        // given // when
+        Map<String, Integer> activeMenuCounts = giftRepository.getActiveMenuCounts();
+
+        // then
+        assertThat(activeMenuCounts)
+                .containsExactlyInAnyOrderEntriesOf(Map.of("샴페인", 1));
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/christmas/domain/order/DayTest.java b/src/test/java/christmas/domain/order/DayTest.java
new file mode 100644
index 0000000..cc2f698
--- /dev/null
+++ b/src/test/java/christmas/domain/order/DayTest.java
@@ -0,0 +1,316 @@
+package christmas.domain.order;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.jupiter.params.provider.Arguments.arguments;
+
+import christmas.domain.order.constant.Category;
+import java.util.stream.Stream;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.CsvSource;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.junit.jupiter.params.provider.ValueSource;
+
+@DisplayName("날짜는")
+class DayTest {
+
+    @Nested
+    @DisplayName("입력 범위가 1~31일 때만 생성된다.")
+    class Create {
+
+        @DisplayName("정상 생성된다.")
+        @ParameterizedTest
+        @ValueSource(ints = {1, 2, 10, 20, 30, 31})
+        void from(int day) {
+            // given // when
+            Day from = Day.from(day);
+
+            // then
+            assertThat(from)
+                    .extracting("day")
+                    .isEqualTo(day);
+        }
+
+        @DisplayName("예외가 나온다.")
+        @ParameterizedTest
+        @ValueSource(ints = {-1, -2, -3, 0, 32, 33, 34})
+        void fromOutOfRange(int day) {
+            assertThatThrownBy(() -> Day.from(day))
+                    .isInstanceOf(IllegalArgumentException.class)
+                    .hasMessage("[ERROR] 유효하지 않은 날짜입니다. 다시 입력해 주세요.");
+        }
+    }
+
+    @DisplayName("날짜 차이를 계산할 수 있다.")
+    @Test
+    void gap() {
+        // given
+        Day day1 = Day.from(1);
+        Day day2 = Day.from(10);
+
+        // when
+        int gap = day2.gap(day1);
+
+        // then
+        assertThat(gap).isEqualTo(9);
+    }
+
+    @DisplayName("날짜의 나머지를 반환할 수 있다.")
+    @ParameterizedTest
+    @ValueSource(ints = {1, 2, 3, 4, 5, 6, 7, 10, 20, 23, 30, 31})
+    void mod(int day) {
+        // given
+        Day orderDay = Day.from(day);
+
+        // when
+        Integer mod = orderDay.mod(7);
+
+        // then
+        assertThat(mod).isEqualTo(day % 7);
+    }
+
+    @DisplayName("주문 일자의 이벤트 메뉴 카테고리를 찾을 수 있다.")
+    @ParameterizedTest
+    @MethodSource("eventCategoryProvider")
+    void checkEventCategory(int input, Category target) {
+        // given
+        Day day = Day.from(input);
+
+        // when
+        Category category = day.getTodayEventCategory();
+
+        // then
+        assertThat(category).isEqualByComparingTo(target);
+    }
+
+    static Stream<Arguments> eventCategoryProvider() {
+        return Stream.of(
+                arguments(1, Category.MAIN),
+                arguments(2, Category.MAIN),
+                arguments(8, Category.MAIN),
+                arguments(23, Category.MAIN),
+                arguments(29, Category.MAIN),
+                arguments(30, Category.MAIN),
+                arguments(3, Category.DESSERT),
+                arguments(4, Category.DESSERT),
+                arguments(5, Category.DESSERT),
+                arguments(10, Category.DESSERT),
+                arguments(21, Category.DESSERT),
+                arguments(25, Category.DESSERT),
+                arguments(28, Category.DESSERT),
+                arguments(31, Category.DESSERT)
+        );
+    }
+
+    @Nested
+    @DisplayName("다른 날짜보다 큰지 판별 할 수 있다.")
+    class IsOverThan {
+
+        @DisplayName("True")
+        @ParameterizedTest
+        @CsvSource(value = {"1,2", "1,31", "2,10", "24,25", "30,31"}, delimiter = ',')
+        void isOverThanTrue(int left, int right) {
+            // given
+            Day leftDay = Day.from(left);
+            Day rightDay = Day.from(right);
+
+            // when
+            boolean over = rightDay.isOverThan(leftDay);
+
+            // then
+            assertThat(over).isTrue();
+        }
+
+        @DisplayName("False")
+        @ParameterizedTest
+        @CsvSource(value = {"2,1", "31,1", "25,1", "25,25", "25,24", "31,31"}, delimiter = ',')
+        void isOverThanFalse(int left, int right) {
+            // given
+            Day leftDay = Day.from(left);
+            Day rightDay = Day.from(right);
+
+            // when
+            boolean over = rightDay.isOverThan(leftDay);
+
+            // then
+            assertThat(over).isFalse();
+        }
+    }
+
+    @Nested
+    @DisplayName("크리스마스인지 판별 할 수 있다.")
+    class IsChristmasDay {
+
+        @DisplayName("True")
+        @Test
+        void isChristmasDayTrue() {
+            // given
+            Day day = Day.from(25);
+
+            // when
+            boolean christmasDay = day.isChristmasDay();
+
+            // then
+            assertThat(christmasDay).isTrue();
+        }
+
+        @DisplayName("False")
+        @ParameterizedTest
+        @ValueSource(ints = {1, 2, 3, 4, 5, 10, 24, 26, 29, 30, 31})
+        void isChristmasDayFalse(int input) {
+            // given
+            Day day = Day.from(input);
+
+            // when
+            boolean christmasDay = day.isChristmasDay();
+
+            // then
+            assertThat(christmasDay).isFalse();
+        }
+    }
+
+
+    @Nested
+    @DisplayName("주말인지 판별 할 수 있다.")
+    class IsWeekend {
+
+        @DisplayName("True")
+        @ParameterizedTest
+        @ValueSource(ints = {8, 9, 15, 16, 22, 23, 29, 30})
+        void isWeekendTrue(int day) {
+            // given
+            Day orderDay = Day.from(day);
+
+            // when
+            boolean weekend = orderDay.isWeekend();
+
+            // then
+            assertThat(weekend).isTrue();
+        }
+
+        @DisplayName("False")
+        @ParameterizedTest
+        @ValueSource(ints = {3, 4, 5, 6, 7,
+                10, 11, 12, 13, 14,
+                17, 18, 19, 20, 21,
+                24, 25, 26, 27, 28,
+                31})
+        void isWeekendFalse(int day) {
+            // given
+            Day orderDay = Day.from(day);
+
+            // when
+            boolean weekend = orderDay.isWeekend();
+
+            // then
+            assertThat(weekend).isFalse();
+        }
+    }
+
+    @Nested
+    @DisplayName("일요일인지 판별 할 수 있다.")
+    class IsSunDay {
+
+        @DisplayName("True")
+        @ParameterizedTest
+        @ValueSource(ints = {3, 10, 17, 24, 31})
+        void isSunDayTrue(int input) {
+            // given
+            Day day = Day.from(input);
+
+            // when // then
+            assertThat(day.isSunDay()).isTrue();
+        }
+
+        @DisplayName("False")
+        @ParameterizedTest
+        @ValueSource(ints = {1, 2, 4, 5, 6, 7, 8, 9, 15, 25, 26})
+        void isSunDayFalse(int input) {
+            // given
+            Day day = Day.from(input);
+
+            // when // then
+            assertThat(day.isSunDay()).isFalse();
+        }
+    }
+
+    @Nested
+    @DisplayName("날짜가 같은지 판별할 수 있다.")
+    class Equals {
+
+        @DisplayName("True")
+        @Test
+        void equalsTrue() {
+            // given
+            Day day = Day.from(1);
+            Day other = Day.from(1);
+
+            // when
+            boolean equals = day.equals(other);
+
+            // then
+            assertThat(equals).isTrue();
+        }
+
+        @DisplayName("False")
+        @Test
+        void equalsFalse() {
+            // given
+            Day day = Day.from(1);
+            Day other = Day.from(2);
+
+            // when
+            boolean equals = day.equals(other);
+
+            // then
+            assertThat(equals).isFalse();
+        }
+
+        @DisplayName("False - Other Type")
+        @Test
+        void equalsFalse2() {
+            // given
+            Day day = Day.from(1);
+            Integer other = 1;
+
+            // when
+            boolean equals = day.equals(other);
+
+            // then
+            assertThat(equals).isFalse();
+        }
+    }
+
+    @Nested
+    @DisplayName("같은 날짜이면 hashCode가 같다.")
+    class Hash {
+
+        @DisplayName("True")
+        @Test
+        void hashCodeEqualTrue() {
+            // given // when
+            int hash = Day.from(1).hashCode();
+            int other = Day.from(1).hashCode();
+
+            // then
+            assertThat(hash == other).isTrue();
+        }
+
+        @DisplayName("False")
+        @Test
+        void hashCodeEqualFalse() {
+            // given // when
+            int hash = Day.from(1).hashCode();
+            int other = Day.from(2).hashCode();
+
+            // then
+            assertThat(hash == other).isFalse();
+        }
+    }
+
+
+}
\ No newline at end of file
diff --git a/src/test/java/christmas/domain/order/OrderTest.java b/src/test/java/christmas/domain/order/OrderTest.java
new file mode 100644
index 0000000..cb8dae4
--- /dev/null
+++ b/src/test/java/christmas/domain/order/OrderTest.java
@@ -0,0 +1,194 @@
+package christmas.domain.order;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.junit.jupiter.params.provider.Arguments.arguments;
+
+import christmas.domain.order.constant.Menu;
+import java.util.Map;
+import java.util.stream.Stream;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.junit.jupiter.params.provider.ValueSource;
+
+@DisplayName("주문은")
+class OrderTest {
+
+    @Nested
+    @DisplayName("날짜와 메뉴 수량 맵으로 생성할 수 있다.")
+    class Create {
+
+        @DisplayName("성공")
+        @ParameterizedTest
+        @ValueSource(ints = {1, 5, 19})
+        void of(int count) {
+            // given
+            Day day = Day.from(1);
+            Map<Menu, Integer> menu = Map.of(Menu.T_BONE_STEAK, count, Menu.ZERO_COLA, 1);
+
+            // when
+            Order order = Order.of(day, menu);
+
+            // then
+            assertThat(order)
+                    .extracting("day", "menuCount")
+                    .containsExactly(day, menu);
+        }
+
+        @Nested
+        @DisplayName("에외")
+        class Exceptions {
+
+            @DisplayName("단일 주문 메뉴의 수가 1미만이면 예외를 발생한다.")
+            @ParameterizedTest
+            @ValueSource(ints = {-10, -5, -1, 0})
+            void validateCountRange(int count) {
+                // given
+                Day day = Day.from(1);
+                Map<Menu, Integer> menu = Map.of(Menu.T_BONE_STEAK, count);
+
+                // when // then
+                assertThatThrownBy(() -> Order.of(day, menu))
+                        .isInstanceOf(IllegalArgumentException.class)
+                        .hasMessage("[ERROR] 유효하지 않은 주문입니다. 다시 입력해 주세요.");
+            }
+
+            @DisplayName("전체 주문 수량이 20개초과이면 예외를 발생한다.")
+            @ParameterizedTest
+            @ValueSource(ints = {21, 22, 100, 9999})
+            void validateTotalCountMax(int count) {
+                // given
+                Day day = Day.from(1);
+                Map<Menu, Integer> menu = Map.of(Menu.T_BONE_STEAK, count);
+
+                // when // then
+                assertThatThrownBy(() -> Order.of(day, menu))
+                        .isInstanceOf(IllegalArgumentException.class)
+                        .hasMessage("[ERROR] 유효하지 않은 주문입니다. 다시 입력해 주세요.");
+            }
+
+            @DisplayName("음료만 주문하면 예외를 발생한다.")
+            @Test
+            void validateOnlyBeverage() {
+                // given
+                Day day = Day.from(1);
+                Map<Menu, Integer> menu = Map.of(Menu.ZERO_COLA, 10);
+
+                // when // then
+                assertThatThrownBy(() -> Order.of(day, menu))
+                        .isInstanceOf(IllegalArgumentException.class)
+                        .hasMessage("[ERROR] 유효하지 않은 주문입니다. 다시 입력해 주세요.");
+            }
+        }
+    }
+
+    @DisplayName("총 주문 가격을 계산할 수 있다.")
+    @ParameterizedTest
+    @MethodSource("menuProvider")
+    void calculateTotalPrice(Map<Menu, Integer> menuCount, int target) {
+        // given
+        Order order = Order.of(Day.from(1), menuCount);
+
+        // when
+        int totalPrice = order.calculateTotalPrice();
+
+        // then
+        assertThat(totalPrice).isEqualTo(target);
+    }
+
+    static Stream<Arguments> menuProvider() {
+        return Stream.of(
+                arguments(Map.of(Menu.ICE_CREAM, 1), 5000),
+                arguments(Map.of(Menu.TAPAS, 2), Menu.TAPAS.getPrice() * 2),
+                arguments(Map.of(Menu.CAESAR_SALAD, 10), Menu.CAESAR_SALAD.getPrice() * 10),
+                arguments(Map.of(Menu.BUTTON_MUSHROOM_SOUP, 1, Menu.ZERO_COLA, 1),
+                        Menu.BUTTON_MUSHROOM_SOUP.getPrice() + Menu.ZERO_COLA.getPrice()),
+                arguments(Map.of(Menu.BUTTON_MUSHROOM_SOUP, 3, Menu.ZERO_COLA, 4),
+                        Menu.BUTTON_MUSHROOM_SOUP.getPrice() * 3 + Menu.ZERO_COLA.getPrice() * 4)
+        );
+    }
+
+    @DisplayName("이벤트 카테고리의 메뉴 개수를 구할 수 있다.")
+    @ParameterizedTest
+    @MethodSource("weekCategoryProvider")
+    void countWeekEventMenu(int day, Map<Menu, Integer> menuCount, int target) {
+        // given
+        Order order = Order.of(Day.from(day), menuCount);
+
+        // when
+        int count = order.countWeekEventMenu();
+
+        // then
+        assertThat(count).isEqualTo(target);
+    }
+
+    static Stream<Arguments> weekCategoryProvider() {
+        return Stream.of(
+                arguments(1, Map.of(Menu.BARBECUE_RIBS, 1), 1),
+                arguments(1, Map.of(Menu.BARBECUE_RIBS, 2, Menu.SEAFOOD_PASTA, 3), 5),
+                arguments(1, Map.of(Menu.BARBECUE_RIBS, 3, Menu.SEAFOOD_PASTA, 3,
+                        Menu.ICE_CREAM, 6), 6),
+                arguments(3, Map.of(Menu.ICE_CREAM, 1), 1),
+                arguments(3, Map.of(Menu.ICE_CREAM, 2, Menu.CHOCOLATE_CAKE, 3), 5),
+                arguments(3, Map.of(Menu.ICE_CREAM, 3, Menu.CHOCOLATE_CAKE, 3,
+                        Menu.SEAFOOD_PASTA, 6), 6)
+        );
+    }
+
+
+    @Nested
+    @DisplayName("전체 주문 가격이 특정 가격보다 적은지 판별할 수 있다. ")
+    class IsTotalPriceUnder {
+
+        @DisplayName("True")
+        @Test
+        void isTotalPriceUnderTrue() {
+            // given
+            Day day = Day.from(1);
+            Map<Menu, Integer> menu = Map.of(Menu.T_BONE_STEAK, 1, Menu.ZERO_COLA, 1);
+            Order order = Order.of(day, menu);
+
+            // when
+            boolean totalPriceUnder = order.isTotalPriceUnder(59_999);
+
+            // then
+            assertThat(totalPriceUnder).isTrue();
+        }
+
+        @DisplayName("False")
+        @Test
+        void isTotalPriceUnderFalse() {
+            // given
+            Day day = Day.from(1);
+            Map<Menu, Integer> menu = Map.of(Menu.T_BONE_STEAK, 1, Menu.ZERO_COLA, 1);
+            Order order = Order.of(day, menu);
+
+            // when
+            boolean totalPriceUnder = order.isTotalPriceUnder(60_000);
+
+            // then
+            assertThat(totalPriceUnder).isTrue();
+        }
+    }
+
+    @DisplayName("getter로 조회한 메뉴 카운트 맵을 변경할 수 없다.")
+    @Test
+    void getMenuCount() {
+        // given
+        Day day = Day.from(1);
+        Map<Menu, Integer> menu = Map.of(Menu.T_BONE_STEAK, 1);
+        Order order = Order.of(day, menu);
+
+        // when
+        Map<Menu, Integer> menuCount = order.getMenuCount();
+
+        assertThatThrownBy(() -> menuCount.put(Menu.ICE_CREAM, 2))
+                .isInstanceOf(UnsupportedOperationException.class);
+
+    }
+
+}
\ No newline at end of file
diff --git a/src/test/java/christmas/domain/order/constant/CategoryTest.java b/src/test/java/christmas/domain/order/constant/CategoryTest.java
new file mode 100644
index 0000000..e7960a7
--- /dev/null
+++ b/src/test/java/christmas/domain/order/constant/CategoryTest.java
@@ -0,0 +1,27 @@
+package christmas.domain.order.constant;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+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;
+
+@DisplayName("카테고리는")
+class CategoryTest {
+
+    @DisplayName("음료가 아닌지 확인할 수 있다. True")
+    @ParameterizedTest
+    @ValueSource(strings = {"APPETIZER", "MAIN", "DESSERT"})
+    void isNotBeverageTrue(Category category) {
+
+        assertThat(category.isNotBeverage()).isTrue();
+    }
+
+    @DisplayName("음료가 아닌지 확인할 수 있다. False")
+    @Test
+    void isNotBeverageFalse() {
+
+        assertThat(Category.BEVERAGE.isNotBeverage()).isFalse();
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/christmas/domain/order/constant/DayOfWeekTest.java b/src/test/java/christmas/domain/order/constant/DayOfWeekTest.java
new file mode 100644
index 0000000..0ca4a5b
--- /dev/null
+++ b/src/test/java/christmas/domain/order/constant/DayOfWeekTest.java
@@ -0,0 +1,112 @@
+package christmas.domain.order.constant;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.params.provider.Arguments.arguments;
+
+import christmas.domain.order.Day;
+import java.util.stream.Stream;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.junit.jupiter.params.provider.ValueSource;
+
+@DisplayName("요일은")
+class DayOfWeekTest {
+
+    @DisplayName("Day의 요일을 구분할 수 있다.")
+    @ParameterizedTest
+    @MethodSource("dayOfWeekProvider")
+    void from(int input, DayOfWeek target) {
+        // given
+        Day day = Day.from(input);
+
+        // when
+        DayOfWeek dayOfWeek = DayOfWeek.from(day);
+
+        // then
+        assertThat(dayOfWeek).isEqualByComparingTo(target);
+    }
+
+    static Stream<Arguments> dayOfWeekProvider() {
+        return Stream.of(
+                arguments(1, DayOfWeek.FRIDAY),
+                arguments(8, DayOfWeek.FRIDAY),
+                arguments(2, DayOfWeek.SATURDAY),
+                arguments(3, DayOfWeek.SUNDAY),
+                arguments(4, DayOfWeek.MONDAY),
+                arguments(5, DayOfWeek.TUESDAY),
+                arguments(6, DayOfWeek.WEDNESDAY),
+                arguments(7, DayOfWeek.THURSDAY),
+                arguments(25, DayOfWeek.MONDAY)
+        );
+    }
+
+    @Nested
+    @DisplayName("일요일인지 확인 할 수 있다.")
+    class Sunday {
+
+        @DisplayName("True")
+        @ParameterizedTest
+        @ValueSource(ints = {3, 10, 17, 24, 31})
+        void isSunDayTrue(int input) {
+            // given
+            Day day = Day.from(input);
+
+            // when
+            DayOfWeek dayOfWeek = DayOfWeek.from(day);
+
+            // then
+            assertThat(dayOfWeek.isSunDay()).isTrue();
+        }
+
+        @DisplayName("False")
+        @ParameterizedTest
+        @ValueSource(ints = {1, 2, 4, 5, 6, 7, 8, 9, 15, 25, 26})
+        void isSunDayFalse(int input) {
+            // given
+            Day day = Day.from(input);
+
+            // when
+            DayOfWeek dayOfWeek = DayOfWeek.from(day);
+
+            // then
+            assertThat(dayOfWeek.isSunDay()).isFalse();
+        }
+    }
+
+    @Nested
+    @DisplayName("주말인지 확인 할 수 있다.")
+    class Weekend {
+
+        @DisplayName("True")
+        @ParameterizedTest
+        @ValueSource(ints = {1, 2, 8, 9, 15, 16, 22, 23, 29, 30})
+        void isWeekendTrue(int input) {
+            // given
+            Day day = Day.from(input);
+
+            // when
+            DayOfWeek dayOfWeek = DayOfWeek.from(day);
+
+            // then
+            assertThat(dayOfWeek.isWeekend()).isTrue();
+        }
+
+        @DisplayName("False")
+        @ParameterizedTest
+        @ValueSource(ints = {3, 4, 5, 6, 7, 10, 11, 12, 13, 19, 20, 21, 24, 25, 31})
+        void isWeekendFalse(int input) {
+            // given
+            Day day = Day.from(input);
+
+            // when
+            DayOfWeek dayOfWeek = DayOfWeek.from(day);
+
+            // then
+            assertThat(dayOfWeek.isWeekend()).isFalse();
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/src/test/java/christmas/domain/order/constant/DecemberTest.java b/src/test/java/christmas/domain/order/constant/DecemberTest.java
new file mode 100644
index 0000000..17c09e2
--- /dev/null
+++ b/src/test/java/christmas/domain/order/constant/DecemberTest.java
@@ -0,0 +1,31 @@
+package christmas.domain.order.constant;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+@DisplayName("12월은")
+class DecemberTest {
+
+    @Nested
+    @DisplayName("12월에 있는 일인지 확인 할 수 있다.")
+    class InRange {
+
+        @DisplayName(" True")
+        @ParameterizedTest
+        @ValueSource(ints = {1, 2, 4, 5, 6, 7, 8, 9, 15, 25, 31})
+        void isInRangeTrue(int day) {
+            assertThat(December.isInRange(day)).isTrue();
+        }
+
+        @DisplayName("False")
+        @ParameterizedTest
+        @ValueSource(ints = {-10, -1, 0, 32, 33, 57, 88, 999, 15000})
+        void isInRangeFalse(int day) {
+            assertThat(December.isInRange(day)).isFalse();
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/christmas/domain/order/constant/MenuTest.java b/src/test/java/christmas/domain/order/constant/MenuTest.java
new file mode 100644
index 0000000..2c23b6b
--- /dev/null
+++ b/src/test/java/christmas/domain/order/constant/MenuTest.java
@@ -0,0 +1,68 @@
+package christmas.domain.order.constant;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.CsvSource;
+import org.junit.jupiter.params.provider.ValueSource;
+
+@DisplayName("메뉴는")
+class MenuTest {
+
+
+    @Nested
+    @DisplayName("메뉴 이름을 Menu에 맞게 찾는다.")
+    class Create {
+        @DisplayName("변환 할 수 있다.")
+        @ParameterizedTest
+        @CsvSource(value = {"양송이수프,BUTTON_MUSHROOM_SOUP", "타파스,TAPAS", "시저샐러드,CAESAR_SALAD",
+                "티본스테이크,T_BONE_STEAK", "바비큐립,BARBECUE_RIBS", "해산물파스타,SEAFOOD_PASTA", "크리스마스파스타,CHRISTMAS_PASTA",
+                "초코케이크,CHOCOLATE_CAKE", "아이스크림,ICE_CREAM",
+                "제로콜라,ZERO_COLA", "레드와인,RED_WINE", "샴페인,CHAMPAGNE"}, delimiter = ',')
+        void from(String name, Menu target) {
+            // given // when
+            Menu menu = Menu.from(name);
+
+            // then
+            assertThat(menu).isEqualByComparingTo(target);
+        }
+
+        @DisplayName("하지만 Menu에 없으면 예외를 반환한다..")
+        @ParameterizedTest
+        @ValueSource(strings = {"스파게티", "치킨", "피자"})
+        void from(String name) {
+            assertThatThrownBy(() -> Menu.from(name))
+                    .isInstanceOf(IllegalArgumentException.class)
+                    .hasMessage("[ERROR] 유효하지 않은 주문입니다. 다시 입력해 주세요.");
+        }
+    }
+
+    @Nested
+    @DisplayName("메뉴의 카테고리를 확인할 수 있다.")
+    class FindCategory {
+        @DisplayName("True")
+        @ParameterizedTest
+        @CsvSource(value = {"APPETIZER,BUTTON_MUSHROOM_SOUP", "APPETIZER,TAPAS", "APPETIZER,CAESAR_SALAD",
+                "MAIN,T_BONE_STEAK", "MAIN,BARBECUE_RIBS", "MAIN,SEAFOOD_PASTA", "MAIN,CHRISTMAS_PASTA",
+                "DESSERT,CHOCOLATE_CAKE", "DESSERT,ICE_CREAM",
+                "BEVERAGE,ZERO_COLA", "BEVERAGE,RED_WINE", "BEVERAGE,CHAMPAGNE"}, delimiter = ',')
+        void isCategoryTrue(Category target, Menu menu) {
+            assertThat(menu.isCategory(target)).isTrue();
+        }
+
+        @DisplayName("False")
+        @ParameterizedTest
+        @CsvSource(value = {"MAIN,BUTTON_MUSHROOM_SOUP", "DESSERT,TAPAS", "DESSERT,CAESAR_SALAD",
+                "APPETIZER,T_BONE_STEAK", "APPETIZER,BARBECUE_RIBS", "DESSERT,SEAFOOD_PASTA", "BEVERAGE,CHRISTMAS_PASTA",
+                "BEVERAGE,CHOCOLATE_CAKE", "MAIN,ICE_CREAM",
+                "MAIN,ZERO_COLA", "DESSERT,RED_WINE", "DESSERT,CHAMPAGNE"}, delimiter = ',')
+        void isCategoryFalse(Category target, Menu menu) {
+            assertThat(menu.isCategory(target)).isFalse();
+        }
+    }
+
+
+}
\ No newline at end of file
diff --git a/src/test/java/christmas/domain/order/constant/WeekTest.java b/src/test/java/christmas/domain/order/constant/WeekTest.java
new file mode 100644
index 0000000..7a5fa3c
--- /dev/null
+++ b/src/test/java/christmas/domain/order/constant/WeekTest.java
@@ -0,0 +1,50 @@
+package christmas.domain.order.constant;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import christmas.domain.order.Day;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+@DisplayName("주말은")
+class WeekTest {
+
+    @Nested
+    @DisplayName("날짜가 주말인지 확인할 수 있다.")
+    class IsWeekend {
+
+        @DisplayName("True")
+        @ParameterizedTest
+        @ValueSource(ints = {8, 9, 15, 16, 22, 23, 29, 30})
+        void isWeekendTrue(int day) {
+            // given
+            Day orderDay = Day.from(day);
+            Week week = Week.from(DayOfWeek.from(orderDay));
+
+            // when
+            boolean weekend = week.isWeekend();
+
+            // then
+            assertThat(weekend).isTrue();
+        }
+
+        @DisplayName("False")
+        @ParameterizedTest
+        @ValueSource(ints = {3, 4, 5, 6, 7, 10, 11, 12, 13, 14, 17, 18, 19, 20, 21, 24, 25, 26, 27, 28, 31})
+        void isWeekendFalse(int day) {
+            // given
+            Day orderDay = Day.from(day);
+            Week week = Week.from(DayOfWeek.from(orderDay));
+
+            // when
+            boolean weekend = week.isWeekend();
+
+            // then
+            assertThat(weekend).isFalse();
+        }
+    }
+
+
+}
\ No newline at end of file
diff --git a/src/test/java/christmas/service/event/DiscountServiceTest.java b/src/test/java/christmas/service/event/DiscountServiceTest.java
new file mode 100644
index 0000000..e070b32
--- /dev/null
+++ b/src/test/java/christmas/service/event/DiscountServiceTest.java
@@ -0,0 +1,68 @@
+package christmas.service.event;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.groups.Tuple.tuple;
+
+import christmas.domain.event.discount.DiscountEventType;
+import christmas.domain.event.discount.DiscountRepository;
+import christmas.domain.order.Order;
+import christmas.domain.order.Day;
+import christmas.domain.order.constant.Menu;
+import christmas.response.EventResponse;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.DynamicTest;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.TestFactory;
+@Nested
+@DisplayName("할인 서비스")
+class DiscountServiceTest {
+
+    DiscountService discountService;
+
+    @BeforeEach
+    void setUp() {
+        DiscountRepository discountRepository = new DiscountRepository();
+        discountService = new DiscountService(discountRepository);
+    }
+
+    @DisplayName("할인 이벤트 적용 시나리오")
+    @TestFactory
+    Collection<DynamicTest> getActiveEventResult() {
+        // given
+        Order order = Order.of(Day.from(3),
+                Map.of(Menu.T_BONE_STEAK, 1, Menu.BARBECUE_RIBS, 1,
+                        Menu.CHOCOLATE_CAKE, 2, Menu.ZERO_COLA, 1));
+
+        discountService.applyEventAll(DiscountEventType.class, order);
+
+        // when // then
+        return List.of(
+                DynamicTest.dynamicTest("적용된 할인 제목과 금액 리스트를 구할 수 있다.", () -> {
+                    // given // when
+                    List<EventResponse> activeEventResult = discountService.getActiveEventResult();
+
+                    // then
+                    assertThat(activeEventResult).hasSize(3)
+                            .extracting("title", "amount")
+                            .containsExactlyInAnyOrder(
+                                    tuple("크리스마스 디데이 할인", 1_200),
+                                    tuple("평일 할인", 4_046),
+                                    tuple("특별 할인", 1_000)
+                            );
+                }),
+                DynamicTest.dynamicTest("전체 적용된 혜택 금액을 구할 수 있다.", () -> {
+                    // given // when
+                    int totalAmount = discountService.calculateTotalBenefits();
+
+                    // then
+                    assertThat(totalAmount).isEqualTo(1_200 + 4_046 + 1_000);
+                })
+        );
+
+    }
+
+}
\ No newline at end of file
diff --git a/src/test/java/christmas/service/event/EventDetailServiceTest.java b/src/test/java/christmas/service/event/EventDetailServiceTest.java
new file mode 100644
index 0000000..851d2d2
--- /dev/null
+++ b/src/test/java/christmas/service/event/EventDetailServiceTest.java
@@ -0,0 +1,76 @@
+package christmas.service.event;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.groups.Tuple.tuple;
+import static org.mockito.BDDMockito.given;
+import static org.mockito.Mockito.mock;
+
+import christmas.response.EventDetailResponse;
+import christmas.response.EventResponse;
+import christmas.response.GiftMenuResponse;
+import java.util.List;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+@Nested
+@DisplayName("이벤트 상세 서비스는")
+class EventDetailServiceTest {
+
+    private DiscountService discountService;
+    private GiftService giftService;
+    private EventDetailService eventDetailService;
+
+    @BeforeEach
+    void setUp() {
+        discountService = mock(DiscountService.class);
+        giftService = mock(GiftService.class);
+        eventDetailService = new EventDetailService(discountService, giftService);
+    }
+
+    @DisplayName("할인 적용 세부 사항을 얻을 수 있다.")
+    @Test
+    void getEventDetail() {
+        // given
+        given(discountService.calculateTotalBenefits()).willReturn(4_023);
+        given(giftService.calculateTotalBenefits()).willReturn(25_000);
+
+        given(giftService.getGiftMenuResponse()).willReturn(List.of(GiftMenuResponse.of("샴페인", 1)));
+
+        given(discountService.getActiveEventResult()).willReturn(
+                List.of(EventResponse.of("크리스마스 디데이 할인", 1_000),
+                        EventResponse.of("평일 할인", 2_023),
+                        EventResponse.of("특별 할인", 1_000))
+        );
+
+        given(giftService.getActiveEventResult()).willReturn(
+                List.of(EventResponse.of("증정 이벤트", 25_000)));
+
+        int priceBeforeDiscount = 150_000;
+
+        // when
+        EventDetailResponse eventDetail = eventDetailService.getEventDetail(priceBeforeDiscount);
+
+        // then
+        assertThat(eventDetail.priceBeforeEvent()).isEqualTo(150_000);
+
+        assertThat(eventDetail.giftMenuResponses()).hasSize(1)
+                .extracting("title", "count")
+                .containsExactly(tuple("샴페인", 1));
+
+        assertThat(eventDetail.activeEvents()).hasSize(4)
+                .extracting("title", "amount")
+                .containsExactlyInAnyOrder(
+                        tuple("크리스마스 디데이 할인", 1_000),
+                        tuple("평일 할인", 2_023),
+                        tuple("특별 할인", 1_000),
+                        tuple("증정 이벤트", 25_000)
+                );
+
+        assertThat(eventDetail.totalBenefitsAmount()).isEqualTo(29_023);
+        assertThat(eventDetail.priceAfterEvent()).isEqualTo(150_000 - 4_023);
+        assertThat(eventDetail.badge()).isEqualTo("산타");
+    }
+
+}
\ No newline at end of file
diff --git a/src/test/java/christmas/service/event/GiftServiceTest.java b/src/test/java/christmas/service/event/GiftServiceTest.java
new file mode 100644
index 0000000..2c0e3c6
--- /dev/null
+++ b/src/test/java/christmas/service/event/GiftServiceTest.java
@@ -0,0 +1,79 @@
+package christmas.service.event;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.groups.Tuple.tuple;
+
+import christmas.domain.event.gift.GiftEventType;
+import christmas.domain.event.gift.GiftRepository;
+import christmas.domain.order.Order;
+import christmas.domain.order.Day;
+import christmas.domain.order.constant.Menu;
+import christmas.response.EventResponse;
+import christmas.response.GiftMenuResponse;
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.DynamicTest;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.TestFactory;
+
+@Nested
+@DisplayName("선물 서비스")
+class GiftServiceTest {
+
+    GiftService giftService;
+
+    @BeforeEach
+    void setUp() {
+        GiftRepository giftRepository = new GiftRepository();
+        giftService = new GiftService(giftRepository);
+    }
+
+    @DisplayName("증정 이벤트 적용 시나리오")
+    @TestFactory
+    Collection<DynamicTest> getActiveEventResult() {
+        // given
+        Order order = Order.of(Day.from(3),
+                Map.of(Menu.T_BONE_STEAK, 1, Menu.BARBECUE_RIBS, 1,
+                        Menu.CHOCOLATE_CAKE, 2, Menu.ZERO_COLA, 1));
+
+        giftService.applyEventAll(GiftEventType.class, order);
+
+        // when // then
+        return List.of(
+                DynamicTest.dynamicTest("적용된 할인 제목과 금액 리스트를 구할 수 있다.", () -> {
+                    // given // when
+                    List<EventResponse> activeEventResult = giftService.getActiveEventResult();
+
+                    // then
+                    assertThat(activeEventResult).hasSize(1)
+                            .extracting("title", "amount")
+                            .containsExactlyInAnyOrder(
+                                    tuple("증정 이벤트", 25_000)
+                            );
+                }),
+                DynamicTest.dynamicTest("전체 적용된 혜택 금액을 구할 수 있다.", () -> {
+                    // given // when
+                    int totalAmount = giftService.calculateTotalBenefits();
+
+                    // then
+                    assertThat(totalAmount).isEqualTo(25_000);
+                }),
+                DynamicTest.dynamicTest("전체 증정되는 메뉴 이름과 수량을 구할 수 있다.", () -> {
+                    // given // when
+                    List<GiftMenuResponse> giftMenuResponse = giftService.getGiftMenuResponse();
+
+                    // then
+                    assertThat(giftMenuResponse).hasSize(1)
+                            .extracting("title", "count")
+                            .containsExactlyInAnyOrder(
+                                    tuple("샴페인", 1)
+                            );
+                })
+        );
+
+    }
+
+}
\ No newline at end of file
diff --git a/src/test/java/christmas/service/order/OrderServiceTest.java b/src/test/java/christmas/service/order/OrderServiceTest.java
new file mode 100644
index 0000000..347755d
--- /dev/null
+++ b/src/test/java/christmas/service/order/OrderServiceTest.java
@@ -0,0 +1,96 @@
+package christmas.service.order;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.tuple;
+import static org.mockito.BDDMockito.given;
+
+import christmas.domain.order.Order;
+import christmas.domain.order.Day;
+import christmas.domain.order.constant.Menu;
+import christmas.response.EventDetailResponse;
+import christmas.response.EventDetailResponse.EventDetailResponseBuilder;
+import christmas.response.EventResponse;
+import christmas.response.GiftMenuResponse;
+import christmas.response.OrderResponse;
+import christmas.response.OrderSummaryResponse;
+import christmas.service.event.EventDetailService;
+import java.util.List;
+import java.util.Map;
+import org.assertj.core.groups.Tuple;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
+
+@Nested
+@DisplayName("주문 서비스는")
+class OrderServiceTest {
+
+    EventDetailService eventDetailService;
+    OrderService orderService;
+
+    @BeforeEach
+    void setUp() {
+        eventDetailService = Mockito.mock(EventDetailService.class);
+        orderService = new OrderService(eventDetailService);
+    }
+
+    @DisplayName("주문 Summary를 생성 할 수 있다.")
+    @Test
+    void createOrderSummary() {
+        // given
+        Order order = Order.of(Day.from(3),
+                Map.of(Menu.T_BONE_STEAK, 1,
+                        Menu.BARBECUE_RIBS, 1,
+                        Menu.CHOCOLATE_CAKE, 2,
+                        Menu.ZERO_COLA, 1));
+
+        given(eventDetailService.getEventDetail(order.calculateTotalPrice()))
+                .willReturn(EventDetailResponseBuilder.builder()
+                        .priceBeforeEvent(142_000)
+                        .priceAfterEvent(135_754)
+                        .totalBenefitsAmount(31_246)
+                        .giftMenuResponses(List.of(GiftMenuResponse.of("샴페인", 1)))
+                        .activeEvents(List.of(EventResponse.of("크리스마스 디데이 할인", 1_200),
+                                EventResponse.of("평일 할인", 4_046),
+                                EventResponse.of("특별 할인", 1_000),
+                                EventResponse.of("증정 이벤트", 2_5000)))
+                        .badge("산타")
+                        .build());
+
+        // when
+        OrderSummaryResponse orderSummary = orderService.createOrderSummary(order);
+
+        // then
+        OrderResponse orderResponse = orderSummary.orderResponse();
+
+        assertThat(orderResponse.day()).isEqualTo(3);
+        assertThat(orderResponse.menuCount()).hasSize(4)
+                .extracting("title", "count")
+                .containsExactlyInAnyOrder(
+                        tuple("티본스테이크", 1),
+                        tuple("바비큐립", 1),
+                        tuple("초코케이크", 2),
+                        tuple("제로콜라", 1)
+                );
+
+        EventDetailResponse eventDetail = orderSummary.eventDetailResponse();
+
+        assertThat(eventDetail.priceBeforeEvent()).isEqualTo(142_000);
+        assertThat(eventDetail.giftMenuResponses()).hasSize(1)
+                .extracting("title", "count")
+                .containsExactly(Tuple.tuple("샴페인", 1));
+        assertThat(eventDetail.activeEvents()).hasSize(4)
+                .extracting("title", "amount")
+                .containsExactlyInAnyOrder(
+                        Tuple.tuple("크리스마스 디데이 할인", 1_200),
+                        Tuple.tuple("평일 할인", 4_046),
+                        Tuple.tuple("특별 할인", 1_000),
+                        Tuple.tuple("증정 이벤트", 25_000)
+                );
+        assertThat(eventDetail.totalBenefitsAmount()).isEqualTo(31_246);
+        assertThat(eventDetail.priceAfterEvent()).isEqualTo(135_754);
+        assertThat(eventDetail.badge()).isEqualTo("산타");
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/christmas/view/InputViewTest.java b/src/test/java/christmas/view/InputViewTest.java
new file mode 100644
index 0000000..e24e7f3
--- /dev/null
+++ b/src/test/java/christmas/view/InputViewTest.java
@@ -0,0 +1,80 @@
+package christmas.view;
+
+import static java.lang.System.lineSeparator;
+import static org.assertj.core.api.Assertions.assertThat;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+@Nested
+@DisplayName("입력 뷰는")
+class InputViewTest {
+
+    TestWriter writer = new TestWriter();
+    InputView inputView;
+
+
+    @BeforeEach
+    void setUp() {
+        writer.clear();
+    }
+
+    @DisplayName("날짜를 입력하라는 문자를 출력할 수 있다.")
+    @Test
+    void readDateWriter() {
+        // given
+        inputView = new InputView(new TestReader("3"), writer);
+
+        // when
+        inputView.readDate();
+
+        // then
+        assertThat(writer.getString())
+                .isEqualTo("12월 중 식당 예상 방문 날짜는 언제인가요? (숫자만 입력해 주세요!)" + lineSeparator());
+    }
+
+    @DisplayName("문자를 입력받을 수 있다.")
+    @Test
+    void readDateReader() {
+        // given
+        inputView = new InputView(new TestReader("3"), writer);
+
+        // when
+        String day = inputView.readDate();
+
+        // then
+        assertThat(day)
+                .isEqualTo("3");
+    }
+
+    @DisplayName("메뉴와 수량을 입력하라는 문자를 출력할 수 있다.")
+    @Test
+    void readMenuAndCountWriter() {
+        // given
+        inputView = new InputView(new TestReader("타파스-1,제로콜라-1"), writer);
+        // when
+        inputView.readMenuAndCount();
+
+        // then
+        assertThat(writer.getString())
+                .isEqualTo("주문하실 메뉴를 메뉴와 개수를 알려 주세요. (e.g. 해산물파스타-2,레드와인-1,초코케이크-1)" +
+                        lineSeparator());
+    }
+
+    @DisplayName("메뉴와 수량을 입력받을 수 있다.")
+    @Test
+    void readMenuAndCountReader() {
+        // given
+        inputView = new InputView(new TestReader("타파스-1,제로콜라-1"), writer);
+
+        // when
+        inputView.readMenuAndCount();
+
+        // then
+        assertThat(writer.getString())
+                .isEqualTo("주문하실 메뉴를 메뉴와 개수를 알려 주세요. (e.g. 해산물파스타-2,레드와인-1,초코케이크-1)" +
+                        lineSeparator());
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/christmas/view/OutputViewTest.java b/src/test/java/christmas/view/OutputViewTest.java
new file mode 100644
index 0000000..a3b5662
--- /dev/null
+++ b/src/test/java/christmas/view/OutputViewTest.java
@@ -0,0 +1,178 @@
+package christmas.view;
+
+import static java.lang.System.lineSeparator;
+import static org.assertj.core.api.Assertions.assertThat;
+
+import christmas.exception.ErrorMessage;
+import christmas.response.EventDetailResponse;
+import christmas.response.EventDetailResponse.EventDetailResponseBuilder;
+import christmas.response.EventResponse;
+import christmas.response.GiftMenuResponse;
+import christmas.response.MenuCountResponse;
+import christmas.response.OrderResponse;
+import christmas.response.OrderSummaryResponse;
+import java.util.List;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+
+@Nested
+@DisplayName("출력 뷰는")
+class OutputViewTest {
+
+    TestWriter writer = new TestWriter();
+    OutputView outputView;
+
+
+    @BeforeEach
+    void setUp() {
+        writer.clear();
+        outputView = new OutputView(writer);
+    }
+
+    @DisplayName("초기 인사를 출력할 수 있다.")
+    @Test
+    void printHello() {
+        // given // when
+        outputView.printHello();
+
+        // then
+        assertThat(writer.getString())
+                .isEqualTo("안녕하세요! 우테코 식당 12월 이벤트 플래너입니다." + lineSeparator());
+    }
+
+    @DisplayName("에러메시지를 출력할 수 있다.")
+    @Test
+    void printError() {
+        // given
+        String message = ErrorMessage.INVALID_ORDER.getMessage();
+
+        // when
+        outputView.printError(message);
+
+        // then
+        assertThat(writer.getString())
+                .isEqualTo("[ERROR] 유효하지 않은 주문입니다. 다시 입력해 주세요." + lineSeparator());
+    }
+
+    @Nested
+    @DisplayName("주문 해택 요약 정보를 출력할 수 있다.")
+    class PrintOrderSummary {
+
+        @DisplayName("해택이 존재한다.")
+        @Test
+        void printOrderSummary() {
+            // given
+            OrderResponse orderResponse = OrderResponse.of(3, List.of(
+                    MenuCountResponse.of("티본스테이크", 1),
+                    MenuCountResponse.of("바비큐립", 1),
+                    MenuCountResponse.of("초코케이크", 2),
+                    MenuCountResponse.of("제로콜라", 1)));
+
+            EventDetailResponse eventDetailResponse = EventDetailResponseBuilder.builder()
+                    .badge("산타")
+                    .totalBenefitsAmount(31_246)
+                    .priceBeforeEvent(142_000)
+                    .priceAfterEvent(135_754)
+                    .giftMenuResponses(List.of(GiftMenuResponse.of("샴페인", 1)))
+                    .activeEvents(List.of(
+                            EventResponse.of("크리스마스 디데이 할인", 1_200),
+                            EventResponse.of("평일 할인", 4_046),
+                            EventResponse.of("특별 할인", 1_000),
+                            EventResponse.of("증정 이벤트", 25_000)))
+                    .build();
+
+            OrderSummaryResponse orderSummaryResponse = OrderSummaryResponse.of(orderResponse, eventDetailResponse);
+
+            // when
+            outputView.printOrderSummary(orderSummaryResponse);
+
+            // then
+            assertThat(writer.getString())
+                    .isEqualTo("""
+                            12월 3일에 우테코 식당에서 받을 이벤트 혜택 미리 보기!
+                                                    
+                            <주문 메뉴>
+                            티본스테이크 1개
+                            바비큐립 1개
+                            초코케이크 2개
+                            제로콜라 1개
+                                                    
+                            <할인 전 총주문 금액>
+                            142,000원
+                                                    
+                            <증정 메뉴>
+                            샴페인 1개
+                                                    
+                            <혜택 내역>
+                            크리스마스 디데이 할인: -1,200원
+                            평일 할인: -4,046원
+                            특별 할인: -1,000원
+                            증정 이벤트: -25,000원
+                                                    
+                            <총혜택 금액>
+                            -31,246원
+                                                    
+                            <할인 후 예상 결제 금액>
+                            135,754원
+                                                    
+                            <12월 이벤트 배지>
+                            산타
+                            """);
+        }
+
+        @DisplayName("적용된 혜택이 없을 경우 없음을 출력한다.")
+        @Test
+        void printOrderSummaryNone() {
+            // given
+            OrderResponse orderResponse = OrderResponse.of(26, List.of(
+                    MenuCountResponse.of("타파스", 1),
+                    MenuCountResponse.of("제로콜라", 1)));
+
+            EventDetailResponse eventDetailResponse = EventDetailResponseBuilder.builder()
+                    .badge("")
+                    .totalBenefitsAmount(0)
+                    .priceBeforeEvent(8_500)
+                    .priceAfterEvent(8_500)
+                    .giftMenuResponses(List.of())
+                    .activeEvents(List.of())
+                    .build();
+
+            OrderSummaryResponse orderSummaryResponse = OrderSummaryResponse.of(orderResponse, eventDetailResponse);
+
+            // when
+            outputView.printOrderSummary(orderSummaryResponse);
+
+            // then
+            assertThat(writer.getString())
+                    .isEqualTo("""
+                            12월 26일에 우테코 식당에서 받을 이벤트 혜택 미리 보기!
+                                                    
+                            <주문 메뉴>
+                            타파스 1개
+                            제로콜라 1개
+                                                    
+                            <할인 전 총주문 금액>
+                            8,500원
+                                                    
+                            <증정 메뉴>
+                            없음
+                                                    
+                            <혜택 내역>
+                            없음
+                                                    
+                            <총혜택 금액>
+                            0원
+                                                    
+                            <할인 후 예상 결제 금액>
+                            8,500원
+                                                    
+                            <12월 이벤트 배지>
+                            없음
+                            """);
+        }
+    }
+
+
+}
\ No newline at end of file
diff --git a/src/test/java/christmas/view/TestReader.java b/src/test/java/christmas/view/TestReader.java
new file mode 100644
index 0000000..6e6a730
--- /dev/null
+++ b/src/test/java/christmas/view/TestReader.java
@@ -0,0 +1,21 @@
+package christmas.view;
+
+import christmas.view.io.Reader;
+
+public class TestReader implements Reader {
+
+    private final String input;
+
+    public TestReader(final String input) {
+        this.input = input;
+    }
+
+    @Override
+    public String readLine() {
+        return input;
+    }
+
+    @Override
+    public void close() {
+    }
+}
diff --git a/src/test/java/christmas/view/TestWriter.java b/src/test/java/christmas/view/TestWriter.java
new file mode 100644
index 0000000..16cff85
--- /dev/null
+++ b/src/test/java/christmas/view/TestWriter.java
@@ -0,0 +1,28 @@
+package christmas.view;
+
+import static java.lang.System.lineSeparator;
+
+import christmas.view.io.Writer;
+
+public class TestWriter implements Writer {
+
+    private static StringBuilder stringBuilder = new StringBuilder();
+
+    @Override
+    public void println(String input) {
+        stringBuilder.append(input).append(lineSeparator());
+    }
+
+    @Override
+    public void printf(String format, Object... args) {
+        stringBuilder.append(String.format(format, args));
+    }
+
+    public void clear() {
+        stringBuilder = new StringBuilder();
+    }
+
+    public String getString() {
+        return stringBuilder.toString();
+    }
+}
\ No newline at end of file