Add required assertion

Author: Oleg

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

@@ -23,6 +23,7 @@ import smirnov.oleg.json.schema.internal.factories.number.MinimumAssertionFactor
 import smirnov.oleg.json.schema.internal.factories.number.MultipleOfAssertionFactory
 import smirnov.oleg.json.schema.internal.factories.`object`.MaxPropertiesAssertionFactory
 import smirnov.oleg.json.schema.internal.factories.`object`.MinPropertiesAssertionFactory
+import smirnov.oleg.json.schema.internal.factories.`object`.RequiredAssertionFactory
 import smirnov.oleg.json.schema.internal.factories.string.MaxLengthAssertionFactory
 import smirnov.oleg.json.schema.internal.factories.string.MinLengthAssertionFactory
 import smirnov.oleg.json.schema.internal.factories.string.PatternAssertionFactory
@@ -46,6 +47,7 @@ private val factories: List<AssertionFactory> = listOf(
   ContainsAssertionFactory,
   MaxPropertiesAssertionFactory,
   MinPropertiesAssertionFactory,
+  RequiredAssertionFactory,
 )
 
 class SchemaLoader {

src/commonMain/kotlin/smirnov/oleg/json/schema/internal/factories/object/RequiredAssertion.kt

@@ -0,0 +1,54 @@
+package smirnov.oleg.json.schema.internal.factories.`object`
+
+import kotlinx.serialization.json.JsonArray
+import kotlinx.serialization.json.JsonElement
+import kotlinx.serialization.json.JsonObject
+import kotlinx.serialization.json.JsonPrimitive
+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
+import smirnov.oleg.json.schema.internal.TrueSchemaAssertion
+import smirnov.oleg.json.schema.internal.factories.AbstractAssertionFactory
+
+@Suppress("unused")
+internal object RequiredAssertionFactory : AbstractAssertionFactory("required") {
+  override fun createFromProperty(element: JsonElement, context: LoadingContext): JsonSchemaAssertion {
+    require(element is JsonArray) { "$property must be an array" }
+    require(element.all { it is JsonPrimitive && it.isString }) { "$property must contain only strings" }
+    val uniqueRequiredProperties = element.mapTo(linkedSetOf()) { (it as JsonPrimitive).content }
+    require(uniqueRequiredProperties.size == element.size) { "$property must consist of unique elements" }
+    return if (uniqueRequiredProperties.isEmpty()) {
+      TrueSchemaAssertion
+    } else {
+      RequiredAssertion(context.schemaPath, uniqueRequiredProperties)
+    }
+  }
+}
+
+private class RequiredAssertion(
+  private val path: JsonPointer,
+  private val requiredProperties: Set<String>,
+) : JsonSchemaAssertion {
+  override fun validate(element: JsonElement, context: AssertionContext, errorCollector: ErrorCollector): Boolean {
+    if (element !is JsonObject) {
+      return true
+    }
+    val missingProperties = requiredProperties.asSequence()
+      .filter { !element.containsKey(it) }
+      .toSet()
+    if (missingProperties.isEmpty()) {
+      return true
+    }
+    errorCollector.onError(
+      ValidationError(
+        schemaPath = path,
+        objectPath = context.objectPath,
+        message = "missing required properties: $missingProperties",
+      )
+    )
+    return false
+  }
+}

src/commonTest/kotlin/smirnov/oleg/json/schema/assertions/object/JsonSchemaRequiredValidationTest.kt

@@ -0,0 +1,92 @@
+package smirnov.oleg.json.schema.assertions.`object`
+
+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.JsonNull
+import kotlinx.serialization.json.JsonPrimitive
+import kotlinx.serialization.json.buildJsonArray
+import kotlinx.serialization.json.buildJsonObject
+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 JsonSchemaRequiredValidationTest : FunSpec() {
+  init {
+    val schema = JsonSchema.fromDescription(
+      """
+      {
+        "${KEY}schema": "http://json-schema.org/draft-07/schema#",
+        "required": ["prop1", "prop2"]
+      }
+      """.trimIndent()
+    )
+
+    listOf(
+      buildJsonObject {
+        put("prop1", JsonPrimitive("a"))
+        put("prop2", JsonPrimitive("b"))
+      },
+      buildJsonObject {
+        put("prop1", JsonPrimitive("a"))
+        put("prop2", JsonPrimitive("b"))
+        put("prop3", JsonPrimitive("c"))
+      },
+    ).forEach {
+      test("object with props ${it.keys} passes validation") {
+        val errors = mutableListOf<ValidationError>()
+        val valid = schema.validate(it, errors::add)
+        it.asClue {
+          valid shouldBe true
+          errors shouldHaveSize 0
+        }
+      }
+    }
+
+    listOf(
+      buildJsonObject {
+        put("prop1", JsonPrimitive("a"))
+      } to listOf("prop2"),
+      buildJsonObject {
+        put("prop2", JsonPrimitive("a"))
+      } to listOf("prop1"),
+      buildJsonObject {
+      } to listOf("prop1", "prop2")
+    ).forEach { (jsonObject, missingProps) ->
+      test("object with props ${jsonObject.keys} fails validation") {
+        val errors = mutableListOf<ValidationError>()
+        val valid = schema.validate(jsonObject, errors::add)
+        jsonObject.asClue {
+          valid shouldBe false
+          errors.shouldContainExactly(
+            ValidationError(
+              schemaPath = JsonPointer("/required"),
+              objectPath = JsonPointer.ROOT,
+              message = "missing required properties: $missingProps",
+            )
+          )
+        }
+      }
+    }
+
+    listOf(
+      JsonPrimitive("a"),
+      JsonPrimitive(42),
+      JsonPrimitive(42.5),
+      JsonPrimitive(true),
+      JsonNull,
+      buildJsonArray { },
+    ).forEach {
+      test("not an object $it passes validation") {
+        val errors = mutableListOf<ValidationError>()
+        val valid = schema.validate(it, errors::add)
+        valid shouldBe true
+        errors shouldHaveSize 0
+      }
+    }
+  }
+}