Migrate testtool to use cbor and websockets to improve compatibility tests performance

Author: whyoleg

cryptography-providers/tests/build.gradle.kts

@@ -48,7 +48,6 @@ kotlin {
             api(projects.cryptographySerializationAsn1)
             api(projects.cryptographySerializationAsn1Modules)
 
-            api(libs.kotlinx.serialization.json)
             api(libs.kotlinx.coroutines.test)
 
             implementation("testtool:client")

cryptography-providers/tests/src/commonMain/kotlin/compatibility/AesCbcCompatibilityTest.kt

@@ -23,7 +23,7 @@ abstract class AesCbcCompatibilityTest(provider: CryptographyProvider) :
     @Serializable
     private data class CipherParameters(
         val padding: Boolean,
-        val iv: ByteStringAsString?,
+        val iv: SerializableByteString?,
     ) : TestParameters
 
     override suspend fun CompatibilityTestScope<AES.CBC>.generate(isStressTest: Boolean) {

cryptography-providers/tests/src/commonMain/kotlin/compatibility/AesCtrCompatibilityTest.kt

@@ -19,7 +19,7 @@ abstract class AesCtrCompatibilityTest(provider: CryptographyProvider) :
 
     @Serializable
     private data class CipherParameters(
-        val iv: ByteStringAsString?,
+        val iv: SerializableByteString?,
     ) : TestParameters {
         override fun toString(): String = "CipherParameters(iv.size=${iv?.size})"
     }

cryptography-providers/tests/src/commonMain/kotlin/compatibility/AesGcmCompatibilityTest.kt

@@ -22,7 +22,7 @@ abstract class AesGcmCompatibilityTest(provider: CryptographyProvider) :
     @Serializable
     private data class CipherParameters(
         val tagSizeBits: Int,
-        val iv: ByteStringAsString?,
+        val iv: SerializableByteString?,
     ) : TestParameters
 
     override suspend fun CompatibilityTestScope<AES.GCM>.generate(isStressTest: Boolean) {

cryptography-providers/tests/src/commonMain/kotlin/compatibility/HkdfCompatibilityTest.kt

@@ -23,8 +23,8 @@ abstract class HkdfCompatibilityTest(provider: CryptographyProvider) : Compatibi
     @Serializable
     private data class Parameters(
         val digestName: String,
-        val salt: ByteStringAsString,
-        val info: ByteStringAsString?,
+        val salt: SerializableByteString,
+        val info: SerializableByteString?,
         val outputSizeBytes: Int,
     ) : TestParameters {
         val digest get() = digest(digestName)

cryptography-providers/tests/src/commonMain/kotlin/compatibility/Pbkdf2CompatibilityTest.kt

@@ -26,7 +26,7 @@ abstract class Pbkdf2CompatibilityTest(provider: CryptographyProvider) : Compati
     @Serializable
     private data class Parameters(
         val digestName: String,
-        val salt: ByteStringAsString,
+        val salt: SerializableByteString,
         val iterations: Int,
         val outputSizeBytes: Int,
     ) : TestParameters {

cryptography-providers/tests/src/commonMain/kotlin/compatibility/api/ByteStringAsStringSerializer.kt

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2024-2025 Oleg Yukhnevich. Use of this source code is governed by the Apache 2.0 license.
+ */
+
+package dev.whyoleg.cryptography.providers.tests.compatibility.api
+
+import kotlinx.io.bytestring.*
+import kotlinx.io.bytestring.unsafe.*
+import kotlinx.serialization.*
+import kotlinx.serialization.descriptors.*
+import kotlinx.serialization.encoding.*
+import kotlin.jvm.*
+
+typealias SerializableByteString = @Serializable(ByteStringSerializer::class) ByteString
+
+@Serializable
+@JvmInline
+private value class ByteStringWrapper(val value: ByteArray)
+
+@OptIn(UnsafeByteStringApi::class)
+internal object ByteStringSerializer : KSerializer<ByteString> {
+    private val delegate get() = ByteStringWrapper.serializer()
+
+    override val descriptor: SerialDescriptor get() = delegate.descriptor
+
+    override fun deserialize(decoder: Decoder): ByteString {
+        return UnsafeByteStringOperations.wrapUnsafe(delegate.deserialize(decoder).value)
+    }
+
+    override fun serialize(encoder: Encoder, value: ByteString) {
+        UnsafeByteStringOperations.withByteArrayUnsafe(value) {
+            delegate.serialize(encoder, ByteStringWrapper(it))
+        }
+    }
+}

cryptography-providers/tests/src/commonMain/kotlin/compatibility/api/ByteStringSerializer.kt

@@ -5,6 +5,7 @@
 package dev.whyoleg.cryptography.providers.tests.compatibility.api
 
 import dev.whyoleg.cryptography.providers.tests.*
+import kotlinx.coroutines.flow.*
 import kotlin.reflect.*
 
 abstract class CompatibilityStorageApi(
@@ -20,9 +21,9 @@ abstract class CompatibilityStorageApi(
     }
 
     suspend inline fun <reified T : TestParameters> getParameters(
-        block: (parameters: T, parametersId: TestParametersId, context: TestContext) -> Unit,
+        crossinline block: suspend (parameters: T, parametersId: TestParametersId, context: TestContext) -> Unit,
     ) {
-        getParameters<T>(typeOf<T>()).forEach { (id, parameters, context) ->
+        getParameters<T>(typeOf<T>()).collect { (id, parameters, context) ->
             logger.log { "$storageName.getParameters: $id -> $parameters | $context" }
             block(parameters, TestParametersId(id), context)
         }
@@ -39,18 +40,18 @@ abstract class CompatibilityStorageApi(
         parametersId: TestParametersId,
         crossinline block: suspend (data: T, reference: TestReference, context: TestContext) -> Unit,
     ) {
-        getData<T>(parametersId, typeOf<T>()).forEach { (id, data, context) ->
+        getData<T>(parametersId, typeOf<T>()).collect { (id, data, context) ->
             val reference = TestReference(parametersId, TestDataId(id))
             logger.log { "$storageName.getData: $reference -> $data | $context" }
             block(data, reference, context)
         }
     }
 
     abstract suspend fun <T : TestParameters> saveParameters(parameters: T, type: KType): String
-    abstract suspend fun <T : TestParameters> getParameters(type: KType): List<TestContent<T>>
+    abstract fun <T : TestParameters> getParameters(type: KType): Flow<TestContent<T>>
 
     abstract suspend fun <T : TestData> saveData(parametersId: TestParametersId, data: T, type: KType): String
-    abstract suspend fun <T : TestData> getData(parametersId: TestParametersId, type: KType): List<TestContent<T>>
+    abstract fun <T : TestData> getData(parametersId: TestParametersId, type: KType): Flow<TestContent<T>>
 
     data class TestContent<T>(
         val id: String,

cryptography-providers/tests/src/commonMain/kotlin/compatibility/api/CompatibilityStorageApi.kt

@@ -6,6 +6,7 @@ package dev.whyoleg.cryptography.providers.tests.compatibility.api
 
 import dev.whyoleg.cryptography.*
 import dev.whyoleg.cryptography.providers.tests.*
+import dev.whyoleg.cryptography.testtool.client.*
 import kotlin.test.*
 
 abstract class CompatibilityTest<A : CryptographyAlgorithm>(
@@ -18,19 +19,25 @@ abstract class CompatibilityTest<A : CryptographyAlgorithm>(
     @Test
     fun generateStep() = testWithAlgorithm {
         val logger = logger.child("GENERATE")
-        runCompatibilityTestStep(logger, ServerApi(algorithmId.name, context, logger)) { generate(isStressTest = false) }
+        withTestToolClient { client ->
+            runCompatibilityTestStep(logger, ServerApi(algorithmId.name, context, logger, client)) { generate(isStressTest = false) }
+        }
     }
 
     @Test
     fun generateStressStep() = testWithAlgorithm {
         val logger = logger.child("GENERATE")
-        runCompatibilityTestStep(logger, ServerApi(algorithmId.name, context, logger)) { generate(isStressTest = true) }
+        withTestToolClient { client ->
+            runCompatibilityTestStep(logger, ServerApi(algorithmId.name, context, logger, client)) { generate(isStressTest = true) }
+        }
     }
 
     @Test
     fun validateStep() = testWithAlgorithm {
         val logger = logger.child("VALIDATE")
-        runCompatibilityTestStep(logger, ServerApi(algorithmId.name, context, logger)) { validate() }
+        withTestToolClient { client ->
+            runCompatibilityTestStep(logger, ServerApi(algorithmId.name, context, logger, client)) { validate() }
+        }
     }
 
     @Test
@@ -49,4 +56,13 @@ abstract class CompatibilityTest<A : CryptographyAlgorithm>(
     ) {
         CompatibilityTestScope(logger, context, provider, algorithm, api).block()
     }
+
+    private suspend inline fun withTestToolClient(block: (TesttoolClient) -> Unit) {
+        val client = TesttoolClient()
+        try {
+            block(client)
+        } finally {
+            client.cleanup()
+        }
+    }
 }