code stringlengths 41 34.3k | lang stringclasses 8
values | review stringlengths 1 4.74k |
|---|---|---|
@@ -0,0 +1,25 @@
+package oncall.exception;
+
+public enum ExceptionMessage {
+ INVALID_MONTH_DAY_INPUT("월과 요일을 올바르게 입력해주세요."),
+ INVALID_MONTH_INPUT("월은 숫자만 입력 가능합니다."),
+ INVALID_DAY_INPUT("올바르지 않은 요일입니다."),
+ INVALID_DAY_OF_MONTH("해당 월에 시작 요일이 일치하지 않습니다."),
+ INVALID_WORKER_COUNTS("비상 근무 사원을 최소 5명 이상 최대 35명 사이로 입력해주세요."),
+ INVALID_NICKNAME_LENGTH("사원의 닉네임은 최대 5글자까지 가능합니다."),
+ INVALID_NICKNAME_CHARACTER("사원의 닉네임은 한글만 가능합니다."),
+ DUPLICATED_NICKNAME("한 근무에 사원이 중복될 수 없습니다."),
+ WORKER_NOT_MATCHED("평일 사원과 휴일 사원이 일치하지 않습니다."),
+ ;
+
+ private static final String PREFIX = "[ERROR] ";
+ private final String message;
+
+ ExceptionMessage(String message) {
+ this.message = PREFIX + message;
+ }
+
+ public String getMessage() {
+ return message;
+ }
+} | Java | `mesasge`라는 변수명 자체는 안내 문구가 더 적합할 것 같습니다. `getMessage()`를 부를 때 `PREFIX`를 더해 주면 어떨까요? |
@@ -0,0 +1,29 @@
+package oncall.domain;
+
+import java.time.LocalDate;
+import java.util.Arrays;
+
+public enum Holiday {
+ NEW_YEAR(LocalDate.of(2023, 1, 1), "신정"),
+ MARCH_FIRST(LocalDate.of(2023, 3, 1), "삼일절"),
+ CHILDREN_DAY(LocalDate.of(2023, 5, 5), "어린이날"),
+ MEMORIAL_DAY(LocalDate.of(2023, 6, 6), "현충일"),
+ LIBERATION_DAY(LocalDate.of(2023, 8, 15), "광복절"),
+ TEN_THIRD(LocalDate.of(2023, 10, 3), "개천절"),
+ KOREAN_DAY(LocalDate.of(2023, 10, 9), "한글날"),
+ CHRISTMAS_DAY(LocalDate.of(2023, 12, 25), "성탄절"),
+ ;
+
+ private final LocalDate date;
+ private final String name;
+
+ Holiday(LocalDate date, String name) {
+ this.date = date;
+ this.name = name;
+ }
+
+ public static boolean isHoliday(LocalDate localDate) {
+ return Arrays.stream(values())
+ .anyMatch(holiday -> holiday.date.equals(localDate));
+ }
+} | Java | 공휴일을 Enum으로 관리하니 훨씬 깔끔하네요! |
@@ -0,0 +1,16 @@
+package oncall.domain;
+
+import java.util.Collections;
+import java.util.List;
+
+public class EmergencyWorkers {
+ private final List<EmergencyWorker> emergencyWorkers;
+
+ public EmergencyWorkers(List<EmergencyWorker> emergencyWorkers) {
+ this.emergencyWorkers = emergencyWorkers;
+ }
+
+ public List<EmergencyWorker> getEmergencyWorkers() {
+ return Collections.unmodifiableList(emergencyWorkers);
+ }
+} | Java | 변경할 수 없더라도, 그 자체를 내주는 것은 지양하면 좋을 것 같습니다. 해당 `List`를 가지고 가서 어떤 연산을 하는지를 파악한 뒤에, 그 연산을 지원하도록 하면 좋을 것 같아요 |
@@ -1,7 +1,11 @@
package oncall;
+import oncall.view.InputView;
+import oncall.view.OutputView;
+
public class Application {
public static void main(String[] args) {
- // TODO: 프로그램 구현
+ EmergencyWorkPlanner emergencyWorkPlanner = new EmergencyWorkPlanner(new InputView(), new OutputView());
+ emergencyWorkPlanner.run();
}
} | Java | 가독성을 위해서 각각의 `View` 선언을 한 줄에 하나씩 해줘도 좋을 것 같아요 |
@@ -0,0 +1,47 @@
+package oncall.view;
+
+import static oncall.view.OutputView.OutputMessage.DATE_WORKER_FORMAT;
+import static oncall.view.OutputView.OutputMessage.HOLIDAY;
+
+import java.time.LocalDate;
+import oncall.domain.Day;
+import oncall.domain.EmergencyWorkers;
+import oncall.domain.Holiday;
+
+public class OutputView {
+
+ public void printEmergencyWork(EmergencyWorkers emergencyWorkers) {
+ emergencyWorkers.getEmergencyWorkers().forEach(worker -> {
+ LocalDate localDate = worker.getLocalDate();
+ String name = worker.getName();
+ String dayOfWeek = Day.of(localDate.getDayOfWeek());
+ if (Holiday.isHoliday(localDate)) {
+ dayOfWeek += HOLIDAY;
+ }
+ printForm(localDate, dayOfWeek, name);
+ });
+ }
+
+ private static void printForm(LocalDate localDate, String dayOfWeek, String name) {
+ System.out.println(
+ String.format(DATE_WORKER_FORMAT.getMessage(), localDate.getMonth().getValue(),
+ localDate.getDayOfMonth(),
+ dayOfWeek, name));
+ }
+
+ protected enum OutputMessage {
+ DATE_WORKER_FORMAT("%d월 %d일 %s %s"),
+ HOLIDAY("(휴일)"),
+ ;
+
+ private final String message;
+
+ OutputMessage(String message) {
+ this.message = message;
+ }
+
+ public String getMessage() {
+ return message;
+ }
+ }
+} | Java | 한 번에 하는 일이 너무 많은 것 같아요. 메서드를 분리해서 참조를 사용하면 좀 더 간략할 것 같습니다! |
@@ -0,0 +1,154 @@
+package oncall.view;
+
+import static oncall.exception.ExceptionMessage.DUPLICATED_NICKNAME;
+import static oncall.exception.ExceptionMessage.INVALID_DAY_OF_MONTH;
+import static oncall.exception.ExceptionMessage.INVALID_MONTH_DAY_INPUT;
+import static oncall.exception.ExceptionMessage.INVALID_MONTH_INPUT;
+import static oncall.exception.ExceptionMessage.INVALID_NICKNAME_CHARACTER;
+import static oncall.exception.ExceptionMessage.INVALID_NICKNAME_LENGTH;
+import static oncall.exception.ExceptionMessage.INVALID_WORKER_COUNTS;
+import static oncall.exception.ExceptionMessage.WORKER_NOT_MATCHED;
+import static oncall.view.InputView.InputMessage.INPUT_MONTH_DAY;
+import static oncall.view.InputView.InputMessage.INPUT_WEEKDAY_EMERGENCY_WORKERS;
+import static oncall.view.InputView.InputMessage.INPUT_WEEKEND_EMERGENCY_WORKERS;
+
+import camp.nextstep.edu.missionutils.Console;
+import java.time.LocalDate;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import oncall.domain.Day;
+import oncall.domain.Worker;
+
+public class InputView {
+ private static final String COMMA = ",";
+ private static final int DEFAULT_YEAR = 2023;
+ private static final int DEFAULT_FIRST_DAY = 1;
+ private static final int MONTH_DAY_INPUT_EXACT_SIZE = 2;
+ private static final int MONTH_INDEX = 0;
+ private static final int MIN_MONTH = 1;
+ private static final int MAX_MONTH = 12;
+ private static final int MIN_WORKER_SIZE = 5;
+ private static final int MAX_WORKER_SIZE = 35;
+ private static final int MIN_WORKER_NICKNAME_LENGTH = 2;
+ private static final int MAX_WORKER_NICKNAME_LENGTH = 5;
+ private static final char MIN_KOREAN_CHARACTER = '가';
+ private static final char MAX_KOREAN_CHARACTER = '힣';
+
+ public LocalDate readEmergencyWorkMonthDay() {
+ System.out.print(INPUT_MONTH_DAY.getMessage());
+ String input = Console.readLine();
+ List<String> parsedMonthDay = parseByComma(input);
+ validateMonthDayForm(parsedMonthDay);
+ int month = parseMonth(parsedMonthDay);
+ validateMonth(month);
+ Day day = Day.of(parsedMonthDay.get(DEFAULT_FIRST_DAY));
+ return validateDay(month, day);
+ }
+
+ private static List<String> parseByComma(String input) {
+ return Arrays.asList(input.split(COMMA));
+ }
+
+ private static LocalDate validateDay(int month, Day day) {
+ LocalDate localDate = LocalDate.of(DEFAULT_YEAR, month, DEFAULT_FIRST_DAY);
+ validateDayOfMonth(day, localDate);
+ return localDate;
+ }
+
+ private static void validateMonthDayForm(List<String> parsedMonthDay) {
+ if (parsedMonthDay.size() != MONTH_DAY_INPUT_EXACT_SIZE) {
+ throw new IllegalArgumentException(INVALID_MONTH_DAY_INPUT.getMessage());
+ }
+ }
+
+ private static int parseMonth(List<String> parsedMonthDay) {
+ try {
+ return Integer.parseInt(parsedMonthDay.get(MONTH_INDEX));
+ } catch (NumberFormatException e) {
+ throw new IllegalArgumentException(INVALID_MONTH_INPUT.getMessage());
+ }
+ }
+
+ private static void validateMonth(int month) {
+ if (month < MIN_MONTH || MAX_MONTH < month) {
+ throw new IllegalArgumentException(INVALID_MONTH_INPUT.getMessage());
+ }
+ }
+
+ private static void validateDayOfMonth(Day day, LocalDate localDate) {
+ if (!day.isSame(localDate.getDayOfWeek())) {
+ throw new IllegalArgumentException(INVALID_DAY_OF_MONTH.getMessage());
+ }
+ }
+
+ public Worker readWorker() {
+ System.out.print(INPUT_WEEKDAY_EMERGENCY_WORKERS.getMessage());
+ List<String> weekdayWorkers = getWorkers();
+ System.out.print(INPUT_WEEKEND_EMERGENCY_WORKERS.getMessage());
+ List<String> holidayWorkers = getWorkers();
+ validateWeekdayAndHolidayWorkers(weekdayWorkers, holidayWorkers);
+ return new Worker(weekdayWorkers, holidayWorkers);
+ }
+
+ private static List<String> getWorkers() {
+ String weekdayWorkers = Console.readLine();
+ List<String> parsedWorkers = parseByComma(weekdayWorkers);
+ validateWorkers(parsedWorkers);
+ return parsedWorkers;
+ }
+
+ private static void validateWorkers(List<String> workers) {
+ validateWorkerCounts(workers);
+ if (isInvalidNickNameLength(workers)) {
+ throw new IllegalArgumentException(INVALID_NICKNAME_LENGTH.getMessage());
+ }
+ if (isInvalidNickNameCharacter(workers)) {
+ throw new IllegalArgumentException(INVALID_NICKNAME_CHARACTER.getMessage());
+ }
+ if (new HashSet<>(workers).size() != workers.size()) {
+ throw new IllegalArgumentException(DUPLICATED_NICKNAME.getMessage());
+ }
+ }
+
+ private static void validateWorkerCounts(List<String> parsedWeekdayWorkers) {
+ int workerSize = parsedWeekdayWorkers.size();
+ if (workerSize < MIN_WORKER_SIZE || MAX_WORKER_SIZE < workerSize) {
+ throw new IllegalArgumentException(INVALID_WORKER_COUNTS.getMessage());
+ }
+ }
+
+ private static boolean isInvalidNickNameLength(List<String> parsedWeekdayWorkers) {
+ return parsedWeekdayWorkers.stream()
+ .anyMatch(nickName -> nickName.length() < MIN_WORKER_NICKNAME_LENGTH
+ || nickName.length() > MAX_WORKER_NICKNAME_LENGTH);
+ }
+
+ private static boolean isInvalidNickNameCharacter(List<String> parsedWeekdayWorkers) {
+ return parsedWeekdayWorkers.stream()
+ .anyMatch(nickName -> nickName.chars()
+ .anyMatch(character -> character < MIN_KOREAN_CHARACTER || MAX_KOREAN_CHARACTER < character));
+ }
+
+ private static void validateWeekdayAndHolidayWorkers(List<String> weekdayWorkers, List<String> holidayWorkers) {
+ if (!new HashSet<>(weekdayWorkers).containsAll(holidayWorkers)) {
+ throw new IllegalArgumentException(WORKER_NOT_MATCHED.getMessage());
+ }
+ }
+
+ protected enum InputMessage {
+ INPUT_MONTH_DAY("비상 근무를 배정할 월과 시작 요일을 입력하세요> "),
+ INPUT_WEEKDAY_EMERGENCY_WORKERS("평일 비상 근무 순번대로 사원 닉네임을 입력하세요> "),
+ INPUT_WEEKEND_EMERGENCY_WORKERS("휴일 비상 근무 순번대로 사원 닉네임을 입력하세요> ");
+
+ private final String message;
+
+ InputMessage(String message) {
+ this.message = message;
+ }
+
+ public String getMessage() {
+ return message;
+ }
+ }
+} | Java | 검증과 관련된 상수가 너무 `View`에 치중된 것 같습니다. 잘못된 객체가 생성되는 것을 도메인 단에서 검증할 수 있는데, 이렇게 한다면 객체 생성도 방지할 수 있어요. 나아가 `View`가 책임을 덜 수 있습니다 |
@@ -0,0 +1,56 @@
+package oncall.domain;
+
+import java.time.DayOfWeek;
+import java.time.LocalDate;
+import java.time.temporal.TemporalAdjusters;
+import java.util.ArrayList;
+import java.util.List;
+
+public class Worker {
+ private static final int INCREASE_DATE = 1;
+ private static final int OFFSET = 1;
+ private final List<String> weekdayWorkers;
+ private final List<String> holidayWorkers;
+
+ public Worker(List<String> weekdayWorkers, List<String> holidayWorkers) {
+ this.weekdayWorkers = weekdayWorkers;
+ this.holidayWorkers = holidayWorkers;
+ }
+
+ public EmergencyWorkers makeEmergencyWork(LocalDate date) {
+ LocalDate lastDayOfMonth = date.with(TemporalAdjusters.lastDayOfMonth());
+ List<EmergencyWorker> emergencyWorkers = new ArrayList<>();
+ int weekdayIndex = 0;
+ int holidayIndex = 0;
+ while (!date.isAfter(lastDayOfMonth)) {
+ if (isWeekend(date) || Holiday.isHoliday(date)) {
+ holidayIndex = assignWorkerAndAdjustIndex(emergencyWorkers, holidayWorkers, holidayIndex, date);
+ date = date.plusDays(INCREASE_DATE);
+ continue;
+ }
+ weekdayIndex = assignWorkerAndAdjustIndex(emergencyWorkers, weekdayWorkers, weekdayIndex, date);
+ date = date.plusDays(INCREASE_DATE);
+ }
+ return new EmergencyWorkers(emergencyWorkers);
+ }
+
+ private boolean isWeekend(LocalDate date) {
+ DayOfWeek dayOfWeek = date.getDayOfWeek();
+ return dayOfWeek.equals(DayOfWeek.SATURDAY) || dayOfWeek.equals(DayOfWeek.SUNDAY);
+ }
+
+ private int assignWorkerAndAdjustIndex(List<EmergencyWorker> emergencyWorkers, List<String> workers, int index,
+ LocalDate date) {
+ String worker = workers.get(index);
+ int nextIndex = (index + OFFSET) % workers.size();
+ if (!emergencyWorkers.isEmpty() && emergencyWorkers.get(emergencyWorkers.size() - OFFSET).isSame(worker)) {
+ String nextWorker = workers.get(nextIndex);
+ workers.set(index, nextWorker);
+ workers.set(nextIndex, worker);
+ worker = nextWorker;
+ }
+ emergencyWorkers.add(new EmergencyWorker(worker, date));
+ return nextIndex;
+ }
+}
+ | Java | 두 조건을 묶어서 하나의 메서드로 나타내도 좋았겠습니다 |
@@ -0,0 +1,56 @@
+package oncall.domain;
+
+import java.time.DayOfWeek;
+import java.time.LocalDate;
+import java.time.temporal.TemporalAdjusters;
+import java.util.ArrayList;
+import java.util.List;
+
+public class Worker {
+ private static final int INCREASE_DATE = 1;
+ private static final int OFFSET = 1;
+ private final List<String> weekdayWorkers;
+ private final List<String> holidayWorkers;
+
+ public Worker(List<String> weekdayWorkers, List<String> holidayWorkers) {
+ this.weekdayWorkers = weekdayWorkers;
+ this.holidayWorkers = holidayWorkers;
+ }
+
+ public EmergencyWorkers makeEmergencyWork(LocalDate date) {
+ LocalDate lastDayOfMonth = date.with(TemporalAdjusters.lastDayOfMonth());
+ List<EmergencyWorker> emergencyWorkers = new ArrayList<>();
+ int weekdayIndex = 0;
+ int holidayIndex = 0;
+ while (!date.isAfter(lastDayOfMonth)) {
+ if (isWeekend(date) || Holiday.isHoliday(date)) {
+ holidayIndex = assignWorkerAndAdjustIndex(emergencyWorkers, holidayWorkers, holidayIndex, date);
+ date = date.plusDays(INCREASE_DATE);
+ continue;
+ }
+ weekdayIndex = assignWorkerAndAdjustIndex(emergencyWorkers, weekdayWorkers, weekdayIndex, date);
+ date = date.plusDays(INCREASE_DATE);
+ }
+ return new EmergencyWorkers(emergencyWorkers);
+ }
+
+ private boolean isWeekend(LocalDate date) {
+ DayOfWeek dayOfWeek = date.getDayOfWeek();
+ return dayOfWeek.equals(DayOfWeek.SATURDAY) || dayOfWeek.equals(DayOfWeek.SUNDAY);
+ }
+
+ private int assignWorkerAndAdjustIndex(List<EmergencyWorker> emergencyWorkers, List<String> workers, int index,
+ LocalDate date) {
+ String worker = workers.get(index);
+ int nextIndex = (index + OFFSET) % workers.size();
+ if (!emergencyWorkers.isEmpty() && emergencyWorkers.get(emergencyWorkers.size() - OFFSET).isSame(worker)) {
+ String nextWorker = workers.get(nextIndex);
+ workers.set(index, nextWorker);
+ workers.set(nextIndex, worker);
+ worker = nextWorker;
+ }
+ emergencyWorkers.add(new EmergencyWorker(worker, date));
+ return nextIndex;
+ }
+}
+ | Java | `EmergencyWorker`는 이곳에서 사용하지 않나요? |
@@ -0,0 +1,16 @@
+package oncall.domain;
+
+import java.util.Collections;
+import java.util.List;
+
+public class EmergencyWorkers {
+ private final List<EmergencyWorker> emergencyWorkers;
+
+ public EmergencyWorkers(List<EmergencyWorker> emergencyWorkers) {
+ this.emergencyWorkers = emergencyWorkers;
+ }
+
+ public List<EmergencyWorker> getEmergencyWorkers() {
+ return Collections.unmodifiableList(emergencyWorkers);
+ }
+} | Java | 네 맞습니다. DTO를 사용하지 못한 것이 아쉽습니다.. |
@@ -0,0 +1,154 @@
+package oncall.view;
+
+import static oncall.exception.ExceptionMessage.DUPLICATED_NICKNAME;
+import static oncall.exception.ExceptionMessage.INVALID_DAY_OF_MONTH;
+import static oncall.exception.ExceptionMessage.INVALID_MONTH_DAY_INPUT;
+import static oncall.exception.ExceptionMessage.INVALID_MONTH_INPUT;
+import static oncall.exception.ExceptionMessage.INVALID_NICKNAME_CHARACTER;
+import static oncall.exception.ExceptionMessage.INVALID_NICKNAME_LENGTH;
+import static oncall.exception.ExceptionMessage.INVALID_WORKER_COUNTS;
+import static oncall.exception.ExceptionMessage.WORKER_NOT_MATCHED;
+import static oncall.view.InputView.InputMessage.INPUT_MONTH_DAY;
+import static oncall.view.InputView.InputMessage.INPUT_WEEKDAY_EMERGENCY_WORKERS;
+import static oncall.view.InputView.InputMessage.INPUT_WEEKEND_EMERGENCY_WORKERS;
+
+import camp.nextstep.edu.missionutils.Console;
+import java.time.LocalDate;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import oncall.domain.Day;
+import oncall.domain.Worker;
+
+public class InputView {
+ private static final String COMMA = ",";
+ private static final int DEFAULT_YEAR = 2023;
+ private static final int DEFAULT_FIRST_DAY = 1;
+ private static final int MONTH_DAY_INPUT_EXACT_SIZE = 2;
+ private static final int MONTH_INDEX = 0;
+ private static final int MIN_MONTH = 1;
+ private static final int MAX_MONTH = 12;
+ private static final int MIN_WORKER_SIZE = 5;
+ private static final int MAX_WORKER_SIZE = 35;
+ private static final int MIN_WORKER_NICKNAME_LENGTH = 2;
+ private static final int MAX_WORKER_NICKNAME_LENGTH = 5;
+ private static final char MIN_KOREAN_CHARACTER = '가';
+ private static final char MAX_KOREAN_CHARACTER = '힣';
+
+ public LocalDate readEmergencyWorkMonthDay() {
+ System.out.print(INPUT_MONTH_DAY.getMessage());
+ String input = Console.readLine();
+ List<String> parsedMonthDay = parseByComma(input);
+ validateMonthDayForm(parsedMonthDay);
+ int month = parseMonth(parsedMonthDay);
+ validateMonth(month);
+ Day day = Day.of(parsedMonthDay.get(DEFAULT_FIRST_DAY));
+ return validateDay(month, day);
+ }
+
+ private static List<String> parseByComma(String input) {
+ return Arrays.asList(input.split(COMMA));
+ }
+
+ private static LocalDate validateDay(int month, Day day) {
+ LocalDate localDate = LocalDate.of(DEFAULT_YEAR, month, DEFAULT_FIRST_DAY);
+ validateDayOfMonth(day, localDate);
+ return localDate;
+ }
+
+ private static void validateMonthDayForm(List<String> parsedMonthDay) {
+ if (parsedMonthDay.size() != MONTH_DAY_INPUT_EXACT_SIZE) {
+ throw new IllegalArgumentException(INVALID_MONTH_DAY_INPUT.getMessage());
+ }
+ }
+
+ private static int parseMonth(List<String> parsedMonthDay) {
+ try {
+ return Integer.parseInt(parsedMonthDay.get(MONTH_INDEX));
+ } catch (NumberFormatException e) {
+ throw new IllegalArgumentException(INVALID_MONTH_INPUT.getMessage());
+ }
+ }
+
+ private static void validateMonth(int month) {
+ if (month < MIN_MONTH || MAX_MONTH < month) {
+ throw new IllegalArgumentException(INVALID_MONTH_INPUT.getMessage());
+ }
+ }
+
+ private static void validateDayOfMonth(Day day, LocalDate localDate) {
+ if (!day.isSame(localDate.getDayOfWeek())) {
+ throw new IllegalArgumentException(INVALID_DAY_OF_MONTH.getMessage());
+ }
+ }
+
+ public Worker readWorker() {
+ System.out.print(INPUT_WEEKDAY_EMERGENCY_WORKERS.getMessage());
+ List<String> weekdayWorkers = getWorkers();
+ System.out.print(INPUT_WEEKEND_EMERGENCY_WORKERS.getMessage());
+ List<String> holidayWorkers = getWorkers();
+ validateWeekdayAndHolidayWorkers(weekdayWorkers, holidayWorkers);
+ return new Worker(weekdayWorkers, holidayWorkers);
+ }
+
+ private static List<String> getWorkers() {
+ String weekdayWorkers = Console.readLine();
+ List<String> parsedWorkers = parseByComma(weekdayWorkers);
+ validateWorkers(parsedWorkers);
+ return parsedWorkers;
+ }
+
+ private static void validateWorkers(List<String> workers) {
+ validateWorkerCounts(workers);
+ if (isInvalidNickNameLength(workers)) {
+ throw new IllegalArgumentException(INVALID_NICKNAME_LENGTH.getMessage());
+ }
+ if (isInvalidNickNameCharacter(workers)) {
+ throw new IllegalArgumentException(INVALID_NICKNAME_CHARACTER.getMessage());
+ }
+ if (new HashSet<>(workers).size() != workers.size()) {
+ throw new IllegalArgumentException(DUPLICATED_NICKNAME.getMessage());
+ }
+ }
+
+ private static void validateWorkerCounts(List<String> parsedWeekdayWorkers) {
+ int workerSize = parsedWeekdayWorkers.size();
+ if (workerSize < MIN_WORKER_SIZE || MAX_WORKER_SIZE < workerSize) {
+ throw new IllegalArgumentException(INVALID_WORKER_COUNTS.getMessage());
+ }
+ }
+
+ private static boolean isInvalidNickNameLength(List<String> parsedWeekdayWorkers) {
+ return parsedWeekdayWorkers.stream()
+ .anyMatch(nickName -> nickName.length() < MIN_WORKER_NICKNAME_LENGTH
+ || nickName.length() > MAX_WORKER_NICKNAME_LENGTH);
+ }
+
+ private static boolean isInvalidNickNameCharacter(List<String> parsedWeekdayWorkers) {
+ return parsedWeekdayWorkers.stream()
+ .anyMatch(nickName -> nickName.chars()
+ .anyMatch(character -> character < MIN_KOREAN_CHARACTER || MAX_KOREAN_CHARACTER < character));
+ }
+
+ private static void validateWeekdayAndHolidayWorkers(List<String> weekdayWorkers, List<String> holidayWorkers) {
+ if (!new HashSet<>(weekdayWorkers).containsAll(holidayWorkers)) {
+ throw new IllegalArgumentException(WORKER_NOT_MATCHED.getMessage());
+ }
+ }
+
+ protected enum InputMessage {
+ INPUT_MONTH_DAY("비상 근무를 배정할 월과 시작 요일을 입력하세요> "),
+ INPUT_WEEKDAY_EMERGENCY_WORKERS("평일 비상 근무 순번대로 사원 닉네임을 입력하세요> "),
+ INPUT_WEEKEND_EMERGENCY_WORKERS("휴일 비상 근무 순번대로 사원 닉네임을 입력하세요> ");
+
+ private final String message;
+
+ InputMessage(String message) {
+ this.message = message;
+ }
+
+ public String getMessage() {
+ return message;
+ }
+ }
+} | Java | 마지막에 Parser와 Validator를 생성해서 파싱과 검증을 분리하려고 하였으나 미처 리팩토링 하지 못했습니다. 피드백 감사드립니다. |
@@ -0,0 +1,56 @@
+package oncall.domain;
+
+import java.time.DayOfWeek;
+import java.time.LocalDate;
+import java.time.temporal.TemporalAdjusters;
+import java.util.ArrayList;
+import java.util.List;
+
+public class Worker {
+ private static final int INCREASE_DATE = 1;
+ private static final int OFFSET = 1;
+ private final List<String> weekdayWorkers;
+ private final List<String> holidayWorkers;
+
+ public Worker(List<String> weekdayWorkers, List<String> holidayWorkers) {
+ this.weekdayWorkers = weekdayWorkers;
+ this.holidayWorkers = holidayWorkers;
+ }
+
+ public EmergencyWorkers makeEmergencyWork(LocalDate date) {
+ LocalDate lastDayOfMonth = date.with(TemporalAdjusters.lastDayOfMonth());
+ List<EmergencyWorker> emergencyWorkers = new ArrayList<>();
+ int weekdayIndex = 0;
+ int holidayIndex = 0;
+ while (!date.isAfter(lastDayOfMonth)) {
+ if (isWeekend(date) || Holiday.isHoliday(date)) {
+ holidayIndex = assignWorkerAndAdjustIndex(emergencyWorkers, holidayWorkers, holidayIndex, date);
+ date = date.plusDays(INCREASE_DATE);
+ continue;
+ }
+ weekdayIndex = assignWorkerAndAdjustIndex(emergencyWorkers, weekdayWorkers, weekdayIndex, date);
+ date = date.plusDays(INCREASE_DATE);
+ }
+ return new EmergencyWorkers(emergencyWorkers);
+ }
+
+ private boolean isWeekend(LocalDate date) {
+ DayOfWeek dayOfWeek = date.getDayOfWeek();
+ return dayOfWeek.equals(DayOfWeek.SATURDAY) || dayOfWeek.equals(DayOfWeek.SUNDAY);
+ }
+
+ private int assignWorkerAndAdjustIndex(List<EmergencyWorker> emergencyWorkers, List<String> workers, int index,
+ LocalDate date) {
+ String worker = workers.get(index);
+ int nextIndex = (index + OFFSET) % workers.size();
+ if (!emergencyWorkers.isEmpty() && emergencyWorkers.get(emergencyWorkers.size() - OFFSET).isSame(worker)) {
+ String nextWorker = workers.get(nextIndex);
+ workers.set(index, nextWorker);
+ workers.set(nextIndex, worker);
+ worker = nextWorker;
+ }
+ emergencyWorkers.add(new EmergencyWorker(worker, date));
+ return nextIndex;
+ }
+}
+ | Java | 시험 당시에는 EmergencyWorker 객체로 변환하기 전에 저장해두고 변환하도록 하였습니다. 피드백 감사드립니다 동훈님! |
@@ -0,0 +1,154 @@
+package oncall.view;
+
+import static oncall.exception.ExceptionMessage.DUPLICATED_NICKNAME;
+import static oncall.exception.ExceptionMessage.INVALID_DAY_OF_MONTH;
+import static oncall.exception.ExceptionMessage.INVALID_MONTH_DAY_INPUT;
+import static oncall.exception.ExceptionMessage.INVALID_MONTH_INPUT;
+import static oncall.exception.ExceptionMessage.INVALID_NICKNAME_CHARACTER;
+import static oncall.exception.ExceptionMessage.INVALID_NICKNAME_LENGTH;
+import static oncall.exception.ExceptionMessage.INVALID_WORKER_COUNTS;
+import static oncall.exception.ExceptionMessage.WORKER_NOT_MATCHED;
+import static oncall.view.InputView.InputMessage.INPUT_MONTH_DAY;
+import static oncall.view.InputView.InputMessage.INPUT_WEEKDAY_EMERGENCY_WORKERS;
+import static oncall.view.InputView.InputMessage.INPUT_WEEKEND_EMERGENCY_WORKERS;
+
+import camp.nextstep.edu.missionutils.Console;
+import java.time.LocalDate;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import oncall.domain.Day;
+import oncall.domain.Worker;
+
+public class InputView {
+ private static final String COMMA = ",";
+ private static final int DEFAULT_YEAR = 2023;
+ private static final int DEFAULT_FIRST_DAY = 1;
+ private static final int MONTH_DAY_INPUT_EXACT_SIZE = 2;
+ private static final int MONTH_INDEX = 0;
+ private static final int MIN_MONTH = 1;
+ private static final int MAX_MONTH = 12;
+ private static final int MIN_WORKER_SIZE = 5;
+ private static final int MAX_WORKER_SIZE = 35;
+ private static final int MIN_WORKER_NICKNAME_LENGTH = 2;
+ private static final int MAX_WORKER_NICKNAME_LENGTH = 5;
+ private static final char MIN_KOREAN_CHARACTER = '가';
+ private static final char MAX_KOREAN_CHARACTER = '힣';
+
+ public LocalDate readEmergencyWorkMonthDay() {
+ System.out.print(INPUT_MONTH_DAY.getMessage());
+ String input = Console.readLine();
+ List<String> parsedMonthDay = parseByComma(input);
+ validateMonthDayForm(parsedMonthDay);
+ int month = parseMonth(parsedMonthDay);
+ validateMonth(month);
+ Day day = Day.of(parsedMonthDay.get(DEFAULT_FIRST_DAY));
+ return validateDay(month, day);
+ }
+
+ private static List<String> parseByComma(String input) {
+ return Arrays.asList(input.split(COMMA));
+ }
+
+ private static LocalDate validateDay(int month, Day day) {
+ LocalDate localDate = LocalDate.of(DEFAULT_YEAR, month, DEFAULT_FIRST_DAY);
+ validateDayOfMonth(day, localDate);
+ return localDate;
+ }
+
+ private static void validateMonthDayForm(List<String> parsedMonthDay) {
+ if (parsedMonthDay.size() != MONTH_DAY_INPUT_EXACT_SIZE) {
+ throw new IllegalArgumentException(INVALID_MONTH_DAY_INPUT.getMessage());
+ }
+ }
+
+ private static int parseMonth(List<String> parsedMonthDay) {
+ try {
+ return Integer.parseInt(parsedMonthDay.get(MONTH_INDEX));
+ } catch (NumberFormatException e) {
+ throw new IllegalArgumentException(INVALID_MONTH_INPUT.getMessage());
+ }
+ }
+
+ private static void validateMonth(int month) {
+ if (month < MIN_MONTH || MAX_MONTH < month) {
+ throw new IllegalArgumentException(INVALID_MONTH_INPUT.getMessage());
+ }
+ }
+
+ private static void validateDayOfMonth(Day day, LocalDate localDate) {
+ if (!day.isSame(localDate.getDayOfWeek())) {
+ throw new IllegalArgumentException(INVALID_DAY_OF_MONTH.getMessage());
+ }
+ }
+
+ public Worker readWorker() {
+ System.out.print(INPUT_WEEKDAY_EMERGENCY_WORKERS.getMessage());
+ List<String> weekdayWorkers = getWorkers();
+ System.out.print(INPUT_WEEKEND_EMERGENCY_WORKERS.getMessage());
+ List<String> holidayWorkers = getWorkers();
+ validateWeekdayAndHolidayWorkers(weekdayWorkers, holidayWorkers);
+ return new Worker(weekdayWorkers, holidayWorkers);
+ }
+
+ private static List<String> getWorkers() {
+ String weekdayWorkers = Console.readLine();
+ List<String> parsedWorkers = parseByComma(weekdayWorkers);
+ validateWorkers(parsedWorkers);
+ return parsedWorkers;
+ }
+
+ private static void validateWorkers(List<String> workers) {
+ validateWorkerCounts(workers);
+ if (isInvalidNickNameLength(workers)) {
+ throw new IllegalArgumentException(INVALID_NICKNAME_LENGTH.getMessage());
+ }
+ if (isInvalidNickNameCharacter(workers)) {
+ throw new IllegalArgumentException(INVALID_NICKNAME_CHARACTER.getMessage());
+ }
+ if (new HashSet<>(workers).size() != workers.size()) {
+ throw new IllegalArgumentException(DUPLICATED_NICKNAME.getMessage());
+ }
+ }
+
+ private static void validateWorkerCounts(List<String> parsedWeekdayWorkers) {
+ int workerSize = parsedWeekdayWorkers.size();
+ if (workerSize < MIN_WORKER_SIZE || MAX_WORKER_SIZE < workerSize) {
+ throw new IllegalArgumentException(INVALID_WORKER_COUNTS.getMessage());
+ }
+ }
+
+ private static boolean isInvalidNickNameLength(List<String> parsedWeekdayWorkers) {
+ return parsedWeekdayWorkers.stream()
+ .anyMatch(nickName -> nickName.length() < MIN_WORKER_NICKNAME_LENGTH
+ || nickName.length() > MAX_WORKER_NICKNAME_LENGTH);
+ }
+
+ private static boolean isInvalidNickNameCharacter(List<String> parsedWeekdayWorkers) {
+ return parsedWeekdayWorkers.stream()
+ .anyMatch(nickName -> nickName.chars()
+ .anyMatch(character -> character < MIN_KOREAN_CHARACTER || MAX_KOREAN_CHARACTER < character));
+ }
+
+ private static void validateWeekdayAndHolidayWorkers(List<String> weekdayWorkers, List<String> holidayWorkers) {
+ if (!new HashSet<>(weekdayWorkers).containsAll(holidayWorkers)) {
+ throw new IllegalArgumentException(WORKER_NOT_MATCHED.getMessage());
+ }
+ }
+
+ protected enum InputMessage {
+ INPUT_MONTH_DAY("비상 근무를 배정할 월과 시작 요일을 입력하세요> "),
+ INPUT_WEEKDAY_EMERGENCY_WORKERS("평일 비상 근무 순번대로 사원 닉네임을 입력하세요> "),
+ INPUT_WEEKEND_EMERGENCY_WORKERS("휴일 비상 근무 순번대로 사원 닉네임을 입력하세요> ");
+
+ private final String message;
+
+ InputMessage(String message) {
+ this.message = message;
+ }
+
+ public String getMessage() {
+ return message;
+ }
+ }
+} | Java | InputView를 확인해보니 validate관련 함수도 전부 작성되어있더라고요 그래서 검증하는 로직은 따로 관리하는 것이 더 가독성이 좋을 것 같다는 생각이 듭니다
예를 들면 각 도메인에 대한 validate 클래스를 만들어서 관리해도 되고요! 프로그램이 커지다 보면 각 모델에 대한 검증 요소들이 더 생길 수 있고 오류가 발생하면 이거 관련 함수가 뭐였지,,하고 찾아보는 시간도 절약할 수 있고요! |
@@ -0,0 +1,72 @@
+# Domain Documentation
+
+## 도메인 계층의 클래스(객체) 구조도
+
+<img width="609" alt="image" src="https://github.com/woowacourse-precourse/javascript-lotto-6/assets/87177577/24677451-b9f5-4c62-919f-f6dc3342bebf"/>
+
+단, `PromotionResult`의 경우 객체가 아닌 결과물로써 존재하며 해당 데이터는 `PromotionResultService`에서 생성합니다.
+
+<br/>
+
+## OrderMenuAmount
+
+> 주문 총액과 관련된 모듈로, 현재는 총 주문 금액을 계산하기 위해 설계한 모듈
+
+| 메서드 | 매개 변수 | 반환 값 | 설명 |
+| -------------- | --------------- | -------- | -------------------------------------------- |
+| calculateTotal | `orderMenuInfo` | `number` | 주문한 메뉴의 총 금액을 계산하여 반환합니다. |
+
+<br/>
+
+## Menu Searcher
+
+> 메뉴 테이블에 존재하는 메뉴를 찾기 위한 모듈
+
+| 메서드 | 매개 변수 | 반환 값 | 설명 |
+| ---------------- | ------------------------------ | --------------------- | ---------------------------------------------------------------- |
+| findByMenuName | `menuName, category(optional)` | `undefined \| object` | 주어진 카테고리에서 메뉴 이름에 해당하는 메뉴를 찾아 반환합니다. |
+| isMenuInCategory | `menuName, category` | `boolean` | 주어진 카테고리에 메뉴 이름이 존재하는지 여부를 반환합니다. |
+
+<br/>
+
+## DecemberPromotionPlan
+
+> 12월의 프로모션 계획 들을(크리스마스, 주말/평일 할인, 특별 이벤트 및 증정 행사)통해 할인 혜택 들을 제공 하는 모듈
+
+| 메서드 | 매개 변수 | 반환 값 | 설명 |
+| ---------------------------- | ------------------------------------------------------------------------- | ------------------------ | --------------------------------------------------------------------------- |
+| execute | `OrdererInfo { visitDate, totalOrderAmount, orderMenuInfo }` | `PromotionBenefitResult` | 계획을 실행하여 각 프로모션 혜택의 금액 정보가 담긴 객체를 반환합니다. |
+| formatVisitDateForPromotion | `visitDate` | `Date` | 방문 일자를 Date 객체로 변환합니다. |
+| isAvailablePromotion | `{ dateInfo: { formatVisitDate, startDate, endDate }, totalOrderAmount }` | `boolean` | 이벤트 기간과 최소 주문 금액 요건을 충족하는지 여부를 반환합니다. |
+| createPromotionBenefitResult | `OrdererInfo` | `PromotionBenefitResult` | 주문 정보를 바탕으로 각 프로모션 혜택의 금액 정보가 담긴 객체를 반환합니다. |
+| calculateChristmasBenefit | `OrdererInfo` | `number \| 0` | 크리스마스 디데이 할인 금액을 계산합니다. |
+| calculateBenefitForDayType | `CalculateBenefitForDayTypeParams` | `number \| 0` | 요일(주말/평일) 할인 금액을 계산합니다. |
+| calculateSpecialBenefit | `{ visitDate: Date }` | `number \| 0` | 특별 할인이 적용되는 금액을 계산합니다. |
+| calculateGiftEvent | `{ totalOrderAmount: number }` | `number \| 0` | 증정 이벤트 적용 금액을 계산합니다. |
+
+<br/>
+
+## PromotionReceipt
+
+> 총 혜택 금액 및 예상 지출 금액을 묶어 프로모션 결과에 대한 영수증을 표현한 모듈
+
+| 메서드 | 매개 변수 | 반환 값 | 설명 |
+| ------------------------ | ------------------------------------------------------------------ | ------------------ | ------------------------------------------------------------------- |
+| issue | `{ promotionBenefitResult, totalOrderAmount }` | `PromotionReceipt` | 혜택 정보 및 총 주문 금액을 바탕으로 영수증을 발행합니다. |
+| calculateBenefitAmount | `PromotionBenefitResult` | `number` | 주어진 프로모션 혜택 결과를 바탕으로 총 혜택 금액을 계산합니다. |
+| calculateExpectedPayment | `{ totalOrderAmount, promotionBenefitResult, totalBenefitAmount }` | `number` | 총 주문 금액과 총 혜택 금액을 바탕으로 예상 지출 금액을 계산합니다. |
+
+<br/>
+
+## EventBadgeMaker
+
+> 12월의 이벤트 뱃지를 생성하는 모듈
+
+| 메서드 | 매개 변수 | 반환 값 | 설명 |
+| --------------------- | -------------------- | -------------------- | ------------------------------------------------------------------- |
+| createByBenefitAmount | `totalBenefitAmount` | `EventBadge \| null` | 총 혜택 금액에 해당하는 이벤트 뱃지를 생성하거나 null을 반환합니다. |
+| searchTargetBadges | `totalBenefitAmount` | `Array` | 총 혜택 금액에 해당되는 뱃지가 있는 배열을 반환합니다. |
+
+<br/>
+
+`Custom Type` 들은 `src/utils/jsDoc.js`에서 확인이 가능합니다. | Unknown | 깔끔한 documentation 배우고 갑니다 :) |
@@ -0,0 +1,132 @@
+import { FORMAT_MESSAGE, OUTPUT_MESSAGE } from './module';
+
+describe('메시지 포맷 테스트', () => {
+ describe('orderMenus 테스트', () => {
+ test.each([
+ {
+ description: '출력 결과는 "피자 2개 - 콜라 1개" 이다.',
+ input: [
+ ['피자', 2],
+ ['콜라', 1],
+ ],
+ output: '피자 2개\n콜라 1개\n',
+ },
+ ])('$description', ({ input, output }) => {
+ // given - when - then
+ expect(FORMAT_MESSAGE.orderMenus(input)).toBe(output);
+ });
+ });
+
+ describe('amount 테스트', () => {
+ test.each([
+ { input: 5000, output: '5,000원' },
+ { input: 0, output: '0원' },
+ ])('amount가 $input일 때, 출력 메시지는 "$output"이어야 한다', ({ input, output }) => {
+ // given - when - then
+ expect(FORMAT_MESSAGE.amount(input)).toBe(output);
+ });
+ });
+
+ describe('benefitHistory 테스트', () => {
+ test.each([
+ {
+ description:
+ '출력 결과는 "크리스마스 디데이 할인: -1,200원 - 평일 할인: -4,046원 - 특별 할인: -1,000원 - 증정 이벤트: -25,000원"이다.',
+ input: {
+ xmasBenefitAmount: 1200,
+ weekDayBenefitAmount: 4046,
+ specialBenefitAmount: 1000,
+ giftAmount: 25000,
+ },
+ output:
+ '크리스마스 디데이 할인: -1,200원\n평일 할인: -4,046원\n특별 할인: -1,000원\n증정 이벤트: -25,000원',
+ },
+ {
+ description: `프로모션 혜택이 모두 0원인 경우 결과는 "${OUTPUT_MESSAGE.nothing}"이다.`,
+ input: {
+ xmasBenefitAmount: 0,
+ weekendBenefitAmount: 0,
+ weekDayBenefitAmount: 0,
+ specialBenefitAmount: 0,
+ giftAmount: 0,
+ },
+ output: OUTPUT_MESSAGE.nothing,
+ },
+ ])('$description', ({ input, output }) => {
+ // given - when - then
+ expect(FORMAT_MESSAGE.benefitHistory(input)).toBe(output);
+ });
+ });
+
+ describe('title 테스트', () => {
+ test.each([
+ {
+ description: 'newLine 옵션이 false일 경우, 출력 결과는 "<제목>"이다.',
+ input: { config: { newLine: false }, title: '제목' },
+ output: '<제목>',
+ },
+ {
+ description: 'newLine 옵션이 true일 경우, 출력 결과는 "\\n<제목>"이다.',
+ input: { config: { newLine: true }, title: '제목' },
+ output: '\n<제목>',
+ },
+ ])('$description', ({ input, output }) => {
+ // given - when - then
+ expect(FORMAT_MESSAGE.title(input.config, input.title)).toBe(output);
+ });
+ });
+
+ describe('gift 테스트', () => {
+ test.each([
+ {
+ description: '증정 이벤트 금액이 있는 경우 출력 결과는 "샴페인 1개" 이다.',
+ input: 25000,
+ output: '샴페인 1개',
+ },
+ {
+ description: `증정 이벤트 금액이 없는 경우 출력 결과는 "${OUTPUT_MESSAGE.nothing}" 이다.`,
+ input: 0,
+ output: OUTPUT_MESSAGE.nothing,
+ },
+ ])('$description', ({ input: giftAmount, output }) => {
+ // given - when - then
+ expect(FORMAT_MESSAGE.gift(giftAmount)).toBe(output);
+ });
+ });
+
+ describe('totalBenefitAmount 테스트', () => {
+ test.each([
+ {
+ description: '입력이 25000인 경우 "-25,000원"을 반환한다.',
+ input: 25000,
+ output: '-25,000원',
+ },
+ {
+ description: '입력이 0인 경우 "0원"을 반환한다.',
+ input: 0,
+ output: '0원',
+ },
+ ])('$description', ({ input: totalBenefitAmount, output }) => {
+ // given - when - then
+ expect(FORMAT_MESSAGE.totalBenefitAmount(totalBenefitAmount)).toBe(output);
+ });
+ });
+
+ describe('eventBadge 테스트', () => {
+ test.each([
+ {
+ description: '입력이 "산타"인 경우 그대로 "산타"를 반환한다.',
+ input: '산타',
+ output: '산타',
+ },
+ {
+ description: `입력 값이 null인 경우 "${OUTPUT_MESSAGE.nothing}"을 반환한다.`,
+ input: null,
+ output: OUTPUT_MESSAGE.nothing,
+ },
+ ])('$description', ({ input: eventBadge, output }) => {
+ // given - when - then
+ expect(FORMAT_MESSAGE.eventBadge(eventBadge)).toBe(output);
+ });
+ });
+}); | JavaScript | input, output으로 묶어서 testCase를 여러가지 설정하는 방법도 있었군요, 좋은 방법 배우고 갑니다. |
@@ -0,0 +1,84 @@
+import { PROMOTION_DATE_INFO } from '../promotionSystem.js';
+import { SYMBOLS } from '../symbols.js';
+
+export const INPUT_MESSAGE = Object.freeze({
+ visitDate: `${PROMOTION_DATE_INFO.month}월 중 식당 예상 방문 날짜는 언제인가요? (숫자만 입력해 주세요!)\n`,
+ orderMenus:
+ '주문하실 메뉴를 메뉴와 개수를 알려 주세요. (e.g. 해산물파스타-2,레드와인-1,초코케이크-1)\n',
+});
+
+export const OUTPUT_MESSAGE = Object.freeze({
+ guideComments: `안녕하세요! 우테코 식당 ${PROMOTION_DATE_INFO.month}월 이벤트 플래너입니다.`,
+
+ title: Object.freeze({
+ orderMenu: '주문 메뉴',
+ totalOrderAmount: '할인 전 총주문 금액',
+ giftMenu: '증정 메뉴',
+ benefitHistory: '혜택 내역',
+ totalBenefitAmount: '총혜택 금액',
+ expectPaymentAmount: '할인 후 예상 결제 금액',
+ eventBadge: `${PROMOTION_DATE_INFO.month}월 이벤트 배지`,
+ }),
+
+ benefitLabels: Object.freeze({
+ xmasBenefitAmount: '크리스마스 디데이 할인',
+ weekDayBenefitAmount: '평일 할인',
+ weekendBenefitAmount: '주말 할인',
+ specialBenefitAmount: '특별 할인',
+ giftAmount: '증정 이벤트',
+ }),
+
+ nothing: '없음',
+
+ gift: '샴페인 1개',
+});
+
+export const FORMAT_MESSAGE = Object.freeze({
+ date(visitDate) {
+ return `${PROMOTION_DATE_INFO.month}월 ${visitDate}일`;
+ },
+
+ endGuideComments(visitDate) {
+ return `${this.date(visitDate)}에 우테코 식당에서 받을 이벤트 혜택 미리 보기!`;
+ },
+
+ title(config, title) {
+ return `${config.newLine ? '\n' : SYMBOLS.emptyString}<${title}>`;
+ },
+
+ orderMenus(orderMenuInfo) {
+ return orderMenuInfo
+ .map(([menuName, quantity]) => `${menuName} ${quantity}개\n`)
+ .join(SYMBOLS.emptyString);
+ },
+
+ amount(amount) {
+ return `${amount.toLocaleString()}원`;
+ },
+
+ benefitHistory(benefitInfo) {
+ return (
+ Object.entries(benefitInfo)
+ .reduce(
+ (acc, [benefitName, amount]) =>
+ amount !== 0
+ ? [...acc, `${OUTPUT_MESSAGE.benefitLabels[benefitName]}: -${this.amount(amount)}`]
+ : acc,
+ [],
+ )
+ .join('\n') || OUTPUT_MESSAGE.nothing
+ );
+ },
+
+ totalBenefitAmount(totalBenefitAmount) {
+ return totalBenefitAmount === 0 ? `${this.amount(0)}` : `-${this.amount(totalBenefitAmount)}`;
+ },
+
+ gift(giftAmount) {
+ return giftAmount === 0 ? OUTPUT_MESSAGE.nothing : OUTPUT_MESSAGE.gift;
+ },
+
+ eventBadge(eventBadge) {
+ return eventBadge ?? OUTPUT_MESSAGE.nothing;
+ },
+}); | JavaScript | freeze된 객체 안에 함수를 넣어서 return값으로 받을 수 있다는 것도 알게 되었습니다.
응용했다면 많이 간단한 코드를 작성해 볼 수 있었을 것 같습니다
좋은 정보 감사합니다! |
@@ -0,0 +1,49 @@
+import InputView from '../views/InputView.js';
+import OutputView from '../views/OutputView.js';
+import PromotionResultService from '../service/PromotionResultService.js';
+import ErrorHandler from '../errors/ErrorHandler/module.js';
+
+/**
+ * @module ChristmasPromotionController
+ * 크리스마스 프로모션 이벤트 관련 애플리케이션의 흐름 제어를 담당
+ */
+const ChristmasPromotionController = {
+ /**
+ * @returns {Promise<void>}
+ */
+ async play() {
+ const { visitDate, orderMenuInfo } = await processUserInput();
+
+ processPromotionResult({ visitDate, orderMenuInfo });
+ },
+};
+
+/**
+ * @returns {Promise<{visitDate : number, orderMenuInfo : [string, number][]}>} 유저가 입력한 방문 일자 및 메뉴 정보를 반환할 Promise 객체
+ */
+async function processUserInput() {
+ OutputView.printStartGuideComments();
+
+ const visitDate = await ErrorHandler.retryOnErrors(InputView.readVisitDate.bind(InputView));
+ const orderMenuInfo = await ErrorHandler.retryOnErrors(
+ InputView.readOrderMenuInfo.bind(InputView),
+ );
+
+ return { visitDate, orderMenuInfo };
+}
+
+/**
+ * @param {{visitDate : number, orderMenuInfo : [string, number][]}} params - 유저가 입력한 방문 일자 및 메뉴 정보
+ * @returns {void}
+ */
+function processPromotionResult({ visitDate, orderMenuInfo }) {
+ const promotionResult = PromotionResultService.createPromotionResult({
+ visitDate,
+ orderMenuInfo,
+ });
+
+ OutputView.printEndGuideComments(visitDate);
+ OutputView.printPromotionResult({ orderMenuInfo, promotionResult });
+}
+
+export default ChristmasPromotionController; | JavaScript | [Nit] 취향에서 갈리는 영역이라고 생각하는데 콜백 대신에 동적 this binding을 사용하신 이유가 있으신가요? |
@@ -0,0 +1,132 @@
+import { FORMAT_MESSAGE, OUTPUT_MESSAGE } from './module';
+
+describe('메시지 포맷 테스트', () => {
+ describe('orderMenus 테스트', () => {
+ test.each([
+ {
+ description: '출력 결과는 "피자 2개 - 콜라 1개" 이다.',
+ input: [
+ ['피자', 2],
+ ['콜라', 1],
+ ],
+ output: '피자 2개\n콜라 1개\n',
+ },
+ ])('$description', ({ input, output }) => {
+ // given - when - then
+ expect(FORMAT_MESSAGE.orderMenus(input)).toBe(output);
+ });
+ });
+
+ describe('amount 테스트', () => {
+ test.each([
+ { input: 5000, output: '5,000원' },
+ { input: 0, output: '0원' },
+ ])('amount가 $input일 때, 출력 메시지는 "$output"이어야 한다', ({ input, output }) => {
+ // given - when - then
+ expect(FORMAT_MESSAGE.amount(input)).toBe(output);
+ });
+ });
+
+ describe('benefitHistory 테스트', () => {
+ test.each([
+ {
+ description:
+ '출력 결과는 "크리스마스 디데이 할인: -1,200원 - 평일 할인: -4,046원 - 특별 할인: -1,000원 - 증정 이벤트: -25,000원"이다.',
+ input: {
+ xmasBenefitAmount: 1200,
+ weekDayBenefitAmount: 4046,
+ specialBenefitAmount: 1000,
+ giftAmount: 25000,
+ },
+ output:
+ '크리스마스 디데이 할인: -1,200원\n평일 할인: -4,046원\n특별 할인: -1,000원\n증정 이벤트: -25,000원',
+ },
+ {
+ description: `프로모션 혜택이 모두 0원인 경우 결과는 "${OUTPUT_MESSAGE.nothing}"이다.`,
+ input: {
+ xmasBenefitAmount: 0,
+ weekendBenefitAmount: 0,
+ weekDayBenefitAmount: 0,
+ specialBenefitAmount: 0,
+ giftAmount: 0,
+ },
+ output: OUTPUT_MESSAGE.nothing,
+ },
+ ])('$description', ({ input, output }) => {
+ // given - when - then
+ expect(FORMAT_MESSAGE.benefitHistory(input)).toBe(output);
+ });
+ });
+
+ describe('title 테스트', () => {
+ test.each([
+ {
+ description: 'newLine 옵션이 false일 경우, 출력 결과는 "<제목>"이다.',
+ input: { config: { newLine: false }, title: '제목' },
+ output: '<제목>',
+ },
+ {
+ description: 'newLine 옵션이 true일 경우, 출력 결과는 "\\n<제목>"이다.',
+ input: { config: { newLine: true }, title: '제목' },
+ output: '\n<제목>',
+ },
+ ])('$description', ({ input, output }) => {
+ // given - when - then
+ expect(FORMAT_MESSAGE.title(input.config, input.title)).toBe(output);
+ });
+ });
+
+ describe('gift 테스트', () => {
+ test.each([
+ {
+ description: '증정 이벤트 금액이 있는 경우 출력 결과는 "샴페인 1개" 이다.',
+ input: 25000,
+ output: '샴페인 1개',
+ },
+ {
+ description: `증정 이벤트 금액이 없는 경우 출력 결과는 "${OUTPUT_MESSAGE.nothing}" 이다.`,
+ input: 0,
+ output: OUTPUT_MESSAGE.nothing,
+ },
+ ])('$description', ({ input: giftAmount, output }) => {
+ // given - when - then
+ expect(FORMAT_MESSAGE.gift(giftAmount)).toBe(output);
+ });
+ });
+
+ describe('totalBenefitAmount 테스트', () => {
+ test.each([
+ {
+ description: '입력이 25000인 경우 "-25,000원"을 반환한다.',
+ input: 25000,
+ output: '-25,000원',
+ },
+ {
+ description: '입력이 0인 경우 "0원"을 반환한다.',
+ input: 0,
+ output: '0원',
+ },
+ ])('$description', ({ input: totalBenefitAmount, output }) => {
+ // given - when - then
+ expect(FORMAT_MESSAGE.totalBenefitAmount(totalBenefitAmount)).toBe(output);
+ });
+ });
+
+ describe('eventBadge 테스트', () => {
+ test.each([
+ {
+ description: '입력이 "산타"인 경우 그대로 "산타"를 반환한다.',
+ input: '산타',
+ output: '산타',
+ },
+ {
+ description: `입력 값이 null인 경우 "${OUTPUT_MESSAGE.nothing}"을 반환한다.`,
+ input: null,
+ output: OUTPUT_MESSAGE.nothing,
+ },
+ ])('$description', ({ input: eventBadge, output }) => {
+ // given - when - then
+ expect(FORMAT_MESSAGE.eventBadge(eventBadge)).toBe(output);
+ });
+ });
+}); | JavaScript | 구조분해를 이용해 `description`은 버리고 `input`, `output`만 가져오는 게 좋은 것 같네요!
그런데 테스트 케이스가 하나인 것 같은데 `test.each()`를 사용하신 이유가 있는지 궁금합니다. |
@@ -0,0 +1,49 @@
+import InputView from '../views/InputView.js';
+import OutputView from '../views/OutputView.js';
+import PromotionResultService from '../service/PromotionResultService.js';
+import ErrorHandler from '../errors/ErrorHandler/module.js';
+
+/**
+ * @module ChristmasPromotionController
+ * 크리스마스 프로모션 이벤트 관련 애플리케이션의 흐름 제어를 담당
+ */
+const ChristmasPromotionController = {
+ /**
+ * @returns {Promise<void>}
+ */
+ async play() {
+ const { visitDate, orderMenuInfo } = await processUserInput();
+
+ processPromotionResult({ visitDate, orderMenuInfo });
+ },
+};
+
+/**
+ * @returns {Promise<{visitDate : number, orderMenuInfo : [string, number][]}>} 유저가 입력한 방문 일자 및 메뉴 정보를 반환할 Promise 객체
+ */
+async function processUserInput() {
+ OutputView.printStartGuideComments();
+
+ const visitDate = await ErrorHandler.retryOnErrors(InputView.readVisitDate.bind(InputView));
+ const orderMenuInfo = await ErrorHandler.retryOnErrors(
+ InputView.readOrderMenuInfo.bind(InputView),
+ );
+
+ return { visitDate, orderMenuInfo };
+}
+
+/**
+ * @param {{visitDate : number, orderMenuInfo : [string, number][]}} params - 유저가 입력한 방문 일자 및 메뉴 정보
+ * @returns {void}
+ */
+function processPromotionResult({ visitDate, orderMenuInfo }) {
+ const promotionResult = PromotionResultService.createPromotionResult({
+ visitDate,
+ orderMenuInfo,
+ });
+
+ OutputView.printEndGuideComments(visitDate);
+ OutputView.printPromotionResult({ orderMenuInfo, promotionResult });
+}
+
+export default ChristmasPromotionController; | JavaScript | 컨트롤러 모듈이 짧고 읽기 편한 것 같아요! |
@@ -0,0 +1,31 @@
+import { PROMOTION_MENU_TABLE } from '../../constants/promotionSystem.js';
+
+/**
+ * @module MenuSearcher
+ * 메뉴 테이블에 존재하는 메뉴를 찾기 위한 모듈
+ */
+const MenuSearcher = Object.freeze({
+ /**
+ * @param {string} menuName - 메뉴 이름
+ * @param {string} category - 메뉴 카테고리
+ * @returns {undefined | string} 매칭 되거나 매칭 되지 않은(undefined) 메뉴 이름
+ */
+ findByMenuName(menuName, category) {
+ const menusForSearch =
+ PROMOTION_MENU_TABLE[category] ??
+ Object.values(PROMOTION_MENU_TABLE).flatMap((section) => section);
+
+ return menusForSearch.find((menu) => menu.name === menuName);
+ },
+
+ /**
+ * @param {string} menuName - 메뉴 이름
+ * @param {string} category - 메뉴 카테고리
+ * @returns {boolean} 카테고리에 있는 메뉴 이름이 실제 메뉴 테이블에 존재하는지에 대한 여부
+ */
+ isMenuInCategory(menuName, category) {
+ return this.findByMenuName(menuName, category) !== undefined;
+ },
+});
+
+export default MenuSearcher; | JavaScript | 빌트인 메서드 활용👍👍👍 |
@@ -0,0 +1,53 @@
+import { PROMOTION_DATE_INFO } from '../../constants/promotionSystem.js';
+
+// constant.js는 테스트 코드 및 module.js에서만 사용
+export const INITIAL_PROMOTION_BENEFIT_RESULT = Object.freeze({
+ xmasBenefitAmount: 0,
+ weekDayBenefitAmount: 0,
+ weekendBenefitAmount: 0,
+ specialBenefitAmount: 0,
+ giftAmount: 0,
+});
+
+export const MINIMUM_TOTAL_ORDER_AMOUNT = 10000;
+
+export const BENEFIT_DATE_INFO = Object.freeze({
+ startDate: new Date(`${PROMOTION_DATE_INFO.year}-${PROMOTION_DATE_INFO.month}-01`),
+ endDate: new Date(`${PROMOTION_DATE_INFO.year}-${PROMOTION_DATE_INFO.month}-31`),
+ christmas: new Date(`${PROMOTION_DATE_INFO.year}-${PROMOTION_DATE_INFO.month}-25`),
+});
+
+export const DAY_OF_BENEFIT_CONDITION = Object.freeze({
+ weekday: Object.freeze({
+ menuCategory: '디저트',
+ days: [0, 1, 2, 3, 4],
+ }),
+
+ weekend: Object.freeze({
+ menuCategory: '메인',
+ days: [5, 6],
+ }),
+});
+
+export const BENEFIT_AMOUNT_INFO = Object.freeze({
+ everyDay: 100,
+ christmas: 1000,
+ dayOfWeek: 2023,
+ special: 1000,
+});
+
+export const MINIMUM_ORDER_AMOUNT_FOR_GIFT = 120000;
+
+export const GIFT_INFO = {
+ menuCategory: '음료',
+ menuName: '샴페인',
+};
+
+export const SPECIAL_DATES = new Set([
+ `${PROMOTION_DATE_INFO.year}-${PROMOTION_DATE_INFO.month}-03`,
+ `${PROMOTION_DATE_INFO.year}-${PROMOTION_DATE_INFO.month}-10`,
+ `${PROMOTION_DATE_INFO.year}-${PROMOTION_DATE_INFO.month}-17`,
+ `${PROMOTION_DATE_INFO.year}-${PROMOTION_DATE_INFO.month}-24`,
+ `${PROMOTION_DATE_INFO.year}-${PROMOTION_DATE_INFO.month}-25`,
+ `${PROMOTION_DATE_INFO.year}-${PROMOTION_DATE_INFO.month}-31`,
+]); | JavaScript | 도메인마다 상수 파일을 만들어서 사용하고 계시는데, 이미 있는 `constants` 디렉토리에 상수를 묶어놓지 않으시는 이유가 있는지 궁금해요. 만약 새로운 개발자가 들어온다면, `constants`에 모든 상수가 들어 있을 거라고 기대할 것 같은데요. 중요한 상수들이 `domain` 안에 있는 하위 디렉토리에 들어있어서 혼란을 줄 수 있을 것 같습니다. 테스트 코드 파일도 마찬가지라고 생각해요😅.
상수나 테스트 파일 모두 특정 디렉토리 안에 묶으면 사용이나 관리가 더 수월할 것 같은데 어떻게 생각하시나요? 또 그렇게 하면 `domain`의 하위 디렉토리들을 없앨 수 있어서 `domain` 파일들도 관리하기가 수월해질 것 같아요. |
@@ -0,0 +1,49 @@
+import InputView from '../views/InputView.js';
+import OutputView from '../views/OutputView.js';
+import PromotionResultService from '../service/PromotionResultService.js';
+import ErrorHandler from '../errors/ErrorHandler/module.js';
+
+/**
+ * @module ChristmasPromotionController
+ * 크리스마스 프로모션 이벤트 관련 애플리케이션의 흐름 제어를 담당
+ */
+const ChristmasPromotionController = {
+ /**
+ * @returns {Promise<void>}
+ */
+ async play() {
+ const { visitDate, orderMenuInfo } = await processUserInput();
+
+ processPromotionResult({ visitDate, orderMenuInfo });
+ },
+};
+
+/**
+ * @returns {Promise<{visitDate : number, orderMenuInfo : [string, number][]}>} 유저가 입력한 방문 일자 및 메뉴 정보를 반환할 Promise 객체
+ */
+async function processUserInput() {
+ OutputView.printStartGuideComments();
+
+ const visitDate = await ErrorHandler.retryOnErrors(InputView.readVisitDate.bind(InputView));
+ const orderMenuInfo = await ErrorHandler.retryOnErrors(
+ InputView.readOrderMenuInfo.bind(InputView),
+ );
+
+ return { visitDate, orderMenuInfo };
+}
+
+/**
+ * @param {{visitDate : number, orderMenuInfo : [string, number][]}} params - 유저가 입력한 방문 일자 및 메뉴 정보
+ * @returns {void}
+ */
+function processPromotionResult({ visitDate, orderMenuInfo }) {
+ const promotionResult = PromotionResultService.createPromotionResult({
+ visitDate,
+ orderMenuInfo,
+ });
+
+ OutputView.printEndGuideComments(visitDate);
+ OutputView.printPromotionResult({ orderMenuInfo, promotionResult });
+}
+
+export default ChristmasPromotionController; | JavaScript | 이름을 통해 의미를 명확하게 파악할 수 있는 경우에는 주석이 없어도 괜찮지 않을까요? |
@@ -0,0 +1,143 @@
+import MenuSearcher from '../MenuSearcher/module.js';
+import { PROMOTION_DATE_INFO } from '../../constants/promotionSystem.js';
+import {
+ DAY_OF_BENEFIT_CONDITION,
+ BENEFIT_DATE_INFO,
+ INITIAL_PROMOTION_BENEFIT_RESULT,
+ MINIMUM_TOTAL_ORDER_AMOUNT,
+ BENEFIT_AMOUNT_INFO,
+ MINIMUM_ORDER_AMOUNT_FOR_GIFT,
+ GIFT_INFO,
+ SPECIAL_DATES,
+} from './constant.js';
+
+/**
+ * @module DecemberPromotionPlan
+ * 12월의 프로모션 계획 들을(크리스마스, 주말/평일 할인, 특별 이벤트 및 증정 행사)통해 할인 혜택 들을 제공 하는 모듈
+ */
+const DecemberPromotionPlan = Object.freeze({
+ /**
+ * @param {import('../../utils/jsDoc.js').OrdererInfo} ordererInfo - 주문자 정보(방문 일자, 총 주문 금액, 주문한 메뉴 정보)
+ * @returns {import('../../utils/jsDoc.js').PromotionBenefitResult} 각 혜택 금액 정보
+ */
+ execute({ visitDate, totalOrderAmount, orderMenuInfo }) {
+ const { startDate, endDate } = BENEFIT_DATE_INFO;
+ const formatVisitDate = formatVisitDateForPromotion(visitDate);
+ const params = { dateInfo: { formatVisitDate, startDate, endDate }, totalOrderAmount };
+
+ return isAvailablePromotion(params)
+ ? createPromotionBenefitResult({
+ visitDate: formatVisitDate,
+ totalOrderAmount,
+ orderMenuInfo,
+ })
+ : INITIAL_PROMOTION_BENEFIT_RESULT;
+ },
+});
+
+export default DecemberPromotionPlan;
+
+/**
+ * @param {number} visitDate - 방문 일자
+ * @returns {Date} 방문 일자에 대한 Date 객체
+ */
+function formatVisitDateForPromotion(visitDate) {
+ const { year, month } = PROMOTION_DATE_INFO;
+
+ return visitDate < 10
+ ? new Date(`${year}-${month}-0${visitDate}`)
+ : new Date(`${year}-${month}-${visitDate}`);
+}
+
+/**
+ * @param {{dateInfo: {formatVisitDate: Date, startDate: Date, endDate: Date}, totalOrderAmount: number}} params - 프로모션이 유효한지 확인할 정보
+ * @returns {boolean} 이벤트 기간 및 최소 주문 금액 요건을 충족하는지 여부
+ */
+function isAvailablePromotion({
+ dateInfo: { formatVisitDate, startDate, endDate },
+ totalOrderAmount,
+}) {
+ return (
+ formatVisitDate >= startDate &&
+ formatVisitDate <= endDate &&
+ totalOrderAmount >= MINIMUM_TOTAL_ORDER_AMOUNT
+ );
+}
+
+/**
+ * @param {import('../../utils/jsDoc.js').OrdererInfo} ordererInfo - 주문자 정보(방문 일자, 총 주문 금액, 주문한 메뉴 정보)
+ * @returns {import('../../utils/jsDoc.js').PromotionBenefitResult} 각 혜택 금액 정보
+ */
+function createPromotionBenefitResult(ordererInfo) {
+ const { weekday, weekend } = DAY_OF_BENEFIT_CONDITION;
+
+ return {
+ xmasBenefitAmount: calculateChristmasBenefit(ordererInfo),
+ weekDayBenefitAmount: calculateBenefitForDayType({ ordererInfo, ...weekday }),
+ weekendBenefitAmount: calculateBenefitForDayType({ ordererInfo, ...weekend }),
+ specialBenefitAmount: calculateSpecialBenefit(ordererInfo),
+ giftAmount: calculateGiftEvent(ordererInfo),
+ };
+}
+
+/**
+ * @param {import('../../utils/jsDoc.js').OrdererInfo} ordererInfo - 주문자 정보(방문 일자, 총 주문 금액, 주문한 메뉴 정보)
+ * @returns {number | 0} 크리스마스 디데이 할인이 적용되거나 적용되지 않은 금액
+ */
+function calculateChristmasBenefit({ visitDate }) {
+ const { startDate, christmas: endDate } = BENEFIT_DATE_INFO;
+
+ if (!(visitDate >= startDate && visitDate <= endDate)) return 0;
+
+ const millisecondPerDay = 1000 * 60 * 60 * 24;
+ const daysUntilChristmas = Math.floor((endDate - visitDate) / millisecondPerDay);
+
+ const { christmas, everyDay } = BENEFIT_AMOUNT_INFO;
+
+ const totalEventDay = 24;
+ return christmas + everyDay * (totalEventDay - daysUntilChristmas);
+}
+
+/**
+ *
+ * @param {import('../../utils/jsDoc.js').CalculateBenefitForDayTypeParams} params - 주문자 정보 + 요일 할인 조건이 들어있는 매개 변수
+ * @returns {number | 0} 요일(주말/평일) 할인이 적용되거나 적용 되지 않은 금액
+ */
+function calculateBenefitForDayType({
+ ordererInfo: { orderMenuInfo, visitDate },
+ menuCategory,
+ days,
+}) {
+ return !days.includes(visitDate.getDay())
+ ? 0
+ : orderMenuInfo
+ .filter(([menuName]) => MenuSearcher.isMenuInCategory(menuName, menuCategory))
+ .reduce(
+ (totalBenefit, [, quantity]) => totalBenefit + BENEFIT_AMOUNT_INFO.dayOfWeek * quantity,
+ 0,
+ );
+}
+
+/**
+ * @param {{visitDate : Date}} params - 방문 일자(Date 객체)가 포함된 객체
+ * @returns {number | 0} 특별 할인이 적용되거나 적용되지 않은 금액
+ */
+function calculateSpecialBenefit({ visitDate }) {
+ const formattedVisitDate = visitDate.toISOString().substring(0, 10);
+ const specialDates = SPECIAL_DATES;
+
+ return specialDates.has(formattedVisitDate) ? BENEFIT_AMOUNT_INFO.special : 0;
+}
+
+/**
+ * @param {{totalOrderAmount : number}} params - 총 주문 금액이 포함된 객체
+ * @returns {number | 0} 증정 이벤트가 적용되거나 적용되지 않은 금액
+ */
+function calculateGiftEvent({ totalOrderAmount }) {
+ if (totalOrderAmount < MINIMUM_ORDER_AMOUNT_FOR_GIFT) return 0;
+
+ const { menuCategory, menuName } = GIFT_INFO;
+ const champagne = MenuSearcher.findByMenuName(menuName, menuCategory);
+
+ return champagne.price;
+} | JavaScript | [Nit] 특별 할인 일자도 `Date`로 관리한다면 파싱 로직을 `Date` 객체에 맞게 선언적으로 관리 할 수 있지 않을까요? 아니면 메모리상 이점을 노리신건가요? |
@@ -0,0 +1,63 @@
+export const PROMOTION_DATE_INFO = Object.freeze({
+ year: 2023,
+ month: 12,
+});
+
+export const PROMOTION_MENU_TABLE = Object.freeze({
+ 애피타이저: [
+ {
+ name: '양송이수프',
+ price: 6_000,
+ },
+ {
+ name: '타파스',
+ price: 5_500,
+ },
+ {
+ name: '시저샐러드',
+ price: 8_000,
+ },
+ ],
+ 메인: [
+ {
+ name: '티본스테이크',
+ price: 55_000,
+ },
+ {
+ name: '바비큐립',
+ price: 54_000,
+ },
+ {
+ name: '해산물파스타',
+ price: 35_000,
+ },
+ {
+ name: '크리스마스파스타',
+ price: 25_000,
+ },
+ ],
+ 디저트: [
+ {
+ name: '초코케이크',
+ price: 15_000,
+ },
+ {
+ name: '아이스크림',
+ price: 5_000,
+ },
+ ],
+ 음료: [
+ {
+ name: '제로콜라',
+ price: 3_000,
+ },
+ {
+ name: '레드와인',
+ price: 60_000,
+ },
+ {
+ name: '샴페인',
+ price: 25_000,
+ },
+ ],
+}); | JavaScript | `Badge` 같은 경우에는 `EventBadgeMaker` 모듈과 같은 디렉토리에 존재하는데 메뉴도 같은 모듈에 있다면 어떨까요? |
@@ -0,0 +1,277 @@
+import { PROMOTION_DATE_INFO } from '../../constants/promotionSystem';
+import {
+ BENEFIT_AMOUNT_INFO,
+ MINIMUM_ORDER_AMOUNT_FOR_GIFT,
+ INITIAL_PROMOTION_BENEFIT_RESULT,
+ MINIMUM_TOTAL_ORDER_AMOUNT,
+} from './constant';
+import DecemberPromotionPlan from './module';
+
+describe('12월 이벤트 계획에 따른 혜택 계산 테스트', () => {
+ const createBenefitResult = (ordererInfo) => DecemberPromotionPlan.execute(ordererInfo);
+
+ const createOrdererInfoTestCase = ({
+ visitDate = 3,
+ orderMenuInfo = [
+ ['티본스테이크', 1],
+ ['바비큐립', 1],
+ ['초코케이크', 2],
+ ['제로콜라', 1],
+ ],
+ totalOrderAmount = 142000,
+ } = {}) => ({
+ visitDate,
+ orderMenuInfo,
+ totalOrderAmount,
+ });
+
+ describe('프로모션 적용 여부 테스트', () => {
+ test.each([
+ {
+ description: `5000원은 ${MINIMUM_TOTAL_ORDER_AMOUNT}원 미만 이기 때문에 프로모션 적용이 되지 않는다.`,
+ ordererInfo: {
+ visitDate: 3,
+ orderMenuInfo: ['아이스크림', 1],
+ totalOrderAmount: 5000,
+ },
+ expectedBenefitInfo: {
+ ...INITIAL_PROMOTION_BENEFIT_RESULT,
+ },
+ },
+ ])('$description', ({ ordererInfo, expectedBenefitInfo }) => {
+ // given - when
+ const benefitResult = createBenefitResult(ordererInfo);
+
+ // then
+ expect(benefitResult).toStrictEqual(expectedBenefitInfo);
+ });
+ });
+
+ describe('평일 할인 적용 여부 테스트', () => {
+ test.each([
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 3일은 평일이기 때문에 할인이 적용된다.`,
+ ordererInfo: {
+ ...createOrdererInfoTestCase(),
+ },
+ expectedBenefitInfo: {
+ weekDayBenefitAmount: 2 * BENEFIT_AMOUNT_INFO.dayOfWeek,
+ },
+ },
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 2일은 주말이기 때문에 할인이 적용되지 않는다.`,
+ ordererInfo: {
+ ...createOrdererInfoTestCase({
+ visitDate: 2,
+ }),
+ },
+ expectedBenefitInfo: {
+ weekDayBenefitAmount: 0,
+ },
+ },
+ ])('$description', ({ ordererInfo, expectedBenefitInfo }) => {
+ // given - when
+ const benefitResult = createBenefitResult(ordererInfo);
+
+ // then
+ expect(benefitResult.weekDayBenefitAmount).toBe(expectedBenefitInfo.weekDayBenefitAmount);
+ });
+ });
+
+ describe('주말 할인 적용 여부 테스트', () => {
+ test.each([
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 2일은 주말이기 때문에 할인이 적용된다.`,
+ ordererInfo: {
+ ...createOrdererInfoTestCase({
+ visitDate: 2,
+ }),
+ },
+ expectedBenefitInfo: {
+ weekendBenefitAmount: BENEFIT_AMOUNT_INFO.dayOfWeek * 2,
+ },
+ },
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 3일은 평일이기 때문에 할인이 적용되지 않는다.`,
+ ordererInfo: {
+ ...createOrdererInfoTestCase(),
+ },
+ expectedBenefitInfo: {
+ weekendBenefitAmount: 0,
+ },
+ },
+ ])('$description', ({ ordererInfo, expectedBenefitInfo }) => {
+ // given - when
+ const benefitResult = createBenefitResult(ordererInfo);
+
+ // then
+ expect(benefitResult.weekendBenefitAmount).toBe(expectedBenefitInfo.weekendBenefitAmount);
+ });
+ });
+
+ describe('12월 이벤트 적용 여부 테스트', () => {
+ test.each([
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 1일은 ${PROMOTION_DATE_INFO.month}월 할인이 적용된다.`,
+ ordererInfo: {
+ ...createOrdererInfoTestCase({ visitDate: 1 }),
+ },
+ expectedBenefitInfo: {
+ xmasBenefitAmount: BENEFIT_AMOUNT_INFO.christmas,
+ giftAmount: 25000,
+ specialBenefitAmount: 0,
+ weekDayBenefitAmount: 0,
+ weekendBenefitAmount: BENEFIT_AMOUNT_INFO.dayOfWeek * 2,
+ },
+ },
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 31일은 12월 할인이 적용된다.`,
+ ordererInfo: {
+ ...createOrdererInfoTestCase({
+ visitDate: 31,
+ }),
+ },
+ expectedBenefitInfo: {
+ xmasBenefitAmount: 0,
+ weekDayBenefitAmount: BENEFIT_AMOUNT_INFO.dayOfWeek * 2,
+ weekendBenefitAmount: 0,
+ specialBenefitAmount: BENEFIT_AMOUNT_INFO.special,
+ giftAmount: 25000,
+ },
+ },
+ ])('$description', ({ ordererInfo, expectedBenefitInfo }) => {
+ // given - when
+ const benefitResult = createBenefitResult(ordererInfo);
+
+ // then
+ expect(benefitResult).toStrictEqual(expectedBenefitInfo);
+ });
+ });
+
+ describe('증정 이벤트 적용 여부 테스트', () => {
+ test.each([
+ {
+ description: `88000원은 ${MINIMUM_ORDER_AMOUNT_FOR_GIFT}만원 미만이므로 샴페인이 증정되지 않는다.`,
+ ordererInfo: {
+ visitDate: 2,
+ orderMenuInfo: [
+ ['티본스테이크', 1],
+ ['초코케이크', 2],
+ ['제로콜라', 1],
+ ],
+ totalOrderAmount: 88000,
+ },
+ expectedBenefitInfo: {
+ giftAmount: 0,
+ },
+ },
+ {
+ description: `142000원은 ${MINIMUM_ORDER_AMOUNT_FOR_GIFT}만원 초과이므로 샴페인이 증정된다.`,
+ ordererInfo: {
+ ...createOrdererInfoTestCase(),
+ },
+ expectedBenefitInfo: {
+ giftAmount: 25000,
+ },
+ },
+ ])('$description', ({ ordererInfo, expectedBenefitInfo }) => {
+ // given - when
+ const benefitResult = createBenefitResult(ordererInfo);
+ // then
+ expect(benefitResult.giftAmount).toBe(expectedBenefitInfo.giftAmount);
+ });
+ });
+
+ describe('크리스마스 이벤트 적용 여부 테스트', () => {
+ test.each([
+ {
+ description: '크리스마스가 지난 이후는 할인이 적용되지 않는다.',
+ ordererInfo: {
+ ...createOrdererInfoTestCase({
+ visitDate: 26,
+ }),
+ },
+ expectedBenefitInfo: {
+ xmasBenefitAmount: 0,
+ },
+ },
+ {
+ description: '크리스마스 전에는 할인이 적용 된다.',
+ ordererInfo: {
+ ...createOrdererInfoTestCase({
+ visitDate: 24,
+ }),
+ },
+ expectedBenefitInfo: {
+ xmasBenefitAmount: 3300,
+ },
+ },
+ ])('$description', ({ ordererInfo, expectedBenefitInfo }) => {
+ // given - when
+ const benefitResult = createBenefitResult(ordererInfo);
+
+ // then
+ expect(benefitResult.xmasBenefitAmount).toBe(expectedBenefitInfo.xmasBenefitAmount);
+ });
+ });
+
+ describe('특별 할인 이벤트 적용 여부 테스트', () => {
+ test.each([
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 3일은 특별 할인 이벤트가 적용된다.`,
+ ordererInfo: createOrdererInfoTestCase({
+ visitDate: 3,
+ }),
+ expectedBenefitInfo: { specialBenefitAmount: BENEFIT_AMOUNT_INFO.special },
+ },
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 10일은 특별 할인 이벤트가 적용된다.`,
+ ordererInfo: createOrdererInfoTestCase({
+ visitDate: 10,
+ }),
+ expectedBenefitInfo: { specialBenefitAmount: BENEFIT_AMOUNT_INFO.special },
+ },
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 17일은 특별 할인 이벤트가 적용된다.`,
+ ordererInfo: createOrdererInfoTestCase({
+ visitDate: 17,
+ }),
+ expectedBenefitInfo: { specialBenefitAmount: BENEFIT_AMOUNT_INFO.special },
+ },
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 24일은 특별 할인 이벤트가 적용된다.`,
+ ordererInfo: createOrdererInfoTestCase({
+ visitDate: 24,
+ }),
+ expectedBenefitInfo: { specialBenefitAmount: BENEFIT_AMOUNT_INFO.special },
+ },
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 25일은 특별 할인 이벤트가 적용된다.`,
+ ordererInfo: createOrdererInfoTestCase({
+ visitDate: 25,
+ }),
+ expectedBenefitInfo: { specialBenefitAmount: BENEFIT_AMOUNT_INFO.special },
+ },
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 31일은 특별 할인 이벤트가 적용된다.`,
+ ordererInfo: createOrdererInfoTestCase({
+ visitDate: 31,
+ }),
+ expectedBenefitInfo: { specialBenefitAmount: BENEFIT_AMOUNT_INFO.special },
+ },
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 30일은 특별 할인 이벤트가 적용되지 않는다.`,
+ ordererInfo: createOrdererInfoTestCase({
+ visitDate: 30,
+ }),
+ expectedBenefitInfo: { specialBenefitAmount: 0 },
+ },
+ ])('$description', ({ ordererInfo, expectedBenefitInfo }) => {
+ // given - when
+ const benefitResult = createBenefitResult(ordererInfo);
+
+ // then
+ expect(benefitResult.specialBenefitAmount).toBe(expectedBenefitInfo.specialBenefitAmount);
+ });
+ });
+}); | JavaScript | `'크리스마스가 지난 이후'`와 `'크리스마스 전'`을 기준으로 테스트를 진행하고 있는데요. 이 말대로라면 `'크리스마스 당일'`에 대한 테스트가 필요하지 않을까요?
실제 구현 로직대로라면 크리스마스 당일에도 이벤트 혜택이 적용되기 때문에 `'크리스마스 전에는 할인이 적용된다'` 쪽의 테스트에 포함되겠지만, `'크리스마스 전'`이라는 말이 `'크리스마스 당일'`을 포함하진 않잖아요. 그래서 좀 더 명확한 뜻을 전달할 수 있게끔 작성하면 더 좋을 것 같아요!
저는 이런 식으로 작성하는데 도움이 되실까 해서 올려봅니다.
```javascript
describe('크리스마스 이벤트 적용 여부 테스트', () => {
test.each([
// 여러 개의 입력 값과 기대 값 케이스
])('OO일에 방문하면 XX원만큼 할인이 적용된다', () => {
// 테스트
})
test.each([
// 여러 개의 입력 값과 기대 값 케이스
])('OO일에 방문하면 할인이 적용되지 않는다', () => {
// 테스트
})
})
``` |
@@ -0,0 +1,53 @@
+import { PROMOTION_DATE_INFO } from '../../constants/promotionSystem.js';
+
+// constant.js는 테스트 코드 및 module.js에서만 사용
+export const INITIAL_PROMOTION_BENEFIT_RESULT = Object.freeze({
+ xmasBenefitAmount: 0,
+ weekDayBenefitAmount: 0,
+ weekendBenefitAmount: 0,
+ specialBenefitAmount: 0,
+ giftAmount: 0,
+});
+
+export const MINIMUM_TOTAL_ORDER_AMOUNT = 10000;
+
+export const BENEFIT_DATE_INFO = Object.freeze({
+ startDate: new Date(`${PROMOTION_DATE_INFO.year}-${PROMOTION_DATE_INFO.month}-01`),
+ endDate: new Date(`${PROMOTION_DATE_INFO.year}-${PROMOTION_DATE_INFO.month}-31`),
+ christmas: new Date(`${PROMOTION_DATE_INFO.year}-${PROMOTION_DATE_INFO.month}-25`),
+});
+
+export const DAY_OF_BENEFIT_CONDITION = Object.freeze({
+ weekday: Object.freeze({
+ menuCategory: '디저트',
+ days: [0, 1, 2, 3, 4],
+ }),
+
+ weekend: Object.freeze({
+ menuCategory: '메인',
+ days: [5, 6],
+ }),
+});
+
+export const BENEFIT_AMOUNT_INFO = Object.freeze({
+ everyDay: 100,
+ christmas: 1000,
+ dayOfWeek: 2023,
+ special: 1000,
+});
+
+export const MINIMUM_ORDER_AMOUNT_FOR_GIFT = 120000;
+
+export const GIFT_INFO = {
+ menuCategory: '음료',
+ menuName: '샴페인',
+};
+
+export const SPECIAL_DATES = new Set([
+ `${PROMOTION_DATE_INFO.year}-${PROMOTION_DATE_INFO.month}-03`,
+ `${PROMOTION_DATE_INFO.year}-${PROMOTION_DATE_INFO.month}-10`,
+ `${PROMOTION_DATE_INFO.year}-${PROMOTION_DATE_INFO.month}-17`,
+ `${PROMOTION_DATE_INFO.year}-${PROMOTION_DATE_INFO.month}-24`,
+ `${PROMOTION_DATE_INFO.year}-${PROMOTION_DATE_INFO.month}-25`,
+ `${PROMOTION_DATE_INFO.year}-${PROMOTION_DATE_INFO.month}-31`,
+]); | JavaScript | P5- 파싱 로직이 유틸리티 함수로 빠질 수 있을 것 같아요! |
@@ -0,0 +1,48 @@
+import { addCalculation } from '../../utils/number.js';
+
+/**
+ * @module PromotionReceipt
+ * 총 혜택 금액 및 예상 지출 금액을 묶어 프로모션 결과에 대한 영수증을 표현한 모듈
+ */
+const PromotionReceipt = Object.freeze({
+ /**
+ *
+ * @param {{promotionBenefitResult : import('../../utils/jsDoc.js').PromotionBenefitResult, totalOrderAmount : number}} params - 혜택 정보 및 총 주문 금액이 들어있는 객체
+ * @returns {import('../../utils/jsDoc.js').PromotionReceipt} 총 혜택 금액 및 예상 지출 금액
+ */
+ issue({ promotionBenefitResult, totalOrderAmount }) {
+ const totalBenefitAmount = calculateBenefitAmount(promotionBenefitResult);
+ const expectPaymentAmount = calculateExpectedPayment({
+ promotionBenefitResult,
+ totalBenefitAmount,
+ totalOrderAmount,
+ });
+
+ return { totalBenefitAmount, expectPaymentAmount };
+ },
+});
+
+export default PromotionReceipt;
+
+/**
+ * @param {import('../../utils/jsDoc.js').PromotionBenefitResult} promotionBenefitResult - 혜택 결과
+ * @returns {number} 총 혜택 금액
+ */
+function calculateBenefitAmount(promotionBenefitResult) {
+ return Object.values(promotionBenefitResult).reduce(addCalculation, 0);
+}
+
+/**
+ *
+ * @param {{totalOrderAmount : number, promotionBenefitResult : import('../../utils/jsDoc.js').PromotionBenefitResult, totalBenefitAmount : number}} params - 함수 실행에 필요한 매개변수들
+ * @returns {number} 예상 지출 금액
+ */
+function calculateExpectedPayment({
+ totalOrderAmount,
+ totalBenefitAmount,
+ promotionBenefitResult,
+}) {
+ const benefitAmount = totalBenefitAmount - promotionBenefitResult.giftAmount;
+
+ return totalOrderAmount - benefitAmount;
+} | JavaScript | 오 이거 신박하네요ㅋㅋㅋ `sort` 같은 메서드에서도 변형해서 쓸 수 있겠어요! |
@@ -0,0 +1,47 @@
+import MenuSearcher from './module.js';
+
+describe('메뉴 찾기 테스트', () => {
+ describe('findByMenuName 테스트', () => {
+ test.each([
+ {
+ menuName: '티본스테이크',
+ category: '스테이크',
+ expectedMenu: { name: '티본스테이크', price: 55000 },
+ },
+ {
+ menuName: '초코케이크',
+ category: '디저트',
+ expectedMenu: { name: '초코케이크', price: 15000 },
+ },
+ { menuName: '제로콜라', category: '음료', expectedMenu: { name: '제로콜라', price: 3000 } },
+ { menuName: '초코케이크', category: '음료', expectedMenu: undefined },
+ ])(
+ '메뉴 이름이 $menuName이고, 카테고리가 $category일 경우 검색 결과는 $expectedMenu 이다.',
+ ({ menuName, category, expectedMenu }) => {
+ // given - when
+ const menu = MenuSearcher.findByMenuName(menuName, category);
+
+ // then
+ expect(menu).toEqual(expectedMenu);
+ },
+ );
+ });
+
+ describe('isMenuInCategory 테스트', () => {
+ test.each([
+ { menuName: '티본스테이크', category: '메인', expectedResult: true },
+ { menuName: '초코케이크', category: '디저트', expectedResult: true },
+ { menuName: '제로콜라', category: '음료', expectedResult: true },
+ { menuName: '초코케이크', category: '음료', expectedResult: false },
+ ])(
+ '메뉴 이름이 $menuName이고, 카테고리가 $category일 때, 실행 결과는 $expectedResult 이다.',
+ ({ menuName, category, expectedResult }) => {
+ // given - when
+ const result = MenuSearcher.isMenuInCategory(menuName, category);
+
+ // then
+ expect(result).toBe(expectedResult);
+ },
+ );
+ });
+}); | JavaScript | 요즘 들어 테스트코드를 짤때 `boolean 반환 함수`에 대한 test suite 분리에 대해 생각을 하게 되더라구요.
_`toBeTruthy`와 `toBeFalsy` matcher도 존재하는데 반환값이 `boolean`인 경우에는 test suite를 분리하는게 맞나?_ 라는 생각이 들어서요! matcher도 더 명시적으로 읽히고 파라미터 테스트의 파라미터도 좀 더 가볍게 다룰 수도 있을것 같구요.
진영님 의견은 어떠신가요? |
@@ -0,0 +1,277 @@
+import { PROMOTION_DATE_INFO } from '../../constants/promotionSystem';
+import {
+ BENEFIT_AMOUNT_INFO,
+ MINIMUM_ORDER_AMOUNT_FOR_GIFT,
+ INITIAL_PROMOTION_BENEFIT_RESULT,
+ MINIMUM_TOTAL_ORDER_AMOUNT,
+} from './constant';
+import DecemberPromotionPlan from './module';
+
+describe('12월 이벤트 계획에 따른 혜택 계산 테스트', () => {
+ const createBenefitResult = (ordererInfo) => DecemberPromotionPlan.execute(ordererInfo);
+
+ const createOrdererInfoTestCase = ({
+ visitDate = 3,
+ orderMenuInfo = [
+ ['티본스테이크', 1],
+ ['바비큐립', 1],
+ ['초코케이크', 2],
+ ['제로콜라', 1],
+ ],
+ totalOrderAmount = 142000,
+ } = {}) => ({
+ visitDate,
+ orderMenuInfo,
+ totalOrderAmount,
+ });
+
+ describe('프로모션 적용 여부 테스트', () => {
+ test.each([
+ {
+ description: `5000원은 ${MINIMUM_TOTAL_ORDER_AMOUNT}원 미만 이기 때문에 프로모션 적용이 되지 않는다.`,
+ ordererInfo: {
+ visitDate: 3,
+ orderMenuInfo: ['아이스크림', 1],
+ totalOrderAmount: 5000,
+ },
+ expectedBenefitInfo: {
+ ...INITIAL_PROMOTION_BENEFIT_RESULT,
+ },
+ },
+ ])('$description', ({ ordererInfo, expectedBenefitInfo }) => {
+ // given - when
+ const benefitResult = createBenefitResult(ordererInfo);
+
+ // then
+ expect(benefitResult).toStrictEqual(expectedBenefitInfo);
+ });
+ });
+
+ describe('평일 할인 적용 여부 테스트', () => {
+ test.each([
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 3일은 평일이기 때문에 할인이 적용된다.`,
+ ordererInfo: {
+ ...createOrdererInfoTestCase(),
+ },
+ expectedBenefitInfo: {
+ weekDayBenefitAmount: 2 * BENEFIT_AMOUNT_INFO.dayOfWeek,
+ },
+ },
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 2일은 주말이기 때문에 할인이 적용되지 않는다.`,
+ ordererInfo: {
+ ...createOrdererInfoTestCase({
+ visitDate: 2,
+ }),
+ },
+ expectedBenefitInfo: {
+ weekDayBenefitAmount: 0,
+ },
+ },
+ ])('$description', ({ ordererInfo, expectedBenefitInfo }) => {
+ // given - when
+ const benefitResult = createBenefitResult(ordererInfo);
+
+ // then
+ expect(benefitResult.weekDayBenefitAmount).toBe(expectedBenefitInfo.weekDayBenefitAmount);
+ });
+ });
+
+ describe('주말 할인 적용 여부 테스트', () => {
+ test.each([
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 2일은 주말이기 때문에 할인이 적용된다.`,
+ ordererInfo: {
+ ...createOrdererInfoTestCase({
+ visitDate: 2,
+ }),
+ },
+ expectedBenefitInfo: {
+ weekendBenefitAmount: BENEFIT_AMOUNT_INFO.dayOfWeek * 2,
+ },
+ },
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 3일은 평일이기 때문에 할인이 적용되지 않는다.`,
+ ordererInfo: {
+ ...createOrdererInfoTestCase(),
+ },
+ expectedBenefitInfo: {
+ weekendBenefitAmount: 0,
+ },
+ },
+ ])('$description', ({ ordererInfo, expectedBenefitInfo }) => {
+ // given - when
+ const benefitResult = createBenefitResult(ordererInfo);
+
+ // then
+ expect(benefitResult.weekendBenefitAmount).toBe(expectedBenefitInfo.weekendBenefitAmount);
+ });
+ });
+
+ describe('12월 이벤트 적용 여부 테스트', () => {
+ test.each([
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 1일은 ${PROMOTION_DATE_INFO.month}월 할인이 적용된다.`,
+ ordererInfo: {
+ ...createOrdererInfoTestCase({ visitDate: 1 }),
+ },
+ expectedBenefitInfo: {
+ xmasBenefitAmount: BENEFIT_AMOUNT_INFO.christmas,
+ giftAmount: 25000,
+ specialBenefitAmount: 0,
+ weekDayBenefitAmount: 0,
+ weekendBenefitAmount: BENEFIT_AMOUNT_INFO.dayOfWeek * 2,
+ },
+ },
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 31일은 12월 할인이 적용된다.`,
+ ordererInfo: {
+ ...createOrdererInfoTestCase({
+ visitDate: 31,
+ }),
+ },
+ expectedBenefitInfo: {
+ xmasBenefitAmount: 0,
+ weekDayBenefitAmount: BENEFIT_AMOUNT_INFO.dayOfWeek * 2,
+ weekendBenefitAmount: 0,
+ specialBenefitAmount: BENEFIT_AMOUNT_INFO.special,
+ giftAmount: 25000,
+ },
+ },
+ ])('$description', ({ ordererInfo, expectedBenefitInfo }) => {
+ // given - when
+ const benefitResult = createBenefitResult(ordererInfo);
+
+ // then
+ expect(benefitResult).toStrictEqual(expectedBenefitInfo);
+ });
+ });
+
+ describe('증정 이벤트 적용 여부 테스트', () => {
+ test.each([
+ {
+ description: `88000원은 ${MINIMUM_ORDER_AMOUNT_FOR_GIFT}만원 미만이므로 샴페인이 증정되지 않는다.`,
+ ordererInfo: {
+ visitDate: 2,
+ orderMenuInfo: [
+ ['티본스테이크', 1],
+ ['초코케이크', 2],
+ ['제로콜라', 1],
+ ],
+ totalOrderAmount: 88000,
+ },
+ expectedBenefitInfo: {
+ giftAmount: 0,
+ },
+ },
+ {
+ description: `142000원은 ${MINIMUM_ORDER_AMOUNT_FOR_GIFT}만원 초과이므로 샴페인이 증정된다.`,
+ ordererInfo: {
+ ...createOrdererInfoTestCase(),
+ },
+ expectedBenefitInfo: {
+ giftAmount: 25000,
+ },
+ },
+ ])('$description', ({ ordererInfo, expectedBenefitInfo }) => {
+ // given - when
+ const benefitResult = createBenefitResult(ordererInfo);
+ // then
+ expect(benefitResult.giftAmount).toBe(expectedBenefitInfo.giftAmount);
+ });
+ });
+
+ describe('크리스마스 이벤트 적용 여부 테스트', () => {
+ test.each([
+ {
+ description: '크리스마스가 지난 이후는 할인이 적용되지 않는다.',
+ ordererInfo: {
+ ...createOrdererInfoTestCase({
+ visitDate: 26,
+ }),
+ },
+ expectedBenefitInfo: {
+ xmasBenefitAmount: 0,
+ },
+ },
+ {
+ description: '크리스마스 전에는 할인이 적용 된다.',
+ ordererInfo: {
+ ...createOrdererInfoTestCase({
+ visitDate: 24,
+ }),
+ },
+ expectedBenefitInfo: {
+ xmasBenefitAmount: 3300,
+ },
+ },
+ ])('$description', ({ ordererInfo, expectedBenefitInfo }) => {
+ // given - when
+ const benefitResult = createBenefitResult(ordererInfo);
+
+ // then
+ expect(benefitResult.xmasBenefitAmount).toBe(expectedBenefitInfo.xmasBenefitAmount);
+ });
+ });
+
+ describe('특별 할인 이벤트 적용 여부 테스트', () => {
+ test.each([
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 3일은 특별 할인 이벤트가 적용된다.`,
+ ordererInfo: createOrdererInfoTestCase({
+ visitDate: 3,
+ }),
+ expectedBenefitInfo: { specialBenefitAmount: BENEFIT_AMOUNT_INFO.special },
+ },
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 10일은 특별 할인 이벤트가 적용된다.`,
+ ordererInfo: createOrdererInfoTestCase({
+ visitDate: 10,
+ }),
+ expectedBenefitInfo: { specialBenefitAmount: BENEFIT_AMOUNT_INFO.special },
+ },
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 17일은 특별 할인 이벤트가 적용된다.`,
+ ordererInfo: createOrdererInfoTestCase({
+ visitDate: 17,
+ }),
+ expectedBenefitInfo: { specialBenefitAmount: BENEFIT_AMOUNT_INFO.special },
+ },
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 24일은 특별 할인 이벤트가 적용된다.`,
+ ordererInfo: createOrdererInfoTestCase({
+ visitDate: 24,
+ }),
+ expectedBenefitInfo: { specialBenefitAmount: BENEFIT_AMOUNT_INFO.special },
+ },
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 25일은 특별 할인 이벤트가 적용된다.`,
+ ordererInfo: createOrdererInfoTestCase({
+ visitDate: 25,
+ }),
+ expectedBenefitInfo: { specialBenefitAmount: BENEFIT_AMOUNT_INFO.special },
+ },
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 31일은 특별 할인 이벤트가 적용된다.`,
+ ordererInfo: createOrdererInfoTestCase({
+ visitDate: 31,
+ }),
+ expectedBenefitInfo: { specialBenefitAmount: BENEFIT_AMOUNT_INFO.special },
+ },
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 30일은 특별 할인 이벤트가 적용되지 않는다.`,
+ ordererInfo: createOrdererInfoTestCase({
+ visitDate: 30,
+ }),
+ expectedBenefitInfo: { specialBenefitAmount: 0 },
+ },
+ ])('$description', ({ ordererInfo, expectedBenefitInfo }) => {
+ // given - when
+ const benefitResult = createBenefitResult(ordererInfo);
+
+ // then
+ expect(benefitResult.specialBenefitAmount).toBe(expectedBenefitInfo.specialBenefitAmount);
+ });
+ });
+}); | JavaScript | `test.each()`를 사용하고 있지만 코드가 중복되고 있고, 라인 수가 너무 긴 것 같아요. "하나의 함수의 라인 수가 15를 넘지 않아야 한다"는 요구 사항이 있는 것처럼, 테스트 코드도 라인 수가 너무 길면 읽기가 힘들 것 같아요.
이런 식으로 변경하면 라인 수도 확 줄일 수 있는데 고려해보시는 건 어떨까요?
```javascript
test.each([3, 10, 17, 24 ...])(
'12월 %d일은 특별 할인 이벤트가 적용된다',
(visitDate) => {
// given
const expected = BENEFIT_AMOUNT_INFO.special;
// when
const result= createBenefitResult(ordererInfo);
// then
expect(result).toBe(expected );
});
``` |
@@ -0,0 +1,143 @@
+import MenuSearcher from '../MenuSearcher/module.js';
+import { PROMOTION_DATE_INFO } from '../../constants/promotionSystem.js';
+import {
+ DAY_OF_BENEFIT_CONDITION,
+ BENEFIT_DATE_INFO,
+ INITIAL_PROMOTION_BENEFIT_RESULT,
+ MINIMUM_TOTAL_ORDER_AMOUNT,
+ BENEFIT_AMOUNT_INFO,
+ MINIMUM_ORDER_AMOUNT_FOR_GIFT,
+ GIFT_INFO,
+ SPECIAL_DATES,
+} from './constant.js';
+
+/**
+ * @module DecemberPromotionPlan
+ * 12월의 프로모션 계획 들을(크리스마스, 주말/평일 할인, 특별 이벤트 및 증정 행사)통해 할인 혜택 들을 제공 하는 모듈
+ */
+const DecemberPromotionPlan = Object.freeze({
+ /**
+ * @param {import('../../utils/jsDoc.js').OrdererInfo} ordererInfo - 주문자 정보(방문 일자, 총 주문 금액, 주문한 메뉴 정보)
+ * @returns {import('../../utils/jsDoc.js').PromotionBenefitResult} 각 혜택 금액 정보
+ */
+ execute({ visitDate, totalOrderAmount, orderMenuInfo }) {
+ const { startDate, endDate } = BENEFIT_DATE_INFO;
+ const formatVisitDate = formatVisitDateForPromotion(visitDate);
+ const params = { dateInfo: { formatVisitDate, startDate, endDate }, totalOrderAmount };
+
+ return isAvailablePromotion(params)
+ ? createPromotionBenefitResult({
+ visitDate: formatVisitDate,
+ totalOrderAmount,
+ orderMenuInfo,
+ })
+ : INITIAL_PROMOTION_BENEFIT_RESULT;
+ },
+});
+
+export default DecemberPromotionPlan;
+
+/**
+ * @param {number} visitDate - 방문 일자
+ * @returns {Date} 방문 일자에 대한 Date 객체
+ */
+function formatVisitDateForPromotion(visitDate) {
+ const { year, month } = PROMOTION_DATE_INFO;
+
+ return visitDate < 10
+ ? new Date(`${year}-${month}-0${visitDate}`)
+ : new Date(`${year}-${month}-${visitDate}`);
+}
+
+/**
+ * @param {{dateInfo: {formatVisitDate: Date, startDate: Date, endDate: Date}, totalOrderAmount: number}} params - 프로모션이 유효한지 확인할 정보
+ * @returns {boolean} 이벤트 기간 및 최소 주문 금액 요건을 충족하는지 여부
+ */
+function isAvailablePromotion({
+ dateInfo: { formatVisitDate, startDate, endDate },
+ totalOrderAmount,
+}) {
+ return (
+ formatVisitDate >= startDate &&
+ formatVisitDate <= endDate &&
+ totalOrderAmount >= MINIMUM_TOTAL_ORDER_AMOUNT
+ );
+}
+
+/**
+ * @param {import('../../utils/jsDoc.js').OrdererInfo} ordererInfo - 주문자 정보(방문 일자, 총 주문 금액, 주문한 메뉴 정보)
+ * @returns {import('../../utils/jsDoc.js').PromotionBenefitResult} 각 혜택 금액 정보
+ */
+function createPromotionBenefitResult(ordererInfo) {
+ const { weekday, weekend } = DAY_OF_BENEFIT_CONDITION;
+
+ return {
+ xmasBenefitAmount: calculateChristmasBenefit(ordererInfo),
+ weekDayBenefitAmount: calculateBenefitForDayType({ ordererInfo, ...weekday }),
+ weekendBenefitAmount: calculateBenefitForDayType({ ordererInfo, ...weekend }),
+ specialBenefitAmount: calculateSpecialBenefit(ordererInfo),
+ giftAmount: calculateGiftEvent(ordererInfo),
+ };
+}
+
+/**
+ * @param {import('../../utils/jsDoc.js').OrdererInfo} ordererInfo - 주문자 정보(방문 일자, 총 주문 금액, 주문한 메뉴 정보)
+ * @returns {number | 0} 크리스마스 디데이 할인이 적용되거나 적용되지 않은 금액
+ */
+function calculateChristmasBenefit({ visitDate }) {
+ const { startDate, christmas: endDate } = BENEFIT_DATE_INFO;
+
+ if (!(visitDate >= startDate && visitDate <= endDate)) return 0;
+
+ const millisecondPerDay = 1000 * 60 * 60 * 24;
+ const daysUntilChristmas = Math.floor((endDate - visitDate) / millisecondPerDay);
+
+ const { christmas, everyDay } = BENEFIT_AMOUNT_INFO;
+
+ const totalEventDay = 24;
+ return christmas + everyDay * (totalEventDay - daysUntilChristmas);
+}
+
+/**
+ *
+ * @param {import('../../utils/jsDoc.js').CalculateBenefitForDayTypeParams} params - 주문자 정보 + 요일 할인 조건이 들어있는 매개 변수
+ * @returns {number | 0} 요일(주말/평일) 할인이 적용되거나 적용 되지 않은 금액
+ */
+function calculateBenefitForDayType({
+ ordererInfo: { orderMenuInfo, visitDate },
+ menuCategory,
+ days,
+}) {
+ return !days.includes(visitDate.getDay())
+ ? 0
+ : orderMenuInfo
+ .filter(([menuName]) => MenuSearcher.isMenuInCategory(menuName, menuCategory))
+ .reduce(
+ (totalBenefit, [, quantity]) => totalBenefit + BENEFIT_AMOUNT_INFO.dayOfWeek * quantity,
+ 0,
+ );
+}
+
+/**
+ * @param {{visitDate : Date}} params - 방문 일자(Date 객체)가 포함된 객체
+ * @returns {number | 0} 특별 할인이 적용되거나 적용되지 않은 금액
+ */
+function calculateSpecialBenefit({ visitDate }) {
+ const formattedVisitDate = visitDate.toISOString().substring(0, 10);
+ const specialDates = SPECIAL_DATES;
+
+ return specialDates.has(formattedVisitDate) ? BENEFIT_AMOUNT_INFO.special : 0;
+}
+
+/**
+ * @param {{totalOrderAmount : number}} params - 총 주문 금액이 포함된 객체
+ * @returns {number | 0} 증정 이벤트가 적용되거나 적용되지 않은 금액
+ */
+function calculateGiftEvent({ totalOrderAmount }) {
+ if (totalOrderAmount < MINIMUM_ORDER_AMOUNT_FOR_GIFT) return 0;
+
+ const { menuCategory, menuName } = GIFT_INFO;
+ const champagne = MenuSearcher.findByMenuName(menuName, menuCategory);
+
+ return champagne.price;
+} | JavaScript | 많은 부분에서 삼항 연산자를 사용하고 계시는데, `if`문을 사용하지 않으시는 이유가 있는지 궁금합니다. |
@@ -0,0 +1,48 @@
+import { addCalculation } from '../../utils/number.js';
+
+/**
+ * @module PromotionReceipt
+ * 총 혜택 금액 및 예상 지출 금액을 묶어 프로모션 결과에 대한 영수증을 표현한 모듈
+ */
+const PromotionReceipt = Object.freeze({
+ /**
+ *
+ * @param {{promotionBenefitResult : import('../../utils/jsDoc.js').PromotionBenefitResult, totalOrderAmount : number}} params - 혜택 정보 및 총 주문 금액이 들어있는 객체
+ * @returns {import('../../utils/jsDoc.js').PromotionReceipt} 총 혜택 금액 및 예상 지출 금액
+ */
+ issue({ promotionBenefitResult, totalOrderAmount }) {
+ const totalBenefitAmount = calculateBenefitAmount(promotionBenefitResult);
+ const expectPaymentAmount = calculateExpectedPayment({
+ promotionBenefitResult,
+ totalBenefitAmount,
+ totalOrderAmount,
+ });
+
+ return { totalBenefitAmount, expectPaymentAmount };
+ },
+});
+
+export default PromotionReceipt;
+
+/**
+ * @param {import('../../utils/jsDoc.js').PromotionBenefitResult} promotionBenefitResult - 혜택 결과
+ * @returns {number} 총 혜택 금액
+ */
+function calculateBenefitAmount(promotionBenefitResult) {
+ return Object.values(promotionBenefitResult).reduce(addCalculation, 0);
+}
+
+/**
+ *
+ * @param {{totalOrderAmount : number, promotionBenefitResult : import('../../utils/jsDoc.js').PromotionBenefitResult, totalBenefitAmount : number}} params - 함수 실행에 필요한 매개변수들
+ * @returns {number} 예상 지출 금액
+ */
+function calculateExpectedPayment({
+ totalOrderAmount,
+ totalBenefitAmount,
+ promotionBenefitResult,
+}) {
+ const benefitAmount = totalBenefitAmount - promotionBenefitResult.giftAmount;
+
+ return totalOrderAmount - benefitAmount;
+} | JavaScript | 이 애플리케이션이 출력하는 데이터를 모르는 사람이 본다면, `benefitAmount`와 `totalBenefitAmount`를 헷갈려할 것 같아요. 총 혜택 금액에서 증정 메뉴의 금액을 뺀 값은 총 할인 받은 금액이니까 `discountedAmount`라고 표현할 수 있지 않을까요? |
@@ -0,0 +1,132 @@
+import { FORMAT_MESSAGE, OUTPUT_MESSAGE } from './module';
+
+describe('메시지 포맷 테스트', () => {
+ describe('orderMenus 테스트', () => {
+ test.each([
+ {
+ description: '출력 결과는 "피자 2개 - 콜라 1개" 이다.',
+ input: [
+ ['피자', 2],
+ ['콜라', 1],
+ ],
+ output: '피자 2개\n콜라 1개\n',
+ },
+ ])('$description', ({ input, output }) => {
+ // given - when - then
+ expect(FORMAT_MESSAGE.orderMenus(input)).toBe(output);
+ });
+ });
+
+ describe('amount 테스트', () => {
+ test.each([
+ { input: 5000, output: '5,000원' },
+ { input: 0, output: '0원' },
+ ])('amount가 $input일 때, 출력 메시지는 "$output"이어야 한다', ({ input, output }) => {
+ // given - when - then
+ expect(FORMAT_MESSAGE.amount(input)).toBe(output);
+ });
+ });
+
+ describe('benefitHistory 테스트', () => {
+ test.each([
+ {
+ description:
+ '출력 결과는 "크리스마스 디데이 할인: -1,200원 - 평일 할인: -4,046원 - 특별 할인: -1,000원 - 증정 이벤트: -25,000원"이다.',
+ input: {
+ xmasBenefitAmount: 1200,
+ weekDayBenefitAmount: 4046,
+ specialBenefitAmount: 1000,
+ giftAmount: 25000,
+ },
+ output:
+ '크리스마스 디데이 할인: -1,200원\n평일 할인: -4,046원\n특별 할인: -1,000원\n증정 이벤트: -25,000원',
+ },
+ {
+ description: `프로모션 혜택이 모두 0원인 경우 결과는 "${OUTPUT_MESSAGE.nothing}"이다.`,
+ input: {
+ xmasBenefitAmount: 0,
+ weekendBenefitAmount: 0,
+ weekDayBenefitAmount: 0,
+ specialBenefitAmount: 0,
+ giftAmount: 0,
+ },
+ output: OUTPUT_MESSAGE.nothing,
+ },
+ ])('$description', ({ input, output }) => {
+ // given - when - then
+ expect(FORMAT_MESSAGE.benefitHistory(input)).toBe(output);
+ });
+ });
+
+ describe('title 테스트', () => {
+ test.each([
+ {
+ description: 'newLine 옵션이 false일 경우, 출력 결과는 "<제목>"이다.',
+ input: { config: { newLine: false }, title: '제목' },
+ output: '<제목>',
+ },
+ {
+ description: 'newLine 옵션이 true일 경우, 출력 결과는 "\\n<제목>"이다.',
+ input: { config: { newLine: true }, title: '제목' },
+ output: '\n<제목>',
+ },
+ ])('$description', ({ input, output }) => {
+ // given - when - then
+ expect(FORMAT_MESSAGE.title(input.config, input.title)).toBe(output);
+ });
+ });
+
+ describe('gift 테스트', () => {
+ test.each([
+ {
+ description: '증정 이벤트 금액이 있는 경우 출력 결과는 "샴페인 1개" 이다.',
+ input: 25000,
+ output: '샴페인 1개',
+ },
+ {
+ description: `증정 이벤트 금액이 없는 경우 출력 결과는 "${OUTPUT_MESSAGE.nothing}" 이다.`,
+ input: 0,
+ output: OUTPUT_MESSAGE.nothing,
+ },
+ ])('$description', ({ input: giftAmount, output }) => {
+ // given - when - then
+ expect(FORMAT_MESSAGE.gift(giftAmount)).toBe(output);
+ });
+ });
+
+ describe('totalBenefitAmount 테스트', () => {
+ test.each([
+ {
+ description: '입력이 25000인 경우 "-25,000원"을 반환한다.',
+ input: 25000,
+ output: '-25,000원',
+ },
+ {
+ description: '입력이 0인 경우 "0원"을 반환한다.',
+ input: 0,
+ output: '0원',
+ },
+ ])('$description', ({ input: totalBenefitAmount, output }) => {
+ // given - when - then
+ expect(FORMAT_MESSAGE.totalBenefitAmount(totalBenefitAmount)).toBe(output);
+ });
+ });
+
+ describe('eventBadge 테스트', () => {
+ test.each([
+ {
+ description: '입력이 "산타"인 경우 그대로 "산타"를 반환한다.',
+ input: '산타',
+ output: '산타',
+ },
+ {
+ description: `입력 값이 null인 경우 "${OUTPUT_MESSAGE.nothing}"을 반환한다.`,
+ input: null,
+ output: OUTPUT_MESSAGE.nothing,
+ },
+ ])('$description', ({ input: eventBadge, output }) => {
+ // given - when - then
+ expect(FORMAT_MESSAGE.eventBadge(eventBadge)).toBe(output);
+ });
+ });
+}); | JavaScript | 테스트 케이스가 충분히 더 생길 수 있다고 생각해서 each를 사용한거도 있고, 테스트 케이스를 변수명과 함께 사용하기 편해서 사용하는것도 있습니다.
제가 description을 굳이 둔 이유는 데이터가 줄바꿈이 있어서 화면에서 많이 깨져서 그걸 좀 더 개선하고자 추가했습니다! |
@@ -0,0 +1,53 @@
+import { PROMOTION_DATE_INFO } from '../../constants/promotionSystem.js';
+
+// constant.js는 테스트 코드 및 module.js에서만 사용
+export const INITIAL_PROMOTION_BENEFIT_RESULT = Object.freeze({
+ xmasBenefitAmount: 0,
+ weekDayBenefitAmount: 0,
+ weekendBenefitAmount: 0,
+ specialBenefitAmount: 0,
+ giftAmount: 0,
+});
+
+export const MINIMUM_TOTAL_ORDER_AMOUNT = 10000;
+
+export const BENEFIT_DATE_INFO = Object.freeze({
+ startDate: new Date(`${PROMOTION_DATE_INFO.year}-${PROMOTION_DATE_INFO.month}-01`),
+ endDate: new Date(`${PROMOTION_DATE_INFO.year}-${PROMOTION_DATE_INFO.month}-31`),
+ christmas: new Date(`${PROMOTION_DATE_INFO.year}-${PROMOTION_DATE_INFO.month}-25`),
+});
+
+export const DAY_OF_BENEFIT_CONDITION = Object.freeze({
+ weekday: Object.freeze({
+ menuCategory: '디저트',
+ days: [0, 1, 2, 3, 4],
+ }),
+
+ weekend: Object.freeze({
+ menuCategory: '메인',
+ days: [5, 6],
+ }),
+});
+
+export const BENEFIT_AMOUNT_INFO = Object.freeze({
+ everyDay: 100,
+ christmas: 1000,
+ dayOfWeek: 2023,
+ special: 1000,
+});
+
+export const MINIMUM_ORDER_AMOUNT_FOR_GIFT = 120000;
+
+export const GIFT_INFO = {
+ menuCategory: '음료',
+ menuName: '샴페인',
+};
+
+export const SPECIAL_DATES = new Set([
+ `${PROMOTION_DATE_INFO.year}-${PROMOTION_DATE_INFO.month}-03`,
+ `${PROMOTION_DATE_INFO.year}-${PROMOTION_DATE_INFO.month}-10`,
+ `${PROMOTION_DATE_INFO.year}-${PROMOTION_DATE_INFO.month}-17`,
+ `${PROMOTION_DATE_INFO.year}-${PROMOTION_DATE_INFO.month}-24`,
+ `${PROMOTION_DATE_INFO.year}-${PROMOTION_DATE_INFO.month}-25`,
+ `${PROMOTION_DATE_INFO.year}-${PROMOTION_DATE_INFO.month}-31`,
+]); | JavaScript | 새로운 개발자가 들어오면 그 분이 스스로 판단할게 아니라 프로젝트에 대한 설명을 충분히 인수인계 받는게 먼저라고 생각합니다.
제가 따로 관리한 이유는 상수를 기존에는 테스트코드와 소스 코드에서 재 사용되는 값들을 관리하고자 상수와 관련된 도메인에서 관리를 하여 코드 응집성을 강화 했었습니다.
이번 미션의 경우 상수 값이 너무 많이 발생해서 로직 내부를 파악하기 어려웠었고(물론 이 부분은 더 분리를 했다면 개선 가능했을거라고 생각해요.) 인스턴스의 생명주기가 대체로 짧은 탓에 함수형 모듈로 개선을 했습니다.
그 과정에서 도메인 static 상수를 어떻게 관리할까 고민했고, constants에 있는 상수는 공통적으로 사용되는 상수로써 관리 되고 있었기 때문에, 여러 라이브러리를 찾아보다 toss/slash와 three.js에서 상수를 디렉토리 내부의 constant.js로 관리해서 저도 디렉토리 내부에 있는 constant.js는 공통적으로 사용하는 것이 아닌 소스코드와 도메인의 테스트 코드에서 재 사용하기 위해 추가했습니다!
그렇게 함으로써 모듈 내부엔 로직에 집중할 수 있고, 관심사가 분리된다고 생각했어요. |
@@ -0,0 +1,49 @@
+import InputView from '../views/InputView.js';
+import OutputView from '../views/OutputView.js';
+import PromotionResultService from '../service/PromotionResultService.js';
+import ErrorHandler from '../errors/ErrorHandler/module.js';
+
+/**
+ * @module ChristmasPromotionController
+ * 크리스마스 프로모션 이벤트 관련 애플리케이션의 흐름 제어를 담당
+ */
+const ChristmasPromotionController = {
+ /**
+ * @returns {Promise<void>}
+ */
+ async play() {
+ const { visitDate, orderMenuInfo } = await processUserInput();
+
+ processPromotionResult({ visitDate, orderMenuInfo });
+ },
+};
+
+/**
+ * @returns {Promise<{visitDate : number, orderMenuInfo : [string, number][]}>} 유저가 입력한 방문 일자 및 메뉴 정보를 반환할 Promise 객체
+ */
+async function processUserInput() {
+ OutputView.printStartGuideComments();
+
+ const visitDate = await ErrorHandler.retryOnErrors(InputView.readVisitDate.bind(InputView));
+ const orderMenuInfo = await ErrorHandler.retryOnErrors(
+ InputView.readOrderMenuInfo.bind(InputView),
+ );
+
+ return { visitDate, orderMenuInfo };
+}
+
+/**
+ * @param {{visitDate : number, orderMenuInfo : [string, number][]}} params - 유저가 입력한 방문 일자 및 메뉴 정보
+ * @returns {void}
+ */
+function processPromotionResult({ visitDate, orderMenuInfo }) {
+ const promotionResult = PromotionResultService.createPromotionResult({
+ visitDate,
+ orderMenuInfo,
+ });
+
+ OutputView.printEndGuideComments(visitDate);
+ OutputView.printPromotionResult({ orderMenuInfo, promotionResult });
+}
+
+export default ChristmasPromotionController; | JavaScript | mvc를 아시는 분들은 쉽게 이해하시겠지만 controller의 역할을 이해하시지 못하는 분들도 있을거라 생각해서 주석을 남겼습니다.
또한, 코드의 일관성의 이유도 있었던거 같습니다! |
@@ -0,0 +1,277 @@
+import { PROMOTION_DATE_INFO } from '../../constants/promotionSystem';
+import {
+ BENEFIT_AMOUNT_INFO,
+ MINIMUM_ORDER_AMOUNT_FOR_GIFT,
+ INITIAL_PROMOTION_BENEFIT_RESULT,
+ MINIMUM_TOTAL_ORDER_AMOUNT,
+} from './constant';
+import DecemberPromotionPlan from './module';
+
+describe('12월 이벤트 계획에 따른 혜택 계산 테스트', () => {
+ const createBenefitResult = (ordererInfo) => DecemberPromotionPlan.execute(ordererInfo);
+
+ const createOrdererInfoTestCase = ({
+ visitDate = 3,
+ orderMenuInfo = [
+ ['티본스테이크', 1],
+ ['바비큐립', 1],
+ ['초코케이크', 2],
+ ['제로콜라', 1],
+ ],
+ totalOrderAmount = 142000,
+ } = {}) => ({
+ visitDate,
+ orderMenuInfo,
+ totalOrderAmount,
+ });
+
+ describe('프로모션 적용 여부 테스트', () => {
+ test.each([
+ {
+ description: `5000원은 ${MINIMUM_TOTAL_ORDER_AMOUNT}원 미만 이기 때문에 프로모션 적용이 되지 않는다.`,
+ ordererInfo: {
+ visitDate: 3,
+ orderMenuInfo: ['아이스크림', 1],
+ totalOrderAmount: 5000,
+ },
+ expectedBenefitInfo: {
+ ...INITIAL_PROMOTION_BENEFIT_RESULT,
+ },
+ },
+ ])('$description', ({ ordererInfo, expectedBenefitInfo }) => {
+ // given - when
+ const benefitResult = createBenefitResult(ordererInfo);
+
+ // then
+ expect(benefitResult).toStrictEqual(expectedBenefitInfo);
+ });
+ });
+
+ describe('평일 할인 적용 여부 테스트', () => {
+ test.each([
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 3일은 평일이기 때문에 할인이 적용된다.`,
+ ordererInfo: {
+ ...createOrdererInfoTestCase(),
+ },
+ expectedBenefitInfo: {
+ weekDayBenefitAmount: 2 * BENEFIT_AMOUNT_INFO.dayOfWeek,
+ },
+ },
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 2일은 주말이기 때문에 할인이 적용되지 않는다.`,
+ ordererInfo: {
+ ...createOrdererInfoTestCase({
+ visitDate: 2,
+ }),
+ },
+ expectedBenefitInfo: {
+ weekDayBenefitAmount: 0,
+ },
+ },
+ ])('$description', ({ ordererInfo, expectedBenefitInfo }) => {
+ // given - when
+ const benefitResult = createBenefitResult(ordererInfo);
+
+ // then
+ expect(benefitResult.weekDayBenefitAmount).toBe(expectedBenefitInfo.weekDayBenefitAmount);
+ });
+ });
+
+ describe('주말 할인 적용 여부 테스트', () => {
+ test.each([
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 2일은 주말이기 때문에 할인이 적용된다.`,
+ ordererInfo: {
+ ...createOrdererInfoTestCase({
+ visitDate: 2,
+ }),
+ },
+ expectedBenefitInfo: {
+ weekendBenefitAmount: BENEFIT_AMOUNT_INFO.dayOfWeek * 2,
+ },
+ },
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 3일은 평일이기 때문에 할인이 적용되지 않는다.`,
+ ordererInfo: {
+ ...createOrdererInfoTestCase(),
+ },
+ expectedBenefitInfo: {
+ weekendBenefitAmount: 0,
+ },
+ },
+ ])('$description', ({ ordererInfo, expectedBenefitInfo }) => {
+ // given - when
+ const benefitResult = createBenefitResult(ordererInfo);
+
+ // then
+ expect(benefitResult.weekendBenefitAmount).toBe(expectedBenefitInfo.weekendBenefitAmount);
+ });
+ });
+
+ describe('12월 이벤트 적용 여부 테스트', () => {
+ test.each([
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 1일은 ${PROMOTION_DATE_INFO.month}월 할인이 적용된다.`,
+ ordererInfo: {
+ ...createOrdererInfoTestCase({ visitDate: 1 }),
+ },
+ expectedBenefitInfo: {
+ xmasBenefitAmount: BENEFIT_AMOUNT_INFO.christmas,
+ giftAmount: 25000,
+ specialBenefitAmount: 0,
+ weekDayBenefitAmount: 0,
+ weekendBenefitAmount: BENEFIT_AMOUNT_INFO.dayOfWeek * 2,
+ },
+ },
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 31일은 12월 할인이 적용된다.`,
+ ordererInfo: {
+ ...createOrdererInfoTestCase({
+ visitDate: 31,
+ }),
+ },
+ expectedBenefitInfo: {
+ xmasBenefitAmount: 0,
+ weekDayBenefitAmount: BENEFIT_AMOUNT_INFO.dayOfWeek * 2,
+ weekendBenefitAmount: 0,
+ specialBenefitAmount: BENEFIT_AMOUNT_INFO.special,
+ giftAmount: 25000,
+ },
+ },
+ ])('$description', ({ ordererInfo, expectedBenefitInfo }) => {
+ // given - when
+ const benefitResult = createBenefitResult(ordererInfo);
+
+ // then
+ expect(benefitResult).toStrictEqual(expectedBenefitInfo);
+ });
+ });
+
+ describe('증정 이벤트 적용 여부 테스트', () => {
+ test.each([
+ {
+ description: `88000원은 ${MINIMUM_ORDER_AMOUNT_FOR_GIFT}만원 미만이므로 샴페인이 증정되지 않는다.`,
+ ordererInfo: {
+ visitDate: 2,
+ orderMenuInfo: [
+ ['티본스테이크', 1],
+ ['초코케이크', 2],
+ ['제로콜라', 1],
+ ],
+ totalOrderAmount: 88000,
+ },
+ expectedBenefitInfo: {
+ giftAmount: 0,
+ },
+ },
+ {
+ description: `142000원은 ${MINIMUM_ORDER_AMOUNT_FOR_GIFT}만원 초과이므로 샴페인이 증정된다.`,
+ ordererInfo: {
+ ...createOrdererInfoTestCase(),
+ },
+ expectedBenefitInfo: {
+ giftAmount: 25000,
+ },
+ },
+ ])('$description', ({ ordererInfo, expectedBenefitInfo }) => {
+ // given - when
+ const benefitResult = createBenefitResult(ordererInfo);
+ // then
+ expect(benefitResult.giftAmount).toBe(expectedBenefitInfo.giftAmount);
+ });
+ });
+
+ describe('크리스마스 이벤트 적용 여부 테스트', () => {
+ test.each([
+ {
+ description: '크리스마스가 지난 이후는 할인이 적용되지 않는다.',
+ ordererInfo: {
+ ...createOrdererInfoTestCase({
+ visitDate: 26,
+ }),
+ },
+ expectedBenefitInfo: {
+ xmasBenefitAmount: 0,
+ },
+ },
+ {
+ description: '크리스마스 전에는 할인이 적용 된다.',
+ ordererInfo: {
+ ...createOrdererInfoTestCase({
+ visitDate: 24,
+ }),
+ },
+ expectedBenefitInfo: {
+ xmasBenefitAmount: 3300,
+ },
+ },
+ ])('$description', ({ ordererInfo, expectedBenefitInfo }) => {
+ // given - when
+ const benefitResult = createBenefitResult(ordererInfo);
+
+ // then
+ expect(benefitResult.xmasBenefitAmount).toBe(expectedBenefitInfo.xmasBenefitAmount);
+ });
+ });
+
+ describe('특별 할인 이벤트 적용 여부 테스트', () => {
+ test.each([
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 3일은 특별 할인 이벤트가 적용된다.`,
+ ordererInfo: createOrdererInfoTestCase({
+ visitDate: 3,
+ }),
+ expectedBenefitInfo: { specialBenefitAmount: BENEFIT_AMOUNT_INFO.special },
+ },
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 10일은 특별 할인 이벤트가 적용된다.`,
+ ordererInfo: createOrdererInfoTestCase({
+ visitDate: 10,
+ }),
+ expectedBenefitInfo: { specialBenefitAmount: BENEFIT_AMOUNT_INFO.special },
+ },
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 17일은 특별 할인 이벤트가 적용된다.`,
+ ordererInfo: createOrdererInfoTestCase({
+ visitDate: 17,
+ }),
+ expectedBenefitInfo: { specialBenefitAmount: BENEFIT_AMOUNT_INFO.special },
+ },
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 24일은 특별 할인 이벤트가 적용된다.`,
+ ordererInfo: createOrdererInfoTestCase({
+ visitDate: 24,
+ }),
+ expectedBenefitInfo: { specialBenefitAmount: BENEFIT_AMOUNT_INFO.special },
+ },
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 25일은 특별 할인 이벤트가 적용된다.`,
+ ordererInfo: createOrdererInfoTestCase({
+ visitDate: 25,
+ }),
+ expectedBenefitInfo: { specialBenefitAmount: BENEFIT_AMOUNT_INFO.special },
+ },
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 31일은 특별 할인 이벤트가 적용된다.`,
+ ordererInfo: createOrdererInfoTestCase({
+ visitDate: 31,
+ }),
+ expectedBenefitInfo: { specialBenefitAmount: BENEFIT_AMOUNT_INFO.special },
+ },
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 30일은 특별 할인 이벤트가 적용되지 않는다.`,
+ ordererInfo: createOrdererInfoTestCase({
+ visitDate: 30,
+ }),
+ expectedBenefitInfo: { specialBenefitAmount: 0 },
+ },
+ ])('$description', ({ ordererInfo, expectedBenefitInfo }) => {
+ // given - when
+ const benefitResult = createBenefitResult(ordererInfo);
+
+ // then
+ expect(benefitResult.specialBenefitAmount).toBe(expectedBenefitInfo.specialBenefitAmount);
+ });
+ });
+}); | JavaScript | 저 테스트의 목적은 25일이 이벤트 종료 시점이라 그 경계 값들의 이벤트 적용 여부를 테스트하는게 가장 중요하다고 생각해서 저렇게 테스트를 진행했습니다.
작성자님의 의견도 저는 맞다고 생각해요. 다만, 저는 현재 테스트 코드가 긴 상황에서 1~25일을 모두 테스트하는게 비용이 너무 크다고 생각해서 다음과 같이 테스트를 진행했습니다! |
@@ -0,0 +1,277 @@
+import { PROMOTION_DATE_INFO } from '../../constants/promotionSystem';
+import {
+ BENEFIT_AMOUNT_INFO,
+ MINIMUM_ORDER_AMOUNT_FOR_GIFT,
+ INITIAL_PROMOTION_BENEFIT_RESULT,
+ MINIMUM_TOTAL_ORDER_AMOUNT,
+} from './constant';
+import DecemberPromotionPlan from './module';
+
+describe('12월 이벤트 계획에 따른 혜택 계산 테스트', () => {
+ const createBenefitResult = (ordererInfo) => DecemberPromotionPlan.execute(ordererInfo);
+
+ const createOrdererInfoTestCase = ({
+ visitDate = 3,
+ orderMenuInfo = [
+ ['티본스테이크', 1],
+ ['바비큐립', 1],
+ ['초코케이크', 2],
+ ['제로콜라', 1],
+ ],
+ totalOrderAmount = 142000,
+ } = {}) => ({
+ visitDate,
+ orderMenuInfo,
+ totalOrderAmount,
+ });
+
+ describe('프로모션 적용 여부 테스트', () => {
+ test.each([
+ {
+ description: `5000원은 ${MINIMUM_TOTAL_ORDER_AMOUNT}원 미만 이기 때문에 프로모션 적용이 되지 않는다.`,
+ ordererInfo: {
+ visitDate: 3,
+ orderMenuInfo: ['아이스크림', 1],
+ totalOrderAmount: 5000,
+ },
+ expectedBenefitInfo: {
+ ...INITIAL_PROMOTION_BENEFIT_RESULT,
+ },
+ },
+ ])('$description', ({ ordererInfo, expectedBenefitInfo }) => {
+ // given - when
+ const benefitResult = createBenefitResult(ordererInfo);
+
+ // then
+ expect(benefitResult).toStrictEqual(expectedBenefitInfo);
+ });
+ });
+
+ describe('평일 할인 적용 여부 테스트', () => {
+ test.each([
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 3일은 평일이기 때문에 할인이 적용된다.`,
+ ordererInfo: {
+ ...createOrdererInfoTestCase(),
+ },
+ expectedBenefitInfo: {
+ weekDayBenefitAmount: 2 * BENEFIT_AMOUNT_INFO.dayOfWeek,
+ },
+ },
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 2일은 주말이기 때문에 할인이 적용되지 않는다.`,
+ ordererInfo: {
+ ...createOrdererInfoTestCase({
+ visitDate: 2,
+ }),
+ },
+ expectedBenefitInfo: {
+ weekDayBenefitAmount: 0,
+ },
+ },
+ ])('$description', ({ ordererInfo, expectedBenefitInfo }) => {
+ // given - when
+ const benefitResult = createBenefitResult(ordererInfo);
+
+ // then
+ expect(benefitResult.weekDayBenefitAmount).toBe(expectedBenefitInfo.weekDayBenefitAmount);
+ });
+ });
+
+ describe('주말 할인 적용 여부 테스트', () => {
+ test.each([
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 2일은 주말이기 때문에 할인이 적용된다.`,
+ ordererInfo: {
+ ...createOrdererInfoTestCase({
+ visitDate: 2,
+ }),
+ },
+ expectedBenefitInfo: {
+ weekendBenefitAmount: BENEFIT_AMOUNT_INFO.dayOfWeek * 2,
+ },
+ },
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 3일은 평일이기 때문에 할인이 적용되지 않는다.`,
+ ordererInfo: {
+ ...createOrdererInfoTestCase(),
+ },
+ expectedBenefitInfo: {
+ weekendBenefitAmount: 0,
+ },
+ },
+ ])('$description', ({ ordererInfo, expectedBenefitInfo }) => {
+ // given - when
+ const benefitResult = createBenefitResult(ordererInfo);
+
+ // then
+ expect(benefitResult.weekendBenefitAmount).toBe(expectedBenefitInfo.weekendBenefitAmount);
+ });
+ });
+
+ describe('12월 이벤트 적용 여부 테스트', () => {
+ test.each([
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 1일은 ${PROMOTION_DATE_INFO.month}월 할인이 적용된다.`,
+ ordererInfo: {
+ ...createOrdererInfoTestCase({ visitDate: 1 }),
+ },
+ expectedBenefitInfo: {
+ xmasBenefitAmount: BENEFIT_AMOUNT_INFO.christmas,
+ giftAmount: 25000,
+ specialBenefitAmount: 0,
+ weekDayBenefitAmount: 0,
+ weekendBenefitAmount: BENEFIT_AMOUNT_INFO.dayOfWeek * 2,
+ },
+ },
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 31일은 12월 할인이 적용된다.`,
+ ordererInfo: {
+ ...createOrdererInfoTestCase({
+ visitDate: 31,
+ }),
+ },
+ expectedBenefitInfo: {
+ xmasBenefitAmount: 0,
+ weekDayBenefitAmount: BENEFIT_AMOUNT_INFO.dayOfWeek * 2,
+ weekendBenefitAmount: 0,
+ specialBenefitAmount: BENEFIT_AMOUNT_INFO.special,
+ giftAmount: 25000,
+ },
+ },
+ ])('$description', ({ ordererInfo, expectedBenefitInfo }) => {
+ // given - when
+ const benefitResult = createBenefitResult(ordererInfo);
+
+ // then
+ expect(benefitResult).toStrictEqual(expectedBenefitInfo);
+ });
+ });
+
+ describe('증정 이벤트 적용 여부 테스트', () => {
+ test.each([
+ {
+ description: `88000원은 ${MINIMUM_ORDER_AMOUNT_FOR_GIFT}만원 미만이므로 샴페인이 증정되지 않는다.`,
+ ordererInfo: {
+ visitDate: 2,
+ orderMenuInfo: [
+ ['티본스테이크', 1],
+ ['초코케이크', 2],
+ ['제로콜라', 1],
+ ],
+ totalOrderAmount: 88000,
+ },
+ expectedBenefitInfo: {
+ giftAmount: 0,
+ },
+ },
+ {
+ description: `142000원은 ${MINIMUM_ORDER_AMOUNT_FOR_GIFT}만원 초과이므로 샴페인이 증정된다.`,
+ ordererInfo: {
+ ...createOrdererInfoTestCase(),
+ },
+ expectedBenefitInfo: {
+ giftAmount: 25000,
+ },
+ },
+ ])('$description', ({ ordererInfo, expectedBenefitInfo }) => {
+ // given - when
+ const benefitResult = createBenefitResult(ordererInfo);
+ // then
+ expect(benefitResult.giftAmount).toBe(expectedBenefitInfo.giftAmount);
+ });
+ });
+
+ describe('크리스마스 이벤트 적용 여부 테스트', () => {
+ test.each([
+ {
+ description: '크리스마스가 지난 이후는 할인이 적용되지 않는다.',
+ ordererInfo: {
+ ...createOrdererInfoTestCase({
+ visitDate: 26,
+ }),
+ },
+ expectedBenefitInfo: {
+ xmasBenefitAmount: 0,
+ },
+ },
+ {
+ description: '크리스마스 전에는 할인이 적용 된다.',
+ ordererInfo: {
+ ...createOrdererInfoTestCase({
+ visitDate: 24,
+ }),
+ },
+ expectedBenefitInfo: {
+ xmasBenefitAmount: 3300,
+ },
+ },
+ ])('$description', ({ ordererInfo, expectedBenefitInfo }) => {
+ // given - when
+ const benefitResult = createBenefitResult(ordererInfo);
+
+ // then
+ expect(benefitResult.xmasBenefitAmount).toBe(expectedBenefitInfo.xmasBenefitAmount);
+ });
+ });
+
+ describe('특별 할인 이벤트 적용 여부 테스트', () => {
+ test.each([
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 3일은 특별 할인 이벤트가 적용된다.`,
+ ordererInfo: createOrdererInfoTestCase({
+ visitDate: 3,
+ }),
+ expectedBenefitInfo: { specialBenefitAmount: BENEFIT_AMOUNT_INFO.special },
+ },
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 10일은 특별 할인 이벤트가 적용된다.`,
+ ordererInfo: createOrdererInfoTestCase({
+ visitDate: 10,
+ }),
+ expectedBenefitInfo: { specialBenefitAmount: BENEFIT_AMOUNT_INFO.special },
+ },
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 17일은 특별 할인 이벤트가 적용된다.`,
+ ordererInfo: createOrdererInfoTestCase({
+ visitDate: 17,
+ }),
+ expectedBenefitInfo: { specialBenefitAmount: BENEFIT_AMOUNT_INFO.special },
+ },
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 24일은 특별 할인 이벤트가 적용된다.`,
+ ordererInfo: createOrdererInfoTestCase({
+ visitDate: 24,
+ }),
+ expectedBenefitInfo: { specialBenefitAmount: BENEFIT_AMOUNT_INFO.special },
+ },
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 25일은 특별 할인 이벤트가 적용된다.`,
+ ordererInfo: createOrdererInfoTestCase({
+ visitDate: 25,
+ }),
+ expectedBenefitInfo: { specialBenefitAmount: BENEFIT_AMOUNT_INFO.special },
+ },
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 31일은 특별 할인 이벤트가 적용된다.`,
+ ordererInfo: createOrdererInfoTestCase({
+ visitDate: 31,
+ }),
+ expectedBenefitInfo: { specialBenefitAmount: BENEFIT_AMOUNT_INFO.special },
+ },
+ {
+ description: `${PROMOTION_DATE_INFO.month}월 30일은 특별 할인 이벤트가 적용되지 않는다.`,
+ ordererInfo: createOrdererInfoTestCase({
+ visitDate: 30,
+ }),
+ expectedBenefitInfo: { specialBenefitAmount: 0 },
+ },
+ ])('$description', ({ ordererInfo, expectedBenefitInfo }) => {
+ // given - when
+ const benefitResult = createBenefitResult(ordererInfo);
+
+ // then
+ expect(benefitResult.specialBenefitAmount).toBe(expectedBenefitInfo.specialBenefitAmount);
+ });
+ });
+}); | JavaScript | 이건 작성자님이 api 스펙을 잘못 이해하고 계신거 같아요..! 저도 간소화 할 수 있었으면 좋았겠지만, 현재 필요한 정보가 visitDate, orderMenuInfo, totalOrderAmount 총 3가지 정보가 필요해서 어쩔수 없이 저렇게 코드를 짠 것 입니다..!
또한 저는 오히려 객체로 나타내는게 약간의 복잡도가 올라갈지언정 더 명시적으로 테스트 스펙을 제공해서 가독성이 더 높다고 생각하는 입장이라 참고 해주시면 좋을거 같아요 !! |
@@ -0,0 +1,143 @@
+import MenuSearcher from '../MenuSearcher/module.js';
+import { PROMOTION_DATE_INFO } from '../../constants/promotionSystem.js';
+import {
+ DAY_OF_BENEFIT_CONDITION,
+ BENEFIT_DATE_INFO,
+ INITIAL_PROMOTION_BENEFIT_RESULT,
+ MINIMUM_TOTAL_ORDER_AMOUNT,
+ BENEFIT_AMOUNT_INFO,
+ MINIMUM_ORDER_AMOUNT_FOR_GIFT,
+ GIFT_INFO,
+ SPECIAL_DATES,
+} from './constant.js';
+
+/**
+ * @module DecemberPromotionPlan
+ * 12월의 프로모션 계획 들을(크리스마스, 주말/평일 할인, 특별 이벤트 및 증정 행사)통해 할인 혜택 들을 제공 하는 모듈
+ */
+const DecemberPromotionPlan = Object.freeze({
+ /**
+ * @param {import('../../utils/jsDoc.js').OrdererInfo} ordererInfo - 주문자 정보(방문 일자, 총 주문 금액, 주문한 메뉴 정보)
+ * @returns {import('../../utils/jsDoc.js').PromotionBenefitResult} 각 혜택 금액 정보
+ */
+ execute({ visitDate, totalOrderAmount, orderMenuInfo }) {
+ const { startDate, endDate } = BENEFIT_DATE_INFO;
+ const formatVisitDate = formatVisitDateForPromotion(visitDate);
+ const params = { dateInfo: { formatVisitDate, startDate, endDate }, totalOrderAmount };
+
+ return isAvailablePromotion(params)
+ ? createPromotionBenefitResult({
+ visitDate: formatVisitDate,
+ totalOrderAmount,
+ orderMenuInfo,
+ })
+ : INITIAL_PROMOTION_BENEFIT_RESULT;
+ },
+});
+
+export default DecemberPromotionPlan;
+
+/**
+ * @param {number} visitDate - 방문 일자
+ * @returns {Date} 방문 일자에 대한 Date 객체
+ */
+function formatVisitDateForPromotion(visitDate) {
+ const { year, month } = PROMOTION_DATE_INFO;
+
+ return visitDate < 10
+ ? new Date(`${year}-${month}-0${visitDate}`)
+ : new Date(`${year}-${month}-${visitDate}`);
+}
+
+/**
+ * @param {{dateInfo: {formatVisitDate: Date, startDate: Date, endDate: Date}, totalOrderAmount: number}} params - 프로모션이 유효한지 확인할 정보
+ * @returns {boolean} 이벤트 기간 및 최소 주문 금액 요건을 충족하는지 여부
+ */
+function isAvailablePromotion({
+ dateInfo: { formatVisitDate, startDate, endDate },
+ totalOrderAmount,
+}) {
+ return (
+ formatVisitDate >= startDate &&
+ formatVisitDate <= endDate &&
+ totalOrderAmount >= MINIMUM_TOTAL_ORDER_AMOUNT
+ );
+}
+
+/**
+ * @param {import('../../utils/jsDoc.js').OrdererInfo} ordererInfo - 주문자 정보(방문 일자, 총 주문 금액, 주문한 메뉴 정보)
+ * @returns {import('../../utils/jsDoc.js').PromotionBenefitResult} 각 혜택 금액 정보
+ */
+function createPromotionBenefitResult(ordererInfo) {
+ const { weekday, weekend } = DAY_OF_BENEFIT_CONDITION;
+
+ return {
+ xmasBenefitAmount: calculateChristmasBenefit(ordererInfo),
+ weekDayBenefitAmount: calculateBenefitForDayType({ ordererInfo, ...weekday }),
+ weekendBenefitAmount: calculateBenefitForDayType({ ordererInfo, ...weekend }),
+ specialBenefitAmount: calculateSpecialBenefit(ordererInfo),
+ giftAmount: calculateGiftEvent(ordererInfo),
+ };
+}
+
+/**
+ * @param {import('../../utils/jsDoc.js').OrdererInfo} ordererInfo - 주문자 정보(방문 일자, 총 주문 금액, 주문한 메뉴 정보)
+ * @returns {number | 0} 크리스마스 디데이 할인이 적용되거나 적용되지 않은 금액
+ */
+function calculateChristmasBenefit({ visitDate }) {
+ const { startDate, christmas: endDate } = BENEFIT_DATE_INFO;
+
+ if (!(visitDate >= startDate && visitDate <= endDate)) return 0;
+
+ const millisecondPerDay = 1000 * 60 * 60 * 24;
+ const daysUntilChristmas = Math.floor((endDate - visitDate) / millisecondPerDay);
+
+ const { christmas, everyDay } = BENEFIT_AMOUNT_INFO;
+
+ const totalEventDay = 24;
+ return christmas + everyDay * (totalEventDay - daysUntilChristmas);
+}
+
+/**
+ *
+ * @param {import('../../utils/jsDoc.js').CalculateBenefitForDayTypeParams} params - 주문자 정보 + 요일 할인 조건이 들어있는 매개 변수
+ * @returns {number | 0} 요일(주말/평일) 할인이 적용되거나 적용 되지 않은 금액
+ */
+function calculateBenefitForDayType({
+ ordererInfo: { orderMenuInfo, visitDate },
+ menuCategory,
+ days,
+}) {
+ return !days.includes(visitDate.getDay())
+ ? 0
+ : orderMenuInfo
+ .filter(([menuName]) => MenuSearcher.isMenuInCategory(menuName, menuCategory))
+ .reduce(
+ (totalBenefit, [, quantity]) => totalBenefit + BENEFIT_AMOUNT_INFO.dayOfWeek * quantity,
+ 0,
+ );
+}
+
+/**
+ * @param {{visitDate : Date}} params - 방문 일자(Date 객체)가 포함된 객체
+ * @returns {number | 0} 특별 할인이 적용되거나 적용되지 않은 금액
+ */
+function calculateSpecialBenefit({ visitDate }) {
+ const formattedVisitDate = visitDate.toISOString().substring(0, 10);
+ const specialDates = SPECIAL_DATES;
+
+ return specialDates.has(formattedVisitDate) ? BENEFIT_AMOUNT_INFO.special : 0;
+}
+
+/**
+ * @param {{totalOrderAmount : number}} params - 총 주문 금액이 포함된 객체
+ * @returns {number | 0} 증정 이벤트가 적용되거나 적용되지 않은 금액
+ */
+function calculateGiftEvent({ totalOrderAmount }) {
+ if (totalOrderAmount < MINIMUM_ORDER_AMOUNT_FOR_GIFT) return 0;
+
+ const { menuCategory, menuName } = GIFT_INFO;
+ const champagne = MenuSearcher.findByMenuName(menuName, menuCategory);
+
+ return champagne.price;
+} | JavaScript | if문을 사용하면 early return으로 2번 return문을 사용해야하지만 3항 연산자는 값이기 때문에 return문을 간소화 할 수 있기 때문입니다! |
@@ -0,0 +1,136 @@
+import Event from "../src/domain/Event.js";
+
+describe('이벤트 관리자 Event 클래스 테스트', () => {
+ test.each([['0'], ['-25'], ['1.1'], ['32']])('1부터 31 사이의 자연수가 아닐시 예외처리', (input) => {
+ expect(() => {
+ const event = new Event(input);
+ event.date()
+ }).toThrow('[ERROR]');
+ });
+
+ test.each([['a'], ['!'], [' '], ['3a'], ['가'], ['1 '], ['1.0']])('숫자 이외의 공백을 포함한 문자 예외처리', (input) => {
+ expect(() => {
+ const event = new Event(input);
+ event.date();
+ }).toThrow('[ERROR]');
+ });
+
+ test('날짜를 숫자형으로 불러오는 기능 테스트', () => {
+ const event = new Event('25');
+
+ expect(event.date()).toEqual(25)
+ });
+
+ test.each([['26'], ['27'], ['28'], ['29'], ['30'], ['31']])('크리스마스D-Day 할인금액은 25일 이후 0원', (input) => {
+ const event = new Event(input);
+
+ expect(event.christmasDDayDiscount()).toEqual(0);
+ });
+
+ test('[크리스마스DDAY할인메서드] 25일까지 적용되는 크리스마스D-Day 할인금액은 1000 + (date-1)*100 원', () => {
+ const DATE = '25';
+ const event = new Event(DATE);
+ const RESULT = 1000 + (25 - 1) * 100;
+
+ expect(event.christmasDDayDiscount()).toEqual(RESULT);
+ });
+
+ test.each([['1'],['2'],['22'],['23'],['29'],['30']])('[평일할인메서드]평일 할인 금액은 주말인 금,토 요일에 0원', (input) => {
+ const event = new Event(input)
+ const DESERT_AMOUNT = 10;
+
+ expect(event.weekdayDiscount(DESERT_AMOUNT)).toEqual(0);
+ });
+
+ test('[평일할인메서드]평일에는 디저트 개수 * 2023의 평일할인 금액 테스트', () => {
+ const DESERT_AMOUNT = 3;
+ const event = new Event('25');
+ const RESULT = 2023 * 3;
+
+ expect(event.weekdayDiscount(DESERT_AMOUNT)).toEqual(RESULT);
+ });
+
+ test('[평일할인메서드] 평일이라도 디저트 수량이 0 이면 평일할인 금액은 0원', () => {
+ const DESERT_AMOUNT = 0;
+ const event = new Event('5');
+
+ expect(event.weekdayDiscount(DESERT_AMOUNT)).toEqual(0);
+ });
+
+ test.each([['4'], ['12'], ['25'], ['28']])('[주말할인메서드] 평일에는 주말 할인 금액 0원', (input) => {
+ const MAIN_AMOUNT = 10;
+ const event = new Event(input);
+
+ expect(event.weekendDiscount(MAIN_AMOUNT)).toEqual(0);
+ });
+
+ test.each([['1'], ['2'], ['22']])('[주말할인메서드] 주말 일지라도 메인요리 수량이 0일시 주말 할인 금액은 0원', (input) => {
+ const MAIN_AMOUNT = 0;
+ const event = new Event(input)
+
+ expect(event.weekendDiscount(MAIN_AMOUNT)).toEqual(0);
+ });
+
+ test('[주말할인메서드] 주말에는 메인요리수량 * 2023원 할인적용', () => {
+ const MAIN_AMOUNT = 3;
+ const RESULT = 3 * 2023;
+ const event = new Event('22');
+
+ expect(event.weekendDiscount(MAIN_AMOUNT)).toEqual(RESULT);
+ });
+
+ test.each([['3'], ['10'], ['17'], ['24'], ['31'], ['25']])('[스페셜할인메서드] 특별한 날짜에 대해서 1000원 할인적용 테스트', (input) => {
+ const RESULT = 1000;
+ const event = new Event(input);
+
+ expect(event.specialDiscount()).toEqual(RESULT);
+ });
+
+ test.each([['1'], ['23'], ['11'], ['27']])('[스패셜할인메서드] 특별한 날이 아닌 날에 대해선 할인금액 0원', (input) => {
+ const RESULT = 0;
+ const event = new Event(input);
+
+ expect(event.specialDiscount()).toEqual(RESULT);
+ });
+
+ test('[사은품금액메서드]총 주문액이 12만원 이상일시 2만5천원 할인적용 보여주기', () => {
+ const TOTAL_FOODS_PRICE_BEFORE_DISCOUNT = 120000;
+ const RESULT = 25000;
+ const event = new Event('1');
+
+ expect(event.freebieDiscount(TOTAL_FOODS_PRICE_BEFORE_DISCOUNT)).toEqual(RESULT);
+ });
+
+ test('[사은품금액메서드]총 주문액이 12만원 미만이면 0원 처리', () => {
+ const TOTAL_FOODS_PRICE_BEFORE_DISCOUNT = 119999;
+ const RESULT = 0;
+ const event = new Event('25');
+
+ expect(event.freebieDiscount(TOTAL_FOODS_PRICE_BEFORE_DISCOUNT)).toEqual(RESULT);
+ });
+
+ test('[이벤트참여가능여부메서드] 총 주문액 만원 이상부터 true 반환', () => {
+ const TOTAL_FOODS_PRICE_BEFORE_DISCOUNT = 10002;
+ const RESULT = true;
+ const event = new Event('24');
+
+ expect(event.condition(TOTAL_FOODS_PRICE_BEFORE_DISCOUNT)).toEqual(RESULT);
+ });
+
+ test('[이벤트참여가능여부메서드] 총 주문액 만원 미만부터 false 반환', () => {
+ const TOTAL_FOODS_PRICE_BEFORE_DISCOUNT = 9999;
+ const RESULT = false;
+ const event = new Event('31');
+
+ expect(event.condition(TOTAL_FOODS_PRICE_BEFORE_DISCOUNT)).toEqual(RESULT);
+ });
+
+ let badgeIndex = 0;
+ test.each([[4999], [5000], [12000], [21000]])('[벳지수여메서드] 해택받은 금액에 따라 뱃지 수여', (totalBenefitAmount) => {
+ const BADGE_RESULT = ['없음', '별', '트리', '산타'];
+ const event = new Event('22');
+
+ expect(event.getBadge(totalBenefitAmount)).toEqual(BADGE_RESULT[badgeIndex]);
+ badgeIndex += 1;
+ });
+}); | JavaScript | 각 테스트에 대해 단일 값을 주는 경우에 대해서는 []를 포함하지 않아도 되는 걸로 알고 있어요!! 한 번 확인해보시면 좋을 것 같아요 |
@@ -0,0 +1,110 @@
+import {
+ priceFilter,
+ PRICE_REFINER,
+ merageFoodInfo,
+ BENEFITS_REFINER,
+ isNotApplicableBenefits
+} from "../src/constants/ViewRefiner.js";
+
+test('숫자를 천단위로 잘라서 문자로 변환되는지 테스트', () => {
+ const NUMBER = 1234567890;
+ const PRICE_STRING = '1,234,567,890';
+
+ expect(priceFilter(NUMBER)).toEqual(PRICE_STRING);
+});
+
+test('숫자가 0일경우 문자로 0원을 반환한다', () => {
+ const PRICE = 0;
+ const RESULT = '0원';
+
+ expect(PRICE_REFINER.negative(PRICE)).toEqual(RESULT);
+});
+
+test('숫자가 0이 아니라면 천단위로 잘라 마이너스와 원을 붙여 문자로 반환한다', () => {
+ const PRICE = 1500000;
+ const RESULT = '-1,500,000원';
+
+ expect(PRICE_REFINER.negative(PRICE)).toEqual(RESULT);
+});
+
+test('음식 이름과 수량을 잘 짝지어 주는지 테스트', () => {
+ const FOOD_NAME = '시골된장찌개';
+ const FOOD_AMOUNT = '7';
+ const FOOD_NAME_WITH_AMOUNT = '시골된장찌개 7개';
+
+ expect(merageFoodInfo(FOOD_NAME, FOOD_AMOUNT)).toEqual(FOOD_NAME_WITH_AMOUNT);
+});
+
+test('혜택 내역이 하나도 없을때(키 condition의 value가 false) 없음이라는 문자만 담긴 배열을 반환한다', () => {
+ const map = new Map();
+ map
+ .set('christmas', 1000)
+ .set('weekday', 2023 * 1)
+ .set('weekend', 0)
+ .set('special', 0)
+ .set('freebie', 0)
+ .set('condition', false);
+
+ const BENEFITS_LIST = ['없음'];
+
+ expect(BENEFITS_REFINER.benfitList(map)).toEqual(BENEFITS_LIST);
+});
+
+test('키 condition의 value가 true라면 map에 담긴 정보를 최종 출력형식에 맞춰 문자 배열로 반환한다', () => {
+ const map = new Map();
+ map
+ .set('christmas', 1000 + (24 -1) * 100)
+ .set('weekday', 2023 * 10)
+ .set('weekend', 0)
+ .set('special', 1000)
+ .set('freebie', 25000)
+ .set('condition', true);
+
+ const BENEFITS_ARRAY = [
+ '크리스마스 디데이 할인: -3,300원',
+ '평일 할인: -20,230원',
+ '특별 할인: -1,000원',
+ '증정 이벤트: -25,000원'
+ ];
+
+ expect(BENEFITS_REFINER.benfitList(map)).toEqual(BENEFITS_ARRAY);
+});
+
+test('모든 혜택 할인금액이 0원이면 true를 반환한다', () => {
+ const map = new Map();
+ map
+ .set('christmas', 0)
+ .set('weekday', 0)
+ .set('weekend', 0)
+ .set('special', 0)
+ .set('freebie', 0)
+ .set('condition', true);
+
+ expect(isNotApplicableBenefits(map)).toEqual(true);
+});
+
+test('map 속의 conditon 의 value 가 false라면 true를 반환한다', () => {
+ const map = new Map();
+ map
+ .set('christmas', 2000)
+ .set('weekday', 2023)
+ .set('weekend', 0)
+ .set('special', 1000)
+ .set('freebie', 25000)
+ .set('condition', false);
+
+ expect(isNotApplicableBenefits(map)).toEqual(true);
+});
+
+test('혜택 금액이 모두 0원이 아니면서 conditon의 value가 true라면 false를 반환한다', () => {
+ const map = new Map();
+ map
+ .set('christmas', 0)
+ .set('weekday', 0)
+ .set('weekend', 0)
+ .set('special', 0)
+ .set('freebie', 25000)
+ .set('condition', true);
+
+ expect(isNotApplicableBenefits(map)).toEqual(false);
+}); | JavaScript | 도메인 로직이란 현실 문제에 대한 의사결정을 하는 코드로 알고 있는데, 혹시 해당 테스트가 도메인 로직에 대한 테스트인지 여쭙고 싶습니당! |
@@ -1,7 +1,67 @@
-export default OutputView = {
- printMenu() {
- Console.print("<주문 메뉴>");
- // ...
- }
- // ...
-}
+import { Console } from "@woowacourse/mission-utils";
+import { ANSWER } from "./constants/PlannerMesseage.js";
+import { PRICE_REFINER, BENEFITS_REFINER } from "./constants/ViewRefiner.js";
+
+const OutputView = {
+ printIntroduce() {
+ Console.print(ANSWER.introduce);
+ },
+
+ printProlog(date) {
+ Console.print(`${ANSWER.prolog(date)}\n`);
+ },
+
+ printOrderMenuResult(foodsArray) {
+ Console.print(ANSWER.orderMenu);
+
+ foodsArray.forEach((food) => Console.print(food));
+ Console.print('');
+ },
+
+ printTotalOrderAmountResult(amount) {
+ Console.print(ANSWER.totalOrderAmount);
+
+ Console.print(PRICE_REFINER.positive(amount));
+ Console.print('');
+ },
+
+ printFreebieMenuResult(freebieMenu) {
+ Console.print(ANSWER.freebieMenu);
+
+ Console.print(freebieMenu);
+ Console.print('');
+ },
+
+ printBenefitListResult(benefitArray) {
+ Console.print(ANSWER.benefitList);
+
+ BENEFITS_REFINER.benfitList(benefitArray).forEach((benefit) => Console.print(benefit));
+ Console.print('');
+ },
+
+ printTotalBenefitAmountResult(totalBenefitAmount) {
+ Console.print(ANSWER.totalBenefitAmount);
+
+ Console.print(PRICE_REFINER.negative(totalBenefitAmount));
+ Console.print('');
+ },
+
+ printFinalPaymentAmountResult(finalPaymentAmount) {
+ Console.print(ANSWER.finalPaymentAmount);
+
+ Console.print(PRICE_REFINER.positive(finalPaymentAmount));
+ Console.print('');
+ },
+
+ printBadgeResult(badge) {
+ Console.print(ANSWER.DecemberEventBadge);
+
+ Console.print(badge);
+ },
+
+ printErrorMesseage(messeage) {
+ Console.print(`${messeage}`);
+ }
+};
+
+export default OutputView; | JavaScript | **OutputView**가 정말 깔끔하게 잘 정리되어 있는 것 같습니다 ! 👍👍 |
@@ -0,0 +1,81 @@
+import Supervisor from "../domain/Supervisor.js";
+import InputView from "../InputView.js";
+import OutputView from "../OutputView.js";
+
+class EventPlanner {
+ #supervisor;
+
+ constructor() {
+ this.#supervisor = new Supervisor();
+ }
+
+ async start() {
+ OutputView.printIntroduce();
+
+ await this.getDate();
+ await this.getMenu();
+
+ this.plannerResult();
+ }
+
+ async getDate() {
+ try {
+ this.#supervisor.dateUpload(await InputView.readDate());
+
+ } catch (error) {
+ OutputView.printErrorMesseage(error);
+ await this.getDate();
+ }
+ }
+
+ async getMenu() {
+ try {
+ this.#supervisor.menuUpload(await InputView.readMenu());
+
+ } catch (error) {
+ OutputView.printErrorMesseage(error);
+ await this.getMenu();
+ }
+ }
+
+ plannerResult() {
+ OutputView.printProlog(this.#supervisor.event().date());
+ this.orderMenu();
+ this.totalOrderAmount();
+ this.freebieMenu();
+ this.benefitList();
+ this.totalBenefitAmount();
+ this.finalPaymentAmount();
+ this.badge();
+ }
+
+ orderMenu() {
+ OutputView.printOrderMenuResult(this.#supervisor.cashier().foodsListWithQuantity());
+ }
+
+ totalOrderAmount() {
+ OutputView.printTotalOrderAmountResult(this.#supervisor.cashier().totalFoodsPrice());
+ }
+
+ freebieMenu() {
+ OutputView.printFreebieMenuResult(this.#supervisor.cashier().freebieMenu());
+ }
+
+ benefitList() {
+ OutputView.printBenefitListResult(this.#supervisor.benefitList());
+ }
+
+ totalBenefitAmount() {
+ OutputView.printTotalBenefitAmountResult(this.#supervisor.totalBenefitAmount());
+ }
+
+ finalPaymentAmount() {
+ OutputView.printFinalPaymentAmountResult(this.#supervisor.finalPaymentAmount());
+ }
+
+ badge() {
+ OutputView.printBadgeResult(this.#supervisor.giveBadge());
+ }
+}
+
+export default EventPlanner; | JavaScript | `getDate`와 `getMenu` 메서드에서 재입력 요청에 대한 `try catch` 구문이 중복되어서 사용되는 것 같아요! 재입력 요청에 대한 `try catch` 구문을 함수로 분리하는 방법에 대해 고려해보시면 좋을 것 같아요! |
@@ -0,0 +1,84 @@
+import { dateValidator } from "../util/Validator.js";
+import {
+ DISCOUNT,
+ BADGE,
+ BENEFIT_MESSEAGE
+} from "../constants/BenefitStorage.js";
+
+class Event {
+ #date;
+
+ constructor(date) {
+ dateValidator(date);
+ this.#date = Number(date);
+ }
+
+ #week() {
+ const WEEK = ['SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA'];
+
+ return WEEK[new Date(2023, 11, this.#date).getDay()];
+ }
+
+ date() {
+ return this.#date;
+ }
+
+ christmasDDayDiscount() {
+ if (this.#date <= DISCOUNT.christmasDate) {
+ return DISCOUNT.christmasBasic + (this.#date - 1) * DISCOUNT.christmasAccumulation;
+ }
+ return DISCOUNT.zero;
+ }
+
+ weekdayDiscount(desertQuantity) {
+ if (this.#week() !== 'FR' && this.#week() !== 'SA') {
+ return desertQuantity * DISCOUNT.weekday;
+ }
+ return DISCOUNT.zero;
+ }
+
+ weekendDiscount(mainQuantity) {
+ if (this.#week() === 'FR' || this.#week() === 'SA') {
+ return mainQuantity * DISCOUNT.weekend;
+ }
+ return DISCOUNT.zero;
+ }
+
+ specialDiscount() {
+ if (this.#week() === 'SU' || this.#date === DISCOUNT.christmasDate) {
+ return DISCOUNT.special;
+ }
+ return DISCOUNT.zero;
+ }
+
+ freebieDiscount(totalFoodsPriceBeforeDiscount) {
+ if (totalFoodsPriceBeforeDiscount >= DISCOUNT.freebieStandard) {
+ return DISCOUNT.freebiePrice;
+ }
+ return DISCOUNT.zero;
+ }
+
+ condition(totalFoodsPriceBeforeDiscount) {
+ if (totalFoodsPriceBeforeDiscount >= DISCOUNT.eventStandardAmount) {
+ return true;
+ }
+ return false;
+ }
+
+ getBadge(totalBenefitAmount) {
+ if (totalBenefitAmount < BADGE.star) {
+ return BENEFIT_MESSEAGE.non;
+ }
+ if (totalBenefitAmount >= BADGE.santa) {
+ return BADGE.santaName;
+ }
+ if (totalBenefitAmount >= BADGE.tree) {
+ return BADGE.treeName;
+ }
+ if (totalBenefitAmount >= BADGE.star) {
+ return BADGE.starName;
+ }
+ }
+}
+
+export default Event; | JavaScript | 요일에 대한 값들을 상수로 선언하고, 상수를 활용하면 가독성 향상에 도움될 것 같아요! |
@@ -0,0 +1,49 @@
+import { foodValidator } from "../util/Validator.js";
+import {
+ MENU,
+ NAME,
+ KNIFE
+} from "../constants/FoodStorage.js";
+
+class Food {
+ #name;
+
+ #quantity;
+
+ constructor(food) {
+ foodValidator(this.#enrollFood(food));
+ }
+
+ #enrollFood(food) {
+ const foodInfoArray = food.split(KNIFE.bladePosition);
+ this.#name = foodInfoArray[KNIFE.namePosition];
+ this.#quantity = Number(foodInfoArray[KNIFE.quantityPosition]);
+
+ return foodInfoArray;
+ }
+
+ #category() {
+ const [foodTypeInfo] = MENU
+ .filter((foodType) => Object.hasOwn(foodType, this.#name));
+
+ return foodTypeInfo;
+ }
+
+ type() {
+ return this.#category()[NAME.type];
+ }
+
+ name() {
+ return this.#name;
+ }
+
+ quantity() {
+ return this.#quantity;
+ }
+
+ totalPrice() {
+ return this.#category()[this.#name] * this.quantity();
+ }
+}
+
+export default Food; | JavaScript | 타입, 이름, 퀀티티 등등 반환해주는 함수명에 대해 `get`을 붙여주는게 가독성 향상에 더 도움이 되지 않을까요?? |
@@ -0,0 +1,46 @@
+import { ERROR_DATE, ERROR_MENU } from "../constants/ErrorMesseage.js";
+import { MENU, KNIFE } from "../constants/FoodStorage.js";
+
+export const dateValidator = (date) => {
+ if (
+ date.includes(' ') ||
+ date.includes('.') ||
+ Number.isNaN(Number(date)) ||
+ !Number.isInteger(Number(date)) ||
+ Number(date) < ERROR_DATE.minDate ||
+ Number(date) > ERROR_DATE.maxDate
+ ) {
+ throw new Error(ERROR_DATE.basic);
+ }
+};
+
+export const nonFoodInMenu = (foodName) => {
+ const foodType = MENU
+ .filter((type) => Object.hasOwn(type, foodName));
+
+ if (foodType.length === 0) {
+ return true;
+ }
+ return false;
+};
+
+export const nonFoodQuantity = (foodQuantity) => {
+ if (foodQuantity < ERROR_MENU.minOrderNumber) {
+ return true;
+ }
+ return false;
+};
+
+export const foodValidator = (foodInfo) => {
+ if (
+ foodInfo.length !== 2 ||
+ foodInfo[KNIFE.quantityPosition].includes('.') ||
+ foodInfo[KNIFE.quantityPosition].includes(' ') ||
+ Number.isNaN(Number(foodInfo[KNIFE.quantityPosition])) ||
+ !Number.isInteger(Number(foodInfo[KNIFE.quantityPosition])) ||
+ nonFoodInMenu(foodInfo[KNIFE.namePosition]) ||
+ nonFoodQuantity(Number(foodInfo[KNIFE.quantityPosition]))
+ ) {
+ throw new Error(ERROR_MENU.basic);
+ }
+}; | JavaScript | `if` 문 내부에서 검증하는 것들이 너무 많아서 오히려 가독성이 떨어져 보일 수도 있을 것 같아요,,!
이 부분을 정규표현식을 활용한다면 가독성 향상에 도움이 될 수 있을 것 같아요! |
@@ -0,0 +1,110 @@
+import {
+ priceFilter,
+ PRICE_REFINER,
+ merageFoodInfo,
+ BENEFITS_REFINER,
+ isNotApplicableBenefits
+} from "../src/constants/ViewRefiner.js";
+
+test('숫자를 천단위로 잘라서 문자로 변환되는지 테스트', () => {
+ const NUMBER = 1234567890;
+ const PRICE_STRING = '1,234,567,890';
+
+ expect(priceFilter(NUMBER)).toEqual(PRICE_STRING);
+});
+
+test('숫자가 0일경우 문자로 0원을 반환한다', () => {
+ const PRICE = 0;
+ const RESULT = '0원';
+
+ expect(PRICE_REFINER.negative(PRICE)).toEqual(RESULT);
+});
+
+test('숫자가 0이 아니라면 천단위로 잘라 마이너스와 원을 붙여 문자로 반환한다', () => {
+ const PRICE = 1500000;
+ const RESULT = '-1,500,000원';
+
+ expect(PRICE_REFINER.negative(PRICE)).toEqual(RESULT);
+});
+
+test('음식 이름과 수량을 잘 짝지어 주는지 테스트', () => {
+ const FOOD_NAME = '시골된장찌개';
+ const FOOD_AMOUNT = '7';
+ const FOOD_NAME_WITH_AMOUNT = '시골된장찌개 7개';
+
+ expect(merageFoodInfo(FOOD_NAME, FOOD_AMOUNT)).toEqual(FOOD_NAME_WITH_AMOUNT);
+});
+
+test('혜택 내역이 하나도 없을때(키 condition의 value가 false) 없음이라는 문자만 담긴 배열을 반환한다', () => {
+ const map = new Map();
+ map
+ .set('christmas', 1000)
+ .set('weekday', 2023 * 1)
+ .set('weekend', 0)
+ .set('special', 0)
+ .set('freebie', 0)
+ .set('condition', false);
+
+ const BENEFITS_LIST = ['없음'];
+
+ expect(BENEFITS_REFINER.benfitList(map)).toEqual(BENEFITS_LIST);
+});
+
+test('키 condition의 value가 true라면 map에 담긴 정보를 최종 출력형식에 맞춰 문자 배열로 반환한다', () => {
+ const map = new Map();
+ map
+ .set('christmas', 1000 + (24 -1) * 100)
+ .set('weekday', 2023 * 10)
+ .set('weekend', 0)
+ .set('special', 1000)
+ .set('freebie', 25000)
+ .set('condition', true);
+
+ const BENEFITS_ARRAY = [
+ '크리스마스 디데이 할인: -3,300원',
+ '평일 할인: -20,230원',
+ '특별 할인: -1,000원',
+ '증정 이벤트: -25,000원'
+ ];
+
+ expect(BENEFITS_REFINER.benfitList(map)).toEqual(BENEFITS_ARRAY);
+});
+
+test('모든 혜택 할인금액이 0원이면 true를 반환한다', () => {
+ const map = new Map();
+ map
+ .set('christmas', 0)
+ .set('weekday', 0)
+ .set('weekend', 0)
+ .set('special', 0)
+ .set('freebie', 0)
+ .set('condition', true);
+
+ expect(isNotApplicableBenefits(map)).toEqual(true);
+});
+
+test('map 속의 conditon 의 value 가 false라면 true를 반환한다', () => {
+ const map = new Map();
+ map
+ .set('christmas', 2000)
+ .set('weekday', 2023)
+ .set('weekend', 0)
+ .set('special', 1000)
+ .set('freebie', 25000)
+ .set('condition', false);
+
+ expect(isNotApplicableBenefits(map)).toEqual(true);
+});
+
+test('혜택 금액이 모두 0원이 아니면서 conditon의 value가 true라면 false를 반환한다', () => {
+ const map = new Map();
+ map
+ .set('christmas', 0)
+ .set('weekday', 0)
+ .set('weekend', 0)
+ .set('special', 0)
+ .set('freebie', 25000)
+ .set('condition', true);
+
+ expect(isNotApplicableBenefits(map)).toEqual(false);
+}); | JavaScript | 혜택 내역을 map에서 관리 하다보니 출력 형태로 변환하는 로직이 다소 복잡해졌습니다. 해당 로직은 그 역할을 해주는데 생각보다 복잡하고 실수를 많이 한 부분이라 테스트를 진행했습니다! |
@@ -0,0 +1,81 @@
+import Supervisor from "../domain/Supervisor.js";
+import InputView from "../InputView.js";
+import OutputView from "../OutputView.js";
+
+class EventPlanner {
+ #supervisor;
+
+ constructor() {
+ this.#supervisor = new Supervisor();
+ }
+
+ async start() {
+ OutputView.printIntroduce();
+
+ await this.getDate();
+ await this.getMenu();
+
+ this.plannerResult();
+ }
+
+ async getDate() {
+ try {
+ this.#supervisor.dateUpload(await InputView.readDate());
+
+ } catch (error) {
+ OutputView.printErrorMesseage(error);
+ await this.getDate();
+ }
+ }
+
+ async getMenu() {
+ try {
+ this.#supervisor.menuUpload(await InputView.readMenu());
+
+ } catch (error) {
+ OutputView.printErrorMesseage(error);
+ await this.getMenu();
+ }
+ }
+
+ plannerResult() {
+ OutputView.printProlog(this.#supervisor.event().date());
+ this.orderMenu();
+ this.totalOrderAmount();
+ this.freebieMenu();
+ this.benefitList();
+ this.totalBenefitAmount();
+ this.finalPaymentAmount();
+ this.badge();
+ }
+
+ orderMenu() {
+ OutputView.printOrderMenuResult(this.#supervisor.cashier().foodsListWithQuantity());
+ }
+
+ totalOrderAmount() {
+ OutputView.printTotalOrderAmountResult(this.#supervisor.cashier().totalFoodsPrice());
+ }
+
+ freebieMenu() {
+ OutputView.printFreebieMenuResult(this.#supervisor.cashier().freebieMenu());
+ }
+
+ benefitList() {
+ OutputView.printBenefitListResult(this.#supervisor.benefitList());
+ }
+
+ totalBenefitAmount() {
+ OutputView.printTotalBenefitAmountResult(this.#supervisor.totalBenefitAmount());
+ }
+
+ finalPaymentAmount() {
+ OutputView.printFinalPaymentAmountResult(this.#supervisor.finalPaymentAmount());
+ }
+
+ badge() {
+ OutputView.printBadgeResult(this.#supervisor.giveBadge());
+ }
+}
+
+export default EventPlanner; | JavaScript | 리팩토링때 적용해보도록 하겠습니다! 👍 |
@@ -0,0 +1,84 @@
+import { dateValidator } from "../util/Validator.js";
+import {
+ DISCOUNT,
+ BADGE,
+ BENEFIT_MESSEAGE
+} from "../constants/BenefitStorage.js";
+
+class Event {
+ #date;
+
+ constructor(date) {
+ dateValidator(date);
+ this.#date = Number(date);
+ }
+
+ #week() {
+ const WEEK = ['SU', 'MO', 'TU', 'WE', 'TH', 'FR', 'SA'];
+
+ return WEEK[new Date(2023, 11, this.#date).getDay()];
+ }
+
+ date() {
+ return this.#date;
+ }
+
+ christmasDDayDiscount() {
+ if (this.#date <= DISCOUNT.christmasDate) {
+ return DISCOUNT.christmasBasic + (this.#date - 1) * DISCOUNT.christmasAccumulation;
+ }
+ return DISCOUNT.zero;
+ }
+
+ weekdayDiscount(desertQuantity) {
+ if (this.#week() !== 'FR' && this.#week() !== 'SA') {
+ return desertQuantity * DISCOUNT.weekday;
+ }
+ return DISCOUNT.zero;
+ }
+
+ weekendDiscount(mainQuantity) {
+ if (this.#week() === 'FR' || this.#week() === 'SA') {
+ return mainQuantity * DISCOUNT.weekend;
+ }
+ return DISCOUNT.zero;
+ }
+
+ specialDiscount() {
+ if (this.#week() === 'SU' || this.#date === DISCOUNT.christmasDate) {
+ return DISCOUNT.special;
+ }
+ return DISCOUNT.zero;
+ }
+
+ freebieDiscount(totalFoodsPriceBeforeDiscount) {
+ if (totalFoodsPriceBeforeDiscount >= DISCOUNT.freebieStandard) {
+ return DISCOUNT.freebiePrice;
+ }
+ return DISCOUNT.zero;
+ }
+
+ condition(totalFoodsPriceBeforeDiscount) {
+ if (totalFoodsPriceBeforeDiscount >= DISCOUNT.eventStandardAmount) {
+ return true;
+ }
+ return false;
+ }
+
+ getBadge(totalBenefitAmount) {
+ if (totalBenefitAmount < BADGE.star) {
+ return BENEFIT_MESSEAGE.non;
+ }
+ if (totalBenefitAmount >= BADGE.santa) {
+ return BADGE.santaName;
+ }
+ if (totalBenefitAmount >= BADGE.tree) {
+ return BADGE.treeName;
+ }
+ if (totalBenefitAmount >= BADGE.star) {
+ return BADGE.starName;
+ }
+ }
+}
+
+export default Event; | JavaScript | 상수 처리는 하였지만 지금 다시 봐도 클래스 내에서 선언한 부분은 말씀대로 많이 아쉬운 것 같습니다ㅠ 요일의 이름을 풀네임을 할지도 고민이었는데 두 글자로도 충분할 것 같아 약어를 사용하였습니다. |
@@ -0,0 +1,49 @@
+import { foodValidator } from "../util/Validator.js";
+import {
+ MENU,
+ NAME,
+ KNIFE
+} from "../constants/FoodStorage.js";
+
+class Food {
+ #name;
+
+ #quantity;
+
+ constructor(food) {
+ foodValidator(this.#enrollFood(food));
+ }
+
+ #enrollFood(food) {
+ const foodInfoArray = food.split(KNIFE.bladePosition);
+ this.#name = foodInfoArray[KNIFE.namePosition];
+ this.#quantity = Number(foodInfoArray[KNIFE.quantityPosition]);
+
+ return foodInfoArray;
+ }
+
+ #category() {
+ const [foodTypeInfo] = MENU
+ .filter((foodType) => Object.hasOwn(foodType, this.#name));
+
+ return foodTypeInfo;
+ }
+
+ type() {
+ return this.#category()[NAME.type];
+ }
+
+ name() {
+ return this.#name;
+ }
+
+ quantity() {
+ return this.#quantity;
+ }
+
+ totalPrice() {
+ return this.#category()[this.#name] * this.quantity();
+ }
+}
+
+export default Food; | JavaScript | get을 정확히 언제 붙여야 할지 고민이 됩니다. type 메서드의 경우 type을 가져오는 것이니 get을 붙여야 할지,
단순히 필드 값을 가져오는게 아니라 엄연히 로직이 구현 되어 있으니 food.type() 우로도 의미 전달히 충분한지 아직 햇갈리는 부분인 것 같습니다.ㅠㅠ |
@@ -0,0 +1,106 @@
+import Cashier from "../src/domain/Cashier.js";
+
+describe('Cashier 클래스 유효성 테스트', () => {
+ test.each([
+ ['제로콜라-10'],
+ ['제로콜라-2,샴페인-4'],
+ ['샴페인-3,레드와인-1,제로콜라-2']
+ ])('음료만 주문시 예외처리', (input) => {
+ expect(() => new Cashier(input)).toThrow('[ERROR');
+ });
+
+ test.each([
+ ['아이스크림-3,초코케이크-4,아이스크림-1'],
+ ['티본스테이크-3,바비큐립-4,양송이수프-3,양송이수프-1'],
+ ['시저샐러드-1,제로콜라-1,제로콜라-1,시저샐러드-4,크리스마스파스타-1']
+ ])('주문한 음식 이름이 중복되면 예외처리', (input) => {
+ expect(() => new Cashier(input)).toThrow('[ERROR]');
+ });
+
+ test.each([
+ ['제로콜라-21'],
+ ['샴페인-3,양송이수프-10,시저셀러드-8,아이스크림-10'],
+ ['티본스테이크-22,레드와인-1']
+ ])('주문 수량이 20 초과시 예외처리', (input) => {
+ expect(() => new Cashier(input)).toThrow('[ERROR]');
+ });
+
+ test.each([
+ ['아이스크림-3.1'],
+ ['초코케이크-3.a'],
+ ['티본스테이크-a'],
+ ['크리스마스파스타-0.99']
+ ])('주문 수량이 올바른 형식이 아니면 예외처리', (input) => {
+ expect(() => new Cashier(input)).toThrow('[ERROR]');
+ });
+
+ test.each([
+ ['제로콜라-1,아이스크림-19'],
+ ['티본스테이크-20'],
+ ['시저샐러드-3,양송이수프-15,레드와인-2']
+ ])('올바르게 입력시 예외를 발생시키지 않는다', (input) => {
+ expect(() => new Cashier(input)).not.toThrow();
+ });
+});
+
+describe('Cashier 클래스 메서드 단위테스트', () => {
+ test('음식 이름과 수량을 잘 짝지어서 보여주는지 테스트', () => {
+ const ORDER_MENU = '티본스테이크-2,샴페인-3,초코케이크-4,시저샐러드-5,바비큐립-3,타파스-3';
+ const RESULT = [
+ '티본스테이크 2개',
+ '샴페인 3개',
+ '초코케이크 4개',
+ '시저샐러드 5개',
+ '바비큐립 3개',
+ '타파스 3개'
+ ];
+
+ const cashier = new Cashier(ORDER_MENU);
+
+ expect(cashier.foodsListWithQuantity()).toEqual(RESULT);
+ });
+
+ test('주문한 음식들의 총 가격을 잘 계산하는지 테스트', () => {
+ const ORDER_MENU = '아이스크림-4,티본스테이크-3,샴페인-2,시저샐러드-1';
+ const RESULT = (5000 * 4) + (55000 * 3) + (25000 * 2) + (8000 * 1);
+ const cashier = new Cashier(ORDER_MENU);
+
+ expect(cashier.totalFoodsPrice()).toEqual(RESULT);
+ });
+
+ let typeIndex = 0
+ test.each([
+ ['appetizer'],
+ ['main'],
+ ['desert'],
+ ['drink']
+ ])('해당 주문에 지정한 타입음식의 총수량을 잘 계산하는지 테스트', (input) => {
+ const ORDER_MENU =
+ '양송이수프-3,타파스-3,' +
+ '티본스테이크-1,해산물파스타-2,바비큐립-2,' +
+ '초코케이크-3,아이스크림-1,' +
+ '제로콜라-2,샴페인-1';
+
+ const RESULT = [6,5,4,3];
+ const cashier = new Cashier(ORDER_MENU);
+
+ expect(cashier.totalTypeQuantity(input)).toEqual(RESULT[typeIndex]);
+ typeIndex += 1;
+ });
+
+ test('주문 금액이 12만원 이상이면 샴페인 증정 해주는지 테스트', () => {
+ const ORDER_MENU = '티본스테이크-2,양송이수프-1,타파스-1';
+ const RESULT = '샴페인 1개';
+ const cashier = new Cashier(ORDER_MENU);
+
+ expect(cashier.freebieMenu()).toEqual(RESULT);
+ });
+
+ test('주문 금액이 12만원 미만이면 없음을 표시하는지 테스트', () => {
+ const ORDER_MENU = '티본스테이크-2,양송이수프-1';
+ const RESULT = '없음';
+ const cashier = new Cashier(ORDER_MENU);
+
+ expect(cashier.freebieMenu()).toEqual(RESULT);
+ });
+}); | JavaScript | 테스트 꼼꼼한거 너무 좋습니다! 👍 그런데 테스트문구 양식을 하나로 통일하면 좋을 것 같아요!
해당 문구처럼 `예외를 발생시키지 않는다`. 에 맞춰서 `예외처리` -> `예외를 발생시킨다` 로 통일하면 좋을 것 같습니다! |
@@ -0,0 +1,70 @@
+import Food from "./Food.js";
+import { ERROR_MENU } from "../constants/ErrorMesseage.js";
+import { merageFoodInfo } from "../constants/ViewRefiner.js";
+import { DISCOUNT, BENEFIT_MESSEAGE } from "../constants/BenefitStorage.js";
+import { NAME } from "../constants/FoodStorage.js";
+
+class Cashier {
+ #foods = [];
+
+ constructor(orderHistory) {
+ this.#enrollFoods(orderHistory);
+ this.#orderDuplicationValidator();
+ this.#onlyDrinkValidator();
+ this.#orderMaxValidator();
+ }
+
+ #enrollFoods(orderHistory) {
+ orderHistory
+ .split(',')
+ .forEach((food) => this.#foods.push(new Food(food)));
+ }
+
+ #orderDuplicationValidator() {
+ const foodNameList = this.#foods.map((food) => food.name());
+ if (foodNameList.length !== new Set(foodNameList).size) {
+ throw new Error(ERROR_MENU.basic);
+ }
+ }
+
+ #onlyDrinkValidator() {
+ const drinkTypeFoodsList = this.#foods.filter((food) => food.type() === NAME.drink);
+
+ if (drinkTypeFoodsList.length === this.#foods.length) {
+ throw new Error(ERROR_MENU.onlyDrink);
+ }
+ }
+
+ #orderMaxValidator() {
+ if (this.#totalFoodsQuantity() > ERROR_MENU.maxOrderNumber) {
+ throw new Error(`${ERROR_MENU.maxOrder}\n${ERROR_MENU.orderAmountExample}`);
+ }
+ }
+
+ #totalFoodsQuantity() {
+ return this.#foods.reduce((acc,cur) => acc + cur.quantity(), 0);
+ }
+
+ foodsListWithQuantity() {
+ return this.#foods.map((foodInfo) => merageFoodInfo(foodInfo.name(), foodInfo.quantity()));
+ }
+
+ totalFoodsPrice() {
+ return this.#foods.reduce((acc, cur) => acc + cur.totalPrice(), 0);
+ }
+
+ totalTypeQuantity(foodType) {
+ return this.#foods
+ .filter((food) => food.type() === foodType)
+ .reduce((acc, cur) => acc + cur.quantity(), 0);
+ }
+
+ freebieMenu() {
+ if (this.totalFoodsPrice() >= DISCOUNT.freebieStandard) {
+ return DISCOUNT.freebieItem;
+ }
+ return BENEFIT_MESSEAGE.non;
+ }
+}
+
+export default Cashier; | JavaScript | 혹시 출력과 관련된 포맷팅 부분을 도메인에서 처리한 이유가 있으실까요? 궁금합니다! 포맷팅해주는 것도 도메인의 역할이라고 생각하셨기 때문일까요? |
@@ -1,7 +1,67 @@
-export default OutputView = {
- printMenu() {
- Console.print("<주문 메뉴>");
- // ...
- }
- // ...
-}
+import { Console } from "@woowacourse/mission-utils";
+import { ANSWER } from "./constants/PlannerMesseage.js";
+import { PRICE_REFINER, BENEFITS_REFINER } from "./constants/ViewRefiner.js";
+
+const OutputView = {
+ printIntroduce() {
+ Console.print(ANSWER.introduce);
+ },
+
+ printProlog(date) {
+ Console.print(`${ANSWER.prolog(date)}\n`);
+ },
+
+ printOrderMenuResult(foodsArray) {
+ Console.print(ANSWER.orderMenu);
+
+ foodsArray.forEach((food) => Console.print(food));
+ Console.print('');
+ },
+
+ printTotalOrderAmountResult(amount) {
+ Console.print(ANSWER.totalOrderAmount);
+
+ Console.print(PRICE_REFINER.positive(amount));
+ Console.print('');
+ },
+
+ printFreebieMenuResult(freebieMenu) {
+ Console.print(ANSWER.freebieMenu);
+
+ Console.print(freebieMenu);
+ Console.print('');
+ },
+
+ printBenefitListResult(benefitArray) {
+ Console.print(ANSWER.benefitList);
+
+ BENEFITS_REFINER.benfitList(benefitArray).forEach((benefit) => Console.print(benefit));
+ Console.print('');
+ },
+
+ printTotalBenefitAmountResult(totalBenefitAmount) {
+ Console.print(ANSWER.totalBenefitAmount);
+
+ Console.print(PRICE_REFINER.negative(totalBenefitAmount));
+ Console.print('');
+ },
+
+ printFinalPaymentAmountResult(finalPaymentAmount) {
+ Console.print(ANSWER.finalPaymentAmount);
+
+ Console.print(PRICE_REFINER.positive(finalPaymentAmount));
+ Console.print('');
+ },
+
+ printBadgeResult(badge) {
+ Console.print(ANSWER.DecemberEventBadge);
+
+ Console.print(badge);
+ },
+
+ printErrorMesseage(messeage) {
+ Console.print(`${messeage}`);
+ }
+};
+
+export default OutputView; | JavaScript | 해당부분 messeage 그냥 바로 출력해도 될것 같습니다! |
@@ -1,7 +1,67 @@
-export default OutputView = {
- printMenu() {
- Console.print("<주문 메뉴>");
- // ...
- }
- // ...
-}
+import { Console } from "@woowacourse/mission-utils";
+import { ANSWER } from "./constants/PlannerMesseage.js";
+import { PRICE_REFINER, BENEFITS_REFINER } from "./constants/ViewRefiner.js";
+
+const OutputView = {
+ printIntroduce() {
+ Console.print(ANSWER.introduce);
+ },
+
+ printProlog(date) {
+ Console.print(`${ANSWER.prolog(date)}\n`);
+ },
+
+ printOrderMenuResult(foodsArray) {
+ Console.print(ANSWER.orderMenu);
+
+ foodsArray.forEach((food) => Console.print(food));
+ Console.print('');
+ },
+
+ printTotalOrderAmountResult(amount) {
+ Console.print(ANSWER.totalOrderAmount);
+
+ Console.print(PRICE_REFINER.positive(amount));
+ Console.print('');
+ },
+
+ printFreebieMenuResult(freebieMenu) {
+ Console.print(ANSWER.freebieMenu);
+
+ Console.print(freebieMenu);
+ Console.print('');
+ },
+
+ printBenefitListResult(benefitArray) {
+ Console.print(ANSWER.benefitList);
+
+ BENEFITS_REFINER.benfitList(benefitArray).forEach((benefit) => Console.print(benefit));
+ Console.print('');
+ },
+
+ printTotalBenefitAmountResult(totalBenefitAmount) {
+ Console.print(ANSWER.totalBenefitAmount);
+
+ Console.print(PRICE_REFINER.negative(totalBenefitAmount));
+ Console.print('');
+ },
+
+ printFinalPaymentAmountResult(finalPaymentAmount) {
+ Console.print(ANSWER.finalPaymentAmount);
+
+ Console.print(PRICE_REFINER.positive(finalPaymentAmount));
+ Console.print('');
+ },
+
+ printBadgeResult(badge) {
+ Console.print(ANSWER.DecemberEventBadge);
+
+ Console.print(badge);
+ },
+
+ printErrorMesseage(messeage) {
+ Console.print(`${messeage}`);
+ }
+};
+
+export default OutputView; | JavaScript | 제목 부분이라서 다 띄어쓰기를 하신걸까요? 꼼꼼합니다! 👍 |
@@ -0,0 +1,40 @@
+export const DISCOUNT = Object.freeze({
+ christmasDate : 25,
+ christmasBasic : 1000,
+ christmasAccumulation : 100,
+ weekday : 2023,
+ weekend : 2023,
+ special : 1000,
+ freebieItem : '샴페인 1개',
+ freebieStandard : 120000,
+ freebiePrice : 25000,
+ eventStandardAmount : 10000,
+ zero : 0,
+});
+
+export const EVENT_NAME = Object.freeze({
+ christmas : 'christmas',
+ weekday : 'weekday',
+ weekend : 'weekend',
+ special : 'special',
+ freebie : 'freebie',
+ condition : 'condition',
+});
+
+export const BADGE = Object.freeze({
+ star : 5000,
+ tree : 10000,
+ santa : 20000,
+ starName : '별',
+ treeName : '트리',
+ santaName : '산타',
+});
+
+export const BENEFIT_MESSEAGE = Object.freeze({
+ christmas : '크리스마스 디데이 할인: ',
+ weekday : '평일 할인: ',
+ weekend : '주말 할인: ',
+ special : '특별 할인: ',
+ freebie : '증정 이벤트: ',
+ non : '없음',
+}); | JavaScript | 해당 샴페인은 string으로 넣기보다 선언해놓으신 상수 써도 좋을 것 같아요! |
@@ -0,0 +1,40 @@
+export const DISCOUNT = Object.freeze({
+ christmasDate : 25,
+ christmasBasic : 1000,
+ christmasAccumulation : 100,
+ weekday : 2023,
+ weekend : 2023,
+ special : 1000,
+ freebieItem : '샴페인 1개',
+ freebieStandard : 120000,
+ freebiePrice : 25000,
+ eventStandardAmount : 10000,
+ zero : 0,
+});
+
+export const EVENT_NAME = Object.freeze({
+ christmas : 'christmas',
+ weekday : 'weekday',
+ weekend : 'weekend',
+ special : 'special',
+ freebie : 'freebie',
+ condition : 'condition',
+});
+
+export const BADGE = Object.freeze({
+ star : 5000,
+ tree : 10000,
+ santa : 20000,
+ starName : '별',
+ treeName : '트리',
+ santaName : '산타',
+});
+
+export const BENEFIT_MESSEAGE = Object.freeze({
+ christmas : '크리스마스 디데이 할인: ',
+ weekday : '평일 할인: ',
+ weekend : '주말 할인: ',
+ special : '특별 할인: ',
+ freebie : '증정 이벤트: ',
+ non : '없음',
+}); | JavaScript | 변수명에 가격이라는게 더 드러나면 좋을 것 같아요! |
@@ -0,0 +1,40 @@
+export const DISCOUNT = Object.freeze({
+ christmasDate : 25,
+ christmasBasic : 1000,
+ christmasAccumulation : 100,
+ weekday : 2023,
+ weekend : 2023,
+ special : 1000,
+ freebieItem : '샴페인 1개',
+ freebieStandard : 120000,
+ freebiePrice : 25000,
+ eventStandardAmount : 10000,
+ zero : 0,
+});
+
+export const EVENT_NAME = Object.freeze({
+ christmas : 'christmas',
+ weekday : 'weekday',
+ weekend : 'weekend',
+ special : 'special',
+ freebie : 'freebie',
+ condition : 'condition',
+});
+
+export const BADGE = Object.freeze({
+ star : 5000,
+ tree : 10000,
+ santa : 20000,
+ starName : '별',
+ treeName : '트리',
+ santaName : '산타',
+});
+
+export const BENEFIT_MESSEAGE = Object.freeze({
+ christmas : '크리스마스 디데이 할인: ',
+ weekday : '평일 할인: ',
+ weekend : '주말 할인: ',
+ special : '특별 할인: ',
+ freebie : '증정 이벤트: ',
+ non : '없음',
+}); | JavaScript | 꼼꼼하십니당!! 👍👍👍 |
@@ -0,0 +1,40 @@
+export const DISCOUNT = Object.freeze({
+ christmasDate : 25,
+ christmasBasic : 1000,
+ christmasAccumulation : 100,
+ weekday : 2023,
+ weekend : 2023,
+ special : 1000,
+ freebieItem : '샴페인 1개',
+ freebieStandard : 120000,
+ freebiePrice : 25000,
+ eventStandardAmount : 10000,
+ zero : 0,
+});
+
+export const EVENT_NAME = Object.freeze({
+ christmas : 'christmas',
+ weekday : 'weekday',
+ weekend : 'weekend',
+ special : 'special',
+ freebie : 'freebie',
+ condition : 'condition',
+});
+
+export const BADGE = Object.freeze({
+ star : 5000,
+ tree : 10000,
+ santa : 20000,
+ starName : '별',
+ treeName : '트리',
+ santaName : '산타',
+});
+
+export const BENEFIT_MESSEAGE = Object.freeze({
+ christmas : '크리스마스 디데이 할인: ',
+ weekday : '평일 할인: ',
+ weekend : '주말 할인: ',
+ special : '특별 할인: ',
+ freebie : '증정 이벤트: ',
+ non : '없음',
+}); | JavaScript | 그리고 해당 `DISCOUNT` 상수에 이벤트와 관련된 모든 정보가 들어가있는데, 아예 크리스마스 이벤트, 평일 이벤트, 등등으로 상수를 쪼개거나, 혹은 중간에 공백라인을 넣으면 좋을 것 같아요! 구분되어있지 않다보니까 파악하기 조금 어려울 것 같아요! |
@@ -0,0 +1,40 @@
+export const DISCOUNT = Object.freeze({
+ christmasDate : 25,
+ christmasBasic : 1000,
+ christmasAccumulation : 100,
+ weekday : 2023,
+ weekend : 2023,
+ special : 1000,
+ freebieItem : '샴페인 1개',
+ freebieStandard : 120000,
+ freebiePrice : 25000,
+ eventStandardAmount : 10000,
+ zero : 0,
+});
+
+export const EVENT_NAME = Object.freeze({
+ christmas : 'christmas',
+ weekday : 'weekday',
+ weekend : 'weekend',
+ special : 'special',
+ freebie : 'freebie',
+ condition : 'condition',
+});
+
+export const BADGE = Object.freeze({
+ star : 5000,
+ tree : 10000,
+ santa : 20000,
+ starName : '별',
+ treeName : '트리',
+ santaName : '산타',
+});
+
+export const BENEFIT_MESSEAGE = Object.freeze({
+ christmas : '크리스마스 디데이 할인: ',
+ weekday : '평일 할인: ',
+ weekend : '주말 할인: ',
+ special : '특별 할인: ',
+ freebie : '증정 이벤트: ',
+ non : '없음',
+}); | JavaScript | `star : { price : 5000, name : '별'}` 해당 형식은 어떨지 추천하고 갑니다! |
@@ -0,0 +1,14 @@
+export const ERROR_DATE = Object.freeze({
+ basic : '[ERROR] 유효하지 않은 날짜입니다. 다시 입력해 주세요.',
+ minDate : 1,
+ maxDate : 31,
+});
+
+export const ERROR_MENU = Object.freeze({
+ basic : '[ERROR] 유효하지 않은 주문입니다. 다시 입력해 주세요.',
+ onlyDrink : '[ERROR] 음료만 주문 시, 주문할 수 없습니다.',
+ maxOrder : '[ERROR] 메뉴는 한 번에 최대 20개까지만 주문할 수 있습니다.',
+ orderAmountExample : '(e.g. 시저샐러드-1, 티본스테이크-1, 크리스마스파스타-1, 제로콜라-3, 아이스크림-1의 총개수는 7개)',
+ minOrderNumber : 1,
+ maxOrderNumber : 20,
+}); | JavaScript | 해당 20도 상수로 빼면 좋을 것 같아요! |
@@ -0,0 +1,43 @@
+export const APPETIZER = Object.freeze({
+ '양송이수프' : 6000,
+ '타파스' : 5500,
+ '시저샐러드' : 8000,
+ 'type' : 'appetizer',
+});
+
+export const MAIN = Object.freeze({
+ '티본스테이크' : 55000,
+ '바비큐립' : 54000,
+ '해산물파스타' : 35000,
+ '크리스마스파스타' : 25000,
+ 'type' : 'main',
+});
+
+export const DESERT = Object.freeze({
+ '초코케이크' : 15000,
+ '아이스크림' : 5000,
+ 'type' : 'desert',
+});
+
+export const DRINK = Object.freeze({
+ '제로콜라' : 3000,
+ '레드와인' : 60000,
+ '샴페인' : 25000,
+ 'type' : 'drink',
+});
+
+export const MENU = [APPETIZER, MAIN, DESERT, DRINK];
+
+export const NAME = Object.freeze({
+ type : 'type',
+ appetizer : 'appetizer',
+ main : 'main',
+ desert : 'desert',
+ drink : 'drink',
+});
+
+export const KNIFE = Object.freeze({
+ namePosition : 0,
+ quantityPosition : 1,
+ bladePosition : '-'
+}); | JavaScript | 타입부분은 해당 객체에 마지막에 넣기보단, 따로 빼서 확인하는게 좋을 것 같습니다!
객체가 중간에 속성이 다를 경우, 유지보수도 힘들뿐만 아니라 매번 `APPETIZER`의 마지막 속성은 type이라는걸 기억해두고 코드를 짜야해서, type은 해당 객체에서 따로 빼는게 좋아보입니다!
```js
export const APPETIZER = Object.freeze({
'양송이수프': 6000,
'타파스': 5500,
'시저샐러드': 8000,
});
``` |
@@ -0,0 +1,43 @@
+export const APPETIZER = Object.freeze({
+ '양송이수프' : 6000,
+ '타파스' : 5500,
+ '시저샐러드' : 8000,
+ 'type' : 'appetizer',
+});
+
+export const MAIN = Object.freeze({
+ '티본스테이크' : 55000,
+ '바비큐립' : 54000,
+ '해산물파스타' : 35000,
+ '크리스마스파스타' : 25000,
+ 'type' : 'main',
+});
+
+export const DESERT = Object.freeze({
+ '초코케이크' : 15000,
+ '아이스크림' : 5000,
+ 'type' : 'desert',
+});
+
+export const DRINK = Object.freeze({
+ '제로콜라' : 3000,
+ '레드와인' : 60000,
+ '샴페인' : 25000,
+ 'type' : 'drink',
+});
+
+export const MENU = [APPETIZER, MAIN, DESERT, DRINK];
+
+export const NAME = Object.freeze({
+ type : 'type',
+ appetizer : 'appetizer',
+ main : 'main',
+ desert : 'desert',
+ drink : 'drink',
+});
+
+export const KNIFE = Object.freeze({
+ namePosition : 0,
+ quantityPosition : 1,
+ bladePosition : '-'
+}); | JavaScript | 이 부분은 `-` 로 쪼갰을때 나오는 배열의 index를 가져오기 위한 상수 맞을까요? 그렇다면 구조분해할당 쓰면 더 깔끔할 것 같아요! 그렇게 된다면 `KNIFE `상수명보다는 `delimiter`나 `seperator`로 바꾸는것도 좋을 것 같아요! |
@@ -0,0 +1,14 @@
+export const ERROR_DATE = Object.freeze({
+ basic : '[ERROR] 유효하지 않은 날짜입니다. 다시 입력해 주세요.',
+ minDate : 1,
+ maxDate : 31,
+});
+
+export const ERROR_MENU = Object.freeze({
+ basic : '[ERROR] 유효하지 않은 주문입니다. 다시 입력해 주세요.',
+ onlyDrink : '[ERROR] 음료만 주문 시, 주문할 수 없습니다.',
+ maxOrder : '[ERROR] 메뉴는 한 번에 최대 20개까지만 주문할 수 있습니다.',
+ orderAmountExample : '(e.g. 시저샐러드-1, 티본스테이크-1, 크리스마스파스타-1, 제로콜라-3, 아이스크림-1의 총개수는 7개)',
+ minOrderNumber : 1,
+ maxOrderNumber : 20,
+}); | JavaScript | `ERROR_MENU`에는 에러와 관련된것만 있으면 좋을 것 같은데, 11,12,13 line은 조금 애매한 것 같습니다!
`ERROR_MENU`-> `MENU`로 바꾸고, 그 안에 `ERROR`로 한번 더 감싸는건 어떨지 추천하고 갑니당! |
@@ -0,0 +1,41 @@
+import { BENEFIT_MESSEAGE } from "./BenefitStorage.js";
+import { EVENT_NAME } from "./BenefitStorage.js";
+
+export const priceFilter = (priceNumber) => new Intl.NumberFormat('ko-KR').format(priceNumber);
+
+export const merageFoodInfo = (foodName, foodAmount) => `${foodName} ${foodAmount}개`;
+
+export const PRICE_REFINER = Object.freeze({
+ positive : (priceNumber) => `${priceFilter(priceNumber)}원`,
+ negative : (priceNumber) => {
+ if (priceNumber === 0) return `${priceNumber}원`;
+
+ return `-${priceFilter(priceNumber)}원`;
+ },
+});
+
+export const isNotApplicableBenefits = (benefitList) => {
+ const benefitsResultArray = [];
+ for (let benefitResult of benefitList.values()) {
+ if (benefitResult !== 0) benefitsResultArray.push(benefitResult);
+ }
+ if (benefitsResultArray.length === 1) return true;
+
+ if (!benefitList.get(EVENT_NAME.condition)) return true;
+
+ return false;
+};
+
+export const BENEFITS_REFINER = Object.freeze({
+ benfitList : (benefitList) => {
+ if (isNotApplicableBenefits(benefitList)) return [BENEFIT_MESSEAGE.non];
+
+ const refinedBenefits = [];
+ benefitList.forEach((value, key) => {
+ if (value !==0 && typeof(value) !== 'boolean') {
+ refinedBenefits.push(`${BENEFIT_MESSEAGE[key]}${PRICE_REFINER.negative(value)}`);
+ }
+ });
+ return refinedBenefits;
+ },
+}); | JavaScript | 해당 객체의 경우 positive, negative속성을 나누지말고 처음부터 3가지 조건문으로 바로 검사하면 어떨까요? |
@@ -0,0 +1,41 @@
+import { BENEFIT_MESSEAGE } from "./BenefitStorage.js";
+import { EVENT_NAME } from "./BenefitStorage.js";
+
+export const priceFilter = (priceNumber) => new Intl.NumberFormat('ko-KR').format(priceNumber);
+
+export const merageFoodInfo = (foodName, foodAmount) => `${foodName} ${foodAmount}개`;
+
+export const PRICE_REFINER = Object.freeze({
+ positive : (priceNumber) => `${priceFilter(priceNumber)}원`,
+ negative : (priceNumber) => {
+ if (priceNumber === 0) return `${priceNumber}원`;
+
+ return `-${priceFilter(priceNumber)}원`;
+ },
+});
+
+export const isNotApplicableBenefits = (benefitList) => {
+ const benefitsResultArray = [];
+ for (let benefitResult of benefitList.values()) {
+ if (benefitResult !== 0) benefitsResultArray.push(benefitResult);
+ }
+ if (benefitsResultArray.length === 1) return true;
+
+ if (!benefitList.get(EVENT_NAME.condition)) return true;
+
+ return false;
+};
+
+export const BENEFITS_REFINER = Object.freeze({
+ benfitList : (benefitList) => {
+ if (isNotApplicableBenefits(benefitList)) return [BENEFIT_MESSEAGE.non];
+
+ const refinedBenefits = [];
+ benefitList.forEach((value, key) => {
+ if (value !==0 && typeof(value) !== 'boolean') {
+ refinedBenefits.push(`${BENEFIT_MESSEAGE[key]}${PRICE_REFINER.negative(value)}`);
+ }
+ });
+ return refinedBenefits;
+ },
+}); | JavaScript | 혹시 얘네도 상수라고 볼 수 있는데 카멜케이스로 작성하신 이유가 있을까요? |
@@ -0,0 +1,41 @@
+import { BENEFIT_MESSEAGE } from "./BenefitStorage.js";
+import { EVENT_NAME } from "./BenefitStorage.js";
+
+export const priceFilter = (priceNumber) => new Intl.NumberFormat('ko-KR').format(priceNumber);
+
+export const merageFoodInfo = (foodName, foodAmount) => `${foodName} ${foodAmount}개`;
+
+export const PRICE_REFINER = Object.freeze({
+ positive : (priceNumber) => `${priceFilter(priceNumber)}원`,
+ negative : (priceNumber) => {
+ if (priceNumber === 0) return `${priceNumber}원`;
+
+ return `-${priceFilter(priceNumber)}원`;
+ },
+});
+
+export const isNotApplicableBenefits = (benefitList) => {
+ const benefitsResultArray = [];
+ for (let benefitResult of benefitList.values()) {
+ if (benefitResult !== 0) benefitsResultArray.push(benefitResult);
+ }
+ if (benefitsResultArray.length === 1) return true;
+
+ if (!benefitList.get(EVENT_NAME.condition)) return true;
+
+ return false;
+};
+
+export const BENEFITS_REFINER = Object.freeze({
+ benfitList : (benefitList) => {
+ if (isNotApplicableBenefits(benefitList)) return [BENEFIT_MESSEAGE.non];
+
+ const refinedBenefits = [];
+ benefitList.forEach((value, key) => {
+ if (value !==0 && typeof(value) !== 'boolean') {
+ refinedBenefits.push(`${BENEFIT_MESSEAGE[key]}${PRICE_REFINER.negative(value)}`);
+ }
+ });
+ return refinedBenefits;
+ },
+}); | JavaScript | 여기 !==뒤에 띄어쓰기 1번 해야할 것 같아요! |
@@ -0,0 +1,81 @@
+import Supervisor from "../domain/Supervisor.js";
+import InputView from "../InputView.js";
+import OutputView from "../OutputView.js";
+
+class EventPlanner {
+ #supervisor;
+
+ constructor() {
+ this.#supervisor = new Supervisor();
+ }
+
+ async start() {
+ OutputView.printIntroduce();
+
+ await this.getDate();
+ await this.getMenu();
+
+ this.plannerResult();
+ }
+
+ async getDate() {
+ try {
+ this.#supervisor.dateUpload(await InputView.readDate());
+
+ } catch (error) {
+ OutputView.printErrorMesseage(error);
+ await this.getDate();
+ }
+ }
+
+ async getMenu() {
+ try {
+ this.#supervisor.menuUpload(await InputView.readMenu());
+
+ } catch (error) {
+ OutputView.printErrorMesseage(error);
+ await this.getMenu();
+ }
+ }
+
+ plannerResult() {
+ OutputView.printProlog(this.#supervisor.event().date());
+ this.orderMenu();
+ this.totalOrderAmount();
+ this.freebieMenu();
+ this.benefitList();
+ this.totalBenefitAmount();
+ this.finalPaymentAmount();
+ this.badge();
+ }
+
+ orderMenu() {
+ OutputView.printOrderMenuResult(this.#supervisor.cashier().foodsListWithQuantity());
+ }
+
+ totalOrderAmount() {
+ OutputView.printTotalOrderAmountResult(this.#supervisor.cashier().totalFoodsPrice());
+ }
+
+ freebieMenu() {
+ OutputView.printFreebieMenuResult(this.#supervisor.cashier().freebieMenu());
+ }
+
+ benefitList() {
+ OutputView.printBenefitListResult(this.#supervisor.benefitList());
+ }
+
+ totalBenefitAmount() {
+ OutputView.printTotalBenefitAmountResult(this.#supervisor.totalBenefitAmount());
+ }
+
+ finalPaymentAmount() {
+ OutputView.printFinalPaymentAmountResult(this.#supervisor.finalPaymentAmount());
+ }
+
+ badge() {
+ OutputView.printBadgeResult(this.#supervisor.giveBadge());
+ }
+}
+
+export default EventPlanner; | JavaScript | 해당 부분은 따로 함수로 안빼고 `OutputView.print~`로 바로 넣어도 괜찮지 않을까 합니다!
각각의 함수에서 따로 추가적인 기능이 있는게 아니라서, OutputView로 바로 들어가도 좋을 것 같아요! |
@@ -0,0 +1,70 @@
+import Food from "./Food.js";
+import { ERROR_MENU } from "../constants/ErrorMesseage.js";
+import { merageFoodInfo } from "../constants/ViewRefiner.js";
+import { DISCOUNT, BENEFIT_MESSEAGE } from "../constants/BenefitStorage.js";
+import { NAME } from "../constants/FoodStorage.js";
+
+class Cashier {
+ #foods = [];
+
+ constructor(orderHistory) {
+ this.#enrollFoods(orderHistory);
+ this.#orderDuplicationValidator();
+ this.#onlyDrinkValidator();
+ this.#orderMaxValidator();
+ }
+
+ #enrollFoods(orderHistory) {
+ orderHistory
+ .split(',')
+ .forEach((food) => this.#foods.push(new Food(food)));
+ }
+
+ #orderDuplicationValidator() {
+ const foodNameList = this.#foods.map((food) => food.name());
+ if (foodNameList.length !== new Set(foodNameList).size) {
+ throw new Error(ERROR_MENU.basic);
+ }
+ }
+
+ #onlyDrinkValidator() {
+ const drinkTypeFoodsList = this.#foods.filter((food) => food.type() === NAME.drink);
+
+ if (drinkTypeFoodsList.length === this.#foods.length) {
+ throw new Error(ERROR_MENU.onlyDrink);
+ }
+ }
+
+ #orderMaxValidator() {
+ if (this.#totalFoodsQuantity() > ERROR_MENU.maxOrderNumber) {
+ throw new Error(`${ERROR_MENU.maxOrder}\n${ERROR_MENU.orderAmountExample}`);
+ }
+ }
+
+ #totalFoodsQuantity() {
+ return this.#foods.reduce((acc,cur) => acc + cur.quantity(), 0);
+ }
+
+ foodsListWithQuantity() {
+ return this.#foods.map((foodInfo) => merageFoodInfo(foodInfo.name(), foodInfo.quantity()));
+ }
+
+ totalFoodsPrice() {
+ return this.#foods.reduce((acc, cur) => acc + cur.totalPrice(), 0);
+ }
+
+ totalTypeQuantity(foodType) {
+ return this.#foods
+ .filter((food) => food.type() === foodType)
+ .reduce((acc, cur) => acc + cur.quantity(), 0);
+ }
+
+ freebieMenu() {
+ if (this.totalFoodsPrice() >= DISCOUNT.freebieStandard) {
+ return DISCOUNT.freebieItem;
+ }
+ return BENEFIT_MESSEAGE.non;
+ }
+}
+
+export default Cashier; | JavaScript | import 순서도 맞춰주면 좋을 것 같아요! 예를 들어 constants부분도 알파벳 순으로 import해준다거나,,! |
@@ -0,0 +1,70 @@
+import Food from "./Food.js";
+import { ERROR_MENU } from "../constants/ErrorMesseage.js";
+import { merageFoodInfo } from "../constants/ViewRefiner.js";
+import { DISCOUNT, BENEFIT_MESSEAGE } from "../constants/BenefitStorage.js";
+import { NAME } from "../constants/FoodStorage.js";
+
+class Cashier {
+ #foods = [];
+
+ constructor(orderHistory) {
+ this.#enrollFoods(orderHistory);
+ this.#orderDuplicationValidator();
+ this.#onlyDrinkValidator();
+ this.#orderMaxValidator();
+ }
+
+ #enrollFoods(orderHistory) {
+ orderHistory
+ .split(',')
+ .forEach((food) => this.#foods.push(new Food(food)));
+ }
+
+ #orderDuplicationValidator() {
+ const foodNameList = this.#foods.map((food) => food.name());
+ if (foodNameList.length !== new Set(foodNameList).size) {
+ throw new Error(ERROR_MENU.basic);
+ }
+ }
+
+ #onlyDrinkValidator() {
+ const drinkTypeFoodsList = this.#foods.filter((food) => food.type() === NAME.drink);
+
+ if (drinkTypeFoodsList.length === this.#foods.length) {
+ throw new Error(ERROR_MENU.onlyDrink);
+ }
+ }
+
+ #orderMaxValidator() {
+ if (this.#totalFoodsQuantity() > ERROR_MENU.maxOrderNumber) {
+ throw new Error(`${ERROR_MENU.maxOrder}\n${ERROR_MENU.orderAmountExample}`);
+ }
+ }
+
+ #totalFoodsQuantity() {
+ return this.#foods.reduce((acc,cur) => acc + cur.quantity(), 0);
+ }
+
+ foodsListWithQuantity() {
+ return this.#foods.map((foodInfo) => merageFoodInfo(foodInfo.name(), foodInfo.quantity()));
+ }
+
+ totalFoodsPrice() {
+ return this.#foods.reduce((acc, cur) => acc + cur.totalPrice(), 0);
+ }
+
+ totalTypeQuantity(foodType) {
+ return this.#foods
+ .filter((food) => food.type() === foodType)
+ .reduce((acc, cur) => acc + cur.quantity(), 0);
+ }
+
+ freebieMenu() {
+ if (this.totalFoodsPrice() >= DISCOUNT.freebieStandard) {
+ return DISCOUNT.freebieItem;
+ }
+ return BENEFIT_MESSEAGE.non;
+ }
+}
+
+export default Cashier; | JavaScript | 해당 부분도 split부분이니까 따로 상수로 만들어줘도 좋을 것 같습니다! |
@@ -0,0 +1,62 @@
+package baseball;
+
+
+import java.util.List;
+
+public class GameUtil {
+
+ public void runGame() {
+
+ if (runOnlyOnceGame()) {
+ showMenu();
+ }
+ }
+
+ public boolean runOnlyOnceGame() {
+
+ Computer computer = new Computer();
+ List<Integer> computers = computer.makeNumbers();
+
+ return gameResult(computers);
+ }
+
+ private boolean gameResult(List<Integer> computers) {
+ boolean threeStrike = true;
+ while (threeStrike) {
+
+ Player player = new Player();
+ List<Integer> playerNumbers = player.makeNumbers();
+ Referee referee = new Referee();
+
+ String result = referee.informStrikeBall(computers, playerNumbers);
+ System.out.println(result);
+ threeStrike = isGame(threeStrike, result);
+ }
+
+ return true;
+ }
+
+ private boolean isGame(boolean game, String result) {
+ if (result.equals("3스트라이크")) {
+ System.out.println("3개의 숫자를 모두 맞히셨습니다! 게임 종료");
+ game = false;
+ }
+ return game;
+ }
+
+ private void showMenu() {
+ ScannerUtil scannerUtil = new ScannerUtil();
+ System.out.println("게임을 새로 시작하려면 1, 종료하려면 2를 입력하세요.");
+
+ int choice = scannerUtil.insertInt();
+ if (choice == 1) {
+ runGame();
+ }
+
+ while (choice != 1 && choice != 2) {
+ System.out.println("잘못 입력하셨습니다. 다시입력해주세요.");
+ choice = scannerUtil.insertInt();
+ }
+ System.out.println("수고하셨습니다.");
+ }
+} | Java | Util 이라는 이름의 클래스는 적합하지 않은 것 같아요 :)
`유틸 클래스`는 보통 실용성이나 유용성에 중점을 둔 정적 메서드들을 모아두고 여러 곳에서 호출하는 형식으로 사용하며 여러 곳에서 호출하기 때문에 유틸 클래스는 공통적인 로직을 다루도록 만들어야하며 합니다.
개인적으로는 실제로는 이러한 유틸 클래스의 메서드를 변경했을 때 영향이 너무 크기 때문에 최대한 사용을 지양하는 것을 선호합니다 :) |
@@ -0,0 +1,62 @@
+package baseball;
+
+
+import java.util.List;
+
+public class GameUtil {
+
+ public void runGame() {
+
+ if (runOnlyOnceGame()) {
+ showMenu();
+ }
+ }
+
+ public boolean runOnlyOnceGame() {
+
+ Computer computer = new Computer();
+ List<Integer> computers = computer.makeNumbers();
+
+ return gameResult(computers);
+ }
+
+ private boolean gameResult(List<Integer> computers) {
+ boolean threeStrike = true;
+ while (threeStrike) {
+
+ Player player = new Player();
+ List<Integer> playerNumbers = player.makeNumbers();
+ Referee referee = new Referee();
+
+ String result = referee.informStrikeBall(computers, playerNumbers);
+ System.out.println(result);
+ threeStrike = isGame(threeStrike, result);
+ }
+
+ return true;
+ }
+
+ private boolean isGame(boolean game, String result) {
+ if (result.equals("3스트라이크")) {
+ System.out.println("3개의 숫자를 모두 맞히셨습니다! 게임 종료");
+ game = false;
+ }
+ return game;
+ }
+
+ private void showMenu() {
+ ScannerUtil scannerUtil = new ScannerUtil();
+ System.out.println("게임을 새로 시작하려면 1, 종료하려면 2를 입력하세요.");
+
+ int choice = scannerUtil.insertInt();
+ if (choice == 1) {
+ runGame();
+ }
+
+ while (choice != 1 && choice != 2) {
+ System.out.println("잘못 입력하셨습니다. 다시입력해주세요.");
+ choice = scannerUtil.insertInt();
+ }
+ System.out.println("수고하셨습니다.");
+ }
+} | Java | 파일 마지막에 엔터(개행문자)를 넣어주세요 :)
이유는 리뷰를 진행할 때 깃허브에서 경고메시지를 지우고 혹시 모르는 파일 읽기 오류에 대비하기 위함입니다.
좀 더 알고싶으시면 참고 링크를 보셔도 재밌을 것 같네요 :)
Intellij 를 사용하실 경우엔Preferences -> Editor -> General -> Ensure line feed at file end on save 를 체크해주시면파일 저장 시 마지막에 개행문자를 자동으로 넣어줍니다!
https://minz.dev/19https://stackoverflow.com/questions/729692/why-should-text-files-end-with-a-newline |
@@ -0,0 +1,62 @@
+package baseball;
+
+
+import java.util.List;
+
+public class GameUtil {
+
+ public void runGame() {
+
+ if (runOnlyOnceGame()) {
+ showMenu();
+ }
+ }
+
+ public boolean runOnlyOnceGame() {
+
+ Computer computer = new Computer();
+ List<Integer> computers = computer.makeNumbers();
+
+ return gameResult(computers);
+ }
+
+ private boolean gameResult(List<Integer> computers) {
+ boolean threeStrike = true;
+ while (threeStrike) {
+
+ Player player = new Player();
+ List<Integer> playerNumbers = player.makeNumbers();
+ Referee referee = new Referee();
+
+ String result = referee.informStrikeBall(computers, playerNumbers);
+ System.out.println(result);
+ threeStrike = isGame(threeStrike, result);
+ }
+
+ return true;
+ }
+
+ private boolean isGame(boolean game, String result) {
+ if (result.equals("3스트라이크")) {
+ System.out.println("3개의 숫자를 모두 맞히셨습니다! 게임 종료");
+ game = false;
+ }
+ return game;
+ }
+
+ private void showMenu() {
+ ScannerUtil scannerUtil = new ScannerUtil();
+ System.out.println("게임을 새로 시작하려면 1, 종료하려면 2를 입력하세요.");
+
+ int choice = scannerUtil.insertInt();
+ if (choice == 1) {
+ runGame();
+ }
+
+ while (choice != 1 && choice != 2) {
+ System.out.println("잘못 입력하셨습니다. 다시입력해주세요.");
+ choice = scannerUtil.insertInt();
+ }
+ System.out.println("수고하셨습니다.");
+ }
+} | Java | - 핵심 로직을 구현하는 코드와 UI를 담당하는 로직을 구분한다.
- UI 로직을 InputView, ResultView와 같은 클래스를 추가해 분리한다.
프로그래밍 요구사항 중에 위와 같은 요구사항이 있었는데요. 이 부분을 어떻게 구현할지 생각해보시면 좋을 것 같습니다. |
@@ -0,0 +1,61 @@
+package baseball;
+
+import java.util.List;
+
+public class Referee {
+
+ public int countBall(List<Integer> list1, List<Integer> list2) {
+
+ int count = 0;
+ int strike = countStrike(list1, list2);
+
+ for (Integer number : list1) {
+ count = getCount(list2, count, number);
+ }
+ return count - strike;
+ }
+
+ public int countStrike(List<Integer> list1, List<Integer> list2) {
+
+ int count = 0;
+ for (int index = 0; index < 3; index++) {
+ count = getCountStrike(list1, list2, count, index);
+ }
+ return count;
+ }
+
+ public String informStrikeBall(List<Integer> list1, List<Integer> list2) {
+
+ int ball = countBall(list1, list2);
+ int strike = countStrike(list1, list2);
+
+ if (strike == 3) {
+ return strike + "스트라이크";
+ }
+
+ if (strike == 0 && ball != 0) {
+ return ball + "볼";
+ }
+
+ if (strike != 0 && ball != 0) {
+ return ball + "볼 " + strike + "스트라이크";
+ }
+
+ return "낫싱";
+ }
+
+ private int getCountStrike(List<Integer> list1, List<Integer> list2, int count, int index) {
+ if (list1.get(index) == list2.get(index)) {
+ count++;
+ }
+ return count;
+ }
+
+ private int getCount(List<Integer> list2, int count, Integer number) {
+ if (list2.contains(number)) {
+ count++;
+ }
+ return count;
+ }
+
+} | Java | Referee 클래스의 인스턴스는 어떤 상태(내부 필드)도 가지지 않기 때문에 이 클래스의 모든 객체들은 동일한 객체이겠네요 !
너무 많은 상태를 가지는 것은 좋은 설계가 아니지만, 아무것도 가지지 않는 방식 또한 바람직한 설계는 아닙니다.
적절한 상태를 가진 객체를 설계해보면 좋을 것 같아요.
다른 클래스들에도 함께 적용되는 피드백일 것 같습니다 :) |
@@ -0,0 +1,61 @@
+package baseball;
+
+import java.util.List;
+
+public class Referee {
+
+ public int countBall(List<Integer> list1, List<Integer> list2) {
+
+ int count = 0;
+ int strike = countStrike(list1, list2);
+
+ for (Integer number : list1) {
+ count = getCount(list2, count, number);
+ }
+ return count - strike;
+ }
+
+ public int countStrike(List<Integer> list1, List<Integer> list2) {
+
+ int count = 0;
+ for (int index = 0; index < 3; index++) {
+ count = getCountStrike(list1, list2, count, index);
+ }
+ return count;
+ }
+
+ public String informStrikeBall(List<Integer> list1, List<Integer> list2) {
+
+ int ball = countBall(list1, list2);
+ int strike = countStrike(list1, list2);
+
+ if (strike == 3) {
+ return strike + "스트라이크";
+ }
+
+ if (strike == 0 && ball != 0) {
+ return ball + "볼";
+ }
+
+ if (strike != 0 && ball != 0) {
+ return ball + "볼 " + strike + "스트라이크";
+ }
+
+ return "낫싱";
+ }
+
+ private int getCountStrike(List<Integer> list1, List<Integer> list2, int count, int index) {
+ if (list1.get(index) == list2.get(index)) {
+ count++;
+ }
+ return count;
+ }
+
+ private int getCount(List<Integer> list2, int count, Integer number) {
+ if (list2.contains(number)) {
+ count++;
+ }
+ return count;
+ }
+
+} | Java | 임의의 숫자를 사용하는 매직넘버는소스 코드를 읽기 어렵게 만드는데요 !
이 부분을 어떻게 개선할 수 있을까요? 관련 링크 남겨놓겠습니다 :)
https://www.slipp.net/questions/356 |
@@ -0,0 +1,60 @@
+package baseball;
+
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.api.Test;
+
+import java.util.Arrays;
+import java.util.List;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+public class RefereeTest {
+
+ @Test
+ @DisplayName("두 개의 리스트에서 몇 개의 숫자가 같은지 확인")
+ void countBall() throws Exception {
+
+ //given
+ Referee referee = new Referee();
+ List<Integer> list1 = Arrays.asList(1, 2, 3);
+ List<Integer> list2 = Arrays.asList(3, 1, 2);
+
+ //when
+ int ball = referee.countBall(list1, list2);
+
+ //then
+ assertThat(ball).isEqualTo(3);
+ }
+
+ @Test
+ @DisplayName("두 개의 리스트에서 같은 자리에 같은 숫자가 몇 개 있는지 확인")
+ void countStrike() throws Exception {
+
+ //given
+ Referee referee = new Referee();
+ List<Integer> list1 = Arrays.asList(1, 2, 3);
+ List<Integer> list2 = Arrays.asList(1, 2, 3);
+
+ //when
+ int strike = referee.countStrike(list1, list2);
+
+ //then
+ assertThat(strike).isEqualTo(3);
+ }
+
+ @Test
+ @DisplayName("볼, 스트라이크 갯수 알려주기")
+ void ballStrikeCount() throws Exception {
+
+ //given
+ Referee referee = new Referee();
+ List<Integer> list1 = Arrays.asList(1, 2, 3);
+ List<Integer> list2 = Arrays.asList(1, 2, 3);
+
+ //when
+ String inform = referee.informStrikeBall(list1, list2);
+
+ //then
+ assertThat(inform).isEqualTo("3스트라이크");
+ }
+} | Java | 해당 테스트 메서드에서 예외를 선언을 하는 특별한 이유가 없다면 지워주세요 :)
테스트 메서드에 예외 선언을 함으로 써`해당 테스트가 실패할 수도 있다`라는 느낌을 주는 것 같습니다. |
@@ -0,0 +1,61 @@
+package baseball;
+
+import java.util.List;
+
+public class Referee {
+
+ public int countBall(List<Integer> list1, List<Integer> list2) {
+
+ int count = 0;
+ int strike = countStrike(list1, list2);
+
+ for (Integer number : list1) {
+ count = getCount(list2, count, number);
+ }
+ return count - strike;
+ }
+
+ public int countStrike(List<Integer> list1, List<Integer> list2) {
+
+ int count = 0;
+ for (int index = 0; index < 3; index++) {
+ count = getCountStrike(list1, list2, count, index);
+ }
+ return count;
+ }
+
+ public String informStrikeBall(List<Integer> list1, List<Integer> list2) {
+
+ int ball = countBall(list1, list2);
+ int strike = countStrike(list1, list2);
+
+ if (strike == 3) {
+ return strike + "스트라이크";
+ }
+
+ if (strike == 0 && ball != 0) {
+ return ball + "볼";
+ }
+
+ if (strike != 0 && ball != 0) {
+ return ball + "볼 " + strike + "스트라이크";
+ }
+
+ return "낫싱";
+ }
+
+ private int getCountStrike(List<Integer> list1, List<Integer> list2, int count, int index) {
+ if (list1.get(index) == list2.get(index)) {
+ count++;
+ }
+ return count;
+ }
+
+ private int getCount(List<Integer> list2, int count, Integer number) {
+ if (list2.contains(number)) {
+ count++;
+ }
+ return count;
+ }
+
+} | Java | 핵심 로직에 화면(콘솔 출력)에 대한 요구사항이 섞여있네요!
만약 화면 요구사항이 변하게 된다면 어떻게 될까요?
화면의 요구사항이 바뀌었지만 개발자가 수정해야하는 부분은 도메인의 핵심 로직입니다.
아래 요구사항을 반영해야하는 이유중 하나가 될 수 있겠네요 :)
> 핵심 로직을 구현하는 코드와 UI를 담당하는 로직을 구분한다. |
@@ -0,0 +1,56 @@
+package baseball;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+
+public class ScannerUtil {
+
+ public List<Integer> makeScannerNumbers() {
+ System.out.print("숫자를 입력하세요: ");
+
+ ListUtil listUtil = new ListUtil();
+
+ List<Integer> integers = stringListToIntegerList();
+
+ while (!listUtil.checkListSize(integers)) {
+ System.out.println("잘못된 숫자입니다.");
+ System.out.print("숫자를 입력하세요: ");
+
+ integers = stringListToIntegerList();
+ }
+ return integers;
+ }
+
+ public String insertString() {
+
+ Scanner scanner = new Scanner(System.in);
+ return scanner.next();
+ }
+
+ public int insertInt() {
+
+ Scanner scanner = new Scanner(System.in);
+ return scanner.nextInt();
+ }
+
+ private String[] splitStringList() {
+ String string = insertString();
+
+ return string.split("");
+ }
+
+ private List<Integer> stringListToIntegerList() {
+ String[] strings = splitStringList();
+
+ List<Integer> temp = new ArrayList<>();
+ ListUtil listUtil = new ListUtil();
+
+ for (String string : strings) {
+ int number = Integer.parseInt(string);
+ listUtil.distinctNumberAdd(temp, number);
+ }
+
+ return temp;
+ }
+} | Java | Scanner는 매우 비싼 자원입니다. 미리 생성해두고 재활용하도록 해보면 어떨까요 ?
static 메서드를 활용해보면 좋을 것 같아요. |
@@ -0,0 +1,62 @@
+import InputView from '../view/InputView.js';
+import Benefit from './Benefit.js';
+import Giveaway from './Giveaway.js';
+import OrderAmount from './OrderAmount.js';
+import OrderManager from './OrderManager.js';
+
+class OrderProcessor {
+ static async processOrder() {
+ const { visitDate, orderMenus } = await this.#inputOrder();
+ const orderManager = this.#createOrderManager(visitDate, orderMenus);
+ const orderAmount = this.#createOrderAmount(visitDate, orderManager);
+ const giveaway = this.#createGiveaway(orderAmount);
+ const benefit = this.#createBenefit(visitDate, orderManager, orderAmount, giveaway);
+ return { visitDate, orderMenus, orderManager, orderAmount, giveaway, benefit };
+ }
+
+ static async #inputOrder() {
+ return {
+ visitDate: await InputView.readVisitDate(),
+ orderMenus: await InputView.readOrderMenu(),
+ };
+ }
+
+ static #createOrderManager(visitDate, orderMenus) {
+ const orderManager = new OrderManager(visitDate, orderMenus);
+ const menusInfo = orderManager.getMenusInfo();
+ const dayOfWeek = orderManager.getDayOfWeek();
+ return { menusInfo, dayOfWeek };
+ }
+
+ static #createOrderAmount(visitDate, orderManager) {
+ const { menusInfo, dayOfWeek } = orderManager;
+ const beforeDiscount = OrderAmount.calculateAmountBeforeDiscount(menusInfo);
+ const totalDiscount = OrderAmount.calculateDiscountTotalAmount(visitDate, menusInfo, dayOfWeek);
+ const afterDiscount = OrderAmount.calculateOrderAmountAfterDiscount(
+ beforeDiscount,
+ totalDiscount,
+ );
+ return { beforeDiscount, totalDiscount, afterDiscount };
+ }
+
+ static #createGiveaway(orderAmount) {
+ const { beforeDiscount } = orderAmount;
+ const isAddGiveaway = Giveaway.checkAddGiveaway(beforeDiscount);
+ const giveawayDiscount = Giveaway.calculateGiveawyDiscountAmount(beforeDiscount);
+ return { isAddGiveaway, giveawayDiscount };
+ }
+
+ static #createBenefit(visitDate, orderManager, orderAmount, giveaway) {
+ const { menusInfo, dayOfWeek } = orderManager;
+ const { totalDiscount } = orderAmount;
+ const { giveawayDiscount } = giveaway;
+ const dDay = Benefit.calculateDDayDiscount(visitDate);
+ const weekDay = Benefit.calculateWeekDayDiscount(menusInfo, dayOfWeek);
+ const weekEnd = Benefit.calculateWeekEndDiscount(menusInfo, dayOfWeek);
+ const special = Benefit.calculateSpecialDiscount(visitDate, dayOfWeek);
+ const eventBadge = Benefit.getEventBadge(totalDiscount + giveawayDiscount);
+ return { dDay, weekDay, weekEnd, special, eventBadge };
+ }
+}
+
+export default OrderProcessor; | JavaScript | 해당 클래스의 함수들에서 static을 모두 붙이셨는데, static을 안 붙여도 괜찮지 않을까요?
모두 static을 붙이신 이유가 궁금합니다! |
@@ -0,0 +1,24 @@
+import Benefit from './Benefit.js';
+
+class OrderAmount {
+ static calculateAmountBeforeDiscount(menusInfo) {
+ return menusInfo.reduce((acc, cur) => acc + cur[1] * cur[2], 0);
+ }
+
+ static calculateDiscountTotalAmount(visitDate, orderMenusInfo, dayOfWeek) {
+ return [
+ Benefit.calculateDDayDiscount(visitDate),
+ Benefit.calculateWeekDayDiscount(orderMenusInfo, dayOfWeek),
+ Benefit.calculateWeekEndDiscount(orderMenusInfo, dayOfWeek),
+ Benefit.calculateSpecialDiscount(visitDate, dayOfWeek),
+ ]
+ .filter(benefitDiscount => benefitDiscount !== false)
+ .reduce((acc, cur) => acc + cur, 0);
+ }
+
+ static calculateOrderAmountAfterDiscount(orderAmountBeforeDiscount, discountTotalAmount) {
+ return orderAmountBeforeDiscount + discountTotalAmount;
+ }
+}
+
+export default OrderAmount; | JavaScript | 고차함수를 굉장히 잘 쓰시네요! 활용법을 많이 배워갑니다. 👍 |
@@ -0,0 +1,34 @@
+import OutputView from '../view/OutputView.js';
+import OrderProcessor from '../domains/OrderProcessor.js';
+
+class ChristmasEventController {
+ static async start() {
+ OutputView.printGreeting();
+ const processedOrder = await OrderProcessor.processOrder();
+ this.#printOutput(processedOrder);
+ }
+
+ static #printOutput(processedOrder) {
+ const { visitDate, orderMenus, orderAmount, giveaway, benefit } = processedOrder;
+ OutputView.printNotification(visitDate);
+ OutputView.printOrderMenu(orderMenus);
+ OutputView.printOrderAmountBeforeDiscount(orderAmount.beforeDiscount);
+ OutputView.printGiveawayMenu(giveaway.isAddGiveaway);
+ this.#printBenefitHistory(benefit, giveaway);
+ OutputView.printBenefitTotalAmount(orderAmount.totalDiscount, giveaway.giveawayDiscount);
+ OutputView.printOrderAmountAfterDiscount(orderAmount.afterDiscount);
+ OutputView.printEventBadge(benefit.eventBadge);
+ }
+
+ static #printBenefitHistory(benefit, giveaway) {
+ OutputView.printBenefitHistory(
+ benefit.dDay,
+ benefit.weekDay,
+ benefit.weekEnd,
+ benefit.special,
+ giveaway.giveawayDiscount,
+ );
+ }
+}
+
+export default ChristmasEventController; | JavaScript | controller와 OrderProcessor를 분리하신게 인상 깊었습니다.
저도 이 부분을 많이 고민했는데요.
이번 미션 같은 작은 코드에서 너무 나누면 오히려 가독성이 안좋아질까 하여 controller에 OrderProcessor 같은 함수들을 모두 넣었는데, 제가 잘못 생각한건 아닌가 싶은 코드였습니다.
controller의 역할에 대한 고민이 많네요..!
병현님께서는 controller의 역할을 Processor를 실행하고, 해당 데이터를 받아와 view로 보내는 중간자로 보신게 맞을까요? |
@@ -0,0 +1,48 @@
+import CONSTANTS from '../constants/constants.js';
+import MENU from '../constants/menu.js';
+import OrderMenuValidator from '../validators/OrderMenuValidator.js';
+import VisitDateValidator from '../validators/VisitDateValidator.js';
+
+class OrderManager {
+ #visitDate;
+
+ #orderMenus;
+
+ constructor(visitDate, orderMenus) {
+ this.#validate(visitDate, orderMenus);
+ this.#visitDate = visitDate;
+ this.#orderMenus = orderMenus;
+ }
+
+ #validate(visitDate, orderMenus) {
+ VisitDateValidator.validateVisitDate(visitDate);
+ OrderMenuValidator.validateOrderMenu(orderMenus);
+ }
+
+ getMenusInfo() {
+ const menuNames = this.#setMenuNames();
+ const menuPrices = this.#setMenuPrices(menuNames);
+ const menuCount = this.#setMenuCount();
+ return menuNames.map((element, index) => [element, menuPrices[index], menuCount[index]]);
+ }
+
+ getDayOfWeek() {
+ return new Date(new Date().getFullYear(), CONSTANTS.month.december, this.#visitDate).getDay();
+ }
+
+ #setMenuNames() {
+ return this.#orderMenus.map(orderMenu =>
+ Object.keys(MENU.menuName).find(key => MENU.menuName[key] === orderMenu[0]),
+ );
+ }
+
+ #setMenuPrices(menuNames) {
+ return menuNames.map(menuName => MENU.menu[MENU.menuName[menuName]].price);
+ }
+
+ #setMenuCount() {
+ return this.#orderMenus.map(orderMenu => Number(orderMenu[1]));
+ }
+}
+
+export default OrderManager; | JavaScript | get함수에서 단순히 get만 하면 어떨지요?
OrderProcessor에서 get함수를 할때마다 set함수들을 실행하니 비효율적이라 생각했습니다. 물론 지금은 한번만 실행이 되지만요!
return문에서 데이터 가공을 모두 한 후 Processor로 보내는 것은 3주차 피드백에서 나온 "getter를 getter로만" 내용을 많이 고민하신 것 같아 인상깊었습니다! |
@@ -0,0 +1,151 @@
+import ERROR from '../../src/constants/error.js';
+import OrderMenuValidator from '../../src/validators/OrderMenuValidator.js';
+
+describe('주문 메뉴와 개수 입력 예외 상황 테스트', () => {
+ test('메뉴판에 있는 메뉴인 경우 undefined를 반환한다.', () => {
+ const value = [
+ ['양송이수프', '1'],
+ ['타파스', '2'],
+ ['바비큐립', '3'],
+ ];
+ const result = OrderMenuValidator.validateNoMenu(value);
+ expect(result).toBeUndefined();
+ });
+
+ test('메뉴판에 있는 메뉴가 아닌 경우 예외 처리를 한다.', () => {
+ const value = [
+ ['피자', '1'],
+ ['크림파스타', '2'],
+ ['데리버거', '3'],
+ ];
+ const result = () => {
+ OrderMenuValidator.validateNoMenu(value);
+ };
+ expect(result).toThrow(ERROR.menu.invalidOrder);
+ });
+
+ test('주문 메뉴의 개수가 1이상인 경우 undefined를 반환한다.', () => {
+ const value = [
+ ['양송이수프', '1'],
+ ['타파스', '2'],
+ ['바비큐립', '3'],
+ ];
+ const result = OrderMenuValidator.validateOrderMenuQuantity(value);
+ expect(result).toBeUndefined();
+ });
+
+ test('주문 메뉴의 개수가 1미만인 경우 예외 처리를 한다.', () => {
+ // given
+ const value = [
+ ['양송이수프', '1'],
+ ['타파스', '0'],
+ ['바비큐립', '3'],
+ ];
+ const result = () => {
+ OrderMenuValidator.validateOrderMenuQuantity(value);
+ };
+ expect(result).toThrow(ERROR.menu.invalidOrder);
+ });
+
+ test('형식이 예시와 같을 경우 undefined를 반환한다.', () => {
+ const value = [
+ ['양송이수프', '1'],
+ ['타파스', '2'],
+ ['바비큐립', '3'],
+ ];
+ const result = OrderMenuValidator.validateFormat(value);
+ expect(result).toBeUndefined();
+ });
+
+ test.each([
+ [
+ ['해산물파스타', '2'],
+ ['레드와인', '1초코케이크', '1'],
+ ],
+ [['해산물파스타', '2'], ['레드와인', '1'], ['초코케이크', '1'], ['']],
+ [['해산물파스타2'], ['레드와인', '1초코케이크', '1'], ['']],
+ ])('형식이 예시와 다른 경우 예외 처리를 한다.', input => {
+ const result = () => OrderMenuValidator.validateFormat(input);
+ expect(result).toThrow(ERROR.menu.invalidOrder);
+ });
+
+ test('중복 메뉴가 없을 경우 undefined를 반환한다.', () => {
+ const value = [
+ ['해산물파스타', '1'],
+ ['타파스', '2'],
+ ['바비큐립', '3'],
+ ];
+ const result = OrderMenuValidator.validateDuplicatedMenu(value);
+ expect(result).toBeUndefined();
+ });
+
+ test('중복 메뉴를 입력한 경우 예외 처리를 한다.', () => {
+ const value = [
+ ['해산물파스타', '1'],
+ ['타파스', '2'],
+ ['해산물파스타', '3'],
+ ];
+ const result = () => OrderMenuValidator.validateDuplicatedMenu(value);
+ expect(result).toThrow(ERROR.menu.invalidOrder);
+ });
+
+ test('메뉴가 모두 음료가 아닐 경우 undefined를 반환한다.', () => {
+ const value = [
+ ['해산물파스타', '1'],
+ ['타파스', '2'],
+ ['바비큐립', '3'],
+ ];
+ const result = OrderMenuValidator.validateAllBeverage(value);
+ expect(result).toBeUndefined();
+ });
+
+ test('메뉴가 모두 음료일 경우 예외처리를 한다.', () => {
+ const value = [
+ ['해산물파스타', '1'],
+ ['타파스', '2'],
+ ['해산물파스타', '3'],
+ ];
+ const result = () => OrderMenuValidator.validateDuplicatedMenu(value);
+ expect(result).toThrow(ERROR.menu.invalidOrder);
+ });
+
+ test('메뉴의 총 개수가 20을 넘지 않은 경우 undefined를 반환한다.', () => {
+ const value = [
+ ['해산물파스타', '1'],
+ ['타파스', '2'],
+ ['바비큐립', '3'],
+ ];
+ const result = OrderMenuValidator.validateMenuCountAboveThreshold(value);
+ expect(result).toBeUndefined();
+ });
+
+ test('메뉴의 총 개수가 20을 넘은 경우 예외처리를 한다.', () => {
+ const value = [
+ ['해산물파스타', '18'],
+ ['타파스', '2'],
+ ['바비큐립', '3'],
+ ];
+ const result = () => OrderMenuValidator.validateMenuCountAboveThreshold(value);
+ expect(result).toThrow(ERROR.menu.invalidOrder);
+ });
+
+ test('메뉴의 개수가 숫자인 경우 undefined를 반환한다.', () => {
+ const value = [
+ ['해산물파스타', '1'],
+ ['타파스', '2'],
+ ['바비큐립', '3'],
+ ];
+ const result = OrderMenuValidator.validateNaNCount(value);
+ expect(result).toBeUndefined();
+ });
+
+ test('메뉴의 개수가 숫자가 아닌 경우 예외처리를 한다.', () => {
+ const value = [
+ ['해산물파스타', '18'],
+ ['타파스', 'a'],
+ ['바비큐립', '3'],
+ ];
+ const result = () => OrderMenuValidator.validateNaNCount(value);
+ expect(result).toThrow(ERROR.menu.invalidOrder);
+ });
+}); | JavaScript | validator들을 test할 생각은 하지 못하였는데, 굉장히 꼼꼼히 테스트코드 작성하신 것 같네요.
하나 또 배워갑니다~! |
@@ -0,0 +1,31 @@
+import { Console } from '@woowacourse/mission-utils';
+import MESSAGE from '../constants/message.js';
+import VisitDateValidator from '../validators/VisitDateValidator.js';
+import OrderMenuValidator from '../validators/OrderMenuValidator.js';
+import reTry from '../utils/reTry.js';
+
+const InputView = {
+ async readVisitDate() {
+ return reTry(async () => {
+ const input = await Console.readLineAsync(MESSAGE.read.visitDate);
+ const visitDate = Number(input);
+ VisitDateValidator.validateVisitDate(visitDate);
+ return Number(visitDate);
+ });
+ },
+
+ async readOrderMenu() {
+ return reTry(async () => {
+ const input = await Console.readLineAsync(MESSAGE.read.orderMenu);
+ const orderMenus = input
+ .split(',')
+ .map(menu => menu.trim())
+ .map(menu => menu.split('-'))
+ .map(menuAndCount => menuAndCount.map(str => str.trim()));
+ OrderMenuValidator.validateOrderMenu(orderMenus);
+ return orderMenus;
+ });
+ },
+};
+
+export default InputView; | JavaScript | 이것도 한번 함께 고민해보면 좋을 것 같은데, 저는 InputView에서는 정말 input만 return을 하고 다른 전처리는 데이터를 다루는 파일에서 처리를 해주었는데요.
혹시 이 부분은 어떻게 생각하시는지 궁금합니다.
데이터 관련 로직이 아닌 input 받은 데이터의 전처리는 inputView에서 처리하고자 하신건가요?! |
@@ -0,0 +1,28 @@
+package racingcar.domain;
+
+import racingcar.constants.ErrorMsg;
+
+public class CarName {
+ private static final int CAR_NAME_LENGTH_MIN = 1;
+ private static final int CAR_NAME_LENGTH_MAX = 5;
+ private final String name;
+
+ public CarName(String name) {
+ validateLength(name);
+ this.name = name;
+ }
+
+ public String getName() {
+ return name;
+ }
+
+ private void validateLength(String name) {
+ if (name.length() < CAR_NAME_LENGTH_MIN) {
+ throw new IllegalArgumentException(ErrorMsg.CAR_NAME_LENGTH_MIN_ERROR.getMsg());
+ }
+
+ if (name.length() > CAR_NAME_LENGTH_MAX) {
+ throw new IllegalArgumentException(ErrorMsg.CAR_NAME_LENGTH_MAX_ERROR.getMsg());
+ }
+ }
+} | Java | 원시값 포장 👍 |
@@ -0,0 +1,30 @@
+package racingcar.domain;
+
+public class RacingCar {
+ private final CarName carName;
+ private int moveCount;
+
+ public RacingCar(String name) {
+ this.carName = new CarName(name);
+ moveCount = 0;
+ }
+
+ public int getMoveCount() {
+ return moveCount;
+ }
+
+ public String getCarName() {
+ return carName.getName();
+ }
+
+ public void attemptToMove(GameRule gameRule) {
+ if (gameRule.canMove()) {
+ move();
+ }
+ }
+
+ private void move() {
+ moveCount++;
+ }
+
+} | Java | 랜덤 숫자에 의해 자동차의 이동 판단역할이
RacinCar에 있는게 맞는지 한번 생각해 보시면 좋을거 같아요
😢 |
@@ -0,0 +1,45 @@
+package racingcar.controller;
+
+import racingcar.domain.*;
+import racingcar.view.UIManager;
+
+public class RacingGameController {
+ private UIManager uiManager;
+
+ public void run() {
+ uiManager = new UIManager();
+
+ uiManager.printGameStartMsg();
+ RacingCars racingCars = createRacingCars(uiManager.inputCarNames());
+
+ TrialCount trialCount = createTrialCount(uiManager.inputTrialCount());
+ RandomNumber randomNumber = new GameRandomNumber();
+ GameRule gameRule = new GameRule(trialCount, randomNumber);
+
+ uiManager.printGameResultMsg();
+ for (int i = 0; i < gameRule.getTrialCount(); i++) {
+ racingCars.moveCars(gameRule);
+ uiManager.printCarPositions(racingCars.getCarPositions());
+ }
+
+ uiManager.printWinners(racingCars.pickWinners());
+ }
+
+ public RacingCars createRacingCars(String userInput) {
+ try {
+ return new RacingCars(userInput);
+ } catch (IllegalArgumentException e) {
+ System.out.println(e.getMessage());
+ return createRacingCars(uiManager.inputCarNames());
+ }
+ }
+
+ public TrialCount createTrialCount(String userInput) {
+ try {
+ return new TrialCount(userInput);
+ } catch (IllegalArgumentException e) {
+ System.out.println(e.getMessage());
+ return createTrialCount(uiManager.inputTrialCount());
+ }
+ }
+} | Java | 해당 controller에서 의존성 주입에 대해서 한번 고민 해볼 필요가 있어요!
controller 계층을 사용하기위해서 만든것으로 보이는데
접근제어자가 없는 객체들을 사용하신 이유가 있을까요 |
@@ -0,0 +1,22 @@
+package racingcar.constants;
+
+public enum ErrorMsg {
+ BLANK_IN_NAME_ERROR("이름에는 공백이 없어야 하며 쉼표(,) 앞뒤에도 공백이 없어야 합니다."),
+ CAR_NAME_LENGTH_MIN_ERROR("자동차 이름은 " + GameConstants.CAR_NAME_LENGTH_MIN.getNumber() + "자 이상이어야 합니다."),
+ CAR_NAME_LENGTH_MAX_ERROR("자동차 이름은 " + GameConstants.CAR_NAME_LENGTH_MAX.getNumber() + "자 이하여야 합니다."),
+ TRIAL_COUNT_INPUT_TYPE_ERROR("시도 횟수는 숫자로 입력해야 합니다."),
+ TRIAL_COUNT_EMPTY_INPUT_ERROR("시도 횟수를 입력하지 않았습니다."),
+ TRIAL_COUNT_ZERO_ERROR("시도 횟수는 1 이상이어야 합니다.");
+
+ private static final String ERROR_MSG_TAG = "[ERROR]";
+ private final String msg;
+
+ ErrorMsg(String msg) {
+ this.msg = ERROR_MSG_TAG + " " + msg + "\n";
+ }
+
+ public String getMsg() {
+ return msg;
+ }
+
+} | Java | default 접근 제어자를 사용하신 이유가 있을까요? |
@@ -0,0 +1,16 @@
+package racingcar.constants;
+
+public enum GameConstants {
+ CAR_NAME_LENGTH_MIN(1),
+ CAR_NAME_LENGTH_MAX(5);
+
+ private final int number;
+
+ GameConstants(int number) {
+ this.number = number;
+ }
+
+ public int getNumber() {
+ return number;
+ }
+} | Java | 여기도 젭근제어자가!@? |
@@ -0,0 +1,16 @@
+package racingcar.constants;
+
+public enum GameConstants {
+ CAR_NAME_LENGTH_MIN(1),
+ CAR_NAME_LENGTH_MAX(5);
+
+ private final int number;
+
+ GameConstants(int number) {
+ this.number = number;
+ }
+
+ public int getNumber() {
+ return number;
+ }
+} | Java | 해당 클래스 역할이 모호하지 않나요??
클래스 이름은 게임전체의 상수를 관리하는 것으로 보여지는데
멤버 변수나 기능은 total_count나 number 세팅도 들어 있어서요 |
@@ -0,0 +1,40 @@
+package racingcar.domain;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+import racingcar.constants.ErrorMsg;
+
+import static org.assertj.core.api.Assertions.assertThatCode;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+public class CarNameTest {
+ @Test
+ void 자동차이름_길이범위최소_벗어났을_때() {
+ // Given
+ String carName = "";
+
+ // When & Then
+ assertThatThrownBy(() -> new CarName(carName))
+ .isInstanceOf(IllegalArgumentException.class)
+ .hasMessage(ErrorMsg.CAR_NAME_LENGTH_MIN_ERROR.getMsg());
+ }
+
+ @Test
+ void 자동차이름_길이범위최대_벗어났을_때() {
+ // Given
+ String carName = "ferrari";
+
+ // When & Then
+ assertThatThrownBy(() -> new CarName(carName))
+ .isInstanceOf(IllegalArgumentException.class)
+ .hasMessage(ErrorMsg.CAR_NAME_LENGTH_MAX_ERROR.getMsg());
+ }
+
+ @ParameterizedTest
+ @ValueSource(strings = {"a", "abc", "abcde"})
+ void 자동차이름_길이범위_정상(String carName) {
+ assertThatCode(() -> new CarName(carName))
+ .doesNotThrowAnyException();
+ }
+} | Java | 테스트 메소드 이름이 충분히 명시적이라서
해당 given/when/then 주석은 없어도 될거 같아요
조건이 바뀔때마다
주석을 수정해주지 않으면 실제 테스트 코드와 주석이 불일치 하는 경우가 발생 할 수 있어요 |
@@ -0,0 +1,40 @@
+package racingcar.domain;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+import racingcar.constants.ErrorMsg;
+
+import static org.assertj.core.api.Assertions.assertThatCode;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+public class CarNameTest {
+ @Test
+ void 자동차이름_길이범위최소_벗어났을_때() {
+ // Given
+ String carName = "";
+
+ // When & Then
+ assertThatThrownBy(() -> new CarName(carName))
+ .isInstanceOf(IllegalArgumentException.class)
+ .hasMessage(ErrorMsg.CAR_NAME_LENGTH_MIN_ERROR.getMsg());
+ }
+
+ @Test
+ void 자동차이름_길이범위최대_벗어났을_때() {
+ // Given
+ String carName = "ferrari";
+
+ // When & Then
+ assertThatThrownBy(() -> new CarName(carName))
+ .isInstanceOf(IllegalArgumentException.class)
+ .hasMessage(ErrorMsg.CAR_NAME_LENGTH_MAX_ERROR.getMsg());
+ }
+
+ @ParameterizedTest
+ @ValueSource(strings = {"a", "abc", "abcde"})
+ void 자동차이름_길이범위_정상(String carName) {
+ assertThatCode(() -> new CarName(carName))
+ .doesNotThrowAnyException();
+ }
+} | Java | 세부 오류 검증 👍 |
@@ -0,0 +1,67 @@
+package racingcar.domain;
+
+import racingcar.constants.ErrorMsg;
+
+import java.util.*;
+
+public class RacingCars {
+ private final List<RacingCar> racingCars;
+
+ public RacingCars(String userInput) {
+ racingCars = new ArrayList<>();
+ createRacingCars(userInput);
+ }
+
+ private void createRacingCars(String userInput) {
+ if (validateBlank(userInput)) {
+ throw new IllegalArgumentException(ErrorMsg.BLANK_IN_NAME_ERROR.getMsg());
+ }
+
+ addRacingCars(userInput);
+ }
+
+ private void addRacingCars(String userInput) {
+ for (String carName : userInput.split(",", -1)) {
+ racingCars.add(new RacingCar(carName));
+ }
+ }
+
+ private boolean validateBlank(String userInput) {
+ return userInput.contains(" ");
+ }
+
+ public void moveCars(GameRule gameRule) {
+ for (RacingCar car : racingCars) {
+ car.attemptToMove(gameRule);
+ }
+ }
+
+ public Map<String, Integer> getCarPositions() {
+ Map<String, Integer> carPosition = new LinkedHashMap<>();
+ for (RacingCar car : racingCars) {
+ carPosition.put(car.getCarName(), car.getMoveCount());
+ }
+ return carPosition;
+ }
+
+ public List<String> pickWinners() {
+ Winners winners = new Winners();
+ int maxStep = getMaxStep();
+
+ for (RacingCar car : racingCars) {
+ winners.pickWinner(car, maxStep);
+ }
+
+ return winners.getWinners();
+ }
+
+ private int getMaxStep() {
+ int maxStep = 0;
+ for (RacingCar car : racingCars) {
+ maxStep = Integer.max(maxStep, car.getMoveCount());
+ }
+
+ return maxStep;
+ }
+
+} | Java | 일급컬렉션 활용 💯 |
@@ -0,0 +1,67 @@
+package racingcar.domain;
+
+import racingcar.constants.ErrorMsg;
+
+import java.util.*;
+
+public class RacingCars {
+ private final List<RacingCar> racingCars;
+
+ public RacingCars(String userInput) {
+ racingCars = new ArrayList<>();
+ createRacingCars(userInput);
+ }
+
+ private void createRacingCars(String userInput) {
+ if (validateBlank(userInput)) {
+ throw new IllegalArgumentException(ErrorMsg.BLANK_IN_NAME_ERROR.getMsg());
+ }
+
+ addRacingCars(userInput);
+ }
+
+ private void addRacingCars(String userInput) {
+ for (String carName : userInput.split(",", -1)) {
+ racingCars.add(new RacingCar(carName));
+ }
+ }
+
+ private boolean validateBlank(String userInput) {
+ return userInput.contains(" ");
+ }
+
+ public void moveCars(GameRule gameRule) {
+ for (RacingCar car : racingCars) {
+ car.attemptToMove(gameRule);
+ }
+ }
+
+ public Map<String, Integer> getCarPositions() {
+ Map<String, Integer> carPosition = new LinkedHashMap<>();
+ for (RacingCar car : racingCars) {
+ carPosition.put(car.getCarName(), car.getMoveCount());
+ }
+ return carPosition;
+ }
+
+ public List<String> pickWinners() {
+ Winners winners = new Winners();
+ int maxStep = getMaxStep();
+
+ for (RacingCar car : racingCars) {
+ winners.pickWinner(car, maxStep);
+ }
+
+ return winners.getWinners();
+ }
+
+ private int getMaxStep() {
+ int maxStep = 0;
+ for (RacingCar car : racingCars) {
+ maxStep = Integer.max(maxStep, car.getMoveCount());
+ }
+
+ return maxStep;
+ }
+
+} | Java | 매게변수를 줄일 수 있는 방법이 있을거 같은데 한번 고민해봐주세요 |
@@ -0,0 +1,46 @@
+package racingcar.domain;
+
+import racingcar.constants.ErrorMsg;
+
+public class TrialCount {
+ private final int count;
+
+ public TrialCount(String userInput) {
+ validateEmptyInput(userInput);
+ validateInputType(userInput);
+ count = convertToInt(userInput);
+ validateTrialCountZero(count);
+ }
+
+ public int getCount() {
+ return count;
+ }
+
+ private int convertToInt(String userInput) {
+ return Integer.parseInt(userInput);
+ }
+
+ private void validateEmptyInput(String userInput) {
+ if (userInput.isEmpty()) {
+ throw new IllegalArgumentException(ErrorMsg.TRIAL_COUNT_EMPTY_INPUT_ERROR.getMsg());
+ }
+ }
+
+ private void validateInputType(String userInput) {
+ for (char c : userInput.toCharArray()) {
+ validateIsDigit(c);
+ }
+ }
+
+ private void validateIsDigit(char c) {
+ if (!Character.isDigit(c)) {
+ throw new IllegalArgumentException(ErrorMsg.TRIAL_COUNT_INPUT_TYPE_ERROR.getMsg());
+ }
+ }
+
+ private void validateTrialCountZero(int trialNumber) {
+ if (trialNumber <= 0) {
+ throw new IllegalArgumentException(ErrorMsg.TRIAL_COUNT_ZERO_ERROR.getMsg());
+ }
+ }
+} | Java | 오 이부분 구조가 좋아보여요
이동 숫자를 객체로 포장해서
validation을 하니 응집력이 상당이 좋아보입니다. |
@@ -0,0 +1,30 @@
+package racingcar.domain;
+
+public class RacingCar {
+ private final CarName carName;
+ private int moveCount;
+
+ public RacingCar(String name) {
+ this.carName = new CarName(name);
+ moveCount = 0;
+ }
+
+ public int getMoveCount() {
+ return moveCount;
+ }
+
+ public String getCarName() {
+ return carName.getName();
+ }
+
+ public void attemptToMove(GameRule gameRule) {
+ if (gameRule.canMove()) {
+ move();
+ }
+ }
+
+ private void move() {
+ moveCount++;
+ }
+
+} | Java | GameRule 도메인을 추가하여 전진여부 판단 로직을 분리하였습니다! |
@@ -0,0 +1,45 @@
+package racingcar.controller;
+
+import racingcar.domain.*;
+import racingcar.view.UIManager;
+
+public class RacingGameController {
+ private UIManager uiManager;
+
+ public void run() {
+ uiManager = new UIManager();
+
+ uiManager.printGameStartMsg();
+ RacingCars racingCars = createRacingCars(uiManager.inputCarNames());
+
+ TrialCount trialCount = createTrialCount(uiManager.inputTrialCount());
+ RandomNumber randomNumber = new GameRandomNumber();
+ GameRule gameRule = new GameRule(trialCount, randomNumber);
+
+ uiManager.printGameResultMsg();
+ for (int i = 0; i < gameRule.getTrialCount(); i++) {
+ racingCars.moveCars(gameRule);
+ uiManager.printCarPositions(racingCars.getCarPositions());
+ }
+
+ uiManager.printWinners(racingCars.pickWinners());
+ }
+
+ public RacingCars createRacingCars(String userInput) {
+ try {
+ return new RacingCars(userInput);
+ } catch (IllegalArgumentException e) {
+ System.out.println(e.getMessage());
+ return createRacingCars(uiManager.inputCarNames());
+ }
+ }
+
+ public TrialCount createTrialCount(String userInput) {
+ try {
+ return new TrialCount(userInput);
+ } catch (IllegalArgumentException e) {
+ System.out.println(e.getMessage());
+ return createTrialCount(uiManager.inputTrialCount());
+ }
+ }
+} | Java | 접근제어자 private으로 수정하였습니다. |
@@ -0,0 +1,22 @@
+package racingcar.constants;
+
+public enum ErrorMsg {
+ BLANK_IN_NAME_ERROR("이름에는 공백이 없어야 하며 쉼표(,) 앞뒤에도 공백이 없어야 합니다."),
+ CAR_NAME_LENGTH_MIN_ERROR("자동차 이름은 " + GameConstants.CAR_NAME_LENGTH_MIN.getNumber() + "자 이상이어야 합니다."),
+ CAR_NAME_LENGTH_MAX_ERROR("자동차 이름은 " + GameConstants.CAR_NAME_LENGTH_MAX.getNumber() + "자 이하여야 합니다."),
+ TRIAL_COUNT_INPUT_TYPE_ERROR("시도 횟수는 숫자로 입력해야 합니다."),
+ TRIAL_COUNT_EMPTY_INPUT_ERROR("시도 횟수를 입력하지 않았습니다."),
+ TRIAL_COUNT_ZERO_ERROR("시도 횟수는 1 이상이어야 합니다.");
+
+ private static final String ERROR_MSG_TAG = "[ERROR]";
+ private final String msg;
+
+ ErrorMsg(String msg) {
+ this.msg = ERROR_MSG_TAG + " " + msg + "\n";
+ }
+
+ public String getMsg() {
+ return msg;
+ }
+
+} | Java | Enum클래스의 생성자는 private만 허용하므로
접근제어자를 지정하지 않으면 private이 기본으로 지정되기 때문에 따로 지정을 안했습니다!
명시적으로 private 키워드를 붙이는 것이 좋을까요? |
@@ -0,0 +1,16 @@
+package racingcar.constants;
+
+public enum GameConstants {
+ CAR_NAME_LENGTH_MIN(1),
+ CAR_NAME_LENGTH_MAX(5);
+
+ private final int number;
+
+ GameConstants(int number) {
+ this.number = number;
+ }
+
+ public int getNumber() {
+ return number;
+ }
+} | Java | 위의 ErrorMsg와 같은 이유로 접근제어자를 지정하지 않았습니다. |
@@ -0,0 +1,16 @@
+package racingcar.constants;
+
+public enum GameConstants {
+ CAR_NAME_LENGTH_MIN(1),
+ CAR_NAME_LENGTH_MAX(5);
+
+ private final int number;
+
+ GameConstants(int number) {
+ this.number = number;
+ }
+
+ public int getNumber() {
+ return number;
+ }
+} | Java | TRIAL_COUNT(시도횟수)도 게임전체 상수 중 하나라고 생각했었는데,
게임 시작 전부터 결정되는 상수와
게임 시작 후 결정되는 TRIAL_COUNT는 차이점이 있는 것 같습니다.
TRIAL_COUNT는 GameConstants에서는 삭제하고, TrialCount 객체를 통해서 값을 받아오도록 수정하였습니다. |
@@ -0,0 +1,40 @@
+package racingcar.domain;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+import racingcar.constants.ErrorMsg;
+
+import static org.assertj.core.api.Assertions.assertThatCode;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+
+public class CarNameTest {
+ @Test
+ void 자동차이름_길이범위최소_벗어났을_때() {
+ // Given
+ String carName = "";
+
+ // When & Then
+ assertThatThrownBy(() -> new CarName(carName))
+ .isInstanceOf(IllegalArgumentException.class)
+ .hasMessage(ErrorMsg.CAR_NAME_LENGTH_MIN_ERROR.getMsg());
+ }
+
+ @Test
+ void 자동차이름_길이범위최대_벗어났을_때() {
+ // Given
+ String carName = "ferrari";
+
+ // When & Then
+ assertThatThrownBy(() -> new CarName(carName))
+ .isInstanceOf(IllegalArgumentException.class)
+ .hasMessage(ErrorMsg.CAR_NAME_LENGTH_MAX_ERROR.getMsg());
+ }
+
+ @ParameterizedTest
+ @ValueSource(strings = {"a", "abc", "abcde"})
+ void 자동차이름_길이범위_정상(String carName) {
+ assertThatCode(() -> new CarName(carName))
+ .doesNotThrowAnyException();
+ }
+} | Java | 불필요한 주석 제거했습니다! |
@@ -0,0 +1,67 @@
+package racingcar.domain;
+
+import racingcar.constants.ErrorMsg;
+
+import java.util.*;
+
+public class RacingCars {
+ private final List<RacingCar> racingCars;
+
+ public RacingCars(String userInput) {
+ racingCars = new ArrayList<>();
+ createRacingCars(userInput);
+ }
+
+ private void createRacingCars(String userInput) {
+ if (validateBlank(userInput)) {
+ throw new IllegalArgumentException(ErrorMsg.BLANK_IN_NAME_ERROR.getMsg());
+ }
+
+ addRacingCars(userInput);
+ }
+
+ private void addRacingCars(String userInput) {
+ for (String carName : userInput.split(",", -1)) {
+ racingCars.add(new RacingCar(carName));
+ }
+ }
+
+ private boolean validateBlank(String userInput) {
+ return userInput.contains(" ");
+ }
+
+ public void moveCars(GameRule gameRule) {
+ for (RacingCar car : racingCars) {
+ car.attemptToMove(gameRule);
+ }
+ }
+
+ public Map<String, Integer> getCarPositions() {
+ Map<String, Integer> carPosition = new LinkedHashMap<>();
+ for (RacingCar car : racingCars) {
+ carPosition.put(car.getCarName(), car.getMoveCount());
+ }
+ return carPosition;
+ }
+
+ public List<String> pickWinners() {
+ Winners winners = new Winners();
+ int maxStep = getMaxStep();
+
+ for (RacingCar car : racingCars) {
+ winners.pickWinner(car, maxStep);
+ }
+
+ return winners.getWinners();
+ }
+
+ private int getMaxStep() {
+ int maxStep = 0;
+ for (RacingCar car : racingCars) {
+ maxStep = Integer.max(maxStep, car.getMoveCount());
+ }
+
+ return maxStep;
+ }
+
+} | Java | Winners 도메인을 추가하여 우승자 추출하는 로직을 분리하였습니다! |
@@ -0,0 +1,30 @@
+package racingcar.domain;
+
+public class RacingCar {
+ private final CarName carName;
+ private int moveCount;
+
+ public RacingCar(String name) {
+ this.carName = new CarName(name);
+ moveCount = 0;
+ }
+
+ public int getMoveCount() {
+ return moveCount;
+ }
+
+ public String getCarName() {
+ return carName.getName();
+ }
+
+ public void attemptToMove(GameRule gameRule) {
+ if (gameRule.canMove()) {
+ move();
+ }
+ }
+
+ private void move() {
+ moveCount++;
+ }
+
+} | Java | 1. 기본생성자를 활용한 도메인 활용은 기본적으로 좋은 방법이 아니에요. -> 해당 도메인은 도메인이라기 보단 static method를 활용 하기 위한 vo 로 생각 되요 ㅠㅜ
2. GameRule을 도메인으로 간주 한다면, racingcar ->gamerule 으로 의존성이 생기는데 합리적인 구조로 보이지는 않아요ㅠ
---------------
힌트준 내용을 좀더 고민해보면 좋았을거 같아요. 단순히 해당 도메인을 추가해서 처리하는것이 아니라
각 도메인을 어떤식으로 호출하고 의존성 관리할지 고민을 좀더해서 수정해봐요 |
@@ -0,0 +1,22 @@
+package racingcar.constants;
+
+public enum ErrorMsg {
+ BLANK_IN_NAME_ERROR("이름에는 공백이 없어야 하며 쉼표(,) 앞뒤에도 공백이 없어야 합니다."),
+ CAR_NAME_LENGTH_MIN_ERROR("자동차 이름은 " + GameConstants.CAR_NAME_LENGTH_MIN.getNumber() + "자 이상이어야 합니다."),
+ CAR_NAME_LENGTH_MAX_ERROR("자동차 이름은 " + GameConstants.CAR_NAME_LENGTH_MAX.getNumber() + "자 이하여야 합니다."),
+ TRIAL_COUNT_INPUT_TYPE_ERROR("시도 횟수는 숫자로 입력해야 합니다."),
+ TRIAL_COUNT_EMPTY_INPUT_ERROR("시도 횟수를 입력하지 않았습니다."),
+ TRIAL_COUNT_ZERO_ERROR("시도 횟수는 1 이상이어야 합니다.");
+
+ private static final String ERROR_MSG_TAG = "[ERROR]";
+ private final String msg;
+
+ ErrorMsg(String msg) {
+ this.msg = ERROR_MSG_TAG + " " + msg + "\n";
+ }
+
+ public String getMsg() {
+ return msg;
+ }
+
+} | Java | 오 이건 제가 실수했네요. 대리님 말씀이 맞아요! |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.