[로또] 주유나 미션 제출합니다.

README.md

@@ -1 +1,66 @@
 # javascript-lotto-precourse
+
+# 🎰 로또
+
+## 📋 구현 기능 목록
+
+---
+
+### 1️⃣ 로또 구입 금액 입력
+
+- [x] 금액 입력 받기
+- [x] 1,000원 단위인지 검증
+- [x] 1,000원 미만 또는 1,000으로 나누어떨어지지 않으면 `[ERROR]` 출력 후 **해당 입력부터 다시 받기**
+
+---
+
+### 2️⃣ 로또 발행
+
+- [x] 구입 금액 ÷ 1,000 = 발행 개수 계산
+- [x] 랜덤으로 로또 번호 생성
+- [x] 1개 로또는 중복 없는 6개 번호
+- [x] 번호는 **오름차순 정렬**해서 보관
+- [x] `N개를 구매했습니다.` 출력 후 각 로또 번호를 `[1, 2, 3, 4, 5, 6]` 형식으로 출력
+
+---
+
+### 3️⃣ 당첨 번호 입력
+
+- [x] 당첨 번호 입력 받기
+- [x] 쉼표(,) 기준으로 6개인지 검증
+- [x] 각 숫자가 1~45 범위인지 검증
+- [x] 중복 숫자 없도록 검증
+- [x] 잘못되면 `[ERROR] ...` 출력 후 **당첨 번호부터 다시 받기**
+
+---
+
+### 4️⃣ 보너스 번호 입력
+
+- [x] 보너스 번호 입력 받기
+- [x] 1~45 범위 검증
+- [x] 당첨 번호와 **겹치지 않도록** 검증
+- [x] 잘못되면 `[ERROR] ...` 출력 후 **보너스 번호부터 다시 받기**
+
+---
+
+### 5️⃣ 당첨 통계 계산
+
+- [x] 사용자가 구매한 모든 로또와 당첨 번호를 비교
+- [x] 일치 개수에 따라 3개/4개/5개/5개+보너스/6개 집계
+- [x] 등수별 상금 합계 계산
+
+---
+
+### 6️⃣ 수익률 계산 및 출력
+
+- [x] 총 상금 ÷ 구입 금액 × 100
+- [x] 소수점 둘째 자리에서 반올림해 **소수 첫째 자리까지만** 출력 (예: `62.5%`)
+- [x] `총 수익률은 62.5%입니다.` 형식으로 출력
+
+---
+
+### 7️⃣ 예외 처리 및 재입력
+
+- [x] 잘못된 값 입력 시 `[ERROR]`로 시작하는 메시지를 출력
+- [x] **예외를 던지되**(throw), `App`에서 잡아서 해당 단계만 다시 입력
+- [x] `process.exit()` 사용하지 않음

__tests__/ApplicationTest.js

@@ -94,4 +94,56 @@ describe("로또 테스트", () => {
   test("예외 테스트", async () => {
     await runException("1000j");
   });
+
+  test("구입 금액이 1000원 단위가 아니면 다시 입력을 받는다", async () => {
+    const logSpy = getLogSpy();
+    mockRandoms([
+      [1, 2, 3, 4, 5, 6],
+      [7, 8, 9, 10, 11, 12],
+      [13, 14, 15, 16, 17, 18],
+      [19, 20, 21, 22, 23, 24],
+      [25, 26, 27, 28, 29, 30],
+    ]);
+    mockQuestions(["8500", "2000", "1,2,3,4,5,6", "7"]);
+
+    const app = new App();
+    await app.run();
+
+    expect(logSpy).toHaveBeenCalledWith(
+      expect.stringContaining("[ERROR] 구입 금액은 1,000원 단위여야 합니다.")
+    );
+    expect(logSpy).toHaveBeenCalledWith(
+      expect.stringContaining("2개를 구매했습니다.")
+    );
+  });
+
+  test("당첨 번호가 6개가 아니면 다시 입력을 받는다", async () => {
+    const logSpy = getLogSpy();
+    mockRandoms([[1, 2, 3, 4, 5, 6]]);
+    mockQuestions(["1000", "1,2,3,4,5", "1,2,3,4,5,6", "7"]);
+
+    const app = new App();
+    await app.run();
+
+    expect(logSpy).toHaveBeenCalledWith(
+      expect.stringContaining("[ERROR] 당첨 번호는 6개여야 합니다.")
+    );
+    expect(logSpy).toHaveBeenCalledWith(expect.stringContaining("당첨 통계"));
+  });
+
+  test("보너스 번호가 당첨 번호와 중복되면 다시 입력을 받는다", async () => {
+    const logSpy = getLogSpy();
+    mockRandoms([[1, 2, 3, 4, 5, 6]]);
+    mockQuestions(["1000", "1,2,3,4,5,6", "3", "7"]);
+
+    const app = new App();
+    await app.run();
+
+    expect(logSpy).toHaveBeenCalledWith(
+      expect.stringContaining(
+        "[ERROR] 보너스 번호는 당첨 번호와 중복될 수 없습니다."
+      )
+    );
+    expect(logSpy).toHaveBeenCalledWith(expect.stringContaining("당첨 통계"));
+  });
 });

