move dokka to new api + tests from kotest to junit

build.gradle.kts

@@ -1,17 +1,14 @@
 @file:Suppress("PropertyName")
 
 import kotlinx.validation.ExperimentalBCVApi
-import org.jetbrains.dokka.base.DokkaBase
-import org.jetbrains.dokka.base.DokkaBaseConfiguration
-import java.time.LocalDate
 
 plugins {
     alias(libs.plugins.deteKT)
-    alias(libs.plugins.dokka)
     alias(libs.plugins.ktlinter)
     alias(libs.plugins.kotlin.binvalid)
     alias(libs.plugins.kover)
-    id("publish")
+    dokka
+    publish
 }
 
 group = "eu.vendeli.re.this"
@@ -33,7 +30,6 @@ configureKotlin {
 
         jvmTest.dependencies {
             implementation(libs.kotlin.reflect)
-            implementation(libs.test.kotest.junit5)
             implementation(libs.test.kotest.assertions)
             implementation(libs.logback)
             implementation("com.redis:testcontainers-redis:1.7.0") {
@@ -44,25 +40,16 @@ configureKotlin {
             implementation("commons-io:commons-io:2.18.0")
             implementation("org.apache.commons:commons-compress:1.27.1")
             implementation("com.fasterxml.woodstox:woodstox-core:7.1.0")
+
+            implementation(libs.kotlin.junit)
+            implementation(libs.junit.api)
+            runtimeOnly(libs.junit.engine)
         }
     }
 }
 
-buildscript { dependencies.classpath(libs.dokka.base) }
-
 tasks {
     withType<Test> { useJUnitPlatform() }
-    dokkaHtml.configure {
-        outputDirectory = layout.buildDirectory.asFile.orNull?.resolve("dokka")
-        dokkaSourceSets {
-            collectionSchema.elements.forEach { _ -> moduleName = "re.this" }
-        }
-        pluginConfiguration<DokkaBase, DokkaBaseConfiguration> {
-            customAssets = listOf(rootDir.resolve("assets/logo-icon.svg"))
-            homepageLink = "https://github.com/vendelieu/re.this"
-            footerMessage = "© ${LocalDate.now().year} Vendelieu"
-        }
-    }
 }
 
 @OptIn(ExperimentalBCVApi::class)

buildSrc/build.gradle.kts

@@ -4,6 +4,7 @@ plugins {
 
 dependencies {
     implementation(libs.kotlin.gradlePlugin)
+    implementation(libs.dokka)
     implementation(libs.publisher)
 }
 

buildSrc/src/main/kotlin/EnvParams.kt → buildSrc/src/main/kotlin/CommonParams.kt

@@ -1,4 +1,6 @@
-object EnvParams {
+object CommonParams {
     val releaseMode get() = System.getenv("release") != null
     val metadataOnly: Boolean get() = System.getenv("meta_only") != null
+
+    const val REPO_URL = "https://github.com/vendelieu/re.this"
 }

buildSrc/src/main/kotlin/CompilationConfiguration.kt

@@ -37,7 +37,7 @@ enum class HostType {
 }
 
 fun KotlinTarget.isCompilationAllowed(): Boolean {
-    if ((name == KotlinMetadataTarget.METADATA_TARGET_NAME) || !EnvParams.releaseMode) {
+    if ((name == KotlinMetadataTarget.METADATA_TARGET_NAME) || !CommonParams.releaseMode) {
         return true
     }
 
@@ -73,9 +73,9 @@ fun AbstractPublishToMaven.isAllowed(targets: NamedDomainObjectCollection<Kotlin
     val publicationName: String? = publication?.name
 
     return when {
-        publicationName == "kotlinMultiplatform" -> !EnvParams.releaseMode || EnvParams.metadataOnly
+        publicationName == "kotlinMultiplatform" -> !CommonParams.releaseMode || CommonParams.metadataOnly
 
-        EnvParams.metadataOnly -> false
+        CommonParams.metadataOnly -> false
 
         publicationName != null -> {
             val target = targets.find { it.name.startsWith(publicationName) }

buildSrc/src/main/kotlin/dokka.gradle.kts

@@ -0,0 +1,22 @@
+import CommonParams.REPO_URL
+import java.time.LocalDate
+
+plugins {
+    id("org.jetbrains.dokka")
+}
+dokka {
+    moduleName = "re.this"
+    dokkaSourceSets.configureEach {
+        sourceRoots.setFrom(project.projectDir.resolve("src/$name/kotlin"))
+        sourceLink {
+            localDirectory.set(file("src/$name/kotlin"))
+            remoteUrl("$REPO_URL/blob/master/src/$name/kotlin")
+            remoteLineSuffix.set("#L")
+        }
+    }
+    pluginsConfiguration.html {
+        customAssets.from(rootDir.resolve("assets/logo-icon.svg"))
+        footerMessage.set("© ${LocalDate.now().year} Vendelieu")
+        homepageLink.set(REPO_URL)
+    }
+}

buildSrc/src/main/kotlin/publish.gradle.kts

@@ -1,3 +1,4 @@
+import CommonParams.REPO_URL
 import com.vanniktech.maven.publish.JavadocJar
 import com.vanniktech.maven.publish.KotlinMultiplatform
 import com.vanniktech.maven.publish.SonatypeHost
@@ -17,7 +18,7 @@ mavenPublishing {
     val javaDoc = if (releaseMode) {
         signAllPublications()
 
-        JavadocJar.Dokka("dokkaHtml")
+        JavadocJar.Dokka("dokkaGenerate")
     } else JavadocJar.Empty()
 
     configure(KotlinMultiplatform(javaDoc, true))
@@ -26,7 +27,7 @@ mavenPublishing {
         name = project.name
         description = "Kotlin Multiplatform Redis Client: coroutine-based, DSL-powered, and easy to use."
         inceptionYear = "2024"
-        url = "https://github.com/vendelieu/re.this"
+        url = REPO_URL
 
         licenses {
             license {
@@ -45,11 +46,11 @@ mavenPublishing {
         scm {
             connection = "scm:git:github.com/vendelieu/re.this.git"
             developerConnection = "scm:git:ssh://github.com/vendelieu/re.this.git"
-            url = "https://github.com/vendelieu/re.this.git"
+            url = "$REPO_URL.git"
         }
         issueManagement {
             system = "Github"
-            url = "https://github.com/vendelieu/re.this/issues"
+            url = "$REPO_URL/issues"
         }
     }
 }

gradle.properties

@@ -1,3 +1,4 @@
 kotlin.code.style=official
 kotlin.native.ignoreDisabledTargets=true
-org.gradle.jvmargs=-Xmx6g -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8 -XX:+UseParallelGC -XX:MaxMetaspaceSize=1g
+org.gradle.jvmargs=-Xmx6g -XX:+HeapDumpOnOutOfMemoryError -Dfile.encoding=UTF-8 -XX:+UseParallelGC -XX:MaxMetaspaceSize=1g
+org.jetbrains.dokka.experimental.gradle.pluginMode=V2Enabled

gradle/libs.versions.toml

@@ -15,6 +15,7 @@ binvalid = "0.17.0"
 kover = "0.9.0"
 
 kotest = "5.9.1"
+junit = "5.11.4"
 logback = "1.5.14"
 
 [libraries]
@@ -25,18 +26,19 @@ ktor-network-tls = { module = "io.ktor:ktor-network-tls", version.ref = "ktor" }
 bignum = { module = "com.ionspin.kotlin:bignum", version.ref = "bignum" }
 
 coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "coroutines" }
-dokka-base = { module = "org.jetbrains.dokka:dokka-base", version.ref = "dokka" }
+dokka = { module = "org.jetbrains.dokka:dokka-gradle-plugin", version.ref = "dokka" }
 kotlin-gradlePlugin = { module = "org.jetbrains.kotlin:kotlin-gradle-plugin", version.ref = "kotlin" }
 publisher = { module = "com.vanniktech:gradle-maven-publish-plugin", version.ref = "publisher" }
 
 # testing
 kotlin-reflect = { module = "org.jetbrains.kotlin:kotlin-reflect", version.ref = "kotlin" }
-test-kotest-junit5 = { module = "io.kotest:kotest-runner-junit5", version.ref = "kotest" }
+kotlin-junit = { module = "org.jetbrains.kotlin:kotlin-test-junit", version.ref = "kotlin" }
 test-kotest-assertions = { module = "io.kotest:kotest-assertions-core", version.ref = "kotest" }
+junit-api = { module = "org.junit.jupiter:junit-jupiter-api", version.ref = "junit" }
+junit-engine = { module = "org.junit.jupiter:junit-jupiter-engine", version.ref = "junit" }
 logback = { module = "ch.qos.logback:logback-classic", version.ref = "logback" }
 
 [plugins]
-dokka = { id = "org.jetbrains.dokka", version.ref = "dokka" }
 ktlinter = { id = "org.jmailen.kotlinter", version.ref = "kotlinter" }
 deteKT = { id = "io.gitlab.arturbosch.detekt", version.ref = "deteKT" }
 kover = { id = "org.jetbrains.kotlinx.kover", version.ref = "kover" }

src/commonMain/kotlin/eu/vendeli/rethis/ReThis.kt

@@ -11,6 +11,7 @@ import eu.vendeli.rethis.utils.Const.DEFAULT_PORT
 import io.ktor.network.sockets.*
 import io.ktor.util.logging.*
 import io.ktor.utils.io.*
+import kotlinx.coroutines.CoroutineName
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.currentCoroutineContext
 import kotlinx.io.Buffer
@@ -32,6 +33,7 @@ class ReThis(
     internal val logger = KtorSimpleLogger("eu.vendeli.rethis.ReThis")
     internal val cfg: ClientConfiguration = ClientConfiguration().apply(configurator)
     internal val rootJob = SupervisorJob()
+    internal val rethisCoScope = rootJob + CoroutineName("ReThis")
     internal val connectionPool by lazy { ConnectionPool(this, address.socket).also { it.prepare() } }
 
     init {

src/commonMain/kotlin/eu/vendeli/rethis/types/core/ConnectionPool.kt

@@ -27,7 +27,7 @@ internal class ConnectionPool(
 
     private val job = SupervisorJob(client.rootJob)
     private val connections = Channel<Connection>(client.cfg.poolConfiguration.poolSize)
-    private val selector = SelectorManager(client.cfg.poolConfiguration.dispatcher + job)
+    private val selector = SelectorManager(client.cfg.poolConfiguration.dispatcher + job + CoroutineName("ReThis Pool"))
 
     internal suspend fun createConn(): Connection {
         logger.trace("Creating connection to $address")

src/jvmTest/kotlin/eu/vendeli/rethis/ReThisTestCtx.kt

@@ -1,8 +1,6 @@
 package eu.vendeli.rethis
 
 import com.redis.testcontainers.RedisContainer
-import io.kotest.core.spec.style.AnnotationSpec
-import io.ktor.network.sockets.*
 import kotlinx.datetime.Clock
 import kotlinx.datetime.Instant
 import org.testcontainers.utility.DockerImageName

src/jvmTest/kotlin/eu/vendeli/rethis/tests/ClientConnectionTest.kt

@@ -2,16 +2,15 @@ package eu.vendeli.rethis.tests
 
 import eu.vendeli.rethis.ReThisTestCtx
 import eu.vendeli.rethis.commands.ping
-import io.kotest.core.spec.IsolationMode
 import io.kotest.matchers.shouldBe
 import kotlinx.coroutines.delay
-import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.runBlocking
 import org.junit.jupiter.api.Test
 
 class ClientConnectionTest : ReThisTestCtx() {
 
     @Test
-    fun `client disconnect test`(): Unit = runTest {
+    fun `client disconnect test`(): Unit = runBlocking {
         client.ping()
 
         client.isDisconnected shouldBe false
@@ -20,7 +19,7 @@ class ClientConnectionTest : ReThisTestCtx() {
     }
 
     @Test
-    fun `client reconnect test`(): Unit = runTest {
+    fun `client reconnect test`(): Unit = runBlocking {
         client.ping()
 
         client.isDisconnected shouldBe false

src/jvmTest/kotlin/eu/vendeli/rethis/tests/PipeliningTest.kt

@@ -9,12 +9,12 @@ import eu.vendeli.rethis.types.core.PlainString
 import eu.vendeli.rethis.types.core.RespVer
 import io.kotest.matchers.collections.shouldHaveSize
 import io.kotest.matchers.shouldBe
-import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.runBlocking
 import org.junit.jupiter.api.Test
 
 class PipeliningTest : ReThisTestCtx() {
     @Test
-    fun `pipelining test`(): Unit = runTest {
+    fun `pipelining test`(): Unit = runBlocking {
         val v2Client = ReThis(redis.host, redis.firstMappedPort, protocol = RespVer.V2) {
             pool {
                 poolSize = 1
@@ -32,7 +32,7 @@ class PipeliningTest : ReThisTestCtx() {
     }
 
     @Test
-    fun `pipelining + transaction test`(): Unit = runTest {
+    fun `pipelining + transaction test`(): Unit = runBlocking {
         client
             .transaction {
                 client.pipeline {
@@ -47,7 +47,7 @@ class PipeliningTest : ReThisTestCtx() {
     }
 
     @Test
-    fun `transaction + pipeline test`(): Unit = runTest {
+    fun `transaction + pipeline test`(): Unit = runBlocking {
         client
             .pipeline {
                 client.transaction {
@@ -67,7 +67,7 @@ class PipeliningTest : ReThisTestCtx() {
     }
 
     @Test
-    fun `nested pipeline test`(): Unit = runTest {
+    fun `nested pipeline test`(): Unit = runBlocking {
         client
             .pipeline {
                 set("test1", "testv1")
@@ -87,7 +87,7 @@ class PipeliningTest : ReThisTestCtx() {
     }
 
     @Test
-    fun `nested transaction test`(): Unit = runTest {
+    fun `nested transaction test`(): Unit = runBlocking {
         client
             .transaction {
                 set("test1", "testv1")

src/jvmTest/kotlin/eu/vendeli/rethis/tests/commands/ConnectionCommandsTest.kt

@@ -11,22 +11,22 @@ import io.kotest.matchers.ints.shouldBeGreaterThan
 import io.kotest.matchers.nulls.shouldNotBeNull
 import io.kotest.matchers.shouldBe
 import io.kotest.matchers.string.shouldContain
-import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.runBlocking
 import org.junit.jupiter.api.Test
 
 class ConnectionCommandsTest : ReThisTestCtx() {
     @Test
-    fun `test HELLO command with default parameters`() = runTest {
+    fun `test HELLO command with default parameters`(): Unit = runBlocking {
         client.hello().shouldNotBeNull().size shouldBeGreaterThan 1
     }
 
     @Test
-    fun `test HELLO command with proto parameter`() = runTest {
+    fun `test HELLO command with proto parameter`(): Unit = runBlocking {
         client.hello(proto = 2).shouldNotBeNull()["proto"] shouldBe Int64(2)
     }
 
     @Test
-    fun `test HELLO command with username and password parameters`() = runTest {
+    fun `test HELLO command with username and password parameters`(): Unit = runBlocking {
         shouldThrow<ReThisException> {
             client.hello(
                 username = "test",
@@ -36,31 +36,31 @@ class ConnectionCommandsTest : ReThisTestCtx() {
     }
 
     @Test
-    fun `test HELLO command with name parameter`() = runTest {
+    fun `test HELLO command with name parameter`(): Unit = runBlocking {
         client.hello(name = "test").shouldNotBeNull().size shouldBeGreaterThan 1
     }
 
     @Test
-    fun `test PING command with default message`() = runTest {
+    fun `test PING command with default message`(): Unit = runBlocking {
         val response = client.ping()
         response shouldBe "PONG"
     }
 
     @Test
-    fun `test PING command with custom message`() = runTest {
+    fun `test PING command with custom message`(): Unit = runBlocking {
         val message = "Hello, Redis!"
         val response = client.ping(message)
         response shouldBe message
     }
 
     @Test
-    fun `test SELECT command with valid database index`() = runTest {
+    fun `test SELECT command with valid database index`(): Unit = runBlocking {
         val response = client.select(0)
         response shouldBe "OK"
     }
 
     @Test
-    fun `test SELECT command with invalid database index`() = runTest {
+    fun `test SELECT command with invalid database index`(): Unit = runBlocking {
         shouldThrow<ReThisException> {
             client.select(100)
         }