Add allOf assertion

Author: Oleg

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

@@ -13,6 +13,7 @@ import smirnov.oleg.json.schema.internal.factories.array.ItemsAssertionFactory
 import smirnov.oleg.json.schema.internal.factories.array.MaxItemsAssertionFactory
 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.IfThenElseAssertionFactory
 import smirnov.oleg.json.schema.internal.factories.general.ConstAssertionFactory
 import smirnov.oleg.json.schema.internal.factories.general.EnumAssertionFactory
@@ -56,6 +57,7 @@ private val factories: List<AssertionFactory> = listOf(
   PropertyNamesAssertionFactory,
   DependenciesAssertionFactory,
   IfThenElseAssertionFactory,
+  AllOfAssertionFactory,
 )
 
 class SchemaLoader {

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

@@ -0,0 +1,39 @@
+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.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 AllOfAssertionFactory : AbstractAssertionFactory("allOf") {
+  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 AllOfAssertion(assertions)
+  }
+}
+
+private class AllOfAssertion(
+  private val assertions: List<JsonSchemaAssertion>,
+) : JsonSchemaAssertion {
+  override fun validate(element: JsonElement, context: AssertionContext, errorCollector: ErrorCollector): Boolean {
+    var valid = true
+
+    assertions.forEach {
+      val res = it.validate(element, context, errorCollector)
+      valid = valid and res
+    }
+
+    return valid
+  }
+}

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

@@ -0,0 +1,102 @@
+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 smirnov.oleg.json.pointer.JsonPointer
+import smirnov.oleg.json.schema.JsonSchema
+import smirnov.oleg.json.schema.KEY
+import smirnov.oleg.json.schema.ValidationError
+
+@Suppress("unused")
+class JsonSchemaAllOfValidationTest : FunSpec() {
+  init {
+    JsonSchema.fromDescription(
+      """
+      {
+        "${KEY}schema": "http://json-schema.org/draft-07/schema#",
+        "allOf": [
+          {
+            "type": "string"
+          },
+          {
+            "minLength": 3
+          },
+          {
+            "maxLength": 6
+          }
+        ]
+      }
+      """.trimIndent()
+    ).also { schema ->
+      test("passes all assertions") {
+        val element = JsonPrimitive("test")
+
+        val errors = mutableListOf<ValidationError>()
+        val valid = schema.validate(element, errors::add)
+
+        element.asClue {
+          valid shouldBe true
+          errors shouldHaveSize 0
+        }
+      }
+
+      test("fails first assertion") {
+        val element = JsonPrimitive(42)
+
+        val errors = mutableListOf<ValidationError>()
+        val valid = schema.validate(element, errors::add)
+
+        element.asClue {
+          valid shouldBe false
+          errors.shouldContainExactly(
+            ValidationError(
+              schemaPath = JsonPointer("/allOf/0/type"),
+              objectPath = JsonPointer.ROOT,
+              message = "element is not a string",
+            )
+          )
+        }
+      }
+
+      test("fails second assertion") {
+        val element = JsonPrimitive("te")
+
+        val errors = mutableListOf<ValidationError>()
+        val valid = schema.validate(element, errors::add)
+
+        element.asClue {
+          valid shouldBe false
+          errors.shouldContainExactly(
+            ValidationError(
+              schemaPath = JsonPointer("/allOf/1/minLength"),
+              objectPath = JsonPointer.ROOT,
+              message = "string length (2) must be greater or equal to 3",
+            )
+          )
+        }
+      }
+
+      test("fails last assertion") {
+        val element = JsonPrimitive("test123")
+
+        val errors = mutableListOf<ValidationError>()
+        val valid = schema.validate(element, errors::add)
+
+        element.asClue {
+          valid shouldBe false
+          errors.shouldContainExactly(
+            ValidationError(
+              schemaPath = JsonPointer("/allOf/2/maxLength"),
+              objectPath = JsonPointer.ROOT,
+              message = "string length (7) must be less or equal to 6",
+            )
+          )
+        }
+      }
+    }
+  }
+}