__tests__/LottoTest.js

@@ -14,5 +14,16 @@ describe("로또 클래스 테스트", () => {
     }).toThrow("[ERROR]");
   });
 
-  // TODO: 추가 기능 구현에 따른 테스트 코드 작성
+  test("로또 번호가 6개 보다 적으면 예외가 발생한다.", () => {
+    expect(() => new Lotto([1, 2, 3, 4, 5]).toThrow("[ERROR]"));
+  });
+
+  test("로또 번호가 1~45 범위를 벗어나면 예외가 발생한다.", () => {
+    expect(() => new Lotto([0, 2, 3, 4, 5, 6])).toThrow("[ERROR]");
+    expect(() => new Lotto([1, 2, 3, 4, 5, 100])).toThrow("[ERROR]");
+  });
+
+  test("유효한 로또 번호 6개라면 예외가 발생하지 않는다.", () => {
+    expect(() => new Lotto([1, 2, 3, 4, 5, 6])).not.toThrow();
+  });
 });

src/App.js

@@ -1,5 +1,37 @@
+import { LOTTO_PRICE } from "./constants/constants.js";
+import InputHandler from "./InputHandler.js";
+import LottoService from "./LottoService.js";
+import { printNewLine } from "./utils/output.js";
+
 class App {
-  async run() {}
+  #inputHandler;
+  #lottoService;
+
+  constructor() {
+    this.#inputHandler = new InputHandler();
+    this.#lottoService = new LottoService();
+  }
+
+  async run() {
+    const purchaseAmount = await this.#inputHandler.readPurchaseAmount();
+    const ticketCount = purchaseAmount / LOTTO_PRICE;
+    printNewLine();
+
+    const tickets = this.#lottoService.publishLottos(ticketCount);
+    this.#lottoService.printTickets(tickets);
+
+    const winningNumbers = await this.#inputHandler.readWinningNumbers();
+    const bonusNumber = await this.#inputHandler.readBonusNumber(
+      winningNumbers
+    );
+
+    const stats = this.#lottoService.calculateStats(
+      tickets,
+      winningNumbers,
+      bonusNumber
+    );
+    this.#lottoService.printStats(stats, purchaseAmount);
+  }
 }
 
 export default App;

src/InputHandler.js

