refactor : 테스트용 생성자 제거

README.md

@@ -95,19 +95,16 @@ ResultView : 결과를 출력
    - [x] `Game` 클래스 수정
      - [x] 경주 종료 후 우승자 출력 로직 추가
 
-5. **테스트 추가**
-
-   - [ ] `RaceTest`에 우승자 판정 테스트 추가
-     - [ ] 단일 우승자 케이스
-     - [ ] 다중 우승자 케이스
-   - [ ] `InputViewTest` 추가
-     - [ ] 자동차 이름 입력 테스트
-     - [ ] 잘못된 입력 처리 테스트
-
-6. **리팩토링 고려사항**
-   - [ ] `Car` 클래스에 `Position` 값 객체 도입 검토
-   - [ ] `CarName` 값 객체 도입 검토
-   - [ ] `CarStatus` DTO 도입 검토 (이름과 위치를 함께 전달하기 위해)
+### 개발 구조
+
+- **Game**: 게임의 전체 생명주기 관리 및 사용자 인터랙션 조정
+- **Race**: 경주 진행 상태 관리, 자동차 이동 처리, 우승자 판정
+- **GameSettings**: 게임 설정값(자동차 이름, 라운드 수) 검증 및 관리
+- **Car**: 자동차의 기본 속성(이름, 위치) 관리
+- **InputView**: 사용자 입력 처리 및 검증
+- **ResultView**: 게임 진행 상태 및 결과 출력
+- **CarStatus**: 자동차의 현재 상태를 불변 객체로 표현
+- **MoveStrategy**: 자동차 이동 전략 정의 (RandomMoveStrategy, FixedMoveStrategy)
 
 ### 프로그래밍 요구사항
 

src/main/java/Car.java

