[로또] 한보은 미션 제출합니다.

.eslintrc.cjs

@@ -0,0 +1,28 @@
+module.exports = {
+  env: {
+    browser: true,
+    es2021: true,
+  },
+  extends: ['airbnb-base', 'prettier', 'jest'],
+  overrides: [
+    {
+      env: {
+        node: true,
+        jest: true,
+      },
+      files: ['.eslintrc.{js,cjs}'],
+      parserOptions: {
+        sourceType: 'script',
+      },
+    },
+  ],
+  parserOptions: {
+    ecmaVersion: 'latest',
+    sourceType: 'module',
+  },
+  rules: {
+    'max-depth': ['error', 2],
+    'max-params': ['error', 3],
+    'max-lines-per-function': ['error', { max: 15 }],
+  },
+};

.prettierrc

@@ -0,0 +1,11 @@
+{
+  "singleQuote": true,
+  "semi": true,
+  "useTabs": false,
+  "tabWidth": 2,
+  "trailingComma": "all",
+  "printWidth": 80,
+  "bracketSpacing": true,
+  "arrowParens": "always",
+  "endOfLine": "auto"
+}

__tests__/ApplicationTest.js

@@ -1,5 +1,5 @@
-import App from "../src/App.js";
-import { MissionUtils } from "@woowacourse/mission-utils";
+import App from '../src/App.js';
+import { MissionUtils } from '@woowacourse/mission-utils';
 
 const mockQuestions = (inputs) => {
   MissionUtils.Console.readLineAsync = jest.fn();
@@ -19,7 +19,7 @@ const mockRandoms = (numbers) => {
 };
 
 const getLogSpy = () => {
-  const logSpy = jest.spyOn(MissionUtils.Console, "print");
+  const logSpy = jest.spyOn(MissionUtils.Console, 'print');
   logSpy.mockClear();
   return logSpy;
 };
@@ -28,8 +28,8 @@ const runException = async (input) => {
   // given
   const logSpy = getLogSpy();
 
-  const RANDOM_NUMBERS_TO_END = [1,2,3,4,5,6];
-  const INPUT_NUMBERS_TO_END = ["1000", "1,2,3,4,5,6", "7"];
+  const RANDOM_NUMBERS_TO_END = [1, 2, 3, 4, 5, 6];
+  const INPUT_NUMBERS_TO_END = ['1000', '1,2,3,4,5,6', '7'];
 
   mockRandoms([RANDOM_NUMBERS_TO_END]);
   mockQuestions([input, ...INPUT_NUMBERS_TO_END]);
@@ -39,15 +39,15 @@ const runException = async (input) => {
   await app.play();
 
   // then
-  expect(logSpy).toHaveBeenCalledWith(expect.stringContaining("[ERROR]"));
-}
+  expect(logSpy).toHaveBeenCalledWith(expect.stringContaining('[ERROR]'));
+};
 
-describe("로또 테스트", () => {
+describe('로또 테스트', () => {
   beforeEach(() => {
     jest.restoreAllMocks();
-  })
+  });
 
-  test("기능 테스트", async () => {
+  test('기능 테스트', async () => {
     // given
     const logSpy = getLogSpy();
 
@@ -61,38 +61,37 @@ describe("로또 테스트", () => {
       [2, 13, 22, 32, 38, 45],
       [1, 3, 5, 14, 22, 45],
     ]);
-    mockQuestions(["8000", "1,2,3,4,5,6", "7"]);
+    mockQuestions(['8000', '1,2,3,4,5,6', '7']);
 
     // when
     const app = new App();
     await app.play();
 
     // then
     const logs = [
-      "8개를 구매했습니다.",
-      "[8, 21, 23, 41, 42, 43]",
-      "[3, 5, 11, 16, 32, 38]",
-      "[7, 11, 16, 35, 36, 44]",
-      "[1, 8, 11, 31, 41, 42]",
-      "[13, 14, 16, 38, 42, 45]",
-      "[7, 11, 30, 40, 42, 43]",
-      "[2, 13, 22, 32, 38, 45]",
-      "[1, 3, 5, 14, 22, 45]",
-      "3개 일치 (5,000원) - 1개",
-      "4개 일치 (50,000원) - 0개",
-      "5개 일치 (1,500,000원) - 0개",
-      "5개 일치, 보너스 볼 일치 (30,000,000원) - 0개",
-      "6개 일치 (2,000,000,000원) - 0개",
-      "총 수익률은 62.5%입니다.",
+      '8개를 구매했습니다.',
+      '[8, 21, 23, 41, 42, 43]',
+      '[3, 5, 11, 16, 32, 38]',
+      '[7, 11, 16, 35, 36, 44]',
+      '[1, 8, 11, 31, 41, 42]',
+      '[13, 14, 16, 38, 42, 45]',
+      '[7, 11, 30, 40, 42, 43]',
+      '[2, 13, 22, 32, 38, 45]',
+      '[1, 3, 5, 14, 22, 45]',
+      '3개 일치 (5,000원) - 1개',
+      '4개 일치 (50,000원) - 0개',
+      '5개 일치 (1,500,000원) - 0개',
+      '5개 일치, 보너스 볼 일치 (30,000,000원) - 0개',
+      '6개 일치 (2,000,000,000원) - 0개',
+      '총 수익률은 62.5%입니다.',
     ];
 
     logs.forEach((log) => {
       expect(logSpy).toHaveBeenCalledWith(expect.stringContaining(log));
     });
   });
 
-  test("예외 테스트", async () => {
-    await runException("1000j");
+  test('예외 테스트', async () => {
+    await runException('1000j');
   });
 });
-

__tests__/ComputerTest.js

@@ -0,0 +1,105 @@
+import { MissionUtils } from '@woowacourse/mission-utils';
+import Computer from '../src/Computer.js';
+import Lotto from '../src/Lotto.js';
+
+const getLogSpy = () => {
+  const logSpy = jest.spyOn(MissionUtils.Console, 'print');
+  logSpy.mockClear();
+  return logSpy;
+};
+
+describe('컴퓨터 기능 테스트', () => {
+  test.each([
+    { input: 1000, count: 1 },
+    { input: 10000, count: 10 },
+  ])('로또 발행 장수 테스트', async ({ input, count }) => {
+    const computer = new Computer();
+    computer.purchaseAmount = input;
+    await computer.issueLottoForPurchaseAmount();
+
+    expect(computer.lottos.length).toBe(count);
+  });
+
+  test('로또 결과 테스트', () => {
+    const computer = new Computer();
+    computer.lottos = [
+      new Lotto([8, 21, 23, 41, 42, 43]),
+      new Lotto([3, 5, 11, 16, 32, 38]),
+      new Lotto([7, 11, 16, 35, 36, 44]),
+      new Lotto([1, 8, 11, 31, 41, 42]),
+      new Lotto([13, 14, 16, 38, 42, 45]),
+      new Lotto([7, 11, 30, 40, 42, 43]),
+      new Lotto([2, 13, 22, 32, 38, 45]),
+      new Lotto([1, 3, 5, 14, 22, 45]),
+    ];
+    computer.winningNumbers = [1, 2, 3, 4, 5, 6];
+    computer.bonusNumber = 7;
+
+    expect(computer.getLottoResults()).toEqual([7, 0, 0, 0, 0, 1]);
+  });
+
+  test('로또 결과 출력 테스트', () => {
+    const computer = new Computer();
+
+    const mockGetLottoResults = (result) => {
+      computer.getLottoResults = jest.fn();
+      computer.getLottoResults.mockReturnValueOnce(result);
+    };
+    mockGetLottoResults([0, 1, 1, 0, 0, 3]);
+    const logSpy = getLogSpy();
+
+    computer.printLottoWinningStatistics();
+
+    const logs = [
+      '당첨 통계',
+      '---',
+      '3개 일치 (5,000원) - 3개',
+      '4개 일치 (50,000원) - 0개',
+      '5개 일치 (1,500,000원) - 0개',
+      '5개 일치, 보너스 볼 일치 (30,000,000원) - 1개',
+      '6개 일치 (2,000,000,000원) - 1개',
+    ];
+
+    logs.forEach((log) => {
+      expect(logSpy).toHaveBeenCalledWith(expect.stringContaining(log));
+    });
+  });
+
+  test.each([
+    { input: [0, 0, 0, 0, 0, 1], expected: 5000 },
+    { input: [0, 0, 0, 1, 1, 0], expected: 1550000 },
+    { input: [0, 1, 0, 0, 1, 0], expected: 2000050000 },
+    { input: [0, 0, 0, 0, 0, 2], expected: 10000 },
+    { input: [0, 0, 1, 2, 1, 0], expected: 33050000 },
+    { input: [0, 1, 1, 1, 1, 1], expected: 2031555000 },
+  ])('총 상금 계산 테스트', ({ input, expected }) => {
+    const computer = new Computer();
+    computer.result = input;
+
+    expect(computer.getTotalWinnings()).toEqual(expected);
+  });
+
+  test.each([
+    { input: 5000, expected: '총 수익률은 6.3%입니다.' },
+    { input: 10000, expected: '총 수익률은 12.5%입니다.' },
+    { input: 15000, expected: '총 수익률은 18.8%입니다.' },
+    { input: 1500000, expected: '총 수익률은 1,875.0%입니다.' },
+    { input: 30000000, expected: '총 수익률은 37,500.0%입니다.' },
+    { input: 20000000000, expected: '총 수익률은 25,000,000.0%입니다.' },
+  ])('총 수익률 출력 테스트', ({ input, expected }) => {
+    const computer = new Computer();
+
+    const mockGetTotalWinnings = (result) => {
+      computer.getTotalWinnings = jest.fn();
+      computer.getTotalWinnings.mockReturnValueOnce(result);
+    };
+
+    mockGetTotalWinnings(input);
+    const logSpy = getLogSpy();
+
+    computer.purchaseAmount = 80000;
+    computer.printTotalRateOfReturn();
+
+    expect(logSpy).toHaveBeenCalledWith(expect.stringContaining(expected));
+  });
+});

__tests__/ConverterTest.js

@@ -0,0 +1,31 @@
+import { NumberConverter, ArrayConverter } from '../src/utils/Converter.js';
+describe('숫자 변환 테스트', () => {
+  test.each([
+    { input: 1000, expected: '1,000' },
+    { input: 10000, expected: '10,000' },
+    { input: 1000000, expected: '1,000,000' },
+  ])('$input에 1000단위로 콤마를 찍으면, $expected가 반환된다.', ({ input, expected }) => {
+    expect(NumberConverter.splitIntoThreeDigitWithComma(input)).toBe(expected);
+  });
+
+  test.each([
+    { input: 1000.0, expected: '1,000.0' },
+    { input: 1000.12, expected: '1,000.1' },
+    { input: 1000.16, expected: '1,000.2' },
+    { input: 37500.0, expected: '37,500.0' },
+    { input: 25000000.0, expected: '25,000,000.0' },
+  ])('$input에 1000단위로 콤마를 찍으면, $expected가 반환된다.', ({ input, expected }) => {
+    expect(NumberConverter.splitIntoThreeDigitWithCommaContainingDecimalPoint(input, 1)).toBe(
+      expected,
+    );
+  });
+});
+
+describe('배열 문자열 변환 테스트', () => {
+  test.each([{ input: [1, 2, 3, 4, 5], expected: '[1, 2, 3, 4, 5]' }])(
+    '$input을 문자열로 변환하면, $expected가 반환된다.',
+    ({ input, expected }) => {
+      expect(ArrayConverter.convertArrayToString(input)).toBe(expected);
+    },
+  );
+});

__tests__/InputTest.js

@@ -0,0 +1,83 @@
+import InputValidator from '../src/InputValidator.js';
+
+describe('입력 유효성 검증 테스트', () => {
+  describe('로또 구입 금액 유효성 테스트', () => {
+    test('빈 값일 경우 예외를 발생시킨다.', () => {
+      expect(() => InputValidator.checkPurchaseAmount('')).toThrow('[ERROR]');
+    });
+
+    test.each(['abc', 'ㄱㄴㄷ'])('숫자가 아닐 경우 예외를 발생시킨다.', (input) => {
+      expect(() => InputValidator.checkPurchaseAmount(input)).toThrow('[ERROR]');
+    });
+
+    test.each(['-1000', '0'])('0 이하의 숫자일 경우 예외를 발생시킨다.', (input) => {
+      expect(() => InputValidator.checkPurchaseAmount(input)).toThrow('[ERROR]');
+    });
+
+    test.each(['1', '100', '1234'])(
+      '1000으로 나누어떨어지지 않는 숫자일 경우 예외를 발생시킨다.',
+      (input) => {
+        expect(() => InputValidator.checkPurchaseAmount(input)).toThrow('[ERROR]');
+      },
+    );
+
+    test.each(['1000', '10000'])('값이 올바를 경우 예외를 발생시키지 않는다.', (input) => {
+      expect(() => InputValidator.checkPurchaseAmount(input)).not.toThrow('[ERROR]');
+    });
+  });
+
+  describe('당첨 번호 유효성 테스트', () => {
+    test('빈 값일 경우 예외를 발생시킨다.', () => {
+      expect(() => InputValidator.checkWinningNumbers('')).toThrow('[ERROR]');
+    });
+
+    test.each(['abc,1,2,3,4,5', '1,2,3,4,5,ㄱㄴㄷ'])(
+      '숫자가 아닐 경우 예외를 발생시킨다.',
+      (input) => {
+        expect(() => InputValidator.checkWinningNumbers(input)).toThrow('[ERROR]');
+      },
+    );
+
+    test.each(['-1000,1,2,3,4,5', '1,2,3,4,5,0'])(
+      '0 이하의 숫자일 경우 예외를 발생시킨다.',
+      (input) => {
+        expect(() => InputValidator.checkWinningNumbers(input)).toThrow('[ERROR]');
+      },
+    );
+
+    test.each(['1,2,3,4', '1,2,3,4,5,6,7'])(
+      '숫자가 6개가 아닐 경우 예외를 발생시킨다.',
+      (input) => {
+        expect(() => InputValidator.checkWinningNumbers(input)).toThrow('[ERROR]');
+      },
+    );
+
+    test.each(['1,2,3,4,4,4', '1,1,1,1,1,1'])('숫자가 중복될 경우 예외를 발생시킨다.', (input) => {
+      expect(() => InputValidator.checkWinningNumbers(input)).toThrow('[ERROR]');
+    });
+
+    test('값이 올바를 경우 예외를 발생시키지 않는다.', () => {
+      expect(() => InputValidator.checkWinningNumbers('1,2,3,4,5,6')).not.toThrow('[ERROR]');
+    });
+  });
+
+  describe('보너스 번호 유효성 테스트', () => {
+    const winningNumbers = [1, 2, 3, 4, 5, 6];
+
+    test('빈 값일 경우 예외를 발생시킨다.', () => {
+      expect(() => InputValidator.checkBonusNumber(winningNumbers, '')).toThrow('[ERROR]');
+    });
+
+    test.each(['abc', 'ㄱㄴㄷ'])('숫자가 아닐 경우 예외를 발생시킨다.', (input) => {
+      expect(() => InputValidator.checkBonusNumber(winningNumbers, input)).toThrow('[ERROR]');
+    });
+
+    test('당첨 번호에 존재하는 번호일 경우 예외를 발생시킨다.', () => {
+      expect(() => InputValidator.checkBonusNumber(winningNumbers, '6')).toThrow('[ERROR]');
+    });
+
+    test('값이 올바를 경우 예외를 발생시키지 않는다.', () => {
+      expect(() => InputValidator.checkBonusNumber(winningNumbers, '7')).not.toThrow('[ERROR]');
+    });
+  });
+});