[Step5] 자동차 경주(리팩토링)

README.md

@@ -1,8 +1,19 @@
 # kotlin-racingcar
 
 - [o] 자동차 생성
-  - [o] 자동차는 4~9 범위 사이일때 움직일 수 있다.  
-  - [o] 자동차는 0~3 범위 사이에는 움직일 수 없다.   
+  - [o] 자동차에 이름을 부여할 수 있다.
+  - [o] 자동차의 이름은 5글자를 초과할 수 없다.
+  - [o] 자동차의 이름이 5글자를 초과하면 예외를 발생시킨다.
+- [o] 자동차의 움직임
+  - [o] 자동차는 4~9 범위 사이일때 움직일 수 있다.
+  - [o] 자동차는 0~3 범위 사이에는 움직일 수 없다.
 - [o] 무작위 값은 0~9 범위 사이이다.  
-- [o] 클라이언트로부터 값을 입력받을 수 있다.  
-- [o] 실행결과를 출력한다.  
+- [o] 클라이언트로부터 값을 입력받을 수 있다. 
+  - [o] 자동차의 이름은 쉼표(,)로 구분할 수 있다.
+- [o] 실행결과를 출력한다.  
+  - [o] 매 횟수마다 출력한다.
+  - [o] 매 횟수마다 전진하는 자동차의 이름도 출력한다.
+  - [o] 최종 우승자를 출력하며, 우승자는 한명 이상이다.
+- [o] 의존관계
+  - [o] Domain -> View X
+  - [o] View -> Domain O

src/main/kotlin/racing/application/RacingGameService.kt

@@ -1,11 +1,18 @@
 package racing.application
 
 import racing.domain.RacingGame
+import racing.view.InputView
+import racing.view.ResultView
 
 class RacingGameService {
 
     fun main() {
+        val racingCarNames = InputView.requireRacingCarNames()
+        val numberOfGames = InputView.requireNumberOfGames()
+
         val racingGame = RacingGame()
-        racingGame.start()
+        val winCars = racingGame.start(racingCarNames, numberOfGames)
+        ResultView.printRacingGameGuideText()
+        ResultView.printRacingGameWinner(winCars)
     }
 }

src/main/kotlin/racing/domain/Car.kt

@@ -1,10 +1,16 @@
 package racing.domain
 
