[부나] 2단계 자동차 경주 제출합니다.

build.gradle.kts

@@ -14,8 +14,7 @@ dependencies {
     testImplementation("org.junit.jupiter", "junit-jupiter", "5.8.2")
     testImplementation("org.assertj", "assertj-core", "3.22.0")
     testImplementation("io.kotest", "kotest-runner-junit5", "5.2.3")
-
-    testImplementation(kotlin("test"))
+    testImplementation("org.mockito:mockito-inline:5.1.1")
 }
 
 tasks {

src/main/kotlin/racingcar/controller/RacingController.kt

@@ -1,63 +1,55 @@
 package racingcar.controller
 
-import racingcar.model.Car
-import racingcar.model.Round
+import racingcar.model.car.CarsDto
+import racingcar.model.car.WinnersDto
+import racingcar.model.round.RoundDto
 import racingcar.service.RacingService
 import racingcar.view.InputView
 import racingcar.view.OutputView
 
 class RacingController(
     private val inputView: InputView = InputView(),
     private val outputView: OutputView = OutputView(),
-    private val racingService: RacingService = RacingService(),
 ) {
-    fun runRacing() {
-        val cars = racingService.createCars(readCarNames())
-        racingService.insertCars(cars)
+    private lateinit var racingService: RacingService
 
+    fun runRacing() {
+        initRacingService()
         val round = readRound()
-
-        runRounds(round.count, cars)
+        runRounds(round)
 
         val winners = getWinners()
         printWinners(winners)
     }
 
-    private fun readCarNames(): List<String> {
+    private fun initRacingService() {
+        racingService = RacingService(readCarNames())
+    }
+
+    private fun readCarNames(): CarsDto {
         outputView.printMessage(CAR_NAMES_REQUEST_MESSAGE)
         return inputView.readCarNames()
     }
 
-    private fun readRound(): Round {
+    private fun readRound(): RoundDto {
         outputView.printMessage(ROUND_COUNT_REQUEST_MESSAGE)
-        return Round(inputView.readNumber())
+        return inputView.readRound()
     }
 
     private fun printRoundCountRequestMessage() = outputView.printMessage(ROUNDS_RESULT_NOTIFICATION_MESSAGE)
 
-    private fun printRoundResult(cars: List<Car>) = outputView.printRoundResult(cars)
+    private fun printRoundResult(cars: CarsDto) = outputView.printRoundResult(cars)
 
-    private fun printWinners(winners: List<Car>) = outputView.printWinners(winners)
+    private fun printWinners(winners: WinnersDto) = outputView.printWinners(winners)
 
-    private fun runRounds(roundCount: Int, cars: List<Car>) {
+    private fun runRounds(round: RoundDto) {
         printRoundCountRequestMessage()
-        repeat(roundCount) {
-            runRound(cars)
-        }
-    }
-
-    private fun runRound(cars: List<Car>) {
-        moveCarsRandomly(cars)
-        printRoundResult(cars)
-    }
-
-    private fun moveCarsRandomly(cars: List<Car>) {
-        cars.forEach { car ->
-            racingService.moveRandomly(car)
+        racingService.runAllRounds(round) { eachRoundCars ->
+            printRoundResult(eachRoundCars)
         }
     }
 
-    private fun getWinners(): List<Car> = racingService.getWinners()
+    private fun getWinners(): WinnersDto = racingService.getWinners()
 
     companion object {
         private const val CAR_NAMES_REQUEST_MESSAGE = "경주할 자동차 이름을 입력하세요(이름은 쉼표(,)를 기준으로 구분)."

src/main/kotlin/racingcar/model/car/Car.kt

@@ -0,0 +1,27 @@
+package racingcar.model.car
+
+open class Car(name: String, _position: Int = 0) {
+    var carName: CarName = CarName(name)
+        private set
+    var position: Int = _position
+        private set
+
+    fun moveRandomly(moveCondition: Int) {
+        if (moveCondition >= MOVEMENT_PROBABILITY) {
+            ++position
+        }
+    }
+
+    fun toDto(): CarDto = CarDto(carName.name)
+
+    companion object {
+        private const val MOVEMENT_PROBABILITY = 4
+    }
+}
+
+class CarDto(_carName: String, val position: Int = 0) {
+    var carName: CarName = CarName(_carName.trim())
+        private set
+
+    fun toModel(): Car = Car(carName.name, position)
+}

src/main/kotlin/racingcar/model/Car.kt → src/main/kotlin/racingcar/model/car/CarName.kt

@@ -1,25 +1,18 @@
-package racingcar.model
+package racingcar.model.car
 
-class Car(val name: String) {
-    var position: Int = 0
-        private set
+class CarName(_name: String) {
+    val name: String
 
     init {
+        name = _name.trim()
         require(name.length in MIN_CAR_NAME_LENGTH..MAX_CAR_NAME_LENGTH) {
-            throw IllegalArgumentException(CAR_NAME_LENGTH_OVER_BOUNDARY_ERROR_MESSAGE)
-        }
-    }
-
-    fun move(condition: Int) {
-        if (condition >= MOVEMENT_PROBABILITY) {
-            ++position
+            CAR_NAME_LENGTH_OVER_BOUNDARY_ERROR_MESSAGE
         }
     }
 
     companion object {
         private const val MIN_CAR_NAME_LENGTH = 1
         private const val MAX_CAR_NAME_LENGTH = 5
-        private const val MOVEMENT_PROBABILITY = 4
 
         private const val CAR_NAME_LENGTH_OVER_BOUNDARY_ERROR_MESSAGE =
             "자동차 이름 길이의 범위는 $MIN_CAR_NAME_LENGTH 이상 $MAX_CAR_NAME_LENGTH 이하입니다."

src/main/kotlin/racingcar/model/car/Cars.kt

@@ -0,0 +1,40 @@
+package racingcar.model.car
+
+import racingcar.utils.random.RandomGenerator
+
+class Cars(_cars: List<Car>) : List<Car> by _cars {
+    init {
+        validateExistDuplicatedCarName()
+    }
+
+    private fun validateExistDuplicatedCarName() {
+        val nonDuplicatedCarsForName = this.distinctBy { it.carName.name }
+
+        require(this.size == nonDuplicatedCarsForName.size) {
+            DUPLICATED_CAR_NAME_ERROR_MESSAGE
+        }
+    }
+
+    fun moveAllRandomly(movementProbabilityGenerator: RandomGenerator): Cars = this.onEach { car ->
+        val moveProbability = movementProbabilityGenerator.generate()
+        car.moveRandomly(moveProbability)
+    }
+
+    fun getWinners(): Winners {
+        val winnerStandard = this.maxBy { it.position }
+        return Winners(this.filter { it.position == winnerStandard.position })
+    }
+
+    fun toDto(): CarsDto = CarsDto(
+        this.map { car -> car.toDto() }
+    )
+
+    companion object {
+        private const val DUPLICATED_CAR_NAME_ERROR_MESSAGE =
+            "중복된 자동차 이름이 존재합니다."
+    }
+}
+
+class CarsDto(_cars: List<CarDto>) : List<CarDto> by _cars {
+    fun toModel(): Cars = Cars(this.map { it.toModel() })
+}

src/main/kotlin/racingcar/model/car/Winners.kt

@@ -0,0 +1,7 @@
+package racingcar.model.car
+
+class Winners(winners: List<Car>) : List<Car> by winners {
+    fun toDto(): WinnersDto = WinnersDto(this)
+}
+
+class WinnersDto(winners: List<Car>) : List<Car> by winners

src/main/kotlin/racingcar/model/Round.kt → src/main/kotlin/racingcar/model/round/Round.kt

@@ -1,4 +1,4 @@
-package racingcar.model
+package racingcar.model.round
 
 class Round(val count: Int) {
     init {
@@ -14,3 +14,7 @@ class Round(val count: Int) {
             "라운드 횟수의 범위는 $MIN_ROUND_COUNT 이상 $MAX_ROUND_COUNT 이하입니다."
     }
 }
+
+class RoundDto(val count: Int) {
+    fun toModel(): Round = Round(count)
+}

src/main/kotlin/racingcar/service/RacingService.kt

@@ -1,38 +1,25 @@
 package racingcar.service
 
-import racingcar.model.Car
-import racingcar.repository.CarRepository
-import racingcar.repository.Repository
+import racingcar.model.car.CarsDto
+import racingcar.model.car.WinnersDto
+import racingcar.model.round.RoundDto
+import racingcar.utils.random.MovementProbabilityGenerator
+import racingcar.utils.random.RandomGenerator
 
 class RacingService(
-    private val carRepository: Repository<Car> = CarRepository()
+    _cars: CarsDto,
+    private val movementProbabilityGenerator: RandomGenerator = MovementProbabilityGenerator()
 ) {
-    fun getAll(): List<Car> = carRepository.selectAll()
+    private val cars = _cars.toModel()
 
-    fun insertCars(cars: List<Car>) {
-        cars.forEach { insertCar(it) }
+    fun runAllRounds(round: RoundDto, doEachRoundResult: (CarsDto) -> Unit) {
+        repeat(round.toModel().count) {
+            doEachRoundResult(moveCarsRandomly())
+        }
     }
 
-    private fun insertCar(car: Car) = carRepository.insert(car)
+    private fun moveCarsRandomly(): CarsDto =
+        cars.moveAllRandomly(movementProbabilityGenerator).toDto()
 
-    fun createCars(names: List<String>): List<Car> =
-        names.map { Car(it) }
-
-    fun moveRandomly(car: Car) {
-        car.move(getRandomProbability())
-    }
-
-    private fun getRandomProbability(): Int =
-        (START_RANDOM_MOVEMENT_PROBABILITY..END_RANDOM_MOVEMENT_PROBABILITY).random()
-
-    fun getWinners(): List<Car> {
-        val cars = getAll()
-        val winnerStandard = cars.maxBy { it.position }
-        return cars.filter { it.position == winnerStandard.position }
-    }
-
-    companion object {
-        private const val START_RANDOM_MOVEMENT_PROBABILITY = 1
-        private const val END_RANDOM_MOVEMENT_PROBABILITY = 10
-    }
+    fun getWinners(): WinnersDto = cars.getWinners().toDto()
 }

src/main/kotlin/racingcar/utils/Extensions.kt

@@ -1,3 +1,4 @@
 package racingcar.utils
 
-fun List<String>.removeBlank() = map { it.trim() }
+fun List<String>.removeBlank(): List<String> =
+    this.map { it.trim() }

src/main/kotlin/racingcar/utils/random/MovementProbabilityGenerator.kt

@@ -0,0 +1,11 @@
+package racingcar.utils.random
+
+class MovementProbabilityGenerator : RandomGenerator {
+    override fun generate(): Int =
+        (START_RANDOM_MOVEMENT_PROBABILITY..END_RANDOM_MOVEMENT_PROBABILITY).random()
+
+    companion object {
+        private const val START_RANDOM_MOVEMENT_PROBABILITY = 1
+        private const val END_RANDOM_MOVEMENT_PROBABILITY = 10
+    }
+}

src/main/kotlin/racingcar/utils/random/RandomGenerator.kt

@@ -0,0 +1,5 @@
+package racingcar.utils.random
+
+interface RandomGenerator {
+    fun generate(): Int
+}

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

@@ -1,17 +1,25 @@
 package racingcar.view
 
+import racingcar.model.car.CarDto
+import racingcar.model.car.CarsDto
+import racingcar.model.round.RoundDto
 import racingcar.utils.removeBlank
 
 class InputView {
-    fun readCarNames(): List<String> = readln()
-        .split(CAR_NAME_DELIMITER)
-        .removeBlank()
+    fun readCarNames(): CarsDto = CarsDto(
+        readln()
+            .split(CAR_NAME_DELIMITER)
+            .removeBlank()
+            .map { carName ->
+                CarDto(carName)
+            }
+    )
 
-    fun readNumber(): Int {
+    fun readRound(): RoundDto {
         val number = readln().toIntOrNull()
         requireNotNull(number) { NOT_NUMERIC_ERROR_MESSAGE }
 
-        return number
+        return RoundDto(number)
     }
 
     companion object {

src/main/kotlin/racingcar/view/OutputView.kt

@@ -1,19 +1,20 @@
 package racingcar.view
 
-import racingcar.model.Car
+import racingcar.model.car.CarsDto
+import racingcar.model.car.WinnersDto
 
 class OutputView {
     fun printMessage(message: String) = println(message)
 
-    fun printRoundResult(cars: List<Car>) {
+    fun printRoundResult(cars: CarsDto) {
         cars.forEach { car ->
-            println("${car.name} : ${getPositionAsDash(car.position)}")
+            println("${car.carName.name} : ${getPositionAsDash(car.position)}")
         }
         println()
     }
 
-    fun printWinners(winners: List<Car>) {
-        println("$WINNER_NOTIFICATION_MESSAGE: ${winners.joinToString(", ") { it.name }}")
+    fun printWinners(winners: WinnersDto) {
+        println("$WINNER_NOTIFICATION_MESSAGE: ${winners.joinToString(", ") { it.carName.name }}")
     }
 
     private fun getPositionAsDash(position: Int): String = DASH.repeat(position)