@@ -1,6 +1,5 @@
 public class Car {
 
-    private static final int MOVEMENT_THRESHOLD = 4;
     private final String name;
     private int position = 0;
 
@@ -9,13 +8,6 @@ public Car(String name) {
         this.name = name.trim();
     }
 
-    // 테스트용 생성자
-    Car(String name, int position) {
-        validateName(name);
-        this.name = name.trim();
-        this.position = position;
-    }
-
     private void validateName(String name) {
         if (name == null || name.trim().isBlank()) {
             throw new IllegalArgumentException("Name cannot be blank");
@@ -25,12 +17,8 @@ private void validateName(String name) {
         }
     }
 
-    public void move(int seed) {
-        if (seed < 0 || seed > 9) {
-            throw new IllegalArgumentException("Invalid seed: " + seed);
-        }
-
-        if (seed >= MOVEMENT_THRESHOLD) {
+    public void move(boolean shouldMove) {
+        if (shouldMove) {
             position++;
         }
     }

src/main/java/MoveStrategy.java

@@ -0,0 +1,4 @@
+@FunctionalInterface
+public interface MoveStrategy {
+    boolean shouldMove();
+} 

src/main/java/Race.java

@@ -4,24 +4,22 @@
 
 public class Race {
 
-    private static final Random random = new Random();
+    private final MoveStrategy moveStrategy;
     private final int totalRounds;
     private final List<Car> cars;
     private int currentRound = 0;
 
     public Race(GameSettings settings) {
+        this(settings, new RandomMoveStrategy());
+    }
+
+    public Race(GameSettings settings, MoveStrategy moveStrategy) {
         this.totalRounds = settings.getRoundCount();
         this.cars = new ArrayList<>();
         for (String carName : settings.getCarNames()) {
             this.cars.add(new Car(carName));
         }
-    }
-
-    // 테스트용 생성자
-    Race(List<Car> cars, int totalRounds) {
-        this.cars = new ArrayList<>(cars);
-        this.totalRounds = totalRounds;
-        this.currentRound = totalRounds;  // 경주가 끝난 상태로 설정
+        this.moveStrategy = moveStrategy;
     }
 
     public List<CarStatus> getCarStatuses() {
@@ -35,7 +33,7 @@ public List<CarStatus> getCarStatuses() {
     public void runRound() {
         validateRaceInProgress();
         for (Car car : cars) {
-            car.move(random.nextInt(10));
+            car.move(moveStrategy.shouldMove());
         }
         currentRound++;
     }

src/main/java/RandomMoveStrategy.java

@@ -0,0 +1,11 @@
+import java.util.Random;
+
+public class RandomMoveStrategy implements MoveStrategy {
+    private static final int MOVE_THRESHOLD = 4;
+    private final Random random = new Random();
+
+    @Override
+    public boolean shouldMove() {
+        return random.nextInt(10) >= MOVE_THRESHOLD;
+    }
+} 

src/test/java/CarTest.java

@@ -5,7 +5,6 @@
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.CsvSource;
-import org.junit.jupiter.params.provider.ValueSource;
 
 class CarTest {
 
@@ -35,19 +34,11 @@ void carNameCannotExceed5Characters() {
     }
 
     @ParameterizedTest
-    @DisplayName("random값이 4 이상일 경우에 자동차의 위치는 1 추가되고, 4 미만일 경우 위치가 변하지 않는다")
-    @CsvSource({"0, 0", "1, 0", "2, 0", "3, 0", "4, 1", "5, 1", "6, 1", "7, 1", "8, 1", "9, 1"})
-    void carMovesAccordingToRandomValue(int seed, int expectedPosition) {
+    @DisplayName("shouldMove가 true일 경우 자동차의 위치는 1 추가되고, false일 경우 위치가 변하지 않는다")
+    @CsvSource({"false, 0", "true, 1"})
+    void carMovesAccordingToShouldMove(boolean shouldMove, int expectedPosition) {
         Car car = new Car("MyCar");
-        car.move(seed);
+        car.move(shouldMove);
         assertThat(car.getPosition()).isEqualTo(expectedPosition);
     }
-
-    @ParameterizedTest
-    @DisplayName("이동을 위한 숫자는 0에서 9 사이여야 한다")
-    @ValueSource(ints = {-1, 10})
-    void carMoveVariableIsBetween0And9(int invalidSeed) {
-        Car car = new Car("MyCar");
-        assertThatThrownBy(() -> car.move(invalidSeed)).isInstanceOf(IllegalArgumentException.class).hasMessage("Invalid seed: " + invalidSeed);
-    }
 }

src/test/java/RaceTest.java

@@ -59,14 +59,14 @@ void getWinnersBeforeRaceFinishThrowsError() {
     @DisplayName("단독 우승자가 있는 경우 해당 자동차만 반환한다")
     void getSingleWinner() {
         // given
-        List<Car> cars = List.of(
-            new Car("car1", 5),
-            new Car("car2", 3),
-            new Car("car3", 4)
-        );
-        Race race = new Race(cars, 1);
+        String[] carNames = {"car1", "car2", "car3"};
+        GameSettings settings = new GameSettings(carNames, 3);
+        Race race = new Race(settings, new FixedMoveStrategy(new boolean[]{true, false, false}));
 
         // when
+        race.runRound();
+        race.runRound();
+        race.runRound();
         List<CarStatus> winners = race.getWinners();
 
         // then
@@ -78,18 +78,35 @@ void getSingleWinner() {
     @DisplayName("공동 우승자가 있는 경우 모든 우승자를 반환한다")
     void getMultipleWinners() {
         // given
-        List<Car> cars = List.of(
-            new Car("car1", 5),
-            new Car("car2", 5),
-            new Car("car3", 3)
-        );
-        Race race = new Race(cars, 1);
+        String[] carNames = {"car1", "car2", "car3"};
+        GameSettings settings = new GameSettings(carNames, 3);
+        Race race = new Race(settings, new FixedMoveStrategy(new boolean[]{true, true, false}));
 
         // when
+        race.runRound();
+        race.runRound();
+        race.runRound();
         List<CarStatus> winners = race.getWinners();
 
         // then
         assertThat(winners).hasSize(2);
         assertThat(winners).extracting("name").containsExactlyInAnyOrder("car1", "car2");
     }
+
+    private static class FixedMoveStrategy implements MoveStrategy {
+        private final boolean[] moves;
+        private int index = 0;
+
+        FixedMoveStrategy(boolean[] moves) {
+            this.moves = moves;
+        }
+
+        @Override
+        public boolean shouldMove() {
+            if (index >= moves.length) {
+                index = 0;
+            }
+            return moves[index++];
+        }
+    }
 }