Persistence & Testing

interface MonsterRepository {
    fun findAll(): List<Monster>
    fun findById(id: Int): Monster?
    fun create(name: String, element: Element, stats: Stats): Monster
    fun update(id: Int, name: String, element: Element, stats: Stats): Monster?
    fun delete(id: Int): Boolean
}

MonsterService gebruikt een contract, geen SQL.

// Persistent database file (H2 JDBC URL):
val jdbcUrl = "jdbc:h2:file:./data/monsterbattles"
// Files remain on disk after the process exits.

jdbc:h2:file:./data/monsterbattles

// De daadwerkelijke InMemoryMonsterRepository uit Week 04 implementeert
// de vijf methoden van MonsterRepository en beheert de ID-uitgifte.
val repository: MonsterRepository = InMemoryMonsterRepository()
val created = repository.create("Pyron", Element.FIRE, Stats(100, 30, 10, 110))
println(repository.findById(created.id)?.name)

Pyron

// H2 in-memory JDBC connection URL:
val url = "jdbc:h2:mem:monsterbattles;DB_CLOSE_DELAY=-1"
// SQL queries work, but data are not durable across process restarts.

jdbc:h2:mem:monsterbattles;DB_CLOSE_DELAY=-1

import java.sql.DriverManager
DriverManager.getConnection("jdbc:h2:mem:monsters;DB_CLOSE_DELAY=-1", "sa", "").use { db ->
    db.createStatement().use { statement ->
        statement.executeUpdate("CREATE TABLE IF NOT EXISTS monsters (id INT PRIMARY KEY, name VARCHAR(80))")
    }
}

Tabel monsters is aangemaakt.

// In Exposed 0.61.0: IntIdTable defines a generated integer primary key.
object MonstersTable : IntIdTable("monsters") {
    val name = varchar("name", 80)
    val element = varchar("element", 16)
    val hp = integer("hp")
    val attack = integer("attack")
    val defense = integer("defense")
    val speed = integer("speed")
}

Tabel monsters met id, name en hp.

// Mapping in ExposedMonsterRepository, using the existing Week 02 model.
fun ResultRow.toMonster(): Monster = Monster(
    id = this[MonstersTable.id].value,
    name = this[MonstersTable.name],
    element = Element.valueOf(this[MonstersTable.element]),
    stats = Stats(
        this[MonstersTable.hp], this[MonstersTable.attack],
        this[MonstersTable.defense], this[MonstersTable.speed]
    )
)

Monster(id=1, name=Pyron, hp=100)

// Use the Week 04 create() method or an idempotent insert if absent.
val pyron = Monster(1, "Pyron", Element.FIRE, Stats(100, 30, 10, 110))
val aquara = Monster(2, "Aquara", Element.WATER, Stats(110, 25, 12, 95))
// Seed only when the corresponding persistent records do not exist.

2 vaste monsters voor de demo.

import kotlin.test.Test
import kotlin.test.assertEquals
fun calculateDamage(attack: Int, defense: Int) = maxOf(1, attack - defense)
class DamageTest {
    @Test fun minimumDamage() {
        assertEquals(1, calculateDamage(10, 25))
    }
}

1 test geslaagd.

testApplication {
    application { module() }
    val response = client.get("/monsters")
    assertEquals(HttpStatusCode.OK, response.status)
}

GET /monsters → 200 OK

val response = client.get("/monsters/1")
assertEquals(HttpStatusCode.OK, response.status)
assertTrue(response.bodyAsText().contains("\"name\":\"Pyron\""))

200 OK met name=Pyron.

      / End-to-end \
     / Integration \
    /  Unit tests   \

Unit > integration > end-to-end als praktische richtlijn.

import kotlin.test.assertEquals
import kotlin.test.assertTrue
val damage = maxOf(1, 30 - 12)
assertEquals(18, damage)
assertTrue(damage > 0)

Assertions slagen.

test-dependencies:
  - $ktor.server.testHost
  - org.junit.jupiter:junit-jupiter-api:5.11.4
  - org.junit.jupiter:junit-jupiter-engine:5.11.4
  - org.junit.jupiter:junit-jupiter-params:5.11.4

Start tests via ./kotlin test (Amper). Controleer de gekozen versies en testrunner.

import org.junit.jupiter.api.Test
import org.junit.jupiter.api.Assertions.assertEquals
class DamageTest {
    @Test fun `damage has minimum one`() {
        assertEquals(1, maxOf(1, 5 - 10))
    }
}

1 test succesvol.

@Test
@DisplayName("Minimum damage is always one")
fun minimumDamage() {
    assertEquals(1, maxOf(1, 5 - 10))
}

Minimum damage is always one ✓

import kotlin.test.*
assertEquals(18, maxOf(1, 30 - 12))
assertTrue(18 > 0)
assertFailsWith<IllegalArgumentException> {
    require(-1 >= 0) { "HP must be positive" }
}

Alle drie assertions slagen.

// Arrange
val attack = 30
val defense = 12
// Act
val damage = maxOf(1, attack - defense)
// Assert
assertEquals(18, damage)

18 damage, test slaagt.