@@ -0,0 +1,117 @@
+import { Console } from "@woowacourse/mission-utils";
+import {
+  LOTTO_COUNT,
+  LOTTO_MAX,
+  LOTTO_MIN,
+  LOTTO_PRICE,
+  NUMBER_REGEX,
+} from "./constants/constants.js";
+import { ERROR_MESSAGES, INPUT_MESSAGES } from "./constants/messages.js";
+import { printNewLine } from "./utils/output.js";
+
+class InputHandler {
+  async readPurchaseAmount() {
+    while (true) {
+      const input = await Console.readLineAsync(INPUT_MESSAGES.PURCHASE_AMOUNT);
+      try {
+        return this.#parsePurchaseAmount(input);
+      } catch (error) {
+        Console.print(error.message);
+      }
+    }
+  }
+
+  #trimInput(input) {
+    return (input ?? "").trim();
+  }
+
+  #parseNumber(input, errorMessage = ERROR_MESSAGES.LOTTO_NUMBER_OUT_OF_RANGE) {
+    if (!NUMBER_REGEX.test(input)) {
+      throw new Error(errorMessage);
+    }
+    return Number(input);
+  }
+
+  #parsePurchaseAmount(input) {
+    const trimmedInput = this.#trimInput(input);
+    const amount = this.#parseNumber(
+      trimmedInput,
+      ERROR_MESSAGES.PURCHASE_AMOUNT_NOT_NUMBER
+    );
+
+    if (amount < LOTTO_PRICE) {
+      throw new Error(ERROR_MESSAGES.PURCHASE_AMOUNT_TOO_LOW);
+    }
+    if (amount % LOTTO_PRICE !== 0) {
+      throw new Error(ERROR_MESSAGES.PURCHASE_AMOUNT_NOT_DIVISIBLE);
+    }
+    return amount;
+  }
+
+  async readWinningNumbers() {
+    printNewLine();
+    while (true) {
+      const input = await Console.readLineAsync(INPUT_MESSAGES.WINNING_NUMBERS);
+      try {
+        return this.#parseWinningNumbers(input);
+      } catch (error) {
+        Console.print(error.message);
+      }
+    }
+  }
+
+  #parseWinningNumbers(input) {
+    const trimmedInput = this.#trimInput(input);
+    const parts = trimmedInput.split(",").map((value) => value.trim());
+    if (parts.length !== LOTTO_COUNT) {
+      throw new Error(ERROR_MESSAGES.WINNING_NUMBERS_COUNT_INVALID);
+    }
+
+    const numbers = parts.map((numberString) =>
+      this.#parseNumber(numberString)
+    );
+    this.#validateLottoNumbers(numbers);
+
+    const unique = new Set(numbers);
+    if (unique.size !== LOTTO_COUNT) {
+      throw new Error(ERROR_MESSAGES.WINNING_NUMBERS_DUPLICATE);
+    }
+    return numbers;
+  }
+
+  #validateLottoNumbers(numbers) {
+    if (
+      !numbers.every(
+        (number) =>
+          Number.isInteger(number) && number >= LOTTO_MIN && number <= LOTTO_MAX
+      )
+    ) {
+      throw new Error(ERROR_MESSAGES.LOTTO_NUMBER_OUT_OF_RANGE);
+    }
+  }
+
+  async readBonusNumber(winningNumbers) {
+    printNewLine();
+    while (true) {
+      const input = await Console.readLineAsync(INPUT_MESSAGES.BONUS_NUMBER);
+      try {
+        return this.#parseBonusNumber(input, winningNumbers);
+      } catch (error) {
+        Console.print(error.message);
+      }
+    }
+  }
+
+  #parseBonusNumber(input, winningNumbers) {
+    const trimmedInput = this.#trimInput(input);
+    const bonus = this.#parseNumber(trimmedInput);
+    this.#validateLottoNumbers([bonus]);
+
+    if (winningNumbers.includes(bonus)) {
+      throw new Error(ERROR_MESSAGES.BONUS_NUMBER_DUPLICATE);
+    }
+    return bonus;
+  }
+}
+
+export default InputHandler;

src/Lotto.js

@@ -1,3 +1,6 @@
+import { LOTTO_COUNT, LOTTO_MAX, LOTTO_MIN } from "./constants/constants.js";
+import { ERROR_MESSAGES } from "./constants/messages.js";
+
 class Lotto {
   #numbers;
 
@@ -7,12 +10,24 @@ class Lotto {
   }
 
   #validate(numbers) {
-    if (numbers.length !== 6) {
-      throw new Error("[ERROR] 로또 번호는 6개여야 합니다.");
+    if (numbers.length !== LOTTO_COUNT) {
+      throw new Error(ERROR_MESSAGES.LOTTO_NUMBERS_COUNT_INVALID);
+    }
+
+    if (
+      !numbers.every(
+        (number) =>
+          Number.isInteger(number) && number >= LOTTO_MIN && number <= LOTTO_MAX
+      )
+    ) {
+      throw new Error(ERROR_MESSAGES.LOTTO_NUMBER_OUT_OF_RANGE);
     }
-  }
 
-  // TODO: 추가 기능 구현
+    const uniqueCount = new Set(numbers).size;
+    if (uniqueCount !== LOTTO_COUNT) {
+      throw new Error(ERROR_MESSAGES.LOTTO_NUMBERS_DUPLICATE);
+    }
+  }
 }
 
 export default Lotto;