[jinhee] 프리코스 미션 제출합니다

README.md

@@ -1 +1,69 @@
-# kotlin-racingcar
+# 과제 요구 사항 
+
+### 기능 요구 사항
+- 초간단 자동차 경주 게임을 구현한다#
+    - 주어진 횟수 동안 n대의 자동차는 전진 또는 멈출 수 있다.
+    - 각 자동차에 이름을 부여할 수 있다. 전진하는 자동차를 출력할 때 자동차 이름을 같이 출력한다.
+    - 자동차 이름은 쉼표(,)를 기준으로 구분하며 이름은 5자 이하만 가능하다.
+    - 사용자는 몇 번의 이동을 할 것인지를 입력할 수 있어야 한다.
+    - 전진하는 조건은 0에서 9 사이에서 무작위 값을 구한 후 무작위 값이 4 이상일 경우이다.
+    - 자동차 경주 게임을 완료한 후 누가 우승했는지를 알려준다. 우승자는 한 명 이상일 수 있다.
+    - 우승자가 여러 명일 경우 쉼표(,)를 이용하여 구분한다.
+    - 사용자가 잘못된 값을 입력할 경우 을 IllegalArgumentException 발생시키고, "[ERROR]"로 시작하는 에러 메시지를 출력 후 그 부분부터 입력을 다
+    - Exception 이 아닌  , IllegalStateException 등과 같은 명확한 유형을 처리한다.
+
+### 프로그래밍 요구 사항 1
+- Kotlin 1.9.0에서 실행 가능해야 한다.
+- Java 코드가 아닌 Kotlin 코드로만 구현해야 한다.
+- 프로그램 실행의 시작점은 Application 의 main() 이다.
+- build.gradle.kts 파일은 변경할 수 없으며, 제공된 라이브러리 이외의 외부 라이브러리는 사용하지 않는다.
+- 프로그램 종료 시 System.exit() 또는 exitProcess() 를 호출하지 않는다.
+- 프로그래밍 요구 사항에서 달리 명시하지 않는 한 파일, 패키지 등의 이름을 바꾸거나 이동하지 않는다.
+
+### 프로그래밍 요구 사항 2
+- 코틀린 코드 컨벤션을 지키면서 프로그래밍한다.
+- 기본적으로 Kotlin Coding conventions를 원칙으로 한다.
+- indent(인덴트, 들여쓰기) depth를 3이 넘지 않도록 구현한다. 2까지만 허용한다.  
+- 예를 들어 while문 안에 if문이 있으면 들여쓰기는 2이다.
+
+# 프로그래밍 요구 사항 3
+- 함수(또는 메서드)의 길이가 15라인을 넘어가지 않도록 구현한다.
+-  함수(또는 메서드)가 한 가지 일만 잘 하도록 구현한다.
+-  가능한 한 else 예약어를 쓰지 않는다.
+-  때로는 else 예약어와 조건식을 사용하는 것이 더 깔끔해 보일 수 있다. 어떤 상황에 사용하는 것이 적절한지 스스로 생각해 본다.
+-  힌트: if 조건절에서 값을 return하는 방식으로 구현하면 else를 사용하지 않아도 된다.
+-  도메인 로직에 단위 테스트를 구현해야 한다. 단, UI(System.out, System.in, Scanner) 로직은 제외한다.
+- 핵심 로직을 구현하는 코드와 UI를 담당하는 로직을 분리해 구현한다.
+- 힌트: MVC 패턴 기반으로 구현한 후, View와 Controller를 제외한 Model에 대한 단위 테스트 추가에 집중한다.
+
+### 기대 실행 결과
+````
+경주할 자동차 이름을 입력하세요.(이름은 쉼표(,) 기준으로 구분)
+pobi,woni,jun
+시도할 회수는 몇회인가요?
+5
+실행 결과
+pobi : -
+woni :
+jun : -
+pobi : --
+woni : -
+jun : --
+pobi : ---
+woni : --
+jun : ---
+pobi : ----
+woni : ---
+jun : ----
+pobi : -----
+woni : ----
+jun : -----
+최종 우승자 : pobi, jun
+````
+
+# 프로젝트 구조
+- com.nextstep.edu
+  - controller
+  - model
+  - view
+  - Application.kt

build.gradle.kts

