ewhk9887/korean_code_reviews_from_github · Datasets at Hugging Face

code stringlengths 41 34.3k	lang stringclasses 8 values	review stringlengths 1 4.74k
@@ -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	오 이건 제가 실수했네요. 대리님 말씀이 맞아요!
@@ -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	GameRule 도메인이 만들어 져서, GameConstants와 중복된 의미를 담는거 같은데 해당 클래스에 대해 고민이 좀더 필요해보여용
@@ -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 도메인의 멤버변수로 RandomNumber와 TrialCount 추가 - RandomNumber는 자동차의 전진여부를 판단할 때만 필요한데, 전진여부 판단로직인 GameRule에 있으므로 RandomNumber를 GameRule의 멤버변수로 추가함 - GameRule 객체를 RacingCar의 메소드 안에서 생성하지 않고 Controller에서 생성하도록 수정 - Controller에서 RacingCars에 GameRule객체를 매개변수로 전달 - GameRandomNumber의 getRandomNumber() 메소드 안에서 바로 랜덤숫자를 반환하도록 수정 - 랜덤숫자가 필요할 때마다 새로운 RandomNumber 객체를 생성하지 않고, GameRule이 가지고 있는 RandomNumber 객체를 통해 랜덤숫자 값만 반환받도록 함 ### Issue 1 : GameRule 도메인과 다른 도메인 간의 의존관계 설정의 어려움 - RacingCars의 메소드 안에서 각 자동차 객체마다 전진여부판단이 필요한데, GameRule 객체를 RacingCar에게 넘겨주지 않고 외부에서 판단 후 RacingCar를 전진시킬 방법을 모르겠습니다..! ### Issue 2 : GameRandomNumber에서 randomNumber라는 멤버변수의 필요성 - getRandomNumber()에서 바로 랜덤숫자를 반환해주는데, 그럼 randomNumber 멤버변수가 없어도 되는 것일까요? ### Issue 3 : GameConstants 클래스 - 게임상수 5개 중, 3개는 한 곳에서만 호출하고 나머지 2개는 두 군데에서 호출하는데, 이 상수들을 어떻게 관리하는 것이 효과적일지 궁금합니다! 아래는 제가 생각해 본 방법들입니다. - 모든 상수를 Enum 클래스로 모아서 관리 - 한 곳에서 호출하는 상수는 각각 사용되는 도메인의 멤버변수로 선언, 나머지는 Enum클래스로 관리 - 모든 상수를 각각 사용되는 도메인의 멤버변수로 선언 - 여러 곳에서 사용되는 상수의 경우, 특정 도메인에 정적 상수로 선언하고 다른 도메인에서 호출 --- 각 도메인의 역할을 구분하는 것과 도메인 간 의존관계를 설정하는 부분이 어렵고 개인적으로 약한 것 같습니다. 전체적으로 제가 혼란스러운 부분이 많아서 코드는 달라진 점이 많이 없고, 이슈들 위에 적어두었습니다. 리뷰 부탁드립니다!
@@ -0,0 +1,24 @@ +package com.example.chatgptcodereviewtest.controller; + +import com.example.chatgptcodereviewtest.service.TestService2; +import lombok.RequiredArgsConstructor; +import org.springframework.web.bind.annotation.; + +/* + * 설명: + * + * @author 최현범(Jayce) / hb.choi@dreamus.io + * @since 2023/03/23 + */ +@RestController +@RequestMapping("/test2") +@RequiredArgsConstructor +public class TestController2 { + + private final TestService2 testService2; + + @GetMapping + public String getText(@RequestParam(value = "label", required = false) String label) { + return testService2.getUppercaseTestLabel(label); + } +} \ No newline at end of file	Java	위 코드는 `TestController2`라는 REST API 컨트롤러 클래스입니다. 개선 제안: 1. Javadoc(주석) 작성이 필요합니다. 메소드와 클래스의 설명을 구체적으로 달아주어 가독성을 높일 수 있습니다. 2. 마지막 줄에 개행 문자열이 없습니다. 소스코드를 수정 및 편집할 때 깃에러가 발생하지 않도록 개행 문자열을 추가하는 것이 좋습니다. 3. `@RequestParam` 어노테이션의 required 속성값은 false로 되어 있어, 필수로 들어올 값이 아닙니다. 이에 대한 처리를 하고 싶다면, 해당 파라미터 변수에 널 체크나 디폴트값 등을 지정해야 합니다. 버그 위험이 없어 보입니다.
@@ -0,0 +1,17 @@ +package com.example.chatgptcodereviewtest.service; + +import org.springframework.stereotype.Service; + +/** + * 설명: + * + * @author 최현범(Jayce) / hb.choi@dreamus.io + * @since 2023/03/23 + */ +@Service +public class TestService2 { + + public String getUppercaseTestLabel(String label) { + return label.toUpperCase(); + } +}	Java	이 코드는 봉쇄적인 문제나 버그가 없는 것 같습니다. 단순하게 문자열을 대문자로 변경하는 메서드를 가지고 있으며, Spring의 Service 어노테이션을 사용하여 Bean으로 등록되어 있습니다. 변수명과 메서드명의 직관성 측면에서 개선할 점이 있는 것 같습니다. 'label'은 구체적인 의미를 알기 어렵습니다. 더 구체적인 명칭을 사용한다면 코드의 가독성이 향상될 것입니다.
@@ -0,0 +1,35 @@ +package nextstep.subway.applicaion; + +import java.util.List; +import nextstep.subway.applicaion.dto.PathResponse; +import nextstep.subway.domain.Line; +import nextstep.subway.domain.LineRepository; +import nextstep.subway.domain.Path; +import nextstep.subway.domain.PathFinder; +import nextstep.subway.domain.Station; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +@Service +@Transactional +public class PathService { + private final LineRepository lineRepository; + private final StationService stationService; + + public PathService(LineRepository lineRepository, + StationService stationService) { + this.lineRepository = lineRepository; + this.stationService = stationService; + } + + public PathResponse searchPath(Long sourceId, Long targetId) { + Station source = stationService.findById(sourceId); + Station target = stationService.findById(targetId); + List<Line> lines = lineRepository.findAll(); + + PathFinder pathFinder = PathFinder.from(lines); + Path shortestPath = pathFinder.searchPath(source, target); + return PathResponse.from(shortestPath); + } + +}	Java	경로를 찾기위해 lines라는 정보가 있고, 이 정보를 이용해 경로를 찾는데 이 경로를 찾는 책임을 PathFinder가 가지고 있고 그 결과 정보는 Path가 가지고 있네요! 객체지향에서 객체는 상태와 행위로 이루어져있다고 하는데요 경로를 찾기 위한 상태인 lines와 행위인 PathFinder를 하나의 객체로 도출해볼 수는 없을까요? 만약에 이렇게 리팩터링 할 경우 기존에 만들어 두었던 테스트를 활용해서 테스트의 검증이라는 보호 속에 리팩터링을 해보시는 것을 권해드립니다!
@@ -63,19 +63,19 @@ public void update(Station newUpStation, int minusDistance) { } public Section merge(Section section) { - if (!isDownStation(section.upStation)) { + if (!hasDownStationAs(section.upStation)) { throw new IllegalArgumentException("합치려는 구간의 상행역이 하행역과 같아야 합니다."); } return Section.of(line, upStation, section.downStation, distance + section.distance); } - public boolean isUpStation(Station station) { + public boolean hasUpStationAs(Station station) { return upStation.equals(station); } - public boolean isDownStation(Station station) { + public boolean hasDownStationAs(Station station) { return downStation.equals(station); }	Java	변경된 네이밍이 의미를 조금 더 잘 전달하는 것 같아요 👍
@@ -1,6 +1,7 @@ package nextstep.subway.domain; import java.util.ArrayList; +import java.util.Collections; import java.util.List; import java.util.Map; import java.util.Optional; @@ -34,23 +35,30 @@ public void add(Section section) { public void remove(Station station) { validationRemoveStation(station); - Optional<Section> firstSection = sections.stream() - .filter(s -> s.isDownStation(station)) - .findAny(); - - Optional<Section> secondSection = sections.stream() - .filter(s -> s.isUpStation(station)) - .findAny(); + Optional<Section> sectionHasUpStation = findSectionHasUpStationAs(station); + Optional<Section> sectionHasDownStation = findSectionHasDownStationAs(station); - firstSection.ifPresent(section -> sections.remove(section)); - secondSection.ifPresent(section -> sections.remove(section)); + sectionHasUpStation.ifPresent(section -> sections.remove(section)); + sectionHasDownStation.ifPresent(section -> sections.remove(section)); - if (firstSection.isPresent() && secondSection.isPresent()) { - mergeExistingSections(firstSection.get(), secondSection.get()); + if (sectionHasUpStation.isPresent() && sectionHasDownStation.isPresent()) { + mergeExistingSections(sectionHasUpStation.get(), sectionHasDownStation.get()); } } + private Optional<Section> findSectionHasDownStationAs(Station station) { + return sections.stream() + .filter(s -> s.hasUpStationAs(station)) + .findAny(); + } + + private Optional<Section> findSectionHasUpStationAs(Station station) { + return sections.stream() + .filter(s -> s.hasDownStationAs(station)) + .findAny(); + } + private List<Station> getStations() { List<Station> stations = new ArrayList<>(); stations.add(sections.get(0).getUpStation()); @@ -152,4 +160,7 @@ private void mergeExistingSections(Section firstSection, Section secondSection) sections.add(firstSection.merge(secondSection)); } + public List<Section> getSectionList() { + return Collections.unmodifiableList(sections); + } }	Java	적절한 사이즈로 메서드를 나누어 주셨네요 👍
@@ -0,0 +1,48 @@ +package nextstep.subway.unit; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import nextstep.subway.domain.Line; +import nextstep.subway.domain.Station; +import org.springframework.test.util.ReflectionTestUtils; + +public class PathFixture { + /** (10) + * 교대역 --- 2호선 --- 강남역 + * \| \| + * 3호선 (2) 신분당선 (5) + * \| \| + * 남부터미널역 --- 3호선 --- 양재 + (3) **/ + + + public static Station 강남역 = new Station("강남역"); + public static Station 교대역 = new Station("교대역"); + public static Station 양재역 = new Station("양재역"); + public static Station 남부터미널역 = new Station("남부터미널역"); + + public static int 교대역_강남역_거리 = 10; + public static int 강남역_양재역_거리 = 5; + public static int 교대역_남부터미널역_거리 = 2; + public static int 남부터미널역_양재역_거리 = 3; + + public static Line 이호선 = Line.of("2호선", "bg-green-600", 교대역, 강남역, 교대역_강남역_거리); + public static Line 삼호선 = Line.of("3호선", "bg-orange-500", 교대역, 남부터미널역, 교대역_남부터미널역_거리); + public static Line 신분당선 = Line.of("신분당선", "bg-red-500", 강남역, 양재역, 강남역_양재역_거리); + + public static List<Line> 노선_목록 = new ArrayList<>(); + + static { + 삼호선.addSection(남부터미널역, 양재역, 남부터미널역_양재역_거리); + + ReflectionTestUtils.setField(강남역, "id", 1L); + ReflectionTestUtils.setField(교대역, "id", 2L); + ReflectionTestUtils.setField(양재역, "id", 3L); + ReflectionTestUtils.setField(남부터미널역, "id", 4L); + + 노선_목록.addAll(Arrays.asList(이호선, 삼호선, 신분당선)); + } + + +}	Java	픽스쳐 분리를 통해 테스트 코드 내 효과적인 중복 제거 👍
@@ -0,0 +1,120 @@ +package nextstep.subway.acceptance; + +import static nextstep.subway.acceptance.LineSteps.지하철_노선_생성_요청; +import static nextstep.subway.acceptance.LineSteps.지하철_노선에_지하철_구간_생성_요청; +import static nextstep.subway.acceptance.PathSteps.경로_조회_요청; +import static nextstep.subway.acceptance.StationSteps.지하철역_생성_요청; +import static org.assertj.core.api.Assertions.assertThat; + +import io.restassured.response.ExtractableResponse; +import io.restassured.response.Response; +import java.util.HashMap; +import java.util.Map; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.springframework.http.HttpStatus; + +@DisplayName("지하철 경로 검색") +public class PathAcceptanceTest extends AcceptanceTest { + private Long 교대역; + private Long 강남역; + private Long 양재역; + private Long 남부터미널역; + private Long 청량리역; + private Long 회기역; + + private Long 일호선; + private Long 이호선; + private Long 신분당선; + private Long 삼호선; + + private int 교대역_강남역_거리 = 10; + private int 강남역_양재역_거리 = 5; + private int 교대역_남부터미널역_거리 = 2; + private int 남부터미널역_양재역_거리 = 3; + private int 청량리역_회기역_거리 = 7; + + /** (10) + * 교대역 --- 2호선 --- 강남역 + * \| \| + * 3호선 (2) 신분당선 (5) + * \| \| + * 남부터미널역 --- 3호선 --- 양재 + (3) / + + @BeforeEach + public void setUp() { + super.setUp(); + + 교대역 = 지하철역_생성_요청("교대역").jsonPath().getLong("id"); + 강남역 = 지하철역_생성_요청("강남역").jsonPath().getLong("id"); + 양재역 = 지하철역_생성_요청("양재역").jsonPath().getLong("id"); + 남부터미널역 = 지하철역_생성_요청("남부터미널역").jsonPath().getLong("id"); + 청량리역 = 지하철역_생성_요청("청량리역").jsonPath().getLong("id"); + 회기역 = 지하철역_생성_요청("회기역").jsonPath().getLong("id"); + + 일호선 = 지하철_노선_생성_요청("1호선", "blue", 청량리역, 회기역, 청량리역_회기역_거리).jsonPath().getLong("id"); + 이호선 = 지하철_노선_생성_요청("2호선", "green", 교대역, 강남역, 교대역_강남역_거리).jsonPath().getLong("id"); + 신분당선 = 지하철_노선_생성_요청("신분당선", "red", 강남역, 양재역, 강남역_양재역_거리).jsonPath().getLong("id"); + 삼호선 = 지하철_노선_생성_요청("3호선", "orange", 교대역, 남부터미널역, 교대역_남부터미널역_거리).jsonPath().getLong("id"); + + 지하철_노선에_지하철_구간_생성_요청(삼호선, createSectionCreateParams(남부터미널역, 양재역, 남부터미널역_양재역_거리)); + } + + / + * Given 지하철 노선 (2호선, 3호선, 신분당선) 을 생성하고 역, 구간을 생성한다. + * When 서로 다른 두 역의 최단 거리를 조회하면 + * Then 최단 거리 조회에 성공한다. + / + @DisplayName("최단 거리 조회하기") + @Test + void searchShortestPath() { + // when + ExtractableResponse<Response> response = 경로_조회_요청(남부터미널역, 강남역); + + // then + assertThat(response.statusCode()).isEqualTo(HttpStatus.OK.value()); + assertThat(response.jsonPath().getList("stations.id", Long.class)).containsExactly(남부터미널역, 양재역, 강남역); + assertThat(response.jsonPath().getInt("distance")).isEqualTo(남부터미널역_양재역_거리 + 강남역_양재역_거리); + } + + /* + * Given 지하철 노선 (2호선, 3호선, 신분당선) 을 생성하고 역, 구간을 생성한다. + * 기존 노선과 연결되지 않는 새로운 노선 (1호선)을 생성한다. + * When 연결 되지 않은 두 역의 최단 거리 조회를 요청 하면 + * Then 최단 거리 조회에 실패한다. + / + @DisplayName("최단 거리 조회하기 - 연결되지 않은 역을 조회 할 경우") + @Test + void searchShortestPathDoesNotExistPath() { + // when + ExtractableResponse<Response> response = 경로_조회_요청(강남역, 청량리역); + + // then + assertThat(response.statusCode()).isEqualTo(HttpStatus.BAD_REQUEST.value());; + } + + /* + * Given 지하철 노선 (2호선, 3호선, 신분당선) 을 생성하고 역, 구간을 생성한다. + * When 출발역과 도착역이 동일한데 최단 거리 조회를 요청하면 + * Then 최단 거리 조회에 실패한다. + */ + @DisplayName("최단 거리 조회하기 - 출발역과 도착역이 동일한 경우") + @Test + void searchShortestPathSourceEqualsTarget() { + // when + ExtractableResponse<Response> response = 경로_조회_요청(강남역, 강남역); + + // then + assertThat(response.statusCode()).isEqualTo(HttpStatus.BAD_REQUEST.value());; + } + + private Map<String, String> createSectionCreateParams(Long upStationId, Long downStationId, int distance) { + Map<String, String> params = new HashMap<>(); + params.put("upStationId", upStationId + ""); + params.put("downStationId", downStationId + ""); + params.put("distance", distance + ""); + return params; + } +}	Java	단위 테스트의 픽스쳐 관리 방법처럼 해당 객체들의 재사용이 필요한 경우 인수 테스트용 픽스쳐를 만들어서 관리할 수 도 있겠네요!
@@ -1,7 +1,10 @@ package christmas; +import christmas.controller.MainController; + public class Application { public static void main(String[] args) { - // TODO: 프로그램 구현 + MainController mainController = new MainController(); + mainController.run(); } }	Java	객체를 생성할 때 new 예약어보다 정적 팩토리 메서드를 사용해보시면 어떨까요. 가독성이나 객체 생성 수 제한 같은 여러 가지 이점이 있어요. https://tecoble.techcourse.co.kr/post/2020-05-26-static-factory-method/
@@ -0,0 +1,47 @@ +package christmas.controller; + +import java.util.Map; + +import christmas.view.; +import christmas.model.; + +public class MainController { + private OrderMenu orderMenu; + + public MainController() { + orderMenu = new OrderMenu(); + } + + public void run() { + orderMenu.setOrderDate(InputView.readDate()); + setReadOrder(); + + OutputView.printPreview(orderMenu.getOrderDate()); + OutputView.printOrder(orderMenu.getUserOrder()); + int totalPrice = orderMenu.getTotalPrice(); + OutputView.printTotalPrice(totalPrice); + OutputView.printPresent(totalPrice); + benefitControl(totalPrice); + } + + private void benefitControl(int totalPrice) { + Benefit benefit = new Benefit(orderMenu.getOrderDate(), orderMenu.getCategoryCount(), totalPrice); + OutputView.printBenefits(benefit.getBenefits()); + + int totalBenefitPrice = benefit.getTotalBenefitPrice(); + OutputView.printTotalBenefitPrice(totalBenefitPrice); + OutputView.printTotalPayment(totalPrice - totalBenefitPrice + benefit.getPresentPrice()); + OutputView.printEventBadge(totalBenefitPrice); + } + + private void setReadOrder() { + Map<String, Integer> orderMenu; + try { + orderMenu = InputView.readOrder(); + this.orderMenu.setUserOrder(orderMenu); + } catch (IllegalArgumentException e) { + System.out.println(e.getMessage()); + setReadOrder(); + } + } +}	Java	OutputView나 InputView의 입출력 기능들을 모두 스태틱 메서드로 구현하셨네요. 보통은 해당 객체를 생성 후에 일반 메서드를 호출하는데 스태틱 메서드를 사용하신 이유가 있으실까요?
@@ -0,0 +1,97 @@ +package christmas.util; + +import java.util.Map; +import java.util.List; + +public class Validator { + private final static char MIN_DIGIT = '0'; + private final static char MAX_DIGIT = '9'; + private final static char CHAR_HYPHEN = '-'; + private final static char CHAR_COMMA = ','; + private final static int MIN_DAY = 1; + private final static int MAX_DAY = 31; + private final static int IS_TWO = 2; + + public static void validateDate(String input) { + if (input.isEmpty()) { + throw new IllegalArgumentException(ErrorMessage.DATE_ERROR.get()); + } + for (int i = Constant.ZERO.get(); i < input.length(); ++i) { + if (input.charAt(i) < MIN_DIGIT \|\| input.charAt(i) > MAX_DIGIT) { + throw new IllegalArgumentException(ErrorMessage.DATE_ERROR.get()); + } + } + int date = Integer.parseInt(input); + if (date < MIN_DAY \|\| date > MAX_DAY) { + throw new IllegalArgumentException(ErrorMessage.DATE_ERROR.get()); + } + } + + public static void validateOrder(String input) { + // split할 경우 마지막의 빈 문자열을 사라지므로 별도로 예외 처리 + if (input.isEmpty() \|\| input.charAt(input.length() - Constant.ONE.get()) == CHAR_COMMA) { + throw new IllegalArgumentException(ErrorMessage.ORDER_ERROR.get()); + } + String[] splittedComma = input.split(Message.COMMA.get()); + if (splittedComma.length == Constant.ZERO.get()) { + throw new IllegalArgumentException(ErrorMessage.ORDER_ERROR.get()); + } + for (String string : splittedComma) { + if (validateFormat(string)) { + throw new IllegalArgumentException(ErrorMessage.ORDER_ERROR.get()); + } + } + } + + public static boolean validateMenu(Map<String, Integer> userOrder, List<Map<String, Integer>> menu) { + int[] countCategory = new int[Constant.CATEGORY_COUNT.get()]; + for (Map.Entry<String, Integer> entry : userOrder.entrySet()) { + if (entry.getValue() <= Constant.ZERO.get()) { + return true; + } + int category = Utility.getCategory(entry.getKey(), menu); + if (category == Constant.NOT_IN_MENU.get()) { + return true; + } + countCategory[category] += entry.getValue(); + } + if (validateCount(countCategory)) { + return true; + } + return false; + } + + private static boolean validateCount(int[] countCategory) { + // 음료만 시킨 경우 예외 처리 + if (countCategory[Constant.EPPETIZER.get()] == Constant.ZERO.get() + && countCategory[Constant.MAINMENU.get()] == Constant.ZERO.get() + && countCategory[Constant.DESSERT.get()] == Constant.ZERO.get()) { + return true; + } + int totalCount = Constant.ZERO.get(); + for (int count : countCategory) { + totalCount += count; + } + if (totalCount > Constant.MAX_MENU_COUNT.get()) { + return true; + } + return false; + } + + private static boolean validateFormat(String input) { + if (input.isEmpty() \|\| input.charAt(input.length() - Constant.ONE.get()) == CHAR_HYPHEN) { + return true; + } + String[] splittedHyphen = input.split(Message.HYPHEN.get()); + if (splittedHyphen.length != IS_TWO) { + return true; + } + for (int i = Constant.ZERO.get(); i < splittedHyphen[Constant.VALUE_INDEX.get()].length(); ++i) { + if (splittedHyphen[Constant.VALUE_INDEX.get()].charAt(i) < MIN_DIGIT + \|\| splittedHyphen[Constant.VALUE_INDEX.get()].charAt(i) > MAX_DIGIT) { + return true; + } + } + return false; + } +}	Java	저도 챙기지 못한 부분이긴합니다만 해당 내용 공유해드리자면, '음료만 주문'과 같은 예외처리는 문자열 파싱 예외가 아닌 비즈니스 로직 예외처리이므로 객체생성에서 예외 처리를 해주면 역할분리 원칙에 훨씬 더 좋은 코드가 될 것 같습니다~!
@@ -1,7 +1,10 @@ package christmas; +import christmas.controller.MainController; + public class Application { public static void main(String[] args) { - // TODO: 프로그램 구현 + MainController mainController = new MainController(); + mainController.run(); } }	Java	생각하지 못했던 개념인데 감사합니다! 리팩토링할 때 적용하면 좋을 것 같네요
@@ -0,0 +1,39 @@ +package christmas.util; + +public enum Constant { + NOT_IN_MENU(-1), + EPPETIZER(0), + MAINMENU(1), + DESSERT(2), + BEVERAGE(3), + CATEGORY_COUNT(4), + ZERO(0), + ONE(1), + THOUSAND(1000), + HUNDRED(100), + CHRISTMAS_DAY(25), + MIN_BENEFIT_PRICE(10000), + PRESENT_COST(120000), + CHAMPAIGN_PRICE(25000), + WEEKDAYS(7), + FRIDAY(1), + SATURDAY(2), + SUNDAY(3), + EVENT_PRICE(2023), + SANTA(20000), + TREE(10000), + STAR(5000), + MAX_MENU_COUNT(20), + KEY_INDEX(0), + VALUE_INDEX(1); + + private final int value; + + Constant(int value) { + this.value = value; + } + + public int get() { + return this.value; + } +}	Java	Enum을 메뉴정보 저장하는 자료구조로 사용하면 용처가 잘 맞을 것 같습니다. 메뉴에 해당하는 한글이름(String)과 가격(Integer)가 존재하기 때문이지요.
@@ -0,0 +1,68 @@ +package christmas.model; + +import christmas.util.Constant; +import christmas.util.ErrorMessage; +import christmas.util.Utility; +import christmas.util.Validator; + +import java.util.ArrayList; +import java.util.Map; +import java.util.List; + +public class OrderMenu { + private final List<Map<String, Integer>> menu; + + private int orderDate; + private Map<String, Integer> userOrder; + + public OrderMenu() { + menu = new ArrayList<>(List.of( + // EPPETIZER 0 + Map.of("양송이수프", 6000, "타파스", 5500, "시저샐러드", 8000), + // MAINMENU 1 + Map.of("티본스테이크", 55000, "바비큐립", 54000, "해산물파스타", 35000, "크리스마스파스타", 25000), + // DESSERT 2 + Map.of("초코케이크", 15000, "아이스크림", 5000), + // BEVERAGE 3 + Map.of("제로콜라", 3000, "레드와인", 60000, "샴페인", 25000) + )); + } + + public int getOrderDate() { + return this.orderDate; + } + + public Map<String, Integer> getUserOrder() { + return this.userOrder; + } + + public int getTotalPrice() { + int totalPrice = Constant.ZERO.get(); + for (Map.Entry<String, Integer> entry : this.userOrder.entrySet()) { + int category = Utility.getCategory(entry.getKey(), menu); + int price = menu.get(category).get(entry.getKey()); + totalPrice += price * entry.getValue(); + } + return totalPrice; + } + + public int[] getCategoryCount() { + int[] categoryCount = new int[Constant.CATEGORY_COUNT.get()]; + for (Map.Entry<String, Integer> entry : this.userOrder.entrySet()) { + int category = Utility.getCategory(entry.getKey(), menu); + categoryCount[category] += entry.getValue(); + } + return categoryCount; + } + + public void setOrderDate(int date) { + this.orderDate = date; + } + + public void setUserOrder(Map<String, Integer> userOrder) { + if (Validator.validateMenu(userOrder, this.menu)) { + throw new IllegalArgumentException(ErrorMessage.ORDER_ERROR.get()); + } + this.userOrder = userOrder; + } +}	Java	Map.of로 초기화하나 편해보이네요! 배웠습니다! 어디가서 써먹어 봐야겠어요!
@@ -0,0 +1,47 @@ +package christmas.controller; + +import java.util.Map; + +import christmas.view.; +import christmas.model.; + +public class MainController { + private OrderMenu orderMenu; + + public MainController() { + orderMenu = new OrderMenu(); + } + + public void run() { + orderMenu.setOrderDate(InputView.readDate()); + setReadOrder(); + + OutputView.printPreview(orderMenu.getOrderDate()); + OutputView.printOrder(orderMenu.getUserOrder()); + int totalPrice = orderMenu.getTotalPrice(); + OutputView.printTotalPrice(totalPrice); + OutputView.printPresent(totalPrice); + benefitControl(totalPrice); + } + + private void benefitControl(int totalPrice) { + Benefit benefit = new Benefit(orderMenu.getOrderDate(), orderMenu.getCategoryCount(), totalPrice); + OutputView.printBenefits(benefit.getBenefits()); + + int totalBenefitPrice = benefit.getTotalBenefitPrice(); + OutputView.printTotalBenefitPrice(totalBenefitPrice); + OutputView.printTotalPayment(totalPrice - totalBenefitPrice + benefit.getPresentPrice()); + OutputView.printEventBadge(totalBenefitPrice); + } + + private void setReadOrder() { + Map<String, Integer> orderMenu; + try { + orderMenu = InputView.readOrder(); + this.orderMenu.setUserOrder(orderMenu); + } catch (IllegalArgumentException e) { + System.out.println(e.getMessage()); + setReadOrder(); + } + } +}	Java	MainController가 크게 컨트롤(객체내 데이터를 수정 및 저장)하는 모델은 orderMenu인 것 같아보입니다. 즉 클래스 이름이 orderController이면 Model과 Controller간의 역할 의존성에 더 맞는 작명일 것 같습니다
@@ -0,0 +1,79 @@ +package christmas.model; + +import christmas.util.Constant; +import christmas.util.Message; + +import java.util.HashMap; +import java.util.Map; + +public class Benefit { + private int orderDate; + private int[] categoryCount; + Map<String, Integer> benefits; + + public Benefit(int orderDate, int[] categoryCount, int totalPrice) { + this.orderDate = orderDate; + this.categoryCount = categoryCount; + benefits = new HashMap<>(); + if (totalPrice < Constant.MIN_BENEFIT_PRICE.get()) { + return; + } + christmasBenefit(); + weekBenefit(); + starBenefit(); + if (totalPrice >= Constant.PRESENT_COST.get()) { + presentBenefit(); + } + } + + public Map<String, Integer> getBenefits() { + return this.benefits; + } + + public int getTotalBenefitPrice() { + int totalBenefitPrice = Constant.ZERO.get(); + for (Map.Entry<String, Integer> entry : this.benefits.entrySet()) { + int benefit = entry.getValue(); + totalBenefitPrice += benefit; + } + return totalBenefitPrice; + } + + public int getPresentPrice() { + if (this.benefits.containsKey(Message.PRESENT_BENEFIT.get())) { + return Constant.CHAMPAIGN_PRICE.get(); + } + return Constant.ZERO.get(); + } + + private void christmasBenefit() { + if (orderDate > Constant.CHRISTMAS_DAY.get()) { + return; + } + int benefit = Constant.THOUSAND.get() + (orderDate - Constant.ONE.get()) * Constant.HUNDRED.get(); + benefits.put(Message.D_DAY_BENEFIT.get(), benefit); + } + + private void weekBenefit() { + if (orderDate % Constant.WEEKDAYS.get() == Constant.FRIDAY.get() + \|\| orderDate % Constant.WEEKDAYS.get() == Constant.SATURDAY.get()) { + int benefit = Constant.EVENT_PRICE.get() * categoryCount[Constant.MAINMENU.get()]; + benefits.put(Message.WEEKEND_BENEFIT.get(), benefit); + return; + } + int benefit = Constant.EVENT_PRICE.get() * categoryCount[Constant.DESSERT.get()]; + benefits.put(Message.WEEKDAY_BENEFIT.get(), benefit); + } + + private void starBenefit() { + if (orderDate != Constant.CHRISTMAS_DAY.get() + && orderDate % Constant.WEEKDAYS.get() != Constant.SUNDAY.get()) { + return; + } + benefits.put(Message.STAR_BENEFIT.get(), Constant.THOUSAND.get()); + } + + private void presentBenefit() { + benefits.put(Message.PRESENT_BENEFIT.get(), Constant.CHAMPAIGN_PRICE.get()); + } +}	Java	전체적으로 함수분리가 잘 돼있어서 함수당 라인이 짧은 편이네요! 굉장히 가독성 좋은 코드가 된 것 같습니다!
@@ -0,0 +1,39 @@ +package christmas.util; + +public enum Constant { + NOT_IN_MENU(-1), + EPPETIZER(0), + MAINMENU(1), + DESSERT(2), + BEVERAGE(3), + CATEGORY_COUNT(4), + ZERO(0), + ONE(1), + THOUSAND(1000), + HUNDRED(100), + CHRISTMAS_DAY(25), + MIN_BENEFIT_PRICE(10000), + PRESENT_COST(120000), + CHAMPAIGN_PRICE(25000), + WEEKDAYS(7), + FRIDAY(1), + SATURDAY(2), + SUNDAY(3), + EVENT_PRICE(2023), + SANTA(20000), + TREE(10000), + STAR(5000), + MAX_MENU_COUNT(20), + KEY_INDEX(0), + VALUE_INDEX(1); + + private final int value; + + Constant(int value) { + this.value = value; + } + + public int get() { + return this.value; + } +}	Java	상수들을 enum으로 관리하시는 것은 좋은 포인트인 것 같습니다. 하지만 constant에 모든 상수를 다 넣어버리시면 개별 상수를 수정하거나 변경해야 할 때 찾기 어려워질 것 같아요. enum을 종류별로, 문맥별로 분리하시는 것을 추천 드려요.
@@ -0,0 +1,79 @@ +package christmas.model; + +import christmas.util.Constant; +import christmas.util.Message; + +import java.util.HashMap; +import java.util.Map; + +public class Benefit { + private int orderDate; + private int[] categoryCount; + Map<String, Integer> benefits; + + public Benefit(int orderDate, int[] categoryCount, int totalPrice) { + this.orderDate = orderDate; + this.categoryCount = categoryCount; + benefits = new HashMap<>(); + if (totalPrice < Constant.MIN_BENEFIT_PRICE.get()) { + return; + } + christmasBenefit(); + weekBenefit(); + starBenefit(); + if (totalPrice >= Constant.PRESENT_COST.get()) { + presentBenefit(); + } + } + + public Map<String, Integer> getBenefits() { + return this.benefits; + } + + public int getTotalBenefitPrice() { + int totalBenefitPrice = Constant.ZERO.get(); + for (Map.Entry<String, Integer> entry : this.benefits.entrySet()) { + int benefit = entry.getValue(); + totalBenefitPrice += benefit; + } + return totalBenefitPrice; + } + + public int getPresentPrice() { + if (this.benefits.containsKey(Message.PRESENT_BENEFIT.get())) { + return Constant.CHAMPAIGN_PRICE.get(); + } + return Constant.ZERO.get(); + } + + private void christmasBenefit() { + if (orderDate > Constant.CHRISTMAS_DAY.get()) { + return; + } + int benefit = Constant.THOUSAND.get() + (orderDate - Constant.ONE.get()) * Constant.HUNDRED.get(); + benefits.put(Message.D_DAY_BENEFIT.get(), benefit); + } + + private void weekBenefit() { + if (orderDate % Constant.WEEKDAYS.get() == Constant.FRIDAY.get() + \|\| orderDate % Constant.WEEKDAYS.get() == Constant.SATURDAY.get()) { + int benefit = Constant.EVENT_PRICE.get() * categoryCount[Constant.MAINMENU.get()]; + benefits.put(Message.WEEKEND_BENEFIT.get(), benefit); + return; + } + int benefit = Constant.EVENT_PRICE.get() * categoryCount[Constant.DESSERT.get()]; + benefits.put(Message.WEEKDAY_BENEFIT.get(), benefit); + } + + private void starBenefit() { + if (orderDate != Constant.CHRISTMAS_DAY.get() + && orderDate % Constant.WEEKDAYS.get() != Constant.SUNDAY.get()) { + return; + } + benefits.put(Message.STAR_BENEFIT.get(), Constant.THOUSAND.get()); + } + + private void presentBenefit() { + benefits.put(Message.PRESENT_BENEFIT.get(), Constant.CHAMPAIGN_PRICE.get()); + } +}	Java	실제 애플리케이션에서 배열 보다는 리스트나, 맵, 셋 등 컬렉션 객체를 사용한다고 해요. 그 이유는 지난 주차 피드백을 보면 배열보다 좀 더 편리한 여러 API들을 제공하기 때문인데요. 이외에도 컬렉션이 선호되는 이유는 이펙티브 자바 등에서도 언급되어 있습니다. https://incheol-jung.gitbook.io/docs/study/effective-java/undefined-3/2020-03-20-effective-28item
@@ -0,0 +1,68 @@ +package christmas.model; + +import christmas.util.Constant; +import christmas.util.ErrorMessage; +import christmas.util.Utility; +import christmas.util.Validator; + +import java.util.ArrayList; +import java.util.Map; +import java.util.List; + +public class OrderMenu { + private final List<Map<String, Integer>> menu; + + private int orderDate; + private Map<String, Integer> userOrder; + + public OrderMenu() { + menu = new ArrayList<>(List.of( + // EPPETIZER 0 + Map.of("양송이수프", 6000, "타파스", 5500, "시저샐러드", 8000), + // MAINMENU 1 + Map.of("티본스테이크", 55000, "바비큐립", 54000, "해산물파스타", 35000, "크리스마스파스타", 25000), + // DESSERT 2 + Map.of("초코케이크", 15000, "아이스크림", 5000), + // BEVERAGE 3 + Map.of("제로콜라", 3000, "레드와인", 60000, "샴페인", 25000) + )); + } + + public int getOrderDate() { + return this.orderDate; + } + + public Map<String, Integer> getUserOrder() { + return this.userOrder; + } + + public int getTotalPrice() { + int totalPrice = Constant.ZERO.get(); + for (Map.Entry<String, Integer> entry : this.userOrder.entrySet()) { + int category = Utility.getCategory(entry.getKey(), menu); + int price = menu.get(category).get(entry.getKey()); + totalPrice += price * entry.getValue(); + } + return totalPrice; + } + + public int[] getCategoryCount() { + int[] categoryCount = new int[Constant.CATEGORY_COUNT.get()]; + for (Map.Entry<String, Integer> entry : this.userOrder.entrySet()) { + int category = Utility.getCategory(entry.getKey(), menu); + categoryCount[category] += entry.getValue(); + } + return categoryCount; + } + + public void setOrderDate(int date) { + this.orderDate = date; + } + + public void setUserOrder(Map<String, Integer> userOrder) { + if (Validator.validateMenu(userOrder, this.menu)) { + throw new IllegalArgumentException(ErrorMessage.ORDER_ERROR.get()); + } + this.userOrder = userOrder; + } +}	Java	메뉴 이름과 가격의 경우 하드 코딩하기보다 enum 등으로 분리하여 관리하는 것이 좋을 것 같습니다.
@@ -0,0 +1,97 @@ +package christmas.util; + +import java.util.Map; +import java.util.List; + +public class Validator { + private final static char MIN_DIGIT = '0'; + private final static char MAX_DIGIT = '9'; + private final static char CHAR_HYPHEN = '-'; + private final static char CHAR_COMMA = ','; + private final static int MIN_DAY = 1; + private final static int MAX_DAY = 31; + private final static int IS_TWO = 2; + + public static void validateDate(String input) { + if (input.isEmpty()) { + throw new IllegalArgumentException(ErrorMessage.DATE_ERROR.get()); + } + for (int i = Constant.ZERO.get(); i < input.length(); ++i) { + if (input.charAt(i) < MIN_DIGIT \|\| input.charAt(i) > MAX_DIGIT) { + throw new IllegalArgumentException(ErrorMessage.DATE_ERROR.get()); + } + } + int date = Integer.parseInt(input); + if (date < MIN_DAY \|\| date > MAX_DAY) { + throw new IllegalArgumentException(ErrorMessage.DATE_ERROR.get()); + } + } + + public static void validateOrder(String input) { + // split할 경우 마지막의 빈 문자열을 사라지므로 별도로 예외 처리 + if (input.isEmpty() \|\| input.charAt(input.length() - Constant.ONE.get()) == CHAR_COMMA) { + throw new IllegalArgumentException(ErrorMessage.ORDER_ERROR.get()); + } + String[] splittedComma = input.split(Message.COMMA.get()); + if (splittedComma.length == Constant.ZERO.get()) { + throw new IllegalArgumentException(ErrorMessage.ORDER_ERROR.get()); + } + for (String string : splittedComma) { + if (validateFormat(string)) { + throw new IllegalArgumentException(ErrorMessage.ORDER_ERROR.get()); + } + } + } + + public static boolean validateMenu(Map<String, Integer> userOrder, List<Map<String, Integer>> menu) { + int[] countCategory = new int[Constant.CATEGORY_COUNT.get()]; + for (Map.Entry<String, Integer> entry : userOrder.entrySet()) { + if (entry.getValue() <= Constant.ZERO.get()) { + return true; + } + int category = Utility.getCategory(entry.getKey(), menu); + if (category == Constant.NOT_IN_MENU.get()) { + return true; + } + countCategory[category] += entry.getValue(); + } + if (validateCount(countCategory)) { + return true; + } + return false; + } + + private static boolean validateCount(int[] countCategory) { + // 음료만 시킨 경우 예외 처리 + if (countCategory[Constant.EPPETIZER.get()] == Constant.ZERO.get() + && countCategory[Constant.MAINMENU.get()] == Constant.ZERO.get() + && countCategory[Constant.DESSERT.get()] == Constant.ZERO.get()) { + return true; + } + int totalCount = Constant.ZERO.get(); + for (int count : countCategory) { + totalCount += count; + } + if (totalCount > Constant.MAX_MENU_COUNT.get()) { + return true; + } + return false; + } + + private static boolean validateFormat(String input) { + if (input.isEmpty() \|\| input.charAt(input.length() - Constant.ONE.get()) == CHAR_HYPHEN) { + return true; + } + String[] splittedHyphen = input.split(Message.HYPHEN.get()); + if (splittedHyphen.length != IS_TWO) { + return true; + } + for (int i = Constant.ZERO.get(); i < splittedHyphen[Constant.VALUE_INDEX.get()].length(); ++i) { + if (splittedHyphen[Constant.VALUE_INDEX.get()].charAt(i) < MIN_DIGIT + \|\| splittedHyphen[Constant.VALUE_INDEX.get()].charAt(i) > MAX_DIGIT) { + return true; + } + } + return false; + } +}	Java	이렇게 유효성 검사 로직을 한 군데에서 관리하는 것도 좋은 방법인 것 같습니다. 개인적인 생각이지만 도메인에서 유효성 검사하게 되면 유효성 검사 로직들이 흩어지는 경향이 있어서 로직을 따라가기 어려운데 이렇게 모아두면 유효성 검사 메서드들만 한눈에 볼 수 있어서 좋은 것 같아요.
@@ -0,0 +1,96 @@ +package christmas.view; + +import christmas.util.Constant; +import christmas.util.Message; +import java.util.Map; + +import java.text.DecimalFormat; + +public class OutputView { + public static void printPreview(int orderDate) { + System.out.println("12월 " + orderDate + "일에 우테코 식당에서 받을 이벤트 혜택 미리 보기!"); + System.out.println(); + } + + public static void printOrder(Map<String, Integer> userOrder) { + System.out.println("<주문 메뉴>"); + for (Map.Entry<String, Integer> entry : userOrder.entrySet()) { + System.out.println(entry.getKey() + Message.SPACE.get() + entry.getValue() + Message.COUNT.get()); + } + System.out.println(); + } + + public static void printTotalPrice(int totalPrice) { + DecimalFormat decimalFormat = new DecimalFormat(Message.PRICE_FORMAT.get()); + + System.out.println("<할인 전 총주문 금액>"); + String formattedNumber = decimalFormat.format(totalPrice); + System.out.println(formattedNumber + Message.WON.get()); + System.out.println(); + } + + public static void printPresent(int totalPrice) { + System.out.println("<증정 메뉴>"); + if (totalPrice < Constant.PRESENT_COST.get()) { + System.out.println(Message.NOTHING.get()); + System.out.println(); + return; + } + System.out.println(Message.ONE_CHAMPAIGN.get()); + System.out.println(); + } + + public static void printBenefits(Map<String, Integer> benefits) { + System.out.println("<혜택 내역>"); + if (benefits.isEmpty()) { + System.out.println(Message.NOTHING.get()); + System.out.println(); + return; + } + DecimalFormat decimalFormat = new DecimalFormat(Message.PRICE_FORMAT.get()); + for (Map.Entry<String, Integer> entry : benefits.entrySet()) { + System.out.print(entry.getKey() + ": -"); + String fomattedNumber = decimalFormat.format(entry.getValue()); + System.out.println(fomattedNumber + Message.WON.get()); + } + System.out.println(); + } + + public static void printTotalBenefitPrice(int totalBenefitPrice) { + System.out.println("<총혜택 금액>"); + if (totalBenefitPrice == Constant.ZERO.get()) { + System.out.println(Message.NOTHING.get()); + System.out.println(); + return; + } + DecimalFormat decimalFormat = new DecimalFormat(Message.PRICE_FORMAT.get()); + String formattedNumber = decimalFormat.format(totalBenefitPrice); + System.out.println(Message.HYPHEN.get() + formattedNumber + Message.WON.get()); + System.out.println(); + } + + public static void printTotalPayment(int totalPayment) { + System.out.println("<할인 후 예상 결제 금액>"); + DecimalFormat decimalFormat = new DecimalFormat(Message.PRICE_FORMAT.get()); + String formattedNumber = decimalFormat.format(totalPayment); + System.out.println(formattedNumber + Message.WON.get()); + System.out.println(); + } + + public static void printEventBadge(int totalBenefitPrice) { + System.out.println("<12월 이벤트 배지>"); + if (totalBenefitPrice >= Constant.SANTA.get()) { + System.out.println("산타"); + return; + } + if (totalBenefitPrice >= Constant.TREE.get()) { + System.out.println("트리"); + return; + } + if (totalBenefitPrice >= Constant.STAR.get()) { + System.out.println("별"); + return; + } + System.out.println(Message.NOTHING.get()); + } +}	Java	출력 뷰 메서드에 주문이나 할인 전 주문금액을 받아서 처리 후 혜택이나 증정 메뉴를 계산하는 분기 로직이 담겨 있네요. 출력 뷰는 출력만에 대한 책임을 가지는 것이 좋을 것 같습니다. 혜택이나 증정메뉴를 계산하는 책임은 각각의 도메인 객체로 이동하시는 게 어떨까요?
@@ -0,0 +1,135 @@ +package christmas; + +import christmas.model.OrderMenu; +import christmas.util.Validator; + +import java.lang.reflect.Array; +import java.util.Map; +import java.util.HashMap; +import java.util.ArrayList; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import java.util.List; + +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.assertj.core.api.Assertions.assertThat; + +public class ValidatorTest { + private List<Map<String, Integer>> menu = new ArrayList<>(List.of( + Map.of("양송이수프", 6000, "타파스", 5500, "시저샐러드", 8000), + Map.of("티본스테이크", 55000, "바비큐립", 54000, "해산물파스타", 35000, "크리스마스파스타", 25000), + Map.of("초코케이크", 15000, "아이스크림", 5000), + Map.of("제로콜라", 3000, "레드와인", 60000, "샴페인", 25000) + )); + + @DisplayName("입력된 날짜가 비어있으면 예외가 발생한다.") + @Test + void isDateNoneTest() { + assertThatThrownBy(() -> Validator.validateDate("")) + .isInstanceOf(IllegalArgumentException.class); + } + + @DisplayName("입력된 날짜가 숫자가 아니면 예외가 발생한다.") + @Test + void isDateInvalidTest() { + assertThatThrownBy(() -> Validator.validateDate("1a")) + .isInstanceOf(IllegalArgumentException.class); + } + + @DisplayName("입력된 날짜가 범위를 벗어나면 예외가 발생한다.") + @Test + void dateRangeTest() { + assertThatThrownBy(() -> Validator.validateDate("123")) + .isInstanceOf(IllegalArgumentException.class); + } + + @DisplayName("입력된 주문이 비어있으면 예외가 발생한다.") + @Test + void isOrderNoneTest() { + assertThatThrownBy(() -> Validator.validateOrder("")) + .isInstanceOf(IllegalArgumentException.class); + } + + @DisplayName("입력된 주문 중 빈 문자열이 있으면 예외가 발생한다.") + @Test + void isParsedNoneTest() { + assertThatThrownBy(() -> Validator.validateOrder("해산물파스타-2,레드와인-1,")) + .isInstanceOf(IllegalArgumentException.class); + assertThatThrownBy(() -> Validator.validateOrder(",해산물파스타-2,레드와인-1")) + .isInstanceOf(IllegalArgumentException.class); + assertThatThrownBy(() -> Validator.validateOrder("해산물파스타-2,레드와인-1,")) + .isInstanceOf(IllegalArgumentException.class); + assertThatThrownBy(() -> Validator.validateOrder("해산물파스타-2,,레드와인-1")) + .isInstanceOf(IllegalArgumentException.class); + assertThatThrownBy(() -> Validator.validateOrder(",,,")) + .isInstanceOf(IllegalArgumentException.class); + } + + @DisplayName("주문 포맷이 올바르지 않으면 예외가 발생한다.") + @Test + void isFormatWrongTest() { + assertThatThrownBy(() -> Validator.validateOrder("해산물파스타")) + .isInstanceOf(IllegalArgumentException.class); + assertThatThrownBy(() -> Validator.validateOrder("해산물파스타-1-1,제로콜라-1")) + .isInstanceOf(IllegalArgumentException.class); + assertThatThrownBy(() -> Validator.validateOrder("해산물파스타-1,제로콜라-")) + .isInstanceOf(IllegalArgumentException.class); + assertThatThrownBy(() -> Validator.validateOrder("해산물파스타-1,---")) + .isInstanceOf(IllegalArgumentException.class); + } + + @DisplayName("개수에 숫자가 아닌 값이 들어가면 예외가 발생한다.") + @Test + void isNotNumberTest() { + assertThatThrownBy(() -> Validator.validateOrder("해산물파스타-레드와인")) + .isInstanceOf(IllegalArgumentException.class); + assertThatThrownBy(() -> Validator.validateOrder("해산물파스타-1,제로콜라-레드와인")) + .isInstanceOf(IllegalArgumentException.class); + assertThatThrownBy(() -> Validator.validateOrder("해산물파스타-1,제로콜라-2레드와인")) + .isInstanceOf(IllegalArgumentException.class); + } + + @DisplayName("메뉴판에 없는 메뉴를 주문하면 예외가 발생한다.") + @Test + void isOrderInMenu() { + Map<String, Integer> order1 = Map.of("똠얌꿍", 1); + Map<String, Integer> order2 = Map.of("양송이수프", 2, "연저육찜", 1); + Map<String, Integer> order3 = Map.of("양송이수프", 1, "아이스크림", 1); + + assertThat(Validator.validateMenu(order1, menu)).isEqualTo(true); + assertThat(Validator.validateMenu(order2, menu)).isEqualTo(true); + assertThat(Validator.validateMenu(order3, menu)).isEqualTo(false); + } + + @DisplayName("0개 이하인 개수가 있다면 예외가 발생한다.") + @Test + void isCountValid() { + Map<String, Integer> order1 = Map.of("아이스크림", 0); + Map<String, Integer> order2 = Map.of("양송이수프", 1, "아이스크림", 0); + + assertThat(Validator.validateMenu(order1, menu)).isEqualTo(true); + assertThat(Validator.validateMenu(order2, menu)).isEqualTo(true); + } + + @DisplayName("20개가 넘어가면 예외가 발생한다.") + @Test + void isUnderTwenty() { + Map<String, Integer> order3 = Map.of("양송이수프", 21); + Map<String, Integer> order4 = Map.of("양송이수프", 10, "아이스크림", 11); + + assertThat(Validator.validateMenu(order3, menu)).isEqualTo(true); + assertThat(Validator.validateMenu(order4, menu)).isEqualTo(true); + } + + @DisplayName("음료만 주문하면 예외가 발생한다.") + @Test + void isOnlyBeverage() { + Map<String, Integer> order3 = Map.of("제로콜라", 1); + Map<String, Integer> order4 = Map.of("제로콜라", 3, "레드와인", 1); + + assertThat(Validator.validateMenu(order3, menu)).isEqualTo(true); + assertThat(Validator.validateMenu(order4, menu)).isEqualTo(true); + } +}	Java	하나의 테스트는 하나의 기능 혹은 책임만을 테스트 하는 것이 더 좋을 것 같아요. 일반적으로 하나의 테스트 메서드에서 무엇을 테스트하려는지 잘 기술할 수 있기 때문에 하나의 테스트에 하나의 단언문을 쓰는 것이 권장됩니다.
@@ -0,0 +1,39 @@ +package christmas.util; + +public enum Constant { + NOT_IN_MENU(-1), + EPPETIZER(0), + MAINMENU(1), + DESSERT(2), + BEVERAGE(3), + CATEGORY_COUNT(4), + ZERO(0), + ONE(1), + THOUSAND(1000), + HUNDRED(100), + CHRISTMAS_DAY(25), + MIN_BENEFIT_PRICE(10000), + PRESENT_COST(120000), + CHAMPAIGN_PRICE(25000), + WEEKDAYS(7), + FRIDAY(1), + SATURDAY(2), + SUNDAY(3), + EVENT_PRICE(2023), + SANTA(20000), + TREE(10000), + STAR(5000), + MAX_MENU_COUNT(20), + KEY_INDEX(0), + VALUE_INDEX(1); + + private final int value; + + Constant(int value) { + this.value = value; + } + + public int get() { + return this.value; + } +}	Java	상수를 하나의 enum에 관리하신것 같은데, enum을 좀 분리해보면 어떨까요? 관련성이 없느 상수들끼리 한군데 몰려있다보니 어색하게 느껴집니다
@@ -0,0 +1,68 @@ +package christmas.model; + +import christmas.util.Constant; +import christmas.util.ErrorMessage; +import christmas.util.Utility; +import christmas.util.Validator; + +import java.util.ArrayList; +import java.util.Map; +import java.util.List; + +public class OrderMenu { + private final List<Map<String, Integer>> menu; + + private int orderDate; + private Map<String, Integer> userOrder; + + public OrderMenu() { + menu = new ArrayList<>(List.of( + // EPPETIZER 0 + Map.of("양송이수프", 6000, "타파스", 5500, "시저샐러드", 8000), + // MAINMENU 1 + Map.of("티본스테이크", 55000, "바비큐립", 54000, "해산물파스타", 35000, "크리스마스파스타", 25000), + // DESSERT 2 + Map.of("초코케이크", 15000, "아이스크림", 5000), + // BEVERAGE 3 + Map.of("제로콜라", 3000, "레드와인", 60000, "샴페인", 25000) + )); + } + + public int getOrderDate() { + return this.orderDate; + } + + public Map<String, Integer> getUserOrder() { + return this.userOrder; + } + + public int getTotalPrice() { + int totalPrice = Constant.ZERO.get(); + for (Map.Entry<String, Integer> entry : this.userOrder.entrySet()) { + int category = Utility.getCategory(entry.getKey(), menu); + int price = menu.get(category).get(entry.getKey()); + totalPrice += price * entry.getValue(); + } + return totalPrice; + } + + public int[] getCategoryCount() { + int[] categoryCount = new int[Constant.CATEGORY_COUNT.get()]; + for (Map.Entry<String, Integer> entry : this.userOrder.entrySet()) { + int category = Utility.getCategory(entry.getKey(), menu); + categoryCount[category] += entry.getValue(); + } + return categoryCount; + } + + public void setOrderDate(int date) { + this.orderDate = date; + } + + public void setUserOrder(Map<String, Integer> userOrder) { + if (Validator.validateMenu(userOrder, this.menu)) { + throw new IllegalArgumentException(ErrorMessage.ORDER_ERROR.get()); + } + this.userOrder = userOrder; + } +}	Java	menu를 list에 관리하셨군요 정답은 없는것 같다만 우테코에서 enum을 사용하라고 권장했으니 이런 메뉴들은 enum에서 관리하면 좀 더 좋지 않을까 생각이 듭니다!
@@ -0,0 +1,68 @@ +package christmas.model; + +import christmas.util.Constant; +import christmas.util.ErrorMessage; +import christmas.util.Utility; +import christmas.util.Validator; + +import java.util.ArrayList; +import java.util.Map; +import java.util.List; + +public class OrderMenu { + private final List<Map<String, Integer>> menu; + + private int orderDate; + private Map<String, Integer> userOrder; + + public OrderMenu() { + menu = new ArrayList<>(List.of( + // EPPETIZER 0 + Map.of("양송이수프", 6000, "타파스", 5500, "시저샐러드", 8000), + // MAINMENU 1 + Map.of("티본스테이크", 55000, "바비큐립", 54000, "해산물파스타", 35000, "크리스마스파스타", 25000), + // DESSERT 2 + Map.of("초코케이크", 15000, "아이스크림", 5000), + // BEVERAGE 3 + Map.of("제로콜라", 3000, "레드와인", 60000, "샴페인", 25000) + )); + } + + public int getOrderDate() { + return this.orderDate; + } + + public Map<String, Integer> getUserOrder() { + return this.userOrder; + } + + public int getTotalPrice() { + int totalPrice = Constant.ZERO.get(); + for (Map.Entry<String, Integer> entry : this.userOrder.entrySet()) { + int category = Utility.getCategory(entry.getKey(), menu); + int price = menu.get(category).get(entry.getKey()); + totalPrice += price * entry.getValue(); + } + return totalPrice; + } + + public int[] getCategoryCount() { + int[] categoryCount = new int[Constant.CATEGORY_COUNT.get()]; + for (Map.Entry<String, Integer> entry : this.userOrder.entrySet()) { + int category = Utility.getCategory(entry.getKey(), menu); + categoryCount[category] += entry.getValue(); + } + return categoryCount; + } + + public void setOrderDate(int date) { + this.orderDate = date; + } + + public void setUserOrder(Map<String, Integer> userOrder) { + if (Validator.validateMenu(userOrder, this.menu)) { + throw new IllegalArgumentException(ErrorMessage.ORDER_ERROR.get()); + } + this.userOrder = userOrder; + } +}	Java	클래스명은 OrderMenu인데 orderDate를 인스턴스 변수로 관리하는게 조금 어색하게 느껴집니다. 클래스 분리를 통해 orderDate와 관련한 클래스를 만들거나, OrderMenu의 클래스명이 메뉴와 날짜를 다 포함하게끔 생각이 들게끔 변경해보면 어떨까요?
@@ -0,0 +1,47 @@ +package christmas.controller; + +import java.util.Map; + +import christmas.view.; +import christmas.model.; + +public class MainController { + private OrderMenu orderMenu; + + public MainController() { + orderMenu = new OrderMenu(); + } + + public void run() { + orderMenu.setOrderDate(InputView.readDate()); + setReadOrder(); + + OutputView.printPreview(orderMenu.getOrderDate()); + OutputView.printOrder(orderMenu.getUserOrder()); + int totalPrice = orderMenu.getTotalPrice(); + OutputView.printTotalPrice(totalPrice); + OutputView.printPresent(totalPrice); + benefitControl(totalPrice); + } + + private void benefitControl(int totalPrice) { + Benefit benefit = new Benefit(orderMenu.getOrderDate(), orderMenu.getCategoryCount(), totalPrice); + OutputView.printBenefits(benefit.getBenefits()); + + int totalBenefitPrice = benefit.getTotalBenefitPrice(); + OutputView.printTotalBenefitPrice(totalBenefitPrice); + OutputView.printTotalPayment(totalPrice - totalBenefitPrice + benefit.getPresentPrice()); + OutputView.printEventBadge(totalBenefitPrice); + } + + private void setReadOrder() { + Map<String, Integer> orderMenu; + try { + orderMenu = InputView.readOrder(); + this.orderMenu.setUserOrder(orderMenu); + } catch (IllegalArgumentException e) { + System.out.println(e.getMessage()); + setReadOrder(); + } + } +}	Java	사실 제가 엄청 오래 찾아보고 고민한 부분이긴 한데 보통 사용하는 방식은 잘 몰라서 제가 생각한 대로 했습니다. 개인적으로 생각한 View 클래스는 상태를 갖고 있지 않고 인스턴스화를 할 필요가 없는 것 같아서 스태틱 클래스나 싱글톤 패턴을 주로 사용한다고 봤었는데, 과제에서 View를 상속할 일은 없을 것 같아서 스태틱 클래스로 구현했습니다. 일반적으로는 싱글톤 패턴을 사용하는 걸까요?
@@ -0,0 +1,39 @@ +package christmas.util; + +public enum Constant { + NOT_IN_MENU(-1), + EPPETIZER(0), + MAINMENU(1), + DESSERT(2), + BEVERAGE(3), + CATEGORY_COUNT(4), + ZERO(0), + ONE(1), + THOUSAND(1000), + HUNDRED(100), + CHRISTMAS_DAY(25), + MIN_BENEFIT_PRICE(10000), + PRESENT_COST(120000), + CHAMPAIGN_PRICE(25000), + WEEKDAYS(7), + FRIDAY(1), + SATURDAY(2), + SUNDAY(3), + EVENT_PRICE(2023), + SANTA(20000), + TREE(10000), + STAR(5000), + MAX_MENU_COUNT(20), + KEY_INDEX(0), + VALUE_INDEX(1); + + private final int value; + + Constant(int value) { + this.value = value; + } + + public int get() { + return this.value; + } +}	Java	enum의 사용 방법을 잘 몰랐던 것 같아요 감사합니다!
@@ -0,0 +1,47 @@ +package christmas.controller; + +import java.util.Map; + +import christmas.view.; +import christmas.model.; + +public class MainController { + private OrderMenu orderMenu; + + public MainController() { + orderMenu = new OrderMenu(); + } + + public void run() { + orderMenu.setOrderDate(InputView.readDate()); + setReadOrder(); + + OutputView.printPreview(orderMenu.getOrderDate()); + OutputView.printOrder(orderMenu.getUserOrder()); + int totalPrice = orderMenu.getTotalPrice(); + OutputView.printTotalPrice(totalPrice); + OutputView.printPresent(totalPrice); + benefitControl(totalPrice); + } + + private void benefitControl(int totalPrice) { + Benefit benefit = new Benefit(orderMenu.getOrderDate(), orderMenu.getCategoryCount(), totalPrice); + OutputView.printBenefits(benefit.getBenefits()); + + int totalBenefitPrice = benefit.getTotalBenefitPrice(); + OutputView.printTotalBenefitPrice(totalBenefitPrice); + OutputView.printTotalPayment(totalPrice - totalBenefitPrice + benefit.getPresentPrice()); + OutputView.printEventBadge(totalBenefitPrice); + } + + private void setReadOrder() { + Map<String, Integer> orderMenu; + try { + orderMenu = InputView.readOrder(); + this.orderMenu.setUserOrder(orderMenu); + } catch (IllegalArgumentException e) { + System.out.println(e.getMessage()); + setReadOrder(); + } + } +}	Java	다시 보니까 MainController가 적절한 이름이 아닌 것 같네요, 보통 모델과 컨트롤러의 관계가 1대 1로 이루어진다고 보면 되는 걸까요?
@@ -0,0 +1,39 @@ +package christmas.util; + +public enum Constant { + NOT_IN_MENU(-1), + EPPETIZER(0), + MAINMENU(1), + DESSERT(2), + BEVERAGE(3), + CATEGORY_COUNT(4), + ZERO(0), + ONE(1), + THOUSAND(1000), + HUNDRED(100), + CHRISTMAS_DAY(25), + MIN_BENEFIT_PRICE(10000), + PRESENT_COST(120000), + CHAMPAIGN_PRICE(25000), + WEEKDAYS(7), + FRIDAY(1), + SATURDAY(2), + SUNDAY(3), + EVENT_PRICE(2023), + SANTA(20000), + TREE(10000), + STAR(5000), + MAX_MENU_COUNT(20), + KEY_INDEX(0), + VALUE_INDEX(1); + + private final int value; + + Constant(int value) { + this.value = value; + } + + public int get() { + return this.value; + } +}	Java	상수처리에만 급급해서 분리하지 못했는데 지금 보니 가독성 측면에서도 좋지 않은 것 같네요. 이 부분은 꼭 수정해야겠습니다 감사합니다!

@@ -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

오 이건 제가 실수했네요. 대리님 말씀이 맞아요!

@@ -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

GameRule 도메인이 만들어 져서, GameConstants와 중복된 의미를 담는거 같은데 해당 클래스에 대해 고민이 좀더 필요해보여용

@@ -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 도메인의 멤버변수로 RandomNumber와 TrialCount 추가 - RandomNumber는 자동차의 전진여부를 판단할 때만 필요한데, 전진여부 판단로직인 GameRule에 있으므로 RandomNumber를 GameRule의 멤버변수로 추가함 - GameRule 객체를 RacingCar의 메소드 안에서 생성하지 않고 Controller에서 생성하도록 수정 - Controller에서 RacingCars에 GameRule객체를 매개변수로 전달 - GameRandomNumber의 getRandomNumber() 메소드 안에서 바로 랜덤숫자를 반환하도록 수정 - 랜덤숫자가 필요할 때마다 새로운 RandomNumber 객체를 생성하지 않고, GameRule이 가지고 있는 RandomNumber 객체를 통해 랜덤숫자 값만 반환받도록 함 ### Issue 1 : GameRule 도메인과 다른 도메인 간의 의존관계 설정의 어려움 - RacingCars의 메소드 안에서 각 자동차 객체마다 전진여부판단이 필요한데, GameRule 객체를 RacingCar에게 넘겨주지 않고 외부에서 판단 후 RacingCar를 전진시킬 방법을 모르겠습니다..! ### Issue 2 : GameRandomNumber에서 randomNumber라는 멤버변수의 필요성 - getRandomNumber()에서 바로 랜덤숫자를 반환해주는데, 그럼 randomNumber 멤버변수가 없어도 되는 것일까요? ### Issue 3 : GameConstants 클래스 - 게임상수 5개 중, 3개는 한 곳에서만 호출하고 나머지 2개는 두 군데에서 호출하는데, 이 상수들을 어떻게 관리하는 것이 효과적일지 궁금합니다! 아래는 제가 생각해 본 방법들입니다. - 모든 상수를 Enum 클래스로 모아서 관리 - 한 곳에서 호출하는 상수는 각각 사용되는 도메인의 멤버변수로 선언, 나머지는 Enum클래스로 관리 - 모든 상수를 각각 사용되는 도메인의 멤버변수로 선언 - 여러 곳에서 사용되는 상수의 경우, 특정 도메인에 정적 상수로 선언하고 다른 도메인에서 호출 --- 각 도메인의 역할을 구분하는 것과 도메인 간 의존관계를 설정하는 부분이 어렵고 개인적으로 약한 것 같습니다. 전체적으로 제가 혼란스러운 부분이 많아서 코드는 달라진 점이 많이 없고, 이슈들 위에 적어두었습니다. 리뷰 부탁드립니다!

@@ -0,0 +1,24 @@ +package com.example.chatgptcodereviewtest.controller; + +import com.example.chatgptcodereviewtest.service.TestService2; +import lombok.RequiredArgsConstructor; +import org.springframework.web.bind.annotation.*; + +/** + * 설명: + * + * @author 최현범(Jayce) / hb.choi@dreamus.io + * @since 2023/03/23 + */ +@RestController +@RequestMapping("/test2") +@RequiredArgsConstructor +public class TestController2 { + + private final TestService2 testService2; + + @GetMapping + public String getText(@RequestParam(value = "label", required = false) String label) { + return testService2.getUppercaseTestLabel(label); + } +} \ No newline at end of file

Java

위 코드는 `TestController2`라는 REST API 컨트롤러 클래스입니다. 개선 제안: 1. Javadoc(주석) 작성이 필요합니다. 메소드와 클래스의 설명을 구체적으로 달아주어 가독성을 높일 수 있습니다. 2. 마지막 줄에 개행 문자열이 없습니다. 소스코드를 수정 및 편집할 때 깃에러가 발생하지 않도록 개행 문자열을 추가하는 것이 좋습니다. 3. `@RequestParam` 어노테이션의 required 속성값은 false로 되어 있어, 필수로 들어올 값이 아닙니다. 이에 대한 처리를 하고 싶다면, 해당 파라미터 변수에 널 체크나 디폴트값 등을 지정해야 합니다. 버그 위험이 없어 보입니다.

@@ -0,0 +1,17 @@ +package com.example.chatgptcodereviewtest.service; + +import org.springframework.stereotype.Service; + +/** + * 설명: + * + * @author 최현범(Jayce) / hb.choi@dreamus.io + * @since 2023/03/23 + */ +@Service +public class TestService2 { + + public String getUppercaseTestLabel(String label) { + return label.toUpperCase(); + } +}

Java

이 코드는 봉쇄적인 문제나 버그가 없는 것 같습니다. 단순하게 문자열을 대문자로 변경하는 메서드를 가지고 있으며, Spring의 Service 어노테이션을 사용하여 Bean으로 등록되어 있습니다. 변수명과 메서드명의 직관성 측면에서 개선할 점이 있는 것 같습니다. 'label'은 구체적인 의미를 알기 어렵습니다. 더 구체적인 명칭을 사용한다면 코드의 가독성이 향상될 것입니다.

@@ -0,0 +1,35 @@ +package nextstep.subway.applicaion; + +import java.util.List; +import nextstep.subway.applicaion.dto.PathResponse; +import nextstep.subway.domain.Line; +import nextstep.subway.domain.LineRepository; +import nextstep.subway.domain.Path; +import nextstep.subway.domain.PathFinder; +import nextstep.subway.domain.Station; +import org.springframework.stereotype.Service; +import org.springframework.transaction.annotation.Transactional; + +@Service +@Transactional +public class PathService { + private final LineRepository lineRepository; + private final StationService stationService; + + public PathService(LineRepository lineRepository, + StationService stationService) { + this.lineRepository = lineRepository; + this.stationService = stationService; + } + + public PathResponse searchPath(Long sourceId, Long targetId) { + Station source = stationService.findById(sourceId); + Station target = stationService.findById(targetId); + List<Line> lines = lineRepository.findAll(); + + PathFinder pathFinder = PathFinder.from(lines); + Path shortestPath = pathFinder.searchPath(source, target); + return PathResponse.from(shortestPath); + } + +}

Java

경로를 찾기위해 lines라는 정보가 있고, 이 정보를 이용해 경로를 찾는데 이 경로를 찾는 책임을 PathFinder가 가지고 있고 그 결과 정보는 Path가 가지고 있네요! 객체지향에서 객체는 상태와 행위로 이루어져있다고 하는데요 경로를 찾기 위한 상태인 lines와 행위인 PathFinder를 하나의 객체로 도출해볼 수는 없을까요? 만약에 이렇게 리팩터링 할 경우 기존에 만들어 두었던 테스트를 활용해서 테스트의 검증이라는 보호 속에 리팩터링을 해보시는 것을 권해드립니다!

@@ -63,19 +63,19 @@ public void update(Station newUpStation, int minusDistance) { } public Section merge(Section section) { - if (!isDownStation(section.upStation)) { + if (!hasDownStationAs(section.upStation)) { throw new IllegalArgumentException("합치려는 구간의 상행역이 하행역과 같아야 합니다."); } return Section.of(line, upStation, section.downStation, distance + section.distance); } - public boolean isUpStation(Station station) { + public boolean hasUpStationAs(Station station) { return upStation.equals(station); } - public boolean isDownStation(Station station) { + public boolean hasDownStationAs(Station station) { return downStation.equals(station); }

Java

변경된 네이밍이 의미를 조금 더 잘 전달하는 것 같아요 👍

@@ -1,6 +1,7 @@ package nextstep.subway.domain; import java.util.ArrayList; +import java.util.Collections; import java.util.List; import java.util.Map; import java.util.Optional; @@ -34,23 +35,30 @@ public void add(Section section) { public void remove(Station station) { validationRemoveStation(station); - Optional<Section> firstSection = sections.stream() - .filter(s -> s.isDownStation(station)) - .findAny(); - - Optional<Section> secondSection = sections.stream() - .filter(s -> s.isUpStation(station)) - .findAny(); + Optional<Section> sectionHasUpStation = findSectionHasUpStationAs(station); + Optional<Section> sectionHasDownStation = findSectionHasDownStationAs(station); - firstSection.ifPresent(section -> sections.remove(section)); - secondSection.ifPresent(section -> sections.remove(section)); + sectionHasUpStation.ifPresent(section -> sections.remove(section)); + sectionHasDownStation.ifPresent(section -> sections.remove(section)); - if (firstSection.isPresent() && secondSection.isPresent()) { - mergeExistingSections(firstSection.get(), secondSection.get()); + if (sectionHasUpStation.isPresent() && sectionHasDownStation.isPresent()) { + mergeExistingSections(sectionHasUpStation.get(), sectionHasDownStation.get()); } } + private Optional<Section> findSectionHasDownStationAs(Station station) { + return sections.stream() + .filter(s -> s.hasUpStationAs(station)) + .findAny(); + } + + private Optional<Section> findSectionHasUpStationAs(Station station) { + return sections.stream() + .filter(s -> s.hasDownStationAs(station)) + .findAny(); + } + private List<Station> getStations() { List<Station> stations = new ArrayList<>(); stations.add(sections.get(0).getUpStation()); @@ -152,4 +160,7 @@ private void mergeExistingSections(Section firstSection, Section secondSection) sections.add(firstSection.merge(secondSection)); } + public List<Section> getSectionList() { + return Collections.unmodifiableList(sections); + } }

Java

적절한 사이즈로 메서드를 나누어 주셨네요 👍

@@ -0,0 +1,48 @@ +package nextstep.subway.unit; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import nextstep.subway.domain.Line; +import nextstep.subway.domain.Station; +import org.springframework.test.util.ReflectionTestUtils; + +public class PathFixture { + /** (10) + * 교대역 --- *2호선* --- 강남역 + * | | + * *3호선* (2) *신분당선* (5) + * | | + * 남부터미널역 --- *3호선* --- 양재 + (3) **/ + + + public static Station 강남역 = new Station("강남역"); + public static Station 교대역 = new Station("교대역"); + public static Station 양재역 = new Station("양재역"); + public static Station 남부터미널역 = new Station("남부터미널역"); + + public static int 교대역_강남역_거리 = 10; + public static int 강남역_양재역_거리 = 5; + public static int 교대역_남부터미널역_거리 = 2; + public static int 남부터미널역_양재역_거리 = 3; + + public static Line 이호선 = Line.of("2호선", "bg-green-600", 교대역, 강남역, 교대역_강남역_거리); + public static Line 삼호선 = Line.of("3호선", "bg-orange-500", 교대역, 남부터미널역, 교대역_남부터미널역_거리); + public static Line 신분당선 = Line.of("신분당선", "bg-red-500", 강남역, 양재역, 강남역_양재역_거리); + + public static List<Line> 노선_목록 = new ArrayList<>(); + + static { + 삼호선.addSection(남부터미널역, 양재역, 남부터미널역_양재역_거리); + + ReflectionTestUtils.setField(강남역, "id", 1L); + ReflectionTestUtils.setField(교대역, "id", 2L); + ReflectionTestUtils.setField(양재역, "id", 3L); + ReflectionTestUtils.setField(남부터미널역, "id", 4L); + + 노선_목록.addAll(Arrays.asList(이호선, 삼호선, 신분당선)); + } + + +}

Java

픽스쳐 분리를 통해 테스트 코드 내 효과적인 중복 제거 👍

@@ -0,0 +1,120 @@ +package nextstep.subway.acceptance; + +import static nextstep.subway.acceptance.LineSteps.지하철_노선_생성_요청; +import static nextstep.subway.acceptance.LineSteps.지하철_노선에_지하철_구간_생성_요청; +import static nextstep.subway.acceptance.PathSteps.경로_조회_요청; +import static nextstep.subway.acceptance.StationSteps.지하철역_생성_요청; +import static org.assertj.core.api.Assertions.assertThat; + +import io.restassured.response.ExtractableResponse; +import io.restassured.response.Response; +import java.util.HashMap; +import java.util.Map; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; +import org.springframework.http.HttpStatus; + +@DisplayName("지하철 경로 검색") +public class PathAcceptanceTest extends AcceptanceTest { + private Long 교대역; + private Long 강남역; + private Long 양재역; + private Long 남부터미널역; + private Long 청량리역; + private Long 회기역; + + private Long 일호선; + private Long 이호선; + private Long 신분당선; + private Long 삼호선; + + private int 교대역_강남역_거리 = 10; + private int 강남역_양재역_거리 = 5; + private int 교대역_남부터미널역_거리 = 2; + private int 남부터미널역_양재역_거리 = 3; + private int 청량리역_회기역_거리 = 7; + + /** (10) + * 교대역 --- *2호선* --- 강남역 + * | | + * *3호선* (2) *신분당선* (5) + * | | + * 남부터미널역 --- *3호선* --- 양재 + (3) **/ + + @BeforeEach + public void setUp() { + super.setUp(); + + 교대역 = 지하철역_생성_요청("교대역").jsonPath().getLong("id"); + 강남역 = 지하철역_생성_요청("강남역").jsonPath().getLong("id"); + 양재역 = 지하철역_생성_요청("양재역").jsonPath().getLong("id"); + 남부터미널역 = 지하철역_생성_요청("남부터미널역").jsonPath().getLong("id"); + 청량리역 = 지하철역_생성_요청("청량리역").jsonPath().getLong("id"); + 회기역 = 지하철역_생성_요청("회기역").jsonPath().getLong("id"); + + 일호선 = 지하철_노선_생성_요청("1호선", "blue", 청량리역, 회기역, 청량리역_회기역_거리).jsonPath().getLong("id"); + 이호선 = 지하철_노선_생성_요청("2호선", "green", 교대역, 강남역, 교대역_강남역_거리).jsonPath().getLong("id"); + 신분당선 = 지하철_노선_생성_요청("신분당선", "red", 강남역, 양재역, 강남역_양재역_거리).jsonPath().getLong("id"); + 삼호선 = 지하철_노선_생성_요청("3호선", "orange", 교대역, 남부터미널역, 교대역_남부터미널역_거리).jsonPath().getLong("id"); + + 지하철_노선에_지하철_구간_생성_요청(삼호선, createSectionCreateParams(남부터미널역, 양재역, 남부터미널역_양재역_거리)); + } + + /** + * Given 지하철 노선 (2호선, 3호선, 신분당선) 을 생성하고 역, 구간을 생성한다. + * When 서로 다른 두 역의 최단 거리를 조회하면 + * Then 최단 거리 조회에 성공한다. + */ + @DisplayName("최단 거리 조회하기") + @Test + void searchShortestPath() { + // when + ExtractableResponse<Response> response = 경로_조회_요청(남부터미널역, 강남역); + + // then + assertThat(response.statusCode()).isEqualTo(HttpStatus.OK.value()); + assertThat(response.jsonPath().getList("stations.id", Long.class)).containsExactly(남부터미널역, 양재역, 강남역); + assertThat(response.jsonPath().getInt("distance")).isEqualTo(남부터미널역_양재역_거리 + 강남역_양재역_거리); + } + + /** + * Given 지하철 노선 (2호선, 3호선, 신분당선) 을 생성하고 역, 구간을 생성한다. + * 기존 노선과 연결되지 않는 새로운 노선 (1호선)을 생성한다. + * When 연결 되지 않은 두 역의 최단 거리 조회를 요청 하면 + * Then 최단 거리 조회에 실패한다. + */ + @DisplayName("최단 거리 조회하기 - 연결되지 않은 역을 조회 할 경우") + @Test + void searchShortestPathDoesNotExistPath() { + // when + ExtractableResponse<Response> response = 경로_조회_요청(강남역, 청량리역); + + // then + assertThat(response.statusCode()).isEqualTo(HttpStatus.BAD_REQUEST.value());; + } + + /** + * Given 지하철 노선 (2호선, 3호선, 신분당선) 을 생성하고 역, 구간을 생성한다. + * When 출발역과 도착역이 동일한데 최단 거리 조회를 요청하면 + * Then 최단 거리 조회에 실패한다. + */ + @DisplayName("최단 거리 조회하기 - 출발역과 도착역이 동일한 경우") + @Test + void searchShortestPathSourceEqualsTarget() { + // when + ExtractableResponse<Response> response = 경로_조회_요청(강남역, 강남역); + + // then + assertThat(response.statusCode()).isEqualTo(HttpStatus.BAD_REQUEST.value());; + } + + private Map<String, String> createSectionCreateParams(Long upStationId, Long downStationId, int distance) { + Map<String, String> params = new HashMap<>(); + params.put("upStationId", upStationId + ""); + params.put("downStationId", downStationId + ""); + params.put("distance", distance + ""); + return params; + } +}

Java

단위 테스트의 픽스쳐 관리 방법처럼 해당 객체들의 재사용이 필요한 경우 인수 테스트용 픽스쳐를 만들어서 관리할 수 도 있겠네요!

@@ -1,7 +1,10 @@ package christmas; +import christmas.controller.MainController; + public class Application { public static void main(String[] args) { - // TODO: 프로그램 구현 + MainController mainController = new MainController(); + mainController.run(); } }

Java

객체를 생성할 때 new 예약어보다 정적 팩토리 메서드를 사용해보시면 어떨까요. 가독성이나 객체 생성 수 제한 같은 여러 가지 이점이 있어요. https://tecoble.techcourse.co.kr/post/2020-05-26-static-factory-method/

@@ -0,0 +1,47 @@ +package christmas.controller; + +import java.util.Map; + +import christmas.view.*; +import christmas.model.*; + +public class MainController { + private OrderMenu orderMenu; + + public MainController() { + orderMenu = new OrderMenu(); + } + + public void run() { + orderMenu.setOrderDate(InputView.readDate()); + setReadOrder(); + + OutputView.printPreview(orderMenu.getOrderDate()); + OutputView.printOrder(orderMenu.getUserOrder()); + int totalPrice = orderMenu.getTotalPrice(); + OutputView.printTotalPrice(totalPrice); + OutputView.printPresent(totalPrice); + benefitControl(totalPrice); + } + + private void benefitControl(int totalPrice) { + Benefit benefit = new Benefit(orderMenu.getOrderDate(), orderMenu.getCategoryCount(), totalPrice); + OutputView.printBenefits(benefit.getBenefits()); + + int totalBenefitPrice = benefit.getTotalBenefitPrice(); + OutputView.printTotalBenefitPrice(totalBenefitPrice); + OutputView.printTotalPayment(totalPrice - totalBenefitPrice + benefit.getPresentPrice()); + OutputView.printEventBadge(totalBenefitPrice); + } + + private void setReadOrder() { + Map<String, Integer> orderMenu; + try { + orderMenu = InputView.readOrder(); + this.orderMenu.setUserOrder(orderMenu); + } catch (IllegalArgumentException e) { + System.out.println(e.getMessage()); + setReadOrder(); + } + } +}

Java

OutputView나 InputView의 입출력 기능들을 모두 스태틱 메서드로 구현하셨네요. 보통은 해당 객체를 생성 후에 일반 메서드를 호출하는데 스태틱 메서드를 사용하신 이유가 있으실까요?

@@ -0,0 +1,97 @@ +package christmas.util; + +import java.util.Map; +import java.util.List; + +public class Validator { + private final static char MIN_DIGIT = '0'; + private final static char MAX_DIGIT = '9'; + private final static char CHAR_HYPHEN = '-'; + private final static char CHAR_COMMA = ','; + private final static int MIN_DAY = 1; + private final static int MAX_DAY = 31; + private final static int IS_TWO = 2; + + public static void validateDate(String input) { + if (input.isEmpty()) { + throw new IllegalArgumentException(ErrorMessage.DATE_ERROR.get()); + } + for (int i = Constant.ZERO.get(); i < input.length(); ++i) { + if (input.charAt(i) < MIN_DIGIT || input.charAt(i) > MAX_DIGIT) { + throw new IllegalArgumentException(ErrorMessage.DATE_ERROR.get()); + } + } + int date = Integer.parseInt(input); + if (date < MIN_DAY || date > MAX_DAY) { + throw new IllegalArgumentException(ErrorMessage.DATE_ERROR.get()); + } + } + + public static void validateOrder(String input) { + // split할 경우 마지막의 빈 문자열을 사라지므로 별도로 예외 처리 + if (input.isEmpty() || input.charAt(input.length() - Constant.ONE.get()) == CHAR_COMMA) { + throw new IllegalArgumentException(ErrorMessage.ORDER_ERROR.get()); + } + String[] splittedComma = input.split(Message.COMMA.get()); + if (splittedComma.length == Constant.ZERO.get()) { + throw new IllegalArgumentException(ErrorMessage.ORDER_ERROR.get()); + } + for (String string : splittedComma) { + if (validateFormat(string)) { + throw new IllegalArgumentException(ErrorMessage.ORDER_ERROR.get()); + } + } + } + + public static boolean validateMenu(Map<String, Integer> userOrder, List<Map<String, Integer>> menu) { + int[] countCategory = new int[Constant.CATEGORY_COUNT.get()]; + for (Map.Entry<String, Integer> entry : userOrder.entrySet()) { + if (entry.getValue() <= Constant.ZERO.get()) { + return true; + } + int category = Utility.getCategory(entry.getKey(), menu); + if (category == Constant.NOT_IN_MENU.get()) { + return true; + } + countCategory[category] += entry.getValue(); + } + if (validateCount(countCategory)) { + return true; + } + return false; + } + + private static boolean validateCount(int[] countCategory) { + // 음료만 시킨 경우 예외 처리 + if (countCategory[Constant.EPPETIZER.get()] == Constant.ZERO.get() + && countCategory[Constant.MAINMENU.get()] == Constant.ZERO.get() + && countCategory[Constant.DESSERT.get()] == Constant.ZERO.get()) { + return true; + } + int totalCount = Constant.ZERO.get(); + for (int count : countCategory) { + totalCount += count; + } + if (totalCount > Constant.MAX_MENU_COUNT.get()) { + return true; + } + return false; + } + + private static boolean validateFormat(String input) { + if (input.isEmpty() || input.charAt(input.length() - Constant.ONE.get()) == CHAR_HYPHEN) { + return true; + } + String[] splittedHyphen = input.split(Message.HYPHEN.get()); + if (splittedHyphen.length != IS_TWO) { + return true; + } + for (int i = Constant.ZERO.get(); i < splittedHyphen[Constant.VALUE_INDEX.get()].length(); ++i) { + if (splittedHyphen[Constant.VALUE_INDEX.get()].charAt(i) < MIN_DIGIT + || splittedHyphen[Constant.VALUE_INDEX.get()].charAt(i) > MAX_DIGIT) { + return true; + } + } + return false; + } +}

Java

저도 챙기지 못한 부분이긴합니다만 해당 내용 공유해드리자면, '음료만 주문'과 같은 예외처리는 문자열 파싱 예외가 아닌 비즈니스 로직 예외처리이므로 객체생성에서 예외 처리를 해주면 역할분리 원칙에 훨씬 더 좋은 코드가 될 것 같습니다~!

@@ -1,7 +1,10 @@ package christmas; +import christmas.controller.MainController; + public class Application { public static void main(String[] args) { - // TODO: 프로그램 구현 + MainController mainController = new MainController(); + mainController.run(); } }

Java

생각하지 못했던 개념인데 감사합니다! 리팩토링할 때 적용하면 좋을 것 같네요

@@ -0,0 +1,39 @@ +package christmas.util; + +public enum Constant { + NOT_IN_MENU(-1), + EPPETIZER(0), + MAINMENU(1), + DESSERT(2), + BEVERAGE(3), + CATEGORY_COUNT(4), + ZERO(0), + ONE(1), + THOUSAND(1000), + HUNDRED(100), + CHRISTMAS_DAY(25), + MIN_BENEFIT_PRICE(10000), + PRESENT_COST(120000), + CHAMPAIGN_PRICE(25000), + WEEKDAYS(7), + FRIDAY(1), + SATURDAY(2), + SUNDAY(3), + EVENT_PRICE(2023), + SANTA(20000), + TREE(10000), + STAR(5000), + MAX_MENU_COUNT(20), + KEY_INDEX(0), + VALUE_INDEX(1); + + private final int value; + + Constant(int value) { + this.value = value; + } + + public int get() { + return this.value; + } +}

Java

Enum을 메뉴정보 저장하는 자료구조로 사용하면 용처가 잘 맞을 것 같습니다. 메뉴에 해당하는 한글이름(String)과 가격(Integer)가 존재하기 때문이지요.

@@ -0,0 +1,68 @@ +package christmas.model; + +import christmas.util.Constant; +import christmas.util.ErrorMessage; +import christmas.util.Utility; +import christmas.util.Validator; + +import java.util.ArrayList; +import java.util.Map; +import java.util.List; + +public class OrderMenu { + private final List<Map<String, Integer>> menu; + + private int orderDate; + private Map<String, Integer> userOrder; + + public OrderMenu() { + menu = new ArrayList<>(List.of( + // EPPETIZER 0 + Map.of("양송이수프", 6000, "타파스", 5500, "시저샐러드", 8000), + // MAINMENU 1 + Map.of("티본스테이크", 55000, "바비큐립", 54000, "해산물파스타", 35000, "크리스마스파스타", 25000), + // DESSERT 2 + Map.of("초코케이크", 15000, "아이스크림", 5000), + // BEVERAGE 3 + Map.of("제로콜라", 3000, "레드와인", 60000, "샴페인", 25000) + )); + } + + public int getOrderDate() { + return this.orderDate; + } + + public Map<String, Integer> getUserOrder() { + return this.userOrder; + } + + public int getTotalPrice() { + int totalPrice = Constant.ZERO.get(); + for (Map.Entry<String, Integer> entry : this.userOrder.entrySet()) { + int category = Utility.getCategory(entry.getKey(), menu); + int price = menu.get(category).get(entry.getKey()); + totalPrice += price * entry.getValue(); + } + return totalPrice; + } + + public int[] getCategoryCount() { + int[] categoryCount = new int[Constant.CATEGORY_COUNT.get()]; + for (Map.Entry<String, Integer> entry : this.userOrder.entrySet()) { + int category = Utility.getCategory(entry.getKey(), menu); + categoryCount[category] += entry.getValue(); + } + return categoryCount; + } + + public void setOrderDate(int date) { + this.orderDate = date; + } + + public void setUserOrder(Map<String, Integer> userOrder) { + if (Validator.validateMenu(userOrder, this.menu)) { + throw new IllegalArgumentException(ErrorMessage.ORDER_ERROR.get()); + } + this.userOrder = userOrder; + } +}

Java

Map.of로 초기화하나 편해보이네요! 배웠습니다! 어디가서 써먹어 봐야겠어요!

@@ -0,0 +1,47 @@ +package christmas.controller; + +import java.util.Map; + +import christmas.view.*; +import christmas.model.*; + +public class MainController { + private OrderMenu orderMenu; + + public MainController() { + orderMenu = new OrderMenu(); + } + + public void run() { + orderMenu.setOrderDate(InputView.readDate()); + setReadOrder(); + + OutputView.printPreview(orderMenu.getOrderDate()); + OutputView.printOrder(orderMenu.getUserOrder()); + int totalPrice = orderMenu.getTotalPrice(); + OutputView.printTotalPrice(totalPrice); + OutputView.printPresent(totalPrice); + benefitControl(totalPrice); + } + + private void benefitControl(int totalPrice) { + Benefit benefit = new Benefit(orderMenu.getOrderDate(), orderMenu.getCategoryCount(), totalPrice); + OutputView.printBenefits(benefit.getBenefits()); + + int totalBenefitPrice = benefit.getTotalBenefitPrice(); + OutputView.printTotalBenefitPrice(totalBenefitPrice); + OutputView.printTotalPayment(totalPrice - totalBenefitPrice + benefit.getPresentPrice()); + OutputView.printEventBadge(totalBenefitPrice); + } + + private void setReadOrder() { + Map<String, Integer> orderMenu; + try { + orderMenu = InputView.readOrder(); + this.orderMenu.setUserOrder(orderMenu); + } catch (IllegalArgumentException e) { + System.out.println(e.getMessage()); + setReadOrder(); + } + } +}

Java

MainController가 크게 컨트롤(객체내 데이터를 수정 및 저장)하는 모델은 orderMenu인 것 같아보입니다. 즉 클래스 이름이 orderController이면 Model과 Controller간의 역할 의존성에 더 맞는 작명일 것 같습니다

@@ -0,0 +1,79 @@ +package christmas.model; + +import christmas.util.Constant; +import christmas.util.Message; + +import java.util.HashMap; +import java.util.Map; + +public class Benefit { + private int orderDate; + private int[] categoryCount; + Map<String, Integer> benefits; + + public Benefit(int orderDate, int[] categoryCount, int totalPrice) { + this.orderDate = orderDate; + this.categoryCount = categoryCount; + benefits = new HashMap<>(); + if (totalPrice < Constant.MIN_BENEFIT_PRICE.get()) { + return; + } + christmasBenefit(); + weekBenefit(); + starBenefit(); + if (totalPrice >= Constant.PRESENT_COST.get()) { + presentBenefit(); + } + } + + public Map<String, Integer> getBenefits() { + return this.benefits; + } + + public int getTotalBenefitPrice() { + int totalBenefitPrice = Constant.ZERO.get(); + for (Map.Entry<String, Integer> entry : this.benefits.entrySet()) { + int benefit = entry.getValue(); + totalBenefitPrice += benefit; + } + return totalBenefitPrice; + } + + public int getPresentPrice() { + if (this.benefits.containsKey(Message.PRESENT_BENEFIT.get())) { + return Constant.CHAMPAIGN_PRICE.get(); + } + return Constant.ZERO.get(); + } + + private void christmasBenefit() { + if (orderDate > Constant.CHRISTMAS_DAY.get()) { + return; + } + int benefit = Constant.THOUSAND.get() + (orderDate - Constant.ONE.get()) * Constant.HUNDRED.get(); + benefits.put(Message.D_DAY_BENEFIT.get(), benefit); + } + + private void weekBenefit() { + if (orderDate % Constant.WEEKDAYS.get() == Constant.FRIDAY.get() + || orderDate % Constant.WEEKDAYS.get() == Constant.SATURDAY.get()) { + int benefit = Constant.EVENT_PRICE.get() * categoryCount[Constant.MAINMENU.get()]; + benefits.put(Message.WEEKEND_BENEFIT.get(), benefit); + return; + } + int benefit = Constant.EVENT_PRICE.get() * categoryCount[Constant.DESSERT.get()]; + benefits.put(Message.WEEKDAY_BENEFIT.get(), benefit); + } + + private void starBenefit() { + if (orderDate != Constant.CHRISTMAS_DAY.get() + && orderDate % Constant.WEEKDAYS.get() != Constant.SUNDAY.get()) { + return; + } + benefits.put(Message.STAR_BENEFIT.get(), Constant.THOUSAND.get()); + } + + private void presentBenefit() { + benefits.put(Message.PRESENT_BENEFIT.get(), Constant.CHAMPAIGN_PRICE.get()); + } +}

Java

전체적으로 함수분리가 잘 돼있어서 함수당 라인이 짧은 편이네요! 굉장히 가독성 좋은 코드가 된 것 같습니다!

@@ -0,0 +1,39 @@ +package christmas.util; + +public enum Constant { + NOT_IN_MENU(-1), + EPPETIZER(0), + MAINMENU(1), + DESSERT(2), + BEVERAGE(3), + CATEGORY_COUNT(4), + ZERO(0), + ONE(1), + THOUSAND(1000), + HUNDRED(100), + CHRISTMAS_DAY(25), + MIN_BENEFIT_PRICE(10000), + PRESENT_COST(120000), + CHAMPAIGN_PRICE(25000), + WEEKDAYS(7), + FRIDAY(1), + SATURDAY(2), + SUNDAY(3), + EVENT_PRICE(2023), + SANTA(20000), + TREE(10000), + STAR(5000), + MAX_MENU_COUNT(20), + KEY_INDEX(0), + VALUE_INDEX(1); + + private final int value; + + Constant(int value) { + this.value = value; + } + + public int get() { + return this.value; + } +}

Java

상수들을 enum으로 관리하시는 것은 좋은 포인트인 것 같습니다. 하지만 constant에 모든 상수를 다 넣어버리시면 개별 상수를 수정하거나 변경해야 할 때 찾기 어려워질 것 같아요. enum을 종류별로, 문맥별로 분리하시는 것을 추천 드려요.

@@ -0,0 +1,79 @@ +package christmas.model; + +import christmas.util.Constant; +import christmas.util.Message; + +import java.util.HashMap; +import java.util.Map; + +public class Benefit { + private int orderDate; + private int[] categoryCount; + Map<String, Integer> benefits; + + public Benefit(int orderDate, int[] categoryCount, int totalPrice) { + this.orderDate = orderDate; + this.categoryCount = categoryCount; + benefits = new HashMap<>(); + if (totalPrice < Constant.MIN_BENEFIT_PRICE.get()) { + return; + } + christmasBenefit(); + weekBenefit(); + starBenefit(); + if (totalPrice >= Constant.PRESENT_COST.get()) { + presentBenefit(); + } + } + + public Map<String, Integer> getBenefits() { + return this.benefits; + } + + public int getTotalBenefitPrice() { + int totalBenefitPrice = Constant.ZERO.get(); + for (Map.Entry<String, Integer> entry : this.benefits.entrySet()) { + int benefit = entry.getValue(); + totalBenefitPrice += benefit; + } + return totalBenefitPrice; + } + + public int getPresentPrice() { + if (this.benefits.containsKey(Message.PRESENT_BENEFIT.get())) { + return Constant.CHAMPAIGN_PRICE.get(); + } + return Constant.ZERO.get(); + } + + private void christmasBenefit() { + if (orderDate > Constant.CHRISTMAS_DAY.get()) { + return; + } + int benefit = Constant.THOUSAND.get() + (orderDate - Constant.ONE.get()) * Constant.HUNDRED.get(); + benefits.put(Message.D_DAY_BENEFIT.get(), benefit); + } + + private void weekBenefit() { + if (orderDate % Constant.WEEKDAYS.get() == Constant.FRIDAY.get() + || orderDate % Constant.WEEKDAYS.get() == Constant.SATURDAY.get()) { + int benefit = Constant.EVENT_PRICE.get() * categoryCount[Constant.MAINMENU.get()]; + benefits.put(Message.WEEKEND_BENEFIT.get(), benefit); + return; + } + int benefit = Constant.EVENT_PRICE.get() * categoryCount[Constant.DESSERT.get()]; + benefits.put(Message.WEEKDAY_BENEFIT.get(), benefit); + } + + private void starBenefit() { + if (orderDate != Constant.CHRISTMAS_DAY.get() + && orderDate % Constant.WEEKDAYS.get() != Constant.SUNDAY.get()) { + return; + } + benefits.put(Message.STAR_BENEFIT.get(), Constant.THOUSAND.get()); + } + + private void presentBenefit() { + benefits.put(Message.PRESENT_BENEFIT.get(), Constant.CHAMPAIGN_PRICE.get()); + } +}

Java

실제 애플리케이션에서 배열 보다는 리스트나, 맵, 셋 등 컬렉션 객체를 사용한다고 해요. 그 이유는 지난 주차 피드백을 보면 배열보다 좀 더 편리한 여러 API들을 제공하기 때문인데요. 이외에도 컬렉션이 선호되는 이유는 이펙티브 자바 등에서도 언급되어 있습니다. https://incheol-jung.gitbook.io/docs/study/effective-java/undefined-3/2020-03-20-effective-28item

@@ -0,0 +1,68 @@ +package christmas.model; + +import christmas.util.Constant; +import christmas.util.ErrorMessage; +import christmas.util.Utility; +import christmas.util.Validator; + +import java.util.ArrayList; +import java.util.Map; +import java.util.List; + +public class OrderMenu { + private final List<Map<String, Integer>> menu; + + private int orderDate; + private Map<String, Integer> userOrder; + + public OrderMenu() { + menu = new ArrayList<>(List.of( + // EPPETIZER 0 + Map.of("양송이수프", 6000, "타파스", 5500, "시저샐러드", 8000), + // MAINMENU 1 + Map.of("티본스테이크", 55000, "바비큐립", 54000, "해산물파스타", 35000, "크리스마스파스타", 25000), + // DESSERT 2 + Map.of("초코케이크", 15000, "아이스크림", 5000), + // BEVERAGE 3 + Map.of("제로콜라", 3000, "레드와인", 60000, "샴페인", 25000) + )); + } + + public int getOrderDate() { + return this.orderDate; + } + + public Map<String, Integer> getUserOrder() { + return this.userOrder; + } + + public int getTotalPrice() { + int totalPrice = Constant.ZERO.get(); + for (Map.Entry<String, Integer> entry : this.userOrder.entrySet()) { + int category = Utility.getCategory(entry.getKey(), menu); + int price = menu.get(category).get(entry.getKey()); + totalPrice += price * entry.getValue(); + } + return totalPrice; + } + + public int[] getCategoryCount() { + int[] categoryCount = new int[Constant.CATEGORY_COUNT.get()]; + for (Map.Entry<String, Integer> entry : this.userOrder.entrySet()) { + int category = Utility.getCategory(entry.getKey(), menu); + categoryCount[category] += entry.getValue(); + } + return categoryCount; + } + + public void setOrderDate(int date) { + this.orderDate = date; + } + + public void setUserOrder(Map<String, Integer> userOrder) { + if (Validator.validateMenu(userOrder, this.menu)) { + throw new IllegalArgumentException(ErrorMessage.ORDER_ERROR.get()); + } + this.userOrder = userOrder; + } +}

Java

메뉴 이름과 가격의 경우 하드 코딩하기보다 enum 등으로 분리하여 관리하는 것이 좋을 것 같습니다.

@@ -0,0 +1,97 @@ +package christmas.util; + +import java.util.Map; +import java.util.List; + +public class Validator { + private final static char MIN_DIGIT = '0'; + private final static char MAX_DIGIT = '9'; + private final static char CHAR_HYPHEN = '-'; + private final static char CHAR_COMMA = ','; + private final static int MIN_DAY = 1; + private final static int MAX_DAY = 31; + private final static int IS_TWO = 2; + + public static void validateDate(String input) { + if (input.isEmpty()) { + throw new IllegalArgumentException(ErrorMessage.DATE_ERROR.get()); + } + for (int i = Constant.ZERO.get(); i < input.length(); ++i) { + if (input.charAt(i) < MIN_DIGIT || input.charAt(i) > MAX_DIGIT) { + throw new IllegalArgumentException(ErrorMessage.DATE_ERROR.get()); + } + } + int date = Integer.parseInt(input); + if (date < MIN_DAY || date > MAX_DAY) { + throw new IllegalArgumentException(ErrorMessage.DATE_ERROR.get()); + } + } + + public static void validateOrder(String input) { + // split할 경우 마지막의 빈 문자열을 사라지므로 별도로 예외 처리 + if (input.isEmpty() || input.charAt(input.length() - Constant.ONE.get()) == CHAR_COMMA) { + throw new IllegalArgumentException(ErrorMessage.ORDER_ERROR.get()); + } + String[] splittedComma = input.split(Message.COMMA.get()); + if (splittedComma.length == Constant.ZERO.get()) { + throw new IllegalArgumentException(ErrorMessage.ORDER_ERROR.get()); + } + for (String string : splittedComma) { + if (validateFormat(string)) { + throw new IllegalArgumentException(ErrorMessage.ORDER_ERROR.get()); + } + } + } + + public static boolean validateMenu(Map<String, Integer> userOrder, List<Map<String, Integer>> menu) { + int[] countCategory = new int[Constant.CATEGORY_COUNT.get()]; + for (Map.Entry<String, Integer> entry : userOrder.entrySet()) { + if (entry.getValue() <= Constant.ZERO.get()) { + return true; + } + int category = Utility.getCategory(entry.getKey(), menu); + if (category == Constant.NOT_IN_MENU.get()) { + return true; + } + countCategory[category] += entry.getValue(); + } + if (validateCount(countCategory)) { + return true; + } + return false; + } + + private static boolean validateCount(int[] countCategory) { + // 음료만 시킨 경우 예외 처리 + if (countCategory[Constant.EPPETIZER.get()] == Constant.ZERO.get() + && countCategory[Constant.MAINMENU.get()] == Constant.ZERO.get() + && countCategory[Constant.DESSERT.get()] == Constant.ZERO.get()) { + return true; + } + int totalCount = Constant.ZERO.get(); + for (int count : countCategory) { + totalCount += count; + } + if (totalCount > Constant.MAX_MENU_COUNT.get()) { + return true; + } + return false; + } + + private static boolean validateFormat(String input) { + if (input.isEmpty() || input.charAt(input.length() - Constant.ONE.get()) == CHAR_HYPHEN) { + return true; + } + String[] splittedHyphen = input.split(Message.HYPHEN.get()); + if (splittedHyphen.length != IS_TWO) { + return true; + } + for (int i = Constant.ZERO.get(); i < splittedHyphen[Constant.VALUE_INDEX.get()].length(); ++i) { + if (splittedHyphen[Constant.VALUE_INDEX.get()].charAt(i) < MIN_DIGIT + || splittedHyphen[Constant.VALUE_INDEX.get()].charAt(i) > MAX_DIGIT) { + return true; + } + } + return false; + } +}

Java

이렇게 유효성 검사 로직을 한 군데에서 관리하는 것도 좋은 방법인 것 같습니다. 개인적인 생각이지만 도메인에서 유효성 검사하게 되면 유효성 검사 로직들이 흩어지는 경향이 있어서 로직을 따라가기 어려운데 이렇게 모아두면 유효성 검사 메서드들만 한눈에 볼 수 있어서 좋은 것 같아요.

@@ -0,0 +1,96 @@ +package christmas.view; + +import christmas.util.Constant; +import christmas.util.Message; +import java.util.Map; + +import java.text.DecimalFormat; + +public class OutputView { + public static void printPreview(int orderDate) { + System.out.println("12월 " + orderDate + "일에 우테코 식당에서 받을 이벤트 혜택 미리 보기!"); + System.out.println(); + } + + public static void printOrder(Map<String, Integer> userOrder) { + System.out.println("<주문 메뉴>"); + for (Map.Entry<String, Integer> entry : userOrder.entrySet()) { + System.out.println(entry.getKey() + Message.SPACE.get() + entry.getValue() + Message.COUNT.get()); + } + System.out.println(); + } + + public static void printTotalPrice(int totalPrice) { + DecimalFormat decimalFormat = new DecimalFormat(Message.PRICE_FORMAT.get()); + + System.out.println("<할인 전 총주문 금액>"); + String formattedNumber = decimalFormat.format(totalPrice); + System.out.println(formattedNumber + Message.WON.get()); + System.out.println(); + } + + public static void printPresent(int totalPrice) { + System.out.println("<증정 메뉴>"); + if (totalPrice < Constant.PRESENT_COST.get()) { + System.out.println(Message.NOTHING.get()); + System.out.println(); + return; + } + System.out.println(Message.ONE_CHAMPAIGN.get()); + System.out.println(); + } + + public static void printBenefits(Map<String, Integer> benefits) { + System.out.println("<혜택 내역>"); + if (benefits.isEmpty()) { + System.out.println(Message.NOTHING.get()); + System.out.println(); + return; + } + DecimalFormat decimalFormat = new DecimalFormat(Message.PRICE_FORMAT.get()); + for (Map.Entry<String, Integer> entry : benefits.entrySet()) { + System.out.print(entry.getKey() + ": -"); + String fomattedNumber = decimalFormat.format(entry.getValue()); + System.out.println(fomattedNumber + Message.WON.get()); + } + System.out.println(); + } + + public static void printTotalBenefitPrice(int totalBenefitPrice) { + System.out.println("<총혜택 금액>"); + if (totalBenefitPrice == Constant.ZERO.get()) { + System.out.println(Message.NOTHING.get()); + System.out.println(); + return; + } + DecimalFormat decimalFormat = new DecimalFormat(Message.PRICE_FORMAT.get()); + String formattedNumber = decimalFormat.format(totalBenefitPrice); + System.out.println(Message.HYPHEN.get() + formattedNumber + Message.WON.get()); + System.out.println(); + } + + public static void printTotalPayment(int totalPayment) { + System.out.println("<할인 후 예상 결제 금액>"); + DecimalFormat decimalFormat = new DecimalFormat(Message.PRICE_FORMAT.get()); + String formattedNumber = decimalFormat.format(totalPayment); + System.out.println(formattedNumber + Message.WON.get()); + System.out.println(); + } + + public static void printEventBadge(int totalBenefitPrice) { + System.out.println("<12월 이벤트 배지>"); + if (totalBenefitPrice >= Constant.SANTA.get()) { + System.out.println("산타"); + return; + } + if (totalBenefitPrice >= Constant.TREE.get()) { + System.out.println("트리"); + return; + } + if (totalBenefitPrice >= Constant.STAR.get()) { + System.out.println("별"); + return; + } + System.out.println(Message.NOTHING.get()); + } +}

Java

출력 뷰 메서드에 주문이나 할인 전 주문금액을 받아서 처리 후 혜택이나 증정 메뉴를 계산하는 분기 로직이 담겨 있네요. 출력 뷰는 출력만에 대한 책임을 가지는 것이 좋을 것 같습니다. 혜택이나 증정메뉴를 계산하는 책임은 각각의 도메인 객체로 이동하시는 게 어떨까요?

@@ -0,0 +1,135 @@ +package christmas; + +import christmas.model.OrderMenu; +import christmas.util.Validator; + +import java.lang.reflect.Array; +import java.util.Map; +import java.util.HashMap; +import java.util.ArrayList; + +import org.junit.jupiter.api.DisplayName; +import org.junit.jupiter.api.Test; + +import java.util.List; + +import static org.assertj.core.api.Assertions.assertThatThrownBy; +import static org.assertj.core.api.Assertions.assertThat; + +public class ValidatorTest { + private List<Map<String, Integer>> menu = new ArrayList<>(List.of( + Map.of("양송이수프", 6000, "타파스", 5500, "시저샐러드", 8000), + Map.of("티본스테이크", 55000, "바비큐립", 54000, "해산물파스타", 35000, "크리스마스파스타", 25000), + Map.of("초코케이크", 15000, "아이스크림", 5000), + Map.of("제로콜라", 3000, "레드와인", 60000, "샴페인", 25000) + )); + + @DisplayName("입력된 날짜가 비어있으면 예외가 발생한다.") + @Test + void isDateNoneTest() { + assertThatThrownBy(() -> Validator.validateDate("")) + .isInstanceOf(IllegalArgumentException.class); + } + + @DisplayName("입력된 날짜가 숫자가 아니면 예외가 발생한다.") + @Test + void isDateInvalidTest() { + assertThatThrownBy(() -> Validator.validateDate("1a")) + .isInstanceOf(IllegalArgumentException.class); + } + + @DisplayName("입력된 날짜가 범위를 벗어나면 예외가 발생한다.") + @Test + void dateRangeTest() { + assertThatThrownBy(() -> Validator.validateDate("123")) + .isInstanceOf(IllegalArgumentException.class); + } + + @DisplayName("입력된 주문이 비어있으면 예외가 발생한다.") + @Test + void isOrderNoneTest() { + assertThatThrownBy(() -> Validator.validateOrder("")) + .isInstanceOf(IllegalArgumentException.class); + } + + @DisplayName("입력된 주문 중 빈 문자열이 있으면 예외가 발생한다.") + @Test + void isParsedNoneTest() { + assertThatThrownBy(() -> Validator.validateOrder("해산물파스타-2,레드와인-1,")) + .isInstanceOf(IllegalArgumentException.class); + assertThatThrownBy(() -> Validator.validateOrder(",해산물파스타-2,레드와인-1")) + .isInstanceOf(IllegalArgumentException.class); + assertThatThrownBy(() -> Validator.validateOrder("해산물파스타-2,레드와인-1,")) + .isInstanceOf(IllegalArgumentException.class); + assertThatThrownBy(() -> Validator.validateOrder("해산물파스타-2,,레드와인-1")) + .isInstanceOf(IllegalArgumentException.class); + assertThatThrownBy(() -> Validator.validateOrder(",,,")) + .isInstanceOf(IllegalArgumentException.class); + } + + @DisplayName("주문 포맷이 올바르지 않으면 예외가 발생한다.") + @Test + void isFormatWrongTest() { + assertThatThrownBy(() -> Validator.validateOrder("해산물파스타")) + .isInstanceOf(IllegalArgumentException.class); + assertThatThrownBy(() -> Validator.validateOrder("해산물파스타-1-1,제로콜라-1")) + .isInstanceOf(IllegalArgumentException.class); + assertThatThrownBy(() -> Validator.validateOrder("해산물파스타-1,제로콜라-")) + .isInstanceOf(IllegalArgumentException.class); + assertThatThrownBy(() -> Validator.validateOrder("해산물파스타-1,---")) + .isInstanceOf(IllegalArgumentException.class); + } + + @DisplayName("개수에 숫자가 아닌 값이 들어가면 예외가 발생한다.") + @Test + void isNotNumberTest() { + assertThatThrownBy(() -> Validator.validateOrder("해산물파스타-레드와인")) + .isInstanceOf(IllegalArgumentException.class); + assertThatThrownBy(() -> Validator.validateOrder("해산물파스타-1,제로콜라-레드와인")) + .isInstanceOf(IllegalArgumentException.class); + assertThatThrownBy(() -> Validator.validateOrder("해산물파스타-1,제로콜라-2레드와인")) + .isInstanceOf(IllegalArgumentException.class); + } + + @DisplayName("메뉴판에 없는 메뉴를 주문하면 예외가 발생한다.") + @Test + void isOrderInMenu() { + Map<String, Integer> order1 = Map.of("똠얌꿍", 1); + Map<String, Integer> order2 = Map.of("양송이수프", 2, "연저육찜", 1); + Map<String, Integer> order3 = Map.of("양송이수프", 1, "아이스크림", 1); + + assertThat(Validator.validateMenu(order1, menu)).isEqualTo(true); + assertThat(Validator.validateMenu(order2, menu)).isEqualTo(true); + assertThat(Validator.validateMenu(order3, menu)).isEqualTo(false); + } + + @DisplayName("0개 이하인 개수가 있다면 예외가 발생한다.") + @Test + void isCountValid() { + Map<String, Integer> order1 = Map.of("아이스크림", 0); + Map<String, Integer> order2 = Map.of("양송이수프", 1, "아이스크림", 0); + + assertThat(Validator.validateMenu(order1, menu)).isEqualTo(true); + assertThat(Validator.validateMenu(order2, menu)).isEqualTo(true); + } + + @DisplayName("20개가 넘어가면 예외가 발생한다.") + @Test + void isUnderTwenty() { + Map<String, Integer> order3 = Map.of("양송이수프", 21); + Map<String, Integer> order4 = Map.of("양송이수프", 10, "아이스크림", 11); + + assertThat(Validator.validateMenu(order3, menu)).isEqualTo(true); + assertThat(Validator.validateMenu(order4, menu)).isEqualTo(true); + } + + @DisplayName("음료만 주문하면 예외가 발생한다.") + @Test + void isOnlyBeverage() { + Map<String, Integer> order3 = Map.of("제로콜라", 1); + Map<String, Integer> order4 = Map.of("제로콜라", 3, "레드와인", 1); + + assertThat(Validator.validateMenu(order3, menu)).isEqualTo(true); + assertThat(Validator.validateMenu(order4, menu)).isEqualTo(true); + } +}

Java

하나의 테스트는 하나의 기능 혹은 책임만을 테스트 하는 것이 더 좋을 것 같아요. 일반적으로 하나의 테스트 메서드에서 무엇을 테스트하려는지 잘 기술할 수 있기 때문에 하나의 테스트에 하나의 단언문을 쓰는 것이 권장됩니다.

@@ -0,0 +1,39 @@ +package christmas.util; + +public enum Constant { + NOT_IN_MENU(-1), + EPPETIZER(0), + MAINMENU(1), + DESSERT(2), + BEVERAGE(3), + CATEGORY_COUNT(4), + ZERO(0), + ONE(1), + THOUSAND(1000), + HUNDRED(100), + CHRISTMAS_DAY(25), + MIN_BENEFIT_PRICE(10000), + PRESENT_COST(120000), + CHAMPAIGN_PRICE(25000), + WEEKDAYS(7), + FRIDAY(1), + SATURDAY(2), + SUNDAY(3), + EVENT_PRICE(2023), + SANTA(20000), + TREE(10000), + STAR(5000), + MAX_MENU_COUNT(20), + KEY_INDEX(0), + VALUE_INDEX(1); + + private final int value; + + Constant(int value) { + this.value = value; + } + + public int get() { + return this.value; + } +}

Java

상수를 하나의 enum에 관리하신것 같은데, enum을 좀 분리해보면 어떨까요? 관련성이 없느 상수들끼리 한군데 몰려있다보니 어색하게 느껴집니다

@@ -0,0 +1,68 @@ +package christmas.model; + +import christmas.util.Constant; +import christmas.util.ErrorMessage; +import christmas.util.Utility; +import christmas.util.Validator; + +import java.util.ArrayList; +import java.util.Map; +import java.util.List; + +public class OrderMenu { + private final List<Map<String, Integer>> menu; + + private int orderDate; + private Map<String, Integer> userOrder; + + public OrderMenu() { + menu = new ArrayList<>(List.of( + // EPPETIZER 0 + Map.of("양송이수프", 6000, "타파스", 5500, "시저샐러드", 8000), + // MAINMENU 1 + Map.of("티본스테이크", 55000, "바비큐립", 54000, "해산물파스타", 35000, "크리스마스파스타", 25000), + // DESSERT 2 + Map.of("초코케이크", 15000, "아이스크림", 5000), + // BEVERAGE 3 + Map.of("제로콜라", 3000, "레드와인", 60000, "샴페인", 25000) + )); + } + + public int getOrderDate() { + return this.orderDate; + } + + public Map<String, Integer> getUserOrder() { + return this.userOrder; + } + + public int getTotalPrice() { + int totalPrice = Constant.ZERO.get(); + for (Map.Entry<String, Integer> entry : this.userOrder.entrySet()) { + int category = Utility.getCategory(entry.getKey(), menu); + int price = menu.get(category).get(entry.getKey()); + totalPrice += price * entry.getValue(); + } + return totalPrice; + } + + public int[] getCategoryCount() { + int[] categoryCount = new int[Constant.CATEGORY_COUNT.get()]; + for (Map.Entry<String, Integer> entry : this.userOrder.entrySet()) { + int category = Utility.getCategory(entry.getKey(), menu); + categoryCount[category] += entry.getValue(); + } + return categoryCount; + } + + public void setOrderDate(int date) { + this.orderDate = date; + } + + public void setUserOrder(Map<String, Integer> userOrder) { + if (Validator.validateMenu(userOrder, this.menu)) { + throw new IllegalArgumentException(ErrorMessage.ORDER_ERROR.get()); + } + this.userOrder = userOrder; + } +}

Java

menu를 list에 관리하셨군요 정답은 없는것 같다만 우테코에서 enum을 사용하라고 권장했으니 이런 메뉴들은 enum에서 관리하면 좀 더 좋지 않을까 생각이 듭니다!

@@ -0,0 +1,68 @@ +package christmas.model; + +import christmas.util.Constant; +import christmas.util.ErrorMessage; +import christmas.util.Utility; +import christmas.util.Validator; + +import java.util.ArrayList; +import java.util.Map; +import java.util.List; + +public class OrderMenu { + private final List<Map<String, Integer>> menu; + + private int orderDate; + private Map<String, Integer> userOrder; + + public OrderMenu() { + menu = new ArrayList<>(List.of( + // EPPETIZER 0 + Map.of("양송이수프", 6000, "타파스", 5500, "시저샐러드", 8000), + // MAINMENU 1 + Map.of("티본스테이크", 55000, "바비큐립", 54000, "해산물파스타", 35000, "크리스마스파스타", 25000), + // DESSERT 2 + Map.of("초코케이크", 15000, "아이스크림", 5000), + // BEVERAGE 3 + Map.of("제로콜라", 3000, "레드와인", 60000, "샴페인", 25000) + )); + } + + public int getOrderDate() { + return this.orderDate; + } + + public Map<String, Integer> getUserOrder() { + return this.userOrder; + } + + public int getTotalPrice() { + int totalPrice = Constant.ZERO.get(); + for (Map.Entry<String, Integer> entry : this.userOrder.entrySet()) { + int category = Utility.getCategory(entry.getKey(), menu); + int price = menu.get(category).get(entry.getKey()); + totalPrice += price * entry.getValue(); + } + return totalPrice; + } + + public int[] getCategoryCount() { + int[] categoryCount = new int[Constant.CATEGORY_COUNT.get()]; + for (Map.Entry<String, Integer> entry : this.userOrder.entrySet()) { + int category = Utility.getCategory(entry.getKey(), menu); + categoryCount[category] += entry.getValue(); + } + return categoryCount; + } + + public void setOrderDate(int date) { + this.orderDate = date; + } + + public void setUserOrder(Map<String, Integer> userOrder) { + if (Validator.validateMenu(userOrder, this.menu)) { + throw new IllegalArgumentException(ErrorMessage.ORDER_ERROR.get()); + } + this.userOrder = userOrder; + } +}

Java

클래스명은 OrderMenu인데 orderDate를 인스턴스 변수로 관리하는게 조금 어색하게 느껴집니다. 클래스 분리를 통해 orderDate와 관련한 클래스를 만들거나, OrderMenu의 클래스명이 메뉴와 날짜를 다 포함하게끔 생각이 들게끔 변경해보면 어떨까요?

@@ -0,0 +1,47 @@ +package christmas.controller; + +import java.util.Map; + +import christmas.view.*; +import christmas.model.*; + +public class MainController { + private OrderMenu orderMenu; + + public MainController() { + orderMenu = new OrderMenu(); + } + + public void run() { + orderMenu.setOrderDate(InputView.readDate()); + setReadOrder(); + + OutputView.printPreview(orderMenu.getOrderDate()); + OutputView.printOrder(orderMenu.getUserOrder()); + int totalPrice = orderMenu.getTotalPrice(); + OutputView.printTotalPrice(totalPrice); + OutputView.printPresent(totalPrice); + benefitControl(totalPrice); + } + + private void benefitControl(int totalPrice) { + Benefit benefit = new Benefit(orderMenu.getOrderDate(), orderMenu.getCategoryCount(), totalPrice); + OutputView.printBenefits(benefit.getBenefits()); + + int totalBenefitPrice = benefit.getTotalBenefitPrice(); + OutputView.printTotalBenefitPrice(totalBenefitPrice); + OutputView.printTotalPayment(totalPrice - totalBenefitPrice + benefit.getPresentPrice()); + OutputView.printEventBadge(totalBenefitPrice); + } + + private void setReadOrder() { + Map<String, Integer> orderMenu; + try { + orderMenu = InputView.readOrder(); + this.orderMenu.setUserOrder(orderMenu); + } catch (IllegalArgumentException e) { + System.out.println(e.getMessage()); + setReadOrder(); + } + } +}

Java

사실 제가 엄청 오래 찾아보고 고민한 부분이긴 한데 보통 사용하는 방식은 잘 몰라서 제가 생각한 대로 했습니다. 개인적으로 생각한 View 클래스는 상태를 갖고 있지 않고 인스턴스화를 할 필요가 없는 것 같아서 스태틱 클래스나 싱글톤 패턴을 주로 사용한다고 봤었는데, 과제에서 View를 상속할 일은 없을 것 같아서 스태틱 클래스로 구현했습니다. 일반적으로는 싱글톤 패턴을 사용하는 걸까요?

@@ -0,0 +1,39 @@ +package christmas.util; + +public enum Constant { + NOT_IN_MENU(-1), + EPPETIZER(0), + MAINMENU(1), + DESSERT(2), + BEVERAGE(3), + CATEGORY_COUNT(4), + ZERO(0), + ONE(1), + THOUSAND(1000), + HUNDRED(100), + CHRISTMAS_DAY(25), + MIN_BENEFIT_PRICE(10000), + PRESENT_COST(120000), + CHAMPAIGN_PRICE(25000), + WEEKDAYS(7), + FRIDAY(1), + SATURDAY(2), + SUNDAY(3), + EVENT_PRICE(2023), + SANTA(20000), + TREE(10000), + STAR(5000), + MAX_MENU_COUNT(20), + KEY_INDEX(0), + VALUE_INDEX(1); + + private final int value; + + Constant(int value) { + this.value = value; + } + + public int get() { + return this.value; + } +}

Java

enum의 사용 방법을 잘 몰랐던 것 같아요 감사합니다!

@@ -0,0 +1,47 @@ +package christmas.controller; + +import java.util.Map; + +import christmas.view.*; +import christmas.model.*; + +public class MainController { + private OrderMenu orderMenu; + + public MainController() { + orderMenu = new OrderMenu(); + } + + public void run() { + orderMenu.setOrderDate(InputView.readDate()); + setReadOrder(); + + OutputView.printPreview(orderMenu.getOrderDate()); + OutputView.printOrder(orderMenu.getUserOrder()); + int totalPrice = orderMenu.getTotalPrice(); + OutputView.printTotalPrice(totalPrice); + OutputView.printPresent(totalPrice); + benefitControl(totalPrice); + } + + private void benefitControl(int totalPrice) { + Benefit benefit = new Benefit(orderMenu.getOrderDate(), orderMenu.getCategoryCount(), totalPrice); + OutputView.printBenefits(benefit.getBenefits()); + + int totalBenefitPrice = benefit.getTotalBenefitPrice(); + OutputView.printTotalBenefitPrice(totalBenefitPrice); + OutputView.printTotalPayment(totalPrice - totalBenefitPrice + benefit.getPresentPrice()); + OutputView.printEventBadge(totalBenefitPrice); + } + + private void setReadOrder() { + Map<String, Integer> orderMenu; + try { + orderMenu = InputView.readOrder(); + this.orderMenu.setUserOrder(orderMenu); + } catch (IllegalArgumentException e) { + System.out.println(e.getMessage()); + setReadOrder(); + } + } +}

Java

다시 보니까 MainController가 적절한 이름이 아닌 것 같네요, 보통 모델과 컨트롤러의 관계가 1대 1로 이루어진다고 보면 되는 걸까요?

@@ -0,0 +1,39 @@ +package christmas.util; + +public enum Constant { + NOT_IN_MENU(-1), + EPPETIZER(0), + MAINMENU(1), + DESSERT(2), + BEVERAGE(3), + CATEGORY_COUNT(4), + ZERO(0), + ONE(1), + THOUSAND(1000), + HUNDRED(100), + CHRISTMAS_DAY(25), + MIN_BENEFIT_PRICE(10000), + PRESENT_COST(120000), + CHAMPAIGN_PRICE(25000), + WEEKDAYS(7), + FRIDAY(1), + SATURDAY(2), + SUNDAY(3), + EVENT_PRICE(2023), + SANTA(20000), + TREE(10000), + STAR(5000), + MAX_MENU_COUNT(20), + KEY_INDEX(0), + VALUE_INDEX(1); + + private final int value; + + Constant(int value) { + this.value = value; + } + + public int get() { + return this.value; + } +}

Java

상수처리에만 급급해서 분리하지 못했는데 지금 보니 가독성 측면에서도 좋지 않은 것 같네요. 이 부분은 꼭 수정해야겠습니다 감사합니다!