Add oneOf assertion

Author: Oleg

src/commonMain/kotlin/smirnov/oleg/json/schema/internal/SchemaLoader.kt

@@ -19,6 +19,7 @@ import smirnov.oleg.json.schema.internal.factories.condition.AllOfAssertionFacto
 import smirnov.oleg.json.schema.internal.factories.condition.AnyOfAssertionFactory
 import smirnov.oleg.json.schema.internal.factories.condition.IfThenElseAssertionFactory
 import smirnov.oleg.json.schema.internal.factories.condition.NotAssertionFactory
+import smirnov.oleg.json.schema.internal.factories.condition.OneOfAssertionFactory
 import smirnov.oleg.json.schema.internal.factories.general.ConstAssertionFactory
 import smirnov.oleg.json.schema.internal.factories.general.EnumAssertionFactory
 import smirnov.oleg.json.schema.internal.factories.general.TypeAssertionFactory
@@ -63,6 +64,7 @@ private val factories: List<AssertionFactory> = listOf(
   IfThenElseAssertionFactory,
   AllOfAssertionFactory,
   AnyOfAssertionFactory,
+  OneOfAssertionFactory,
   NotAssertionFactory,
 )
 

src/commonMain/kotlin/smirnov/oleg/json/schema/internal/factories/condition/AbstractAssertionsCollectionFactory.kt

@@ -16,8 +16,8 @@ internal abstract class AbstractAssertionsCollectionFactory(property: String) :
       context.at(index).schemaFrom(item)
     }
 
-    return createAssertion(assertions)
+    return createAssertion(context, assertions)
   }
 
-  protected abstract fun createAssertion(assertions: List<JsonSchemaAssertion>): JsonSchemaAssertion
+  protected abstract fun createAssertion(context: LoadingContext, assertions: List<JsonSchemaAssertion>): JsonSchemaAssertion
 }

src/commonMain/kotlin/smirnov/oleg/json/schema/internal/factories/condition/AllOfAssertion.kt

@@ -4,10 +4,12 @@ import kotlinx.serialization.json.JsonElement
 import smirnov.oleg.json.schema.ErrorCollector
 import smirnov.oleg.json.schema.internal.AssertionContext
 import smirnov.oleg.json.schema.internal.JsonSchemaAssertion