-class Car(position: Int = 0) {
+class Car(val name: String, position: Int = 0) {
 
     var position = position
         private set
 
+    init {
+        require(name.length <= CAR_NAME_LIMIT) {
+            "자동차의 이름은 ${CAR_NAME_LIMIT}글자를 초과할 수 없습니다."
+        }
+    }
+
     fun move(num: Int) {
         if (num >= FORWARD_MOVE) {
             position++
@@ -13,5 +19,7 @@ class Car(position: Int = 0) {
 
     companion object {
         const val FORWARD_MOVE: Int = 4
+        const val CAR_NAME_LIMIT: Int = 5
+        fun produce(name: String, position: Int = 0) = Car(name, position)
     }
 }

src/main/kotlin/racing/domain/CarFactory.kt

@@ -3,8 +3,8 @@ package racing.domain
 class CarFactory {
 
     companion object {
-        fun create(count: Int): Cars {
-            return Cars(count)
+        fun create(names: Array<String>): Cars {
+            return Cars(names)
         }
     }
 }

src/main/kotlin/racing/domain/Cars.kt

@@ -1,22 +1,20 @@
 package racing.domain
 
-class Cars(count: Int) : Iterable<Car> {
-
-    private val list: List<Car>
-
-    init {
-        list = List(count) {
-            Car()
-        }
-    }
+class Cars(private val list: List<Car>) : Iterable<Car> {
+    constructor(names: Array<String>) : this(names.map { Car.produce(it) })
 
     fun count() = list.size
 
     fun race(movable: () -> Int) {
         list.forEach {
             car ->
-            car.move(movable.invoke())
+            car.move(movable())
         }
     }
+
+    private fun isWinnerPosition() = list.maxOf { it.position }
+
+    fun isWinner() = list.filter { it.position == isWinnerPosition() }
+
     override fun iterator(): Iterator<Car> = list.iterator()
 }

src/main/kotlin/racing/domain/RacingGame.kt

@@ -1,22 +1,19 @@
 package racing.domain
 
-import racing.ui.InputView
-import racing.ui.ResultView
+import racing.view.ResultView
 
 class RacingGame {
 
-    fun start() {
+    fun start(carNames: Array<String>, numberOfGames: Int): List<Car> {
 
-        val carCount = InputView.requireCarsCount()
-        val cars = CarFactory.create(carCount)
-        var numberOfGames = InputView.requireNumberOfGames()
+        val cars = CarFactory.create(carNames)
 
-        while (numberOfGames-- > 0) {
-            cars.race {
-                RandomGenerator.generate()
-            }
+        for (i in 1..numberOfGames) {
+            cars.race { RandomGenerator.generate() }
+            ResultView.printRacingGameResult(ResultView.toRaceResult(cars))
         }
 
-        ResultView.printGameResult(ResultStatistics(cars).toResult())
+        val winner = Winner(cars)
+        return winner.win()
     }
 }

src/main/kotlin/racing/domain/RandomGenerator.kt

@@ -3,6 +3,6 @@ package racing.domain
 class RandomGenerator {
 
     companion object {
-        fun generate(): Int = (0..9).random()
+        fun generate() = (0..9).random()
     }
 }

src/main/kotlin/racing/domain/Winner.kt

@@ -0,0 +1,6 @@
+package racing.domain
+
+class Winner(private val cars: Cars) {
+
+    fun win(): List<Car> = cars.isWinner()
+}

src/main/kotlin/racing/view/InputView.kt

@@ -0,0 +1,23 @@
+package racing.view
+
+class InputView {
+
+    companion object {
+        private const val SEPARATOR = ","
+
+        fun requireRacingCarNames(): Array<String> {
+            println("경주할 자동차 이름을 입력하세요(이름은 쉼표(,)를 기준으로 구분")
+            val readString = readString()
+            return readString.split(SEPARATOR).toTypedArray()
+        }
+
+        fun requireNumberOfGames(): Int {
+            println("시도할 횟수는 몇 회인가요?")
+            return readNum()
+        }
+
+        private fun readNum() = readln().toInt()
+
+        private fun readString() = readln()
+    }
+}

src/main/kotlin/racing/view/ResultView.kt

@@ -0,0 +1,32 @@
+package racing.view
+
+import racing.domain.Car
+import racing.domain.Cars
+
+class ResultView {
+
+    companion object {
+        fun toRaceResult(cars: Cars): String {
+            return cars.map { "${it.name} : ${toMark(it)}" }.joinToString(separator = System.lineSeparator()).trimIndent()
+        }
+
+        private fun toMark(car: Car): String {
+            return MARK.repeat(car.position)
+        }
+
+        fun printRacingGameGuideText() {
+            println("실행결과")
+        }
+
+        fun printRacingGameResult(result: String) {
+            println(result)
+        }
+
+        fun printRacingGameWinner(cars: List<Car>) {
+            val winner = cars.joinToString { it.name }
+            println("${winner}가 최종 우승했습니다.")
+        }
+
+        private const val MARK = "-"
+    }
+}

src/test/kotlin/racing/CarTest.kt

@@ -1,7 +1,9 @@
 package racing
 
-import org.assertj.core.api.AssertionsForInterfaceTypes
+import org.assertj.core.api.AssertionsForInterfaceTypes.assertThat
+import org.assertj.core.util.Arrays
 import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertThrows
 import org.junit.jupiter.params.ParameterizedTest
 import org.junit.jupiter.params.provider.ValueSource
 import racing.domain.CarFactory
@@ -10,28 +12,39 @@ import racing.domain.Cars
 class CarTest {
 
     @Test
-    fun `자동차 생성`() {
-        val cars: Cars = CarFactory.create(3)
-        AssertionsForInterfaceTypes.assertThat(cars.count()).isEqualTo(3)
+    fun `자동차를 생성할 때 자동차의 이름은 5글자 이하이다`() {
+        val names = Arrays.array("lee", "kkoks", "amery")
+        val cars: Cars = CarFactory.create(names)
+        assertThat(cars.count()).isEqualTo(3)
+    }
+
+    @Test
+    fun `자동차를 생성할 때 자동차의 이름은 5글자를 초과한다`() {
+        val names = Arrays.array("lee", "kkokss", "amery")
+        assertThrows<IllegalArgumentException> {
+            CarFactory.create(names)
+        }
     }
 
     @ParameterizedTest
     @ValueSource(ints = [4, 9])
     fun `자동차 이동`(num: Int) {
-        val cars: Cars = CarFactory.create(3)
+        val names = Arrays.array("lee", "kkoks", "amery")
+        val cars: Cars = CarFactory.create(names)
         for (car in cars) {
             car.move(num)
-            AssertionsForInterfaceTypes.assertThat(car.position).isEqualTo(1)
+            assertThat(car.position).isEqualTo(1)
         }
     }
 
     @ParameterizedTest
     @ValueSource(ints = [0, 3])
     fun `자동차 이동실패`(num: Int) {
-        val cars: Cars = CarFactory.create(3)
+        val names = Arrays.array("lee", "kkoks", "amery")
+        val cars: Cars = CarFactory.create(names)
         for (car in cars) {
             car.move(num)
-            AssertionsForInterfaceTypes.assertThat(car.position).isEqualTo(0)
+            assertThat(car.position).isEqualTo(0)
         }
     }
 }

src/test/kotlin/racing/RacingGameTest.kt

@@ -1,19 +1,55 @@
 package racing
 
 import org.assertj.core.api.AssertionsForInterfaceTypes.assertThat
+import org.assertj.core.util.Arrays
 import org.junit.jupiter.api.Test
+import racing.domain.Car
 import racing.domain.CarFactory
 import racing.domain.Cars
-import racing.domain.ResultStatistics
+import racing.domain.Winner
+import racing.view.ResultView
 
 class RacingGameTest {
 
     @Test
     fun `실행결과 출력`() {
-        val cars: Cars = CarFactory.create(2)
+        val names = Arrays.array("lee", "kkoks")
+        val cars: Cars = CarFactory.create(names)
         for (car in cars) {
             car.move(4)
         }
-        assertThat(ResultStatistics(cars).toResult()).isEqualTo("-${System.lineSeparator()}-")
+
+        val result = """
+            lee : -
+            kkoks : -
+        """.trimIndent()
+        assertThat(ResultView.toRaceResult(cars)).isEqualTo(result)
+    }
+
+    @Test
+    fun `Racing Game 단독 우승자 출력(차가 한대일경우)`() {
+        val kkoksCar = Car.produce("kkoks", 3)
+        val winner = Winner(Cars(listOf(kkoksCar)))
+        val result = winner.win()
+        assertThat(result).contains(kkoksCar)
+    }
+
+    @Test
+    fun `Racing Game 단독 우승자 출력`() {
+        val leeCar = Car.produce("lee", 5)
+        val kkoksCar = Car.produce("kkoks", 3)
+        val winner = Winner(Cars(listOf(leeCar, kkoksCar)))
+        val result = winner.win()
+        assertThat(result).contains(leeCar)
+    }
+
+    @Test
+    fun `Racing Game 공동 우승자 출력`() {
+        val leeCar = Car.produce("lee", 5)
+        val kkoksCar = Car.produce("kkoks", 5)
+        val tesyCar = Car.produce("tesy", 3)
+        val winner = Winner(Cars(listOf(leeCar, kkoksCar, tesyCar)))
+        val result = winner.win()
+        assertThat(result).contains(leeCar, kkoksCar)
     }
 }