fix(#10): versioning is not properly handled for multiple versions (#11)

Author: y9vad9

gradle/libs.versions.toml

@@ -4,6 +4,8 @@ kotlinx-coroutines = "1.6.4"
 kotlinx-serialization = "1.4.1"
 sqldelight = "2.0.0-alpha05"
 rsocket = "0.15.4"
+ktor = "2.3.0"
+mockk = "1.13.5"
 
 [libraries]
 kotlinx-coroutines = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kotlinx-coroutines" }
@@ -15,9 +17,13 @@ kotlin-test = { module = "org.jetbrains.kotlin:kotlin-test", version.ref = "kotl
 kotlin-plugin = { module = "org.jetbrains.kotlin:kotlin-gradle-plugin", version.ref = "kotlin" }
 publish-library = { module = "publish-library:publish-library", version.require = "SNAPSHOT" }
 vanniktech-maven-publish = { module = "com.vanniktech.maven.publish:com.vanniktech.maven.publish.gradle.plugin", version.require = "0.25.3" }
+ktor-server-core = { module = "io.ktor:ktor-server-core", version.ref = "ktor" }
+ktor-server-netty = { module = "io.ktor:ktor-server-netty", version.ref = "ktor" }
+mockk = { module = "io.mockk:mockk", version.ref = "mockk" }
 
 [plugins]
 kotlinx-serialization = { id = "org.jetbrains.kotlin.plugin.serialization", version.ref = "kotlin" }
 kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }
 kotlin-multiplatform = { id = "org.jetbrains.kotlin.multiplatform", version.ref = "kotlin" }
 multiplatform-module-convention = { id = "multiplatform-module-convention", version.require = "SNAPSHOT" }
+example-module-convention = { id = "example-module-convention", version.require = "SNAPSHOT" }

router-versioning/core/build.gradle.kts

@@ -5,6 +5,9 @@ plugins {
 dependencies {
     commonMainImplementation(libs.rsocket.server)
     commonMainImplementation(projects.routerCore)
+
+    jvmTestImplementation(libs.kotlin.test)
+    jvmTestImplementation(projects.routerCore.test)
 }
 
 mavenPublishing {

router-versioning/core/src/commonMain/kotlin/com/y9vad9/rsocket/router/versioning/RouterBuilderExt.kt

@@ -0,0 +1,21 @@
+package com.y9vad9.rsocket.router.versioning
+
+import com.y9vad9.rsocket.router.annotations.ExperimentalInterceptorsApi
+import com.y9vad9.rsocket.router.builders.RouterBuilder
+import com.y9vad9.rsocket.router.versioning.preprocessor.VersionPreprocessor
+import io.ktor.utils.io.core.*
+import io.rsocket.kotlin.payload.Payload
+import kotlin.coroutines.CoroutineContext
+
+@OptIn(ExperimentalInterceptorsApi::class)
+public fun RouterBuilder.versioning(
+    block: (metadata: ByteReadPacket?, coroutineContext: CoroutineContext) -> Version,
+) {
+    preprocessors {
+        forCoroutineContext(object : VersionPreprocessor() {
+            override fun version(payload: Payload, coroutineContext: CoroutineContext): Version {
+                return block(payload.metadata, coroutineContext)
+            }
+        })
+    }
+}

router-versioning/core/src/commonMain/kotlin/com/y9vad9/rsocket/router/versioning/Version.kt

@@ -5,10 +5,13 @@ import com.y9vad9.rsocket.router.versioning.preprocessor.VersionPreprocessor
 import kotlin.coroutines.coroutineContext
 
 /**
- * Represents a version number.
+ * Represents a version with major, minor, and patch components.
  *
- * @param double The numerical value of the version.
- * @throws IllegalArgumentException if the version is negative.
+ * @property major The major version component.
+ * @property minor The minor version component.
+ * @property patch The patch version component.
+ * @constructor Creates a Version instance with the specified major, minor, and patch components.
+ * @throws IllegalArgumentException if major, minor, or patch is negative.
  */
 public data class Version(public val major: Int, public val minor: Int, public val patch: Int = 0) : Comparable<Version> {
     init {
@@ -59,9 +62,13 @@ public data class Version(public val major: Int, public val minor: Int, public v
  */
 public infix fun Version.until(another: Version): ClosedRange<Version> {
     return when {
-        another.patch > 0 -> this .. another.copy(patch = patch - 1)
-        another.minor > 0 -> this .. another.copy(minor = minor - 1)
-        another.major > 0 -> this .. another.copy(major = major - 1)
+        another.patch > 0 -> this .. another.copy(patch = another.patch - 1)
+        another.minor > 0 -> this .. another.copy(minor = another.minor - 1, patch = Int.MAX_VALUE)
+        another.major > 0 -> this .. another.copy(
+            major = another.major - 1,
+            minor = Int.MAX_VALUE,
+            patch = Int.MAX_VALUE,
+        )
         else -> error("Unable to create `until` range – version cannot be negative.")
     }
 }

router-versioning/core/src/commonMain/kotlin/com/y9vad9/rsocket/router/versioning/VersionedRequest.kt

@@ -53,11 +53,12 @@ internal sealed class VersionedRequest<T, R> {
 
             return variants.firstOrNull { (requirement, _) ->
                 requirement.satisfies(version)
-            }?.second?.invoke(input) ?: throw RSocketError.Rejected("Request is not available for your API version.")
+            }?.also { println(it.first) }?.second?.invoke(input) ?: throw RSocketError.Rejected("Request is not available for your API version.")
         }
     }
 }
 
+
 public data class PayloadStream(
     val initPayload: io.rsocket.kotlin.payload.Payload,
     val payloads: Flow<io.rsocket.kotlin.payload.Payload>,

router-versioning/core/src/commonMain/kotlin/com/y9vad9/rsocket/router/versioning/builders/VersioningBuilder.kt

@@ -19,7 +19,7 @@ public class VersioningBuilder<T, R> internal constructor() {
      * @param version The new version to be applied.
      * @param block The coroutine block that will be executed for the given version.
      */
-    public fun version(version: Version, block: suspend (T) -> R): Unit {
+    public fun version(version: Version, block: suspend (T) -> R) {
         versionedRequest = when (val versionedRequest = versionedRequest) {
             null -> {
                 VersionedRequest.SingleConditional(
@@ -41,12 +41,14 @@ public class VersioningBuilder<T, R> internal constructor() {
 
             is VersionedRequest.MultipleConditional<T, R> -> {
                 versionedRequest.copy(
-                    variants = versionedRequest.variants.mapIndexed { index, (requirements, function) ->
+                    variants = (versionedRequest.variants.mapIndexed { index, (requirements, function) ->
                         if (index == versionedRequest.variants.lastIndex)
                             requirements.copy(
                                 lastAcceptableVersion = (requirements.firstAcceptableVersion until version).endInclusive,
                             ) to function
                         else requirements to function
+                    } + (VersionRequirements(version, Version.INDEFINITE) to block)).sortedBy {
+                        it.first.firstAcceptableVersion
                     }
                 )
             }

router-versioning/core/src/commonMain/kotlin/com/y9vad9/rsocket/router/versioning/preprocessor/VersionPreprocessor.kt

@@ -21,9 +21,9 @@ public abstract class VersionPreprocessor : Preprocessor.CoroutineContext {
      * @param payload The payload containing the version information.
      * @return The version extracted from the payload.
      */
-    public abstract fun version(payload: Payload): Version
+    public abstract fun version(payload: Payload, coroutineContext: CoroutineContext): Version
 
     final override fun intercept(coroutineContext: CoroutineContext, input: Payload): CoroutineContext {
-        return coroutineContext + VersionElement(version(input))
+        return coroutineContext + VersionElement(version(input, coroutineContext))
     }
 }

router-versioning/core/src/jvmTest/kotlin/com/y9vad9/rsocket/router/versioning/test/DeclarableRoutingBuilderExtTest.kt

@@ -0,0 +1,104 @@
+package com.y9vad9.rsocket.router.versioning.test
+
+import com.y9vad9.rsocket.router.annotations.ExperimentalInterceptorsApi
+import com.y9vad9.rsocket.router.router
+import com.y9vad9.rsocket.router.test.requestResponseOrAssert
+import com.y9vad9.rsocket.router.test.routeAtOrAssert
+import com.y9vad9.rsocket.router.versioning.Version
+import com.y9vad9.rsocket.router.versioning.builders.version
+import com.y9vad9.rsocket.router.versioning.preprocessor.VersionPreprocessor
+import com.y9vad9.rsocket.router.versioning.requestResponseV
+import com.y9vad9.rsocket.router.versioning.versioning
+import io.ktor.utils.io.core.*
+import io.rsocket.kotlin.RSocketError
+import io.rsocket.kotlin.payload.Payload
+import kotlinx.coroutines.runBlocking
+import kotlinx.coroutines.withContext
+import kotlin.test.Test
+import kotlin.test.assertEquals
+import kotlin.test.assertFailsWith
+
+@OptIn(ExperimentalInterceptorsApi::class)
+class DeclarableRoutingBuilderExtTest {
+    private val thirdRequestResponse = Payload(ByteReadPacket("test".toByteArray()))
+
+    private val router = router {
+        routeProvider { error("Stub!") }
+        versioning { _, _ -> error("Stub!") }
+
+        routing {
+            route("test") {
+                requestResponseV {
+                    version(2) { _ ->
+                        Payload.Empty
+                    }
+
+                    version(3) { _ ->
+                        return@version thirdRequestResponse
+                    }
+                }
+            }
+        }
+    }
+
+    // это ахуенно
+    @Test
+    fun `test invalid version should fail`(): Unit = runBlocking {
+        // GIVEN
+        val context = VersionPreprocessor.VersionElement(Version(1, 0))
+
+        // THEN
+        assertFailsWith<RSocketError.Rejected> {
+            withContext(context) {
+                router.routeAtOrAssert("test")
+                    .requestResponse(payload = Payload.Empty)
+            }
+        }
+    }
+
+    @Test
+    fun `test 2 version should pass within range`(): Unit = runBlocking {
+        // GIVEN
+        val contexts = listOf(
+            VersionPreprocessor.VersionElement(Version(2, 0)),
+            VersionPreprocessor.VersionElement(Version(2, 1)),
+            VersionPreprocessor.VersionElement(Version(2, 9)),
+        )
+
+        // WHEN
+        repeat(contexts.size) { time ->
+            withContext(contexts[time]) {
+                val result = router.routeAtOrAssert("test")
+                    .requestResponseOrAssert(payload = Payload.Empty)
+
+                // THEN
+                assertEquals(
+                    expected = Payload.Empty,
+                    actual = result,
+                )
+            }
+        }
+    }
+
+    @Test
+    fun `test 3 version should be correct`(): Unit = runBlocking {
+        // GIVEN
+        val contexts = listOf(
+            VersionPreprocessor.VersionElement(Version(3, 0)),
+            VersionPreprocessor.VersionElement(Version(3, 9)),
+            VersionPreprocessor.VersionElement(Version(4, 0)),
+        )
+
+        repeat(contexts.size) { time ->
+            withContext(contexts[time]) {
+                val result = router.routeAtOrAssert("test")
+                    .requestResponseOrAssert(payload = Payload.Empty)
+
+                assertEquals(
+                    expected = thirdRequestResponse,
+                    actual = result,
+                )
+            }
+        }
+    }
+}