Add not assertion

Author: Oleg

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

@@ -16,6 +16,7 @@ import smirnov.oleg.json.schema.internal.factories.array.UniqueItemsAssertionFac
 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.condition.NotAssertionFactory
 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
@@ -60,6 +61,7 @@ private val factories: List<AssertionFactory> = listOf(
   IfThenElseAssertionFactory,
   AllOfAssertionFactory,
   AnyOfAssertionFactory,
+  NotAssertionFactory,
 )
 
 class SchemaLoader {

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

@@ -0,0 +1,38 @@
+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
+import smirnov.oleg.json.schema.internal.factories.AbstractAssertionFactory
+
+@Suppress("unused")
+internal object NotAssertionFactory : AbstractAssertionFactory("not") {
+  override fun createFromProperty(element: JsonElement, context: LoadingContext): JsonSchemaAssertion {
+    require(context.isJsonSchema(element)) { "$property must be a valid JSON schema" }
+    val assertion = context.schemaFrom(element)
+    return NotAssertion(context.schemaPath, assertion)
+  }
+}
+
+private class NotAssertion(
+  private val path: JsonPointer,
+  private val delegate: JsonSchemaAssertion,
+) : JsonSchemaAssertion {
+  override fun validate(element: JsonElement, context: AssertionContext, errorCollector: ErrorCollector): Boolean {
+    if (!delegate.validate(element, context, ErrorCollector.EMPTY)) {
+      return true
+    }
+    errorCollector.onError(
+      ValidationError(
+        schemaPath = path,
+        objectPath = context.objectPath,
+        message = "element must not be valid against child JSON schema but was",
+      )
+    )
+    return false
+  }
+}

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

@@ -0,0 +1,79 @@
+package smirnov.oleg.json.schema.assertions.condition
+
+import io.kotest.assertions.asClue
+import io.kotest.assertions.throwables.shouldThrow
+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 JsonSchemaNotValidationTest : FunSpec() {
+  init {
+    JsonSchema.fromDescription(
+      """
+      {
+        "${KEY}schema": "http://json-schema.org/draft-07/schema#",
+        "not": {
+          "type": "object"
+        }
+      }
+      """.trimIndent()
+    ).also { schema ->
+      listOf(
+        JsonPrimitive(42),
+        JsonPrimitive(42.5),
+        JsonPrimitive("test"),
+        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
+        }
+      }
+
+      test("object fails validation") {
+        val jsonObject = buildJsonObject { }
+        val errors = mutableListOf<ValidationError>()
+        val valid = schema.validate(jsonObject, errors::add)
+
+        jsonObject.asClue {
+          valid shouldBe false
+          errors.shouldContainExactly(
+            ValidationError(
+              schemaPath = JsonPointer("/not"),
+              objectPath = JsonPointer.ROOT,
+              message = "element must not be valid against child JSON schema but was",
+            ),
+          )
+        }
+      }
+    }
+
+    test("reports if value is not a valid JSON schema") {
+      shouldThrow<IllegalArgumentException> {
+        JsonSchema.fromDescription(
+          """
+          {
+            "${KEY}schema": "http://json-schema.org/draft-07/schema#",
+            "not": 42
+          }
+          """.trimIndent()
+        )
+      }.message shouldBe "not must be a valid JSON schema"
+    }
+  }
+}