+import smirnov.oleg.json.schema.internal.LoadingContext
 
 @Suppress("unused")
 internal object AllOfAssertionFactory : AbstractAssertionsCollectionFactory("allOf") {
-  override fun createAssertion(assertions: List<JsonSchemaAssertion>): JsonSchemaAssertion = AllOfAssertion(assertions)
+  override fun createAssertion(context: LoadingContext, assertions: List<JsonSchemaAssertion>): JsonSchemaAssertion =
+    AllOfAssertion(assertions)
 }
 
 private class AllOfAssertion(

src/commonMain/kotlin/smirnov/oleg/json/schema/internal/factories/condition/AnyOfAssertion.kt

@@ -5,10 +5,12 @@ import smirnov.oleg.json.schema.ErrorCollector
 import smirnov.oleg.json.schema.ValidationError
 import smirnov.oleg.json.schema.internal.AssertionContext
 import smirnov.oleg.json.schema.internal.JsonSchemaAssertion
+import smirnov.oleg.json.schema.internal.LoadingContext
 
 @Suppress("unused")
 internal object AnyOfAssertionFactory : AbstractAssertionsCollectionFactory("anyOf") {
-  override fun createAssertion(assertions: List<JsonSchemaAssertion>): JsonSchemaAssertion = AnyOfAssertion(assertions)
+  override fun createAssertion(context: LoadingContext, assertions: List<JsonSchemaAssertion>): JsonSchemaAssertion =
+    AnyOfAssertion(assertions)
 }
 
 private class AnyOfAssertion(

src/commonMain/kotlin/smirnov/oleg/json/schema/internal/factories/condition/OneOfAssertion.kt

@@ -0,0 +1,43 @@
+package smirnov.oleg.json.schema.internal.factories.condition
+
+import kotlinx.serialization.json.JsonElement
+import smirnov.oleg.json.pointer.JsonPointer
+import smirnov.oleg.json.schema.ErrorCollector
+import smirnov.oleg.json.schema.ValidationError
+import smirnov.oleg.json.schema.internal.AssertionContext
+import smirnov.oleg.json.schema.internal.JsonSchemaAssertion
+import smirnov.oleg.json.schema.internal.LoadingContext
+
+internal object OneOfAssertionFactory : AbstractAssertionsCollectionFactory("oneOf") {
+  override fun createAssertion(context: LoadingContext, assertions: List<JsonSchemaAssertion>): JsonSchemaAssertion =
+    OneOfAssertion(context.schemaPath, assertions)
+}
+
+private class OneOfAssertion(
+  private val path: JsonPointer,
+  private val assertions: List<JsonSchemaAssertion>,
+) : JsonSchemaAssertion {
+  override fun validate(element: JsonElement, context: AssertionContext, errorCollector: ErrorCollector): Boolean {
+    val suppressedErrors = mutableListOf<ValidationError>()
+    val matched: MutableList<Int> = ArrayList(1)
+    for ((index, assertion) in assertions.withIndex()) {
+      val res = assertion.validate(element, context, suppressedErrors::add)
+      if (res) {
+        matched += index
+      }
+    }
+
+    when {
+        matched.size > 1 -> errorCollector.onError(
+          ValidationError(
+            schemaPath = path,
+            objectPath = context.objectPath,
+            message = "element matches more than one JSON schema at indexes: $matched"
+          )
+        )
+        matched.size == 0 -> suppressedErrors.forEach(errorCollector::onError)
+    }
+
+    return matched.size == 1
+  }
+}

src/commonTest/kotlin/smirnov/oleg/json/schema/assertions/condition/JsonSchemaOneOfValidationTest.kt

@@ -0,0 +1,105 @@
+package smirnov.oleg.json.schema.assertions.condition
+
+import io.kotest.core.spec.style.FunSpec
+import io.kotest.matchers.collections.shouldContainExactly
+import io.kotest.matchers.collections.shouldHaveSize
+import io.kotest.matchers.shouldBe
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.buildJsonObject
+import smirnov.oleg.json.pointer.JsonPointer
+import smirnov.oleg.json.schema.JsonSchema
+import smirnov.oleg.json.schema.ValidationError
+import smirnov.oleg.json.schema.base.KEY
+
+@Suppress("unused")
+class JsonSchemaOneOfValidationTest : FunSpec() {
+  init {
+    testInvalidSchemaInArray("oneOf")
+    JsonSchema.fromDescription(
+      """
+      {
+        "${KEY}schema": "http://json-schema.org/draft-07/schema#",
+        "oneOf": [
+          {
+            "type": "string"
+          },
+          {
+            "type": "number"
+          },
+          {
+            "type": "boolean"
+          }
+        ]
+      }
+      """.trimIndent()
+    ).apply {
+      listOf(
+        JsonPrimitive("test"),
+        JsonPrimitive(42),
+        JsonPrimitive(true),
+      ).forEach {
+        test("element $it matches one of the schemas and passes validation") {
+          val errors = mutableListOf<ValidationError>()
+          val valid = validate(it, errors::add)
+
+          valid shouldBe true
+          errors shouldHaveSize 0
+        }
+      }
+
+      test("element does not match any of the schemas and fails validation") {
+        val errors = mutableListOf<ValidationError>()
+        val valid = validate(buildJsonObject { }, errors::add)
+
+        valid shouldBe false
+        errors.shouldContainExactly(
+          ValidationError(
+            schemaPath = JsonPointer("/oneOf/0/type"),
+            objectPath = JsonPointer.ROOT,
+            message = "element is not a string",
+          ),
+          ValidationError(
+            schemaPath = JsonPointer("/oneOf/1/type"),
+            objectPath = JsonPointer.ROOT,
+            message = "element is not a number",
+          ),
+          ValidationError(
+            schemaPath = JsonPointer("/oneOf/2/type"),
+            objectPath = JsonPointer.ROOT,
+            message = "element is not a boolean",
+          ),
+        )
+      }
+    }
+
+    JsonSchema.fromDescription(
+      """
+      {
+        "${KEY}schema": "http://json-schema.org/draft-07/schema#",
+        "oneOf": [
+          {
+            "type": "integer"
+          },
+          {
+            "type": "number"
+          }
+        ]
+      }
+      """.trimIndent()
+    ).apply {
+      test("element matches more than one JSON schema and fails validation") {
+        val errors = mutableListOf<ValidationError>()
+        val valid = validate(JsonPrimitive(42), errors::add)
+
+        valid shouldBe false
+        errors.shouldContainExactly(
+          ValidationError(
+            schemaPath = JsonPointer("/oneOf"),
+            objectPath = JsonPointer.ROOT,
+            message = "element matches more than one JSON schema at indexes: [0, 1]",
+          ),
+        )
+      }
+    }
+  }
+}