Refactor tests to replace Kotest matchers with JUnit assertions, remove SuspendFun test suite, and update documentation for Kotlin 2.4.0 features.

# Conflicts:
#	gradle/libs.versions.toml

Author: nomisRev

.agents/skills/ktor/references/routes-and-validation.md

@@ -1,7 +1,7 @@
 # Routes and Validation
 
 This project defines its HTTP contracts with [Spine](https://gitlab.com/opensavvy/spine) instead of raw Ktor
-`routing { }` blocks, and models failures as `Raise<DomainError>` (Arrow) instead of exceptions. Keep that
+`routing { }` blocks, and models failures as `DomainErrors` (Arrow) instead of exceptions. Keep that
 combination in mind whenever you add or change an endpoint.
 
 ## Define the contract in `Api.kt`
@@ -68,12 +68,12 @@ Inside the block:
 ## `ErrorRoutes.kt`: how failures become HTTP responses
 
 `Route.route(endpoint) { block }` in `ErrorRoutes.kt` runs `block` inside `arrow.core.raise.recover` with the
-handler's body scoped to `context(Raise<DomainError>)`:
+handler's body scoped to `context(DomainErrors)`:
 
 ```kotlin
 inline fun <...> Route.route(
     endpoint: Endpoint<In, Out, Failure, Params>,
-    crossinline block: suspend context(Raise<DomainError>) TypedResponseScope<...>.() -> Unit,
+    crossinline block: suspend context(DomainErrors) TypedResponseScope<...>.() -> Unit,
 ): Unit =
     route(endpoint) response@{
         recover(
@@ -125,14 +125,14 @@ fun select(userId: UserId): UserInfo { ... }
 ```
 
 Because `UserError`, `ArticleError`, `ValidationError`, etc. are all subtypes of `DomainError`, and Arrow's
-`context(Raise<E>)` is contravariant in the way it composes, a function written as `context(_: Raise<DomainError>)`
+`context(Raise<E>)` is contravariant in the way it composes, a function written as `context(_: DomainErrors)`
 can call any function that raises a narrower error type directly — no wrapping, no `mapLeft`, no manual lifting.
 This is how the error type **grows** as you move up the call stack:
 
 ```kotlin
 class UserService(private val repo: UserPersistence, private val jwtService: JwtService) {
     // register only fails with UserError (repo.insert) plus IncorrectInput (validate) -> DomainError
-    context(_: Raise<DomainError>)
+    context(_: DomainErrors)
     fun register(input: RegisterUser): JwtToken {
         val (username, email, password) = input.validate()   // Raise<IncorrectInput>
         val userId = repo.insert(username, email, password)  // Raise<UserError>
@@ -149,10 +149,10 @@ Guidelines:
 
 - Repository/persistence functions: narrowest possible error type (`UserError`, `ArticleError`, a single
   variant like `UserNotFound`, ...).
-- Service functions: `Raise<DomainError>` **only when they genuinely combine multiple error families** (validation
+- Service functions: `DomainErrors` **only when they genuinely combine multiple error families** (validation
   + persistence + JWT, etc.). If a service function only ever delegates to one narrow-error repository call, keep
   that narrow type instead of widening to `DomainError` for no reason.
-- Route handlers (the `route(endpoint) { ... }` block body): always `context(Raise<DomainError>)` — this is the
+- Route handlers (the `route(endpoint) { ... }` block body): always `context(DomainErrors)` — this is the
   edge of the service, where any remaining domain error must be convertible to `GenericErrorModel` via
   `toGenericErrorModel`.
 - Never introduce exceptions for expected failures. `raise`/`ensure`/`ensureNotNull`/`catch` (Arrow) are the only

.agents/skills/ktor/references/service-architecture.md

@@ -37,7 +37,7 @@ Keep the boundary explicit per feature:
   handling happens (see `UserPersistence.raiseUniqueViolation`).
 - `*Service` classes hold business rules that span persistence calls (validation, ownership checks, composing
   profiles/tags/favorites onto an article). Simple pass-throughs stay in the narrowest `Raise` type; only widen to
-  `Raise<DomainError>` when a function genuinely combines multiple error families — see
+  `DomainErrors` when a function genuinely combines multiple error families — see
   `references/routes-and-validation.md`.
 - `*Routes` files only decode/encode DTOs and call into a service — no persistence access, no manual error mapping.
 - Small features with no extra business logic (`tags`, `profiles`) skip the `*Service` layer entirely: their routes

AGENTS.md

@@ -9,6 +9,34 @@
 - When the user asks a question, answer it first before making edits or running implementation commands.
 - When responding to user feedback or an analysis, explicitly say whether you agree or disagree before saying what you changed.
 
+## Kotlin
+
+### Name-based destructing (2.4.0)
+
+Since Kotlin 2.4.0 we can use name-based destructing data classes.
+
+```kotlin
+data class Person(val age: Int, val name: String)
+
+fun example() {
+    val (name) = Person(20, "John")
+    println(name) // "John"
+}
+
+fun example2() {
+    val (age2, name) = Person(20, "John")
+    val
+}
+```
+
+### Collection literals (2.4.0)
+
+Since Kotlin 2.4.0 we can use collection literals to create collection types.
+
+```kotlin
+val x: List<Int> = [1, 2, 3]
+```
+
 ## Gradle
 
 Always use `-q`/`--quiet` when running `./gradlew` commands to avoid noisy output.

README.MD

@@ -28,7 +28,7 @@ and [Arrow](https://arrow-kt.io/) as the main building blocks.
 Other technologies used:
 
 - [SqlDelight](https://cashapp.github.io/sqldelight/) for the persistence layer
-- [Kotest](https://kotest.io/) for testing
+- [TestBalloon](https://infix-de.github.io/testBalloon/latest/) for testing
 
 ## Running the project
 

build.gradle.kts

@@ -7,7 +7,6 @@ import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
   alias(libs.plugins.kotlin.assert)
   alias(libs.plugins.kover)
   alias(libs.plugins.kotlinx.serialization)
-  alias(libs.plugins.kotest.multiplatform)
   alias(libs.plugins.sqldelight)
   alias(libs.plugins.ktor)
   alias(libs.plugins.testballoon)
@@ -75,7 +74,6 @@ dependencies {
   testImplementation(libs.spine.client)
   testImplementation(libs.testcontainers.postgresql)
   testImplementation(libs.ktor.server.tests)
-  testImplementation(libs.bundles.kotest)
   testImplementation(libs.testballoon.framework.core)
 }
 

gradle/libs.versions.toml

@@ -5,8 +5,6 @@ detekt = "1.23.8"
 dev-tools = "0.0.1"
 hikari = "7.1.0"
 kjwt = "1.0.0"
-kotest = "6.2.2"
-kotest-testcontainers = "2.0.2"
 kotlin = "2.4.0"
 kover = "0.9.8"
 ktor = "3.5.1"
@@ -29,13 +27,6 @@ cohort-hikari = { module = "com.sksamuel.cohort:cohort-hikari", version.ref = "c
 cohort-ktor = { module = "com.sksamuel.cohort:cohort-ktor", version.ref = "cohort" }
 hikari = { module = "com.zaxxer:HikariCP", version.ref = "hikari" }
 kjwt-core = { module = "io.github.nefilim.kjwt:kjwt-core", version.ref = "kjwt" }
-kotest-arrow = { module = "io.kotest:kotest-assertions-arrow", version.ref = "kotest" }
-kotest-arrow-fx = { module = "io.kotest:kotest-assertions-arrow-fx-coroutines", version.ref = "kotest" }
-kotest-assertionsCore = { module = "io.kotest:kotest-assertions-core", version.ref = "kotest" }
-kotest-frameworkEngine = { module = "io.kotest:kotest-framework-engine", version.ref = "kotest" }
-kotest-property = { module = "io.kotest:kotest-property", version.ref = "kotest" }
-kotest-runnerJUnit5 = { module = "io.kotest:kotest-runner-junit5", version.ref = "kotest" }
-kotest-testcontainers = { module = "io.kotest.extensions:kotest-extensions-testcontainers", version.ref = "kotest-testcontainers" }
 ktor-server-tests = { module = "io.ktor:ktor-server-test-host", version.ref = "ktor" }
 logback-classic = { module = "ch.qos.logback:logback-classic", version.ref = "logback" }
 postgresql = { module = "org.postgresql:postgresql", version.ref = "postgresql" }
@@ -60,20 +51,9 @@ cohort = [
     "cohort-hikari",
     "cohort-ktor",
 ]
-kotest = [
-    "kotest-arrow",
-    "kotest-arrow-fx",
-    "kotest-assertionsCore",
-    "kotest-frameworkEngine",
-    "kotest-property",
-    "kotest-runnerJUnit5",
-    "kotest-testcontainers",
-]
 
 [plugins]
-detekt = { id = "io.gitlab.arturbosch.detekt", version.ref = "detekt" }
 dev-tools = { id = "io.github.nomisrev.dev-tools", version.ref = "dev-tools" }
-kotest-multiplatform = { id = "io.kotest", version.ref = "kotest" }
 kotlin-assert = { id = "org.jetbrains.kotlin.plugin.power-assert", version.ref = "kotlin" }
 kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }
 kotlinx-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }

src/main/kotlin/io/github/nomisrev/Api.kt

@@ -26,129 +26,111 @@ import opensavvy.spine.api.StaticResource
 
 object Api : SpineRootResource("api") {
     object Tags : StaticResource<Api>("tags", Api) {
-        val list by
-            get()
-                .response<TagsResponse>()
-                .failure<GenericErrorModel>(HttpStatusCode.UnprocessableEntity)
+        val list by get()
+            .response<TagsResponse>()
+            .failure<GenericErrorModel>(HttpStatusCode.UnprocessableEntity)
     }
 
     object Articles : StaticResource<Api>("articles", Api) {
-        val list by
+        val list by get()
+            .parameters(::ArticlesParameters)
+            .response<MultipleArticlesResponse>()
+            .failure<GenericErrorModel>(HttpStatusCode.UnprocessableEntity)
+
+        val create by post()
+            .request<ArticleWrapper<NewArticle>>()
+            .response<SingleArticleResponse>()
+            .failure<GenericErrorModel>(HttpStatusCode.UnprocessableEntity)
+
+        val feed by get("feed")
+            .parameters(::FeedParameters)
+            .response<MultipleArticlesResponse>()
+            .failure<GenericErrorModel>(HttpStatusCode.UnprocessableEntity)
+
+        object Slug : DynamicResource<Articles>("slug", Articles) {
+            val get by
             get()
-                .parameters(::ArticlesParameters)
-                .response<MultipleArticlesResponse>()
+                .response<SingleArticleResponse>()
                 .failure<GenericErrorModel>(HttpStatusCode.UnprocessableEntity)
 
-        val create by
-            post()
-                .request<ArticleWrapper<NewArticle>>()
+            val update by put()
+                .request<ArticleWrapper<UpdateArticle>>()
                 .response<SingleArticleResponse>()
                 .failure<GenericErrorModel>(HttpStatusCode.UnprocessableEntity)
 
-        val feed by
-            get("feed")
-                .parameters(::FeedParameters)
-                .response<MultipleArticlesResponse>()
+            val delete by delete()
+                .response<Unit>()
                 .failure<GenericErrorModel>(HttpStatusCode.UnprocessableEntity)
 
-        object Slug : DynamicResource<Articles>("slug", Articles) {
-            val get by
-                get()
+            object Favorite : StaticResource<Slug>("favorite", Slug) {
+                val add by post()
                     .response<SingleArticleResponse>()
                     .failure<GenericErrorModel>(HttpStatusCode.UnprocessableEntity)
 
-            val update by
-                put()
-                    .request<ArticleWrapper<UpdateArticle>>()
+                val remove by delete()
                     .response<SingleArticleResponse>()
                     .failure<GenericErrorModel>(HttpStatusCode.UnprocessableEntity)
-
-            val delete by
-                delete()
-                    .response<Unit>()
-                    .failure<GenericErrorModel>(HttpStatusCode.UnprocessableEntity)
-
-            object Favorite : StaticResource<Slug>("favorite", Slug) {
-                val add by
-                    post()
-                        .response<SingleArticleResponse>()
-                        .failure<GenericErrorModel>(HttpStatusCode.UnprocessableEntity)
-
-                val remove by
-                    delete()
-                        .response<SingleArticleResponse>()
-                        .failure<GenericErrorModel>(HttpStatusCode.UnprocessableEntity)
             }
 
             object Comments : StaticResource<Slug>("comments", Slug) {
-                val create by
-                    post()
-                        .request<CommentWrapper<NewComment>>()
-                        .response<SingleCommentResponse>()
-                        .failure<GenericErrorModel>(HttpStatusCode.UnprocessableEntity)
+                val create by post()
+                    .request<CommentWrapper<NewComment>>()
+                    .response<SingleCommentResponse>()
+                    .failure<GenericErrorModel>(HttpStatusCode.UnprocessableEntity)
 
-                val list by
-                    get()
-                        .response<MultipleCommentsResponse>()
-                        .failure<GenericErrorModel>(HttpStatusCode.UnprocessableEntity)
+                val list by get()
+                    .response<MultipleCommentsResponse>()
+                    .failure<GenericErrorModel>(HttpStatusCode.UnprocessableEntity)
 
                 object Id : DynamicResource<Comments>("id", Comments) {
-                    val delete by
-                        delete()
-                            .response<Unit>()
-                            .failure<GenericErrorModel>(HttpStatusCode.UnprocessableEntity)
+                    val delete by delete()
+                        .response<Unit>()
+                        .failure<GenericErrorModel>(HttpStatusCode.UnprocessableEntity)
                 }
             }
         }
     }
 
     object Profiles : StaticResource<Api>("profiles", Api) {
         object Username : DynamicResource<Profiles>("username", Profiles) {
-            val get by
-                get()
-                    .response<ProfileWrapper<Profile>>()
-                    .failure<GenericErrorModel>(HttpStatusCode.UnprocessableEntity)
+            val get by get()
+                .response<ProfileWrapper<Profile>>()
+                .failure<GenericErrorModel>(HttpStatusCode.UnprocessableEntity)
 
             object Follow : StaticResource<Username>("follow", Username) {
-                val add by
-                    post()
-                        .response<ProfileWrapper<Profile>>()
-                        .failure<GenericErrorModel>(HttpStatusCode.UnprocessableEntity)
+                val add by post()
+                    .response<ProfileWrapper<Profile>>()
+                    .failure<GenericErrorModel>(HttpStatusCode.UnprocessableEntity)
 
-                val remove by
-                    delete()
-                        .response<ProfileWrapper<Profile>>()
-                        .failure<GenericErrorModel>(HttpStatusCode.UnprocessableEntity)
+                val remove by delete()
+                    .response<ProfileWrapper<Profile>>()
+                    .failure<GenericErrorModel>(HttpStatusCode.UnprocessableEntity)
             }
         }
     }
 
     object Users : StaticResource<Api>("users", Api) {
-        val register by
-            post()
-                .request<UserWrapper<NewUser>>()
-                .response<UserWrapper<User>>()
-                .failure<GenericErrorModel>(HttpStatusCode.UnprocessableEntity)
+        val register by post()
+            .request<UserWrapper<NewUser>>()
+            .response<UserWrapper<User>>()
+            .failure<GenericErrorModel>(HttpStatusCode.UnprocessableEntity)
 
         object Login : StaticResource<Users>("login", Users) {
-            val authenticate by
-                post()
-                    .request<UserWrapper<LoginUser>>()
-                    .response<UserWrapper<User>>()
-                    .failure<GenericErrorModel>(HttpStatusCode.UnprocessableEntity)
+            val authenticate by post()
+                .request<UserWrapper<LoginUser>>()
+                .response<UserWrapper<User>>()
+                .failure<GenericErrorModel>(HttpStatusCode.UnprocessableEntity)
         }
     }
 
     object CurrentUser : StaticResource<Api>("user", Api) {
-        val get by
-            get()
-                .response<UserWrapper<User>>()
-                .failure<GenericErrorModel>(HttpStatusCode.UnprocessableEntity)
-
-        val update by
-            put()
-                .request<UserWrapper<UpdateUser>>()
-                .response<UserWrapper<User>>()
-                .failure<GenericErrorModel>(HttpStatusCode.UnprocessableEntity)
+        val get by get()
+            .response<UserWrapper<User>>()
+            .failure<GenericErrorModel>(HttpStatusCode.UnprocessableEntity)
+
+        val update by put()
+            .request<UserWrapper<UpdateUser>>()
+            .response<UserWrapper<User>>()
+            .failure<GenericErrorModel>(HttpStatusCode.UnprocessableEntity)
     }
 }

src/main/kotlin/io/github/nomisrev/DomainError.kt

@@ -1,9 +1,12 @@
 package io.github.nomisrev
 
 import arrow.core.NonEmptyList
+import arrow.core.raise.context.Raise
 import kotlinx.serialization.ExperimentalSerializationApi
 import kotlinx.serialization.MissingFieldException
 
+typealias DomainErrors = Raise<DomainError>
+
 sealed interface DomainError
 
 sealed interface ValidationError : DomainError