Add concurrency test

build.gradle.kts

@@ -45,6 +45,7 @@ kotlin {
             apiVersion = kotlinApiTarget
         }
     }
+
     jvm {
         compilations.all {
             kotlinOptions.jvmTarget = jvmTarget.toString()

src/commonMain/kotlin/io/konform/validation/internal/Validation.kt

@@ -33,7 +33,7 @@ internal class NonNullPropertyValidation<T, R>(
 ) : Validation<T> {
     override fun validate(value: T): ValidationResult<T> {
         val propertyValue = property(value)
-        return validation(propertyValue).mapError { ".${property.name}$it" }.map { value }
+        return validation.validate(propertyValue).mapError { ".${property.name}$it" }.map { value }
     }
 }
 
@@ -75,7 +75,7 @@ internal class ArrayValidation<T>(
 ) : Validation<Array<T>> {
     override fun validate(value: Array<T>): ValidationResult<Array<T>> {
         return value.foldIndexed(Valid(value)) { index, result: ValidationResult<Array<T>>, propertyValue ->
-            val propertyValidation = validation(propertyValue).mapError { "[$index]$it" }.map { value }
+            val propertyValidation = validation.validate(propertyValue).mapError { "[$index]$it" }.map { value }
             result.combineWith(propertyValidation)
         }
     }
@@ -86,7 +86,10 @@ internal class MapValidation<K, V>(
 ) : Validation<Map<K, V>> {
     override fun validate(value: Map<K, V>): ValidationResult<Map<K, V>> {
         return value.asSequence().fold(Valid(value)) { result: ValidationResult<Map<K, V>>, entry ->
-            val propertyValidation = validation(entry).mapError { ".${entry.key}${it.removePrefix(".value")}" }.map { value }
+            val propertyValidation =
+                validation.validate(entry)
+                    .mapError { ".${entry.key}${it.removePrefix(".value")}" }
+                    .map { value }
             result.combineWith(propertyValidation)
         }
     }

src/commonTest/kotlin/io/konform/validation/ValidationBuilderTest.kt

@@ -160,7 +160,7 @@ class ValidationBuilderTest {
     fun validatingNullableValues() {
         val nullableValueValidation =
             Validation<String?> {
-                addConstraint("cannot be null") { it != null}
+                addConstraint("cannot be null") { it != null }
             }
 
         "poweruser@test.com".let { assertEquals(Valid(it), nullableValueValidation(it)) }

src/jvmTest/kotlin/io/konform/validation/ConcurrencyTest.kt

@@ -0,0 +1,42 @@
+package io.konform.validation
+
+import kotlin.concurrent.thread
+import kotlin.test.Test
+import kotlin.test.assertContentEquals
+import kotlin.test.assertEquals
+
+class ConcurrencyTest {
+    data class User(val name: String)
+
+    val user1 = User("a")
+    val user2 = User("invalid")
+
+    private val sleepTimeMs = 300L
+
+    val mustNotBeNamedInvalidValidation =
+        Validation<User> { (user) ->
+            addConstraint("Cannot be 'invalid'") {
+                // Simulate a long expensive blocking operation
+                Thread.sleep(sleepTimeMs)
+                user.name != "invalid"
+            }
+        }
+
+    @Test
+    fun validationsMustBeThreadSafe() {
+        var validation1Holder: ValidationResult<User>? = null
+        // Run the first validation concurrently
+        thread {
+            validation1Holder = mustNotBeNamedInvalidValidation.validate(user1)
+        }
+        val validation2 = mustNotBeNamedInvalidValidation.validate(user2)
+        // Give the thread time to finish
+        Thread.sleep(sleepTimeMs + 100)
+        val validation1 =
+            requireNotNull(validation1Holder) {
+                "Validation 1 should have completed by now"
+            }
+        assertContentEquals(validation1.errors, listOf())
+        assertEquals(1, validation2.errors.size)
+    }
+}