[정찬욱] 자동차 경주 미션 Step2

src/__tests__/Race.test.js

@@ -1,15 +1,7 @@
 import { describe, expect, test } from "vitest";
-import { Car, Race } from "../domain/index.js";
+import { Racer, Race } from "../domain/index.js";
 
 describe("Race 클래스 테스트", () => {
-  test("레이서가 Racer 클래스의 자식 클래스가 아니면 오류가 발생한다.", () => {
-    expect(() => new Race({}, 1)).toThrowError();
-  });
-
-  test("레이서가 Racer 클래스의 자식 클래스면 오류가 발생하지 않는다.", () => {
-    expect(() => new Race(Car, 1)).not.toThrowError();
-  });
-
   test.each([
     { value: "1" },
     { value: true },
@@ -20,21 +12,21 @@ describe("Race 클래스 테스트", () => {
   ])(
     "레이스 횟수로 숫자가 아닌 값($value)을 할당하면 오류가 발생한다.",
     ({ value }) => {
-      expect(() => new Race(Car, value)).toThrowError();
+      expect(() => new Race(value)).toThrowError();
     }
   );
 
   test("레이스 횟수로 숫자를 할당하면 오류가 발생하지 않는다.", () => {
-    expect(() => new Race(Car, 1)).not.toThrowError();
+    expect(() => new Race(1)).not.toThrowError();
   });
 
   test("레이스 횟수가 0이하면 오류가 발생한다.", () => {
-    expect(() => new Race(Car, 0)).toThrowError();
-    expect(() => new Race(Car, -1)).toThrowError();
+    expect(() => new Race(0)).toThrowError();
+    expect(() => new Race(-1)).toThrowError();
   });
 
   test("레이스 횟수가 1이상이면 오류가 발생하지 않는다.", () => {
-    expect(() => new Race(Car, 1)).not.toThrowError();
+    expect(() => new Race(1)).not.toThrowError();
   });
 
   test.each([
@@ -45,67 +37,124 @@ describe("Race 클래스 테스트", () => {
     { value: null },
     { value: {} },
   ])(
-    "레이스 준비시 배열이 아닌 값($value)을 할당하면 오류가 발생한다.",
+    "레이스 시작시 배열이 아닌 값($value)을 할당하면 오류가 발생한다.",
     ({ value }) => {
-      const race = createCarRaceWith5Laps();
+      const race = createRaceWith5Laps();
 
-      expect(() => race.ready(value)).toThrowError(
-        "경기 준비에 적합하지 않은 입력값입니다."
+      expect(() => race.start(value)).toThrowError(
+        "레이스 시작에 적합하지 않은 입력값입니다."
       );
     }
   );
 
-  test("레이스 준비시 배열을 할당하면 오류가 발생하지 않는다.", () => {
-    const race = createCarRaceWith5Laps();
-
-    expect(() => race.ready(["1", "2"])).not.toThrowError();
-  });
+  test("레이스 시작의 입력값이 0개 이하면 오류가 발생한다.", () => {
+    const race = createRaceWith5Laps();
 
-  test("레이스 준비의 입력값이 0개 이하면 오류가 발생한다.", () => {
-    const race = createCarRaceWith5Laps();
-
-    expect(() => race.ready([])).toThrowError(
-      "경기를 준비하기엔 레이서가 부족합니다."
+    expect(() => race.start([])).toThrowError(
+      "레이스를 시작하기엔 레이서가 부족합니다."
     );
   });
 
-  test("레이스 준비의 입력값이 1개 이상이면 오류가 발생하지 않는다.", () => {
-    const race = createCarRaceWith5Laps();
+  test("레이스 시작의 입력값이 레이서들이면 오류가 발생하지 않는다.", () => {
+    const race = createRaceWith5Laps();
 
-    expect(() => race.ready(["1"])).not.toThrowError();
+    expect(() => race.start([new Racer("1")])).not.toThrowError();
   });
 
   test("레이스 시작전에 기록을 가져오면 빈배열입니다.", () => {
-    const race = createCarRaceWith5Laps();
-    race.ready(["1", "2"]);
+    const race = createRaceWith5Laps();
 
     expect(race.records).toEqual([]);
   });
 
   test("레이스 시작후에 기록을 알 수 있습니다.", () => {
-    const race = createCarRaceWith5Laps();
-    race.ready(["1", "2"]);
-    race.start();
+    const race = createRaceWith5Laps();
+    race.start([new Racer("1"), new Racer("2")]);
 
     expect(race.records).toHaveLength(5);
   });
 
   test("레이스 시작전에 우승자를 가져오면 빈배열입니다.", () => {
-    const race = createCarRaceWith5Laps();
-    race.ready(["1", "2"]);
+    const race = createRaceWith5Laps();
 
     expect(race.winners).toEqual([]);
   });
 
-  test("레이스 우승자는 1이상입니다..", () => {
-    const race = createCarRaceWith5Laps();
-    race.ready(["1", "2"]);
-    race.start();
+  test("레이스 우승자는 1이상입니다.", () => {
+    const race = createRaceWith5Laps();
+    race.start([new Racer("1"), new Racer("2")]);
 
     expect(race.winners.length).toBeGreaterThanOrEqual(1);
   });
+
+  test.each([
+    { value: 1 },
+    { value: "str" },
+    { value: true },
+    { value: null },
+    { value: {} },
+  ])(
+    "레이스 규칙에 적합하지 않은 입력값($value)이면 오류가 발생합니다.",
+    ({ value }) => {
+      const race = createRaceWith5Laps();
+
+      expect(() =>
+        race.start([new Racer("1"), new Racer("2")], value)
+      ).toThrowError("레이스 규칙에 적합하지 않은 입력값입니다.");
+    }
+  );
+
+  test("레이스 규칙이 1개미만이면 오류가 발생한다.", () => {
+    const race = createRaceWith5Laps();
+
+    expect(() => race.start([new Racer("1"), new Racer("2")], [])).toThrowError(
+      "레이스를 시작하기엔 규칙이 부족합니다."
+    );
+  });
+
+  test.each([
+    { value: 1 },
+    { value: "str" },
+    { value: true },
+    { value: undefined },
+    { value: null },
+    { value: [] },
+    { value: {} },
+  ])(
+    "레이스 규칙이 함수가 아닌 값($value)이면 오류가 발생한다.",
+    ({ value }) => {
+      const race = createRaceWith5Laps();
+
+      expect(() =>
+        race.start([new Racer("1"), new Racer("2")], [value])
+      ).toThrowError("레이스 규칙은 함수여야 합니다.");
+    }
+  );
+
+  test.each([
+    { fn: () => 1 },
+    { fn: () => "str" },
+    { fn: () => undefined },
+    { fn: () => null },
+    { fn: () => [] },
+    { fn: () => {} },
+  ])("레이스 규칙의 반환값이 불린값이 아니면 오류가 발생한다.", ({ fn }) => {
+    const race = createRaceWith5Laps();
+
+    expect(() =>
+      race.start([new Racer("1"), new Racer("2")], [fn])
+    ).toThrowError("레이스 규칙의 반환값으로 적합하지 않습니다.");
+  });
+
+  test("레이스 규칙이 불린값을 반환하는 함수이면 오류가 발생하지 않는다.", () => {
+    const race = createRaceWith5Laps();
+
+    expect(() =>
+      race.start([new Racer("1"), new Racer("2")], [() => true])
+    ).not.toThrowError();
+  });
 });
 
-function createCarRaceWith5Laps() {
-  return new Race(Car, 5);
+function createRaceWith5Laps() {
+  return new Race(5);
 }

src/__tests__/RaceEntry.test.js

@@ -0,0 +1,68 @@
+import { describe, expect, test, vi } from "vitest";
+import { Race, RaceEntry } from "../domain/index.js";
+import { inputManager } from "../service/index.js";
+
+vi.mock("../service/index.js");
+
+function retryScanMock(inputValue) {
+  inputManager.retryScan.mockImplementationOnce(async (_, processFn) => {
+    return processFn(inputValue);
+  });
+}
+
+describe("RaceEntry 클래스 테스트", () => {
+  test("올바른 유형을 선택하지 않으면 오류가 발생한다.", async () => {
+    retryScanMock("5");
+
+    const register = new RaceEntry();
+
+    await expect(register.selectEntityType()).rejects.toThrowError(
+      "올바른 유형의 번호가 아닙니다."
+    );
+  });
+
+  test("올바른 유형을 선택하면 오류가 발생하지 않는다.", async () => {
+    retryScanMock("1");
+
+    const register = new RaceEntry();
+
+    await expect(register.selectEntityType()).resolves.not.toThrowError();
+  });
+
+  test("레이스 횟수로 정수가 아닌 값을 입력하면 오류가 발생한다.", async () => {
+    retryScanMock("a");
+
+    const register = new RaceEntry();
+
+    await expect(register.setRaceLaps()).rejects.toThrowError(
+      "시도할 횟수로 정수를 입력해야 합니다."
+    );
+  });
+
+  test("레이스 횟수로 0이하를 입력하면 오류가 발생한다.", async () => {
+    retryScanMock("0");
+
+    const register = new RaceEntry();
+
+    await expect(register.setRaceLaps()).rejects.toThrowError(
+      "시도할 횟수는 1이상이어야 합니다."
+    );
+  });
+
+  test("레이스 횟수로 1이상을 입력하면 오류가 발생하지 않는다.", async () => {
+    retryScanMock("1");
+
+    const register = new RaceEntry();
+
+    await expect(register.setRaceLaps()).resolves.not.toThrowError();
+  });
+
+  test("레이스 횟수를 설정하면 Race 클래스 인스턴스를 반환받는다.", async () => {
+    retryScanMock("1");
+    const register = new RaceEntry();
+
+    const race = await register.setRaceLaps();
+
+    expect(race).toEqual(new Race(1));
+  });
+});

src/__tests__/RaceScoreboard.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "vitest";
-import { Car, Race, RaceScoreboard } from "../domain/index.js";
+import { Race, RaceScoreboard } from "../domain/index.js";
 
 describe("RaceScoreboard 클래스 테스트", () => {
   test("Race 클래스의 인스턴스를 할당하지 않으면 오류가 발생한다.", () => {
@@ -10,9 +10,9 @@ describe("RaceScoreboard 클래스 테스트", () => {
     expect(() => new RaceScoreboard(person)).toThrowError();
   });
 
-  test("Race 클래스의 인스턴스를 할당하면 오류가 발생한다.", () => {
-    const carRace = new Race(Car, 5);
+  test("Race 클래스의 인스턴스를 할당하면 오류가 발생하지 않는다.", () => {
+    const race = new Race(5);
 
-    expect(() => new RaceScoreboard(carRace)).not.toThrowError();
+    expect(() => new RaceScoreboard(race)).not.toThrowError();
   });
 });

src/__tests__/Racer.test.js

@@ -1,27 +1,55 @@
-import { beforeEach, describe, expect, test } from "vitest";
+import { describe, expect, test } from "vitest";
 import { Racer } from "../domain/index.js";
 
 describe("Racer 클래스 테스트", () => {
-  let racer;
-
-  beforeEach(() => {
-    racer = new Racer(" jeong ");
-  });
-
-  test("레이서의 이름 앞뒤 공백은 제거된다.", () => {
-    expect(racer.name).toHaveLength(5);
-  });
-
   test("레이서에 이름을 지어줄 수 있다.", () => {
-    expect(racer.name).toBe("jeong");
+    const racer = new Racer("tom");
+
+    expect(racer.name).toBe("tom");
   });
 
   test("레이서는 움직일 수 있다.", () => {
+    const racer = createRacerWithName();
+
     racer.move();
 
     expect(racer.position).toBe(1);
   });
 
+  test.each([
+    { value: 1.1 },
+    { value: "1" },
+    { value: true },
+    { value: null },
+    { value: {} },
+  ])(
+    "레이서의 이동 거리로 정수가 아닌 값($value)을 할당하면 오류가 발생한다.",
+    ({ value }) => {
+      const racer = createRacerWithName();
+
+      expect(() => racer.move(value)).toThrowError();
+    }
+  );
+
+  test.each([2, 3, 4, 5])(
+    "레이서의 이동 거리(%i)를 지정할 수 있다.",
+    (distance) => {
+      const racer = createRacerWithName();
+
+      racer.move(distance);
+
+      expect(racer.position).toBe(distance);
+    }
+  );
+
+  test("레이서의 위치는 0미만이 될 수 없다.", () => {
+    const racer = createRacerWithName();
+
+    racer.move(-1);
+
+    expect(racer.position).toBe(0);
+  });
+
   test("레이서의 이름을 수정하려고 하면 오류가 발생한다.", () => {
     const racer = createRacerWithName();