@@ -15,9 +15,13 @@ repositories {
 }
 
 dependencies {
-    testImplementation("org.junit.jupiter", "junit-jupiter", "5.10.2")
-    testImplementation("org.assertj", "assertj-core", "3.25.3")
-    testImplementation("io.kotest", "kotest-runner-junit5", "5.8.0")
+    testImplementation("org.junit.jupiter:junit-jupiter:5.10.2")
+    testImplementation("org.assertj:assertj-core:3.25.3")
+    testImplementation("io.kotest:kotest-runner-junit5:5.8.0")
+    testImplementation("org.mockito.kotlin:mockito-kotlin:5.1.0")
+    testImplementation("io.kotest:kotest-runner-junit5:5.7.7")
+    testImplementation("io.kotest:kotest-assertions-core:5.7.7")
+    testImplementation("io.mockk:mockk:1.13.8")
 }
 
 tasks {

src/main/kotlin/camp/nextstep/edu/Application.kt

@@ -0,0 +1,14 @@
+package camp.nextstep.edu
+
+import camp.nextstep.edu.controller.RacingController
+import camp.nextstep.edu.model.RacingGame
+import camp.nextstep.edu.view.InputHandler
+import camp.nextstep.edu.view.OutputHandler
+
+fun main() {
+    val inputHandler = InputHandler
+    val racingGame = RacingGame
+    val outputHandler = OutputHandler
+    val controller = RacingController(inputHandler, racingGame, outputHandler)
+    controller.startGame()
+}

src/main/kotlin/camp/nextstep/edu/controller/RacingController.kt

@@ -0,0 +1,41 @@
+package camp.nextstep.edu.controller
+
+import camp.nextstep.edu.model.Car
+import camp.nextstep.edu.model.RacingGame
+import camp.nextstep.edu.view.InputHandler
+import camp.nextstep.edu.view.OutputHandler
+
+class RacingController(
+    private val inputHandler: InputHandler,
+    private val racingGame: RacingGame,
+    private val outputHandler: OutputHandler
+) {
+
+    fun startGame() {
+        val carNames = inputHandler.readCarNames()
+        val cars = createCars(carNames)
+        val numberOfMoves = inputHandler.getNumberOfMoves()
+
+        outputHandler.displayStartMessage()
+        playRounds(cars, numberOfMoves)
+        displayResults(cars)
+    }
+
+    fun createCars(carNames: List<String>): List<Car> {
+        return carNames.map(::Car)
+    }
+
+    private fun playRounds(cars: List<Car>, numberOfMoves: Int) {
+        repeat(numberOfMoves) { round ->
+            outputHandler.displayRoundStartMessage(round + 1)
+            racingGame.playRound(cars)
+            val positions = racingGame.getCarPositions(cars)
+            outputHandler.displayRoundResult(positions)
+        }
+    }
+
+    private fun displayResults(cars: List<Car>) {
+        val winners = racingGame.findWinners(cars)
+        outputHandler.displayWinners(winners)
+    }
+}

src/main/kotlin/camp/nextstep/edu/model/Car.kt

@@ -0,0 +1,19 @@
+package camp.nextstep.edu.model
+
+import kotlin.random.Random
+
+data class Car(val name: String, var position: Int = 0) {
+    init {
+        require(isValidName(name)) { "[ERROR] 자동차 이름은 1자 이상 5자 이하여야 합니다." }
+    }
+
+    private fun isValidName(name: String): Boolean = name.isNotBlank() && name.length <= 5
+    private fun canMove(): Boolean = Random.nextInt(0, 10) >= 4
+
+    fun move() {
+        if (canMove()) position++
+
+    }
+
+    fun displayPosition() = "$name : ${"-".repeat(position) + "-".repeat(position)}"
+}

src/main/kotlin/camp/nextstep/edu/model/RacingGame.kt

@@ -0,0 +1,22 @@
+package camp.nextstep.edu.model
+
+object RacingGame {
+    fun playRound(cars: List<Car>) {
+        cars.forEach(::tryMoveCar)
+    }
+    fun getCarPositions(cars: List<Car>): List<String> = cars.map(Car::displayPosition)
+
+    fun findWinners(cars: List<Car>): List<Car> {
+        val maxPosition = getMaxPosition(cars)
+        return filterWinnerByPosition(cars, maxPosition)
+    }
+
+    private fun tryMoveCar(car: Car) {
+        car.move()
+    }
+
+    private fun getMaxPosition(cars: List<Car>): Int = cars.maxOfOrNull { it.position } ?: 0
+    private fun filterWinnerByPosition(cars: List<Car>, maxPosition: Int): List<Car> =
+        cars.filter { it.position == maxPosition }
+
+}

src/main/kotlin/camp/nextstep/edu/view/InputHandler.kt

@@ -0,0 +1,41 @@
+package camp.nextstep.edu.view
+
+object InputHandler {
+    private const val NAME_DELIMITER = ","
+    private const val MAX_NAME_LENGTH = 5
+    private const val MIN_MOVE_COUNT = 1
+
+    fun readCarNames(): List<String> {
+        println("경주할 자동차 이름을 입력하세요.(이름은 쉼표(,) 기준으로 구분)")
+        val input = readlnOrNull()
+        return parseAndValidateNames(input)
+    }
+
+    private fun parseAndValidateNames(input: String?): List<String> {
+        requireNotNull(input) { "[ERROR] 입력을 읽을 수 없습니다." }
+        return input.split(NAME_DELIMITER)
+            .map { it.trim() }
+            .also(::validateCarNames)
+    }
+
+    private fun validateCarNames(names: List<String>) {
+        require(names.all { it.isNotBlank() && it.length <= MAX_NAME_LENGTH }) { "[ERROR] 자동차 이름은 1자 이상 ${MAX_NAME_LENGTH}자 이하여야 합니다." }
+    }
+
+    fun getNumberOfMoves(): Int {
+        println("시도할 횟수를 입력하세요:")
+        val input = readlnOrNull()
+        return parseAndValidateMoveCount(input)
+    }
+
+    private fun parseAndValidateMoveCount(input: String?): Int {
+        val count = input?.toIntOrNull() ?: throw IllegalArgumentException("[ERROR] 유효한 숫자를 입력해야 합니다.")
+        validateMoveCount(count)
+        return count
+    }
+
+    private fun validateMoveCount(count: Int) {
+        require(count >= MIN_MOVE_COUNT) { "[ERROR] 시도 횟수는 $MIN_MOVE_COUNT 이상이어야 합니다." }
+    }
+
+}

src/main/kotlin/camp/nextstep/edu/view/OutputHandler.kt

@@ -0,0 +1,28 @@
+package camp.nextstep.edu.view
+
+import camp.nextstep.edu.model.Car
+
+object OutputHandler {
+    fun displayRoundResult(positions: List<String>) {
+        positions.forEach(::println)
+        println()
+    }
+
+    fun displayWinners(winners: List<Car>) {
+        if (winners.isNotEmpty()) {
+            val winnerNames = winners.joinToString(", ") { it.name }
+            println("우승자: $winnerNames")
+        } else {
+            println("우승자가 없습니다.")
+        }
+    }
+
+    fun displayStartMessage() {
+        println("경주 시작!")
+    }
+
+    fun displayRoundStartMessage(round: Int) {
+        println("$round 번째 이동")
+    }
+
+}

src/test/kotlin/camp/nextstep/edu/model/CarTest.kt

@@ -0,0 +1,32 @@
+import camp.nextstep.edu.model.Car
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.Assertions.*
+
+class CarTest {
+
+    @Test
+    fun createCar_validName() {
+        val car = Car("car")
+        assertEquals("car", car.name)
+        assertEquals(0, car.position)
+    }
+
+    @Test
+    fun createCar_nameTooLong() {
+        assertThrows(IllegalArgumentException::class.java) {
+            Car("tooLongName")
+        }.apply {
+            assertEquals("[ERROR] 자동차 이름은 1자 이상 5자 이하여야 합니다.", message)
+        }
+    }
+
+    @Test
+    fun createCar_emptyName() {
+        assertThrows(IllegalArgumentException::class.java) {
+            Car("")
+        }.apply {
+            assertEquals("[ERROR] 자동차 이름은 1자 이상 5자 이하여야 합니다.", message)
+        }
+    }
+
+}

src/test/kotlin/camp/nextstep/edu/model/RacingGameTest.kt

@@ -0,0 +1,50 @@
+package camp.nextstep.edu.model
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.Assertions.*
+
+class RacingGameTest {
+    @Test
+    fun playRound_carsMoveRandomly() {
+        val cars = listOf(Car("car1"), Car("car2"))
+        val initialPositions = cars.map { it.position }
+        RacingGame.playRound(cars)
+        val finalPositions = cars.map { it.position }
+        finalPositions.forEachIndexed { index, finalPosition ->
+            assertTrue(finalPosition >= initialPositions[index])
+        }
+    }
+
+    @Test
+    fun findWinners_singleWinner() {
+        val cars = listOf(Car("car1", 2), Car("car2", 5), Car("car3", 3))
+        val winners = RacingGame.findWinners(cars)
+        assertEquals(listOf(Car("car2", 5)), winners)
+    }
+
+    @Test
+    fun findWinners_multipleWinners() {
+        val cars = listOf(Car("car1", 5), Car("car2", 5), Car("car3", 3))
+        val winners = RacingGame.findWinners(cars)
+        assertEquals(listOf(Car("car1", 5), Car("car2", 5)), winners)
+    }
+
+    @Test
+    fun findWinners_noWinners() {
+        val cars = emptyList<Car>()
+        val winners = RacingGame.findWinners(cars)
+        assertEquals(emptyList<Car>(), winners)
+    }
+
+    @Test
+    fun findWinners_allCarsSamePosition() {
+        val cars = listOf(Car("car1", 1), Car("car2", 1), Car("car3", 1))
+        val winners = RacingGame.findWinners(cars)
+        assertEquals(listOf(Car("car1", 1), Car("car2", 1), Car("car3", 1)), winners)
+    }
+
+    @Test
+    fun findWinners_emptyCarsList() {
+        val winners = RacingGame.findWinners(emptyList())
+        assertTrue(winners.isEmpty())
+    }
+}