Add anyOf assertion

Author: Oleg

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

@@ -14,6 +14,7 @@ import smirnov.oleg.json.schema.internal.factories.array.MaxItemsAssertionFactor
 import smirnov.oleg.json.schema.internal.factories.array.MinItemsAssertionFactory
 import smirnov.oleg.json.schema.internal.factories.array.UniqueItemsAssertionFactory
 import smirnov.oleg.json.schema.internal.factories.condition.AllOfAssertionFactory
+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.general.ConstAssertionFactory
 import smirnov.oleg.json.schema.internal.factories.general.EnumAssertionFactory
@@ -58,6 +59,7 @@ private val factories: List<AssertionFactory> = listOf(
   DependenciesAssertionFactory,
   IfThenElseAssertionFactory,
   AllOfAssertionFactory,
+  AnyOfAssertionFactory,
 )
 
 class SchemaLoader {

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

@@ -0,0 +1,42 @@
+package smirnov.oleg.json.schema.internal.factories.condition
+
+import kotlinx.serialization.json.JsonArray
+import kotlinx.serialization.json.JsonElement
+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
+import smirnov.oleg.json.schema.internal.factories.AbstractAssertionFactory
+
+@Suppress("unused")
+internal object AnyOfAssertionFactory : AbstractAssertionFactory("anyOf") {
+  override fun createFromProperty(element: JsonElement, context: LoadingContext): JsonSchemaAssertion {
+    require(element is JsonArray) { "$property must be an array" }
+    require(element.isNotEmpty()) { "$property must have at least one element" }
+    require(element.all(context::isJsonSchema)) { "each element in $property must be a valid JSON schema" }
+
+    val assertions: List<JsonSchemaAssertion> = element.mapIndexed { index, item ->
+      context.at(index).schemaFrom(item)
+    }
+
+    return AnyOfAssertion(assertions)
+  }
+}
+
+private class AnyOfAssertion(
+  private val assertions: List<JsonSchemaAssertion>,
+) : JsonSchemaAssertion {
+  override fun validate(element: JsonElement, context: AssertionContext, errorCollector: ErrorCollector): Boolean {
+    var valid = false
+    val tempHandler = mutableListOf<ValidationError>()
+    assertions.forEach {
+      val res = it.validate(element, context, tempHandler::add)
+      valid = valid or res
+    }
+    if (!valid) {
+      tempHandler.forEach(errorCollector::onError)
+    }
+    return valid
+  }
+}

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

@@ -0,0 +1,82 @@
+package smirnov.oleg.json.schema.assertions.condition
+
+import io.kotest.assertions.asClue
+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.pointer.JsonPointer.Companion
+import smirnov.oleg.json.schema.JsonSchema
+import smirnov.oleg.json.schema.KEY
+import smirnov.oleg.json.schema.ValidationError
+
+@Suppress("unused")
+class JsonSchemaAnyOfValidationTest : FunSpec() {
+  init {
+    JsonSchema.fromDescription(
+      """
+      {
+        "${KEY}schema": "http://json-schema.org/draft-07/schema#",
+        "anyOf": [
+          {
+            "type": "string"
+          },
+          {
+            "type": "number"
+          },
+          {
+            "type": "boolean"
+          }
+        ]
+      }
+      """.trimIndent()
+    ).also { schema ->
+      listOf(
+        JsonPrimitive("str"),
+        JsonPrimitive(42),
+        JsonPrimitive(true),
+      ).forEach {
+        test("element $it passes validation") {
+          val errors = mutableListOf<ValidationError>()
+          val valid  = schema.validate(it, errors::add)
+
+          valid shouldBe true
+          errors shouldHaveSize 0
+        }
+      }
+
+      test("element does not match any assertion") {
+        val jsonObject = buildJsonObject {
+          put("test", JsonPrimitive(42))
+        }
+
+        val errors = mutableListOf<ValidationError>()
+        val valid  = schema.validate(jsonObject, errors::add)
+
+        jsonObject.asClue {
+          valid shouldBe false
+          errors.shouldContainExactly(
+            ValidationError(
+              schemaPath = JsonPointer("/anyOf/0/type"),
+              objectPath = JsonPointer.ROOT,
+              message = "element is not a string",
+            ),
+            ValidationError(
+              schemaPath = JsonPointer("/anyOf/1/type"),
+              objectPath = JsonPointer.ROOT,
+              message = "element is not a number",
+            ),
+            ValidationError(
+              schemaPath = JsonPointer("/anyOf/2/type"),
+              objectPath = JsonPointer.ROOT,
+              message = "element is not a boolean",
+            ),
+          )
+        }
+      }
+    }
+  }
+}