@ParameterizedTest
@CsvSource("30, 12, 18", "10, 50, 1", "20, 20, 1")
fun damageCases(attack: Int, defense: Int, expected: Int) {
    assertEquals(expected, maxOf(1, attack - defense))
}

3 parametrische testgevallen slagen.

@ParameterizedTest
@ValueSource(ints = [0, 1, 50, 100])
fun hpCannotBecomeNegative(damage: Int) {
    assertTrue(maxOf(0, 40 - damage) >= 0)
}

4 uitvoeringen van dezelfde test.

companion object {
    @JvmStatic
    fun cases() = listOf(
        Arguments.of(30, 12, 18),
        Arguments.of(10, 20, 1)
    ).stream()
}
@ParameterizedTest
@MethodSource("cases")
fun damageCases(attack: Int, defense: Int, expected: Int) {
    assertEquals(expected, maxOf(1, attack - defense))
}

2 testgevallen uit de method source.

class DamageSourceTest {
    companion object {
        @JvmStatic fun names() = listOf("Pyron", "Aquara").stream()
    }
    @ParameterizedTest
    @MethodSource("names")
    fun nonEmptyName(name: String) = assertTrue(name.isNotBlank())
}

2 testgevallen met namen.

@BeforeEach
fun setUp() { repository = InMemoryMonsterRepository() }
@AfterEach
fun tearDown() { repository.clear() }
// @BeforeAll / @AfterAll are used for class-wide setup and cleanup.

Voor elke test een schone repository.

// A fake must implement the COMPLETE MonsterRepository interface.
class FakeRepository(private val delegate: MonsterRepository) : MonsterRepository by delegate
// Supply an InMemoryMonsterRepository, never a second Monster model.

FakeRepository.findById(1) → Pyron.

val response = client.get("/monsters")
assertEquals(HttpStatusCode.OK, response.status)
assertTrue(response.bodyAsText().contains("Pyron"))

200 OK met Pyron.

val attackerSpeed = 100
val defenderSpeed = 100
val attackerStarts = attackerSpeed >= defenderSpeed
assertTrue(attackerStarts)
assertEquals(0, maxOf(0, 3 - 99))

Gelijke Speed → eerste monster; HP = 0.

val response = client.get("/monsters/999")
assertEquals(HttpStatusCode.NotFound, response.status)
// POST /battles with the same IDs should return 400.

404 Not Found.

// Week 02 defines the canonical model with stats.speed.
val first = if (pyron.stats.speed >= aquara.stats.speed) pyron else aquara
println(first.name)

Pyron

// Inspect the temporary HP variables inside BattleService.fight().
val damage = DamageCalculator.calculate(source.stats.attack, target.stats.defense)
val remaining = maxOf(0, hp.getValue(target.id) - damage)
hp[target.id] = remaining

Debugger pauzeert vóór HP-aanpassing.

// Inspect in the debugger:
// attackerHp = 100
// defenderHp = 110
// damage = 18
// after update, defenderHp = 92

defenderHp = 92

// Test failure example:
// Expected: 18
// Actual:   17
// at DamageTest.damageSubtractsDefense(DamageTest.kt:12)

Zoek fout in damageberekening of testdata.

val create = client.post("/monsters") {
    contentType(ContentType.Application.Json)
    setBody("""{"name":"Zephyra","element":"WIND","hp":90,"attack":20,"defense":8,"speed":120}""")
}
assertEquals(HttpStatusCode.Created, create.status)
// Follow with GET, PUT and DELETE against the returned ID.

201 Created, daarna ophalen/wijzigen/verwijderen.

val response = client.post("/battles") {
    contentType(ContentType.Application.Json)
    setBody("""{"attackerId":1,"defenderId":2}""")
}
assertEquals(HttpStatusCode.OK, response.status)
assertTrue(response.bodyAsText().contains("winnerId"))

200 OK + winnerId en log.

./kotlin build
./kotlin run
# Configure host, port and database path for deployment.

Ktor server gestart op ingestelde poort.

./kotlin test
./kotlin run
curl http://localhost:8080/monsters
# Windows: kotlin.bat test / kotlin.bat run

GET /monsters → JSON met monsters.

src/nl/monsterbattles/api/
  Application.kt
  common/ApiError.kt
  config/Plugins.kt, DatabaseFactory.kt
  features/monsters/model/{Monster,Stats,Element}.kt
  features/monsters/repository/{MonsterRepository,InMemoryMonsterRepository,ExposedMonsterRepository,MonstersTable}.kt
  features/monsters/{MonsterService,MonsterRoutes}.kt
  features/battles/model/{BattleEvent,BattleResult}.kt
  features/battles/dto/BattleDtos.kt
  features/battles/{DamageCalculator,BattleService,BattleRoutes}.kt
resources/application.yaml
resources/logback.xml
test/nl/monsterbattles/api/

Herkenbare Kotlin/Ktor-projectstructuur.

GET    /monsters                 → 200
GET    /monsters/{id}            → 200 / 404
POST   /monsters                 → 201 / 400
PUT    /monsters/{id}            → 200 / 400 / 404
DELETE /monsters/{id}            → 204 / 404
POST   /battles                  → 200 / 400 / 404

Zes routes met expliciete verwachte statussen.