Extract common part from allOf and anyOf factories. Add negative tests

Author: Oleg

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

@@ -0,0 +1,23 @@
+package smirnov.oleg.json.schema.internal.factories.condition
+
+import kotlinx.serialization.json.JsonArray
+import kotlinx.serialization.json.JsonElement
+import smirnov.oleg.json.schema.internal.JsonSchemaAssertion
+import smirnov.oleg.json.schema.internal.LoadingContext
+import smirnov.oleg.json.schema.internal.factories.AbstractAssertionFactory
+
+internal abstract class AbstractAssertionsCollectionFactory(property: String) : AbstractAssertionFactory(property) {
+  final 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 createAssertion(assertions)
+  }
+
+  protected abstract fun createAssertion(assertions: List<JsonSchemaAssertion>): JsonSchemaAssertion
+}

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

@@ -1,26 +1,13 @@
 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)
-  }
+internal object AllOfAssertionFactory : AbstractAssertionsCollectionFactory("allOf") {
+  override fun createAssertion(assertions: List<JsonSchemaAssertion>): JsonSchemaAssertion = AllOfAssertion(assertions)
 }
 
 private class AllOfAssertion(

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

@@ -1,27 +1,14 @@
 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)
-  }
+internal object AnyOfAssertionFactory : AbstractAssertionsCollectionFactory("anyOf") {
+  override fun createAssertion(assertions: List<JsonSchemaAssertion>): JsonSchemaAssertion = AnyOfAssertion(assertions)
 }
 
 private class AnyOfAssertion(

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

@@ -0,0 +1,48 @@
+package smirnov.oleg.json.schema.assertions.condition
+
+import io.kotest.assertions.throwables.shouldThrow
+import io.kotest.core.spec.style.FunSpec
+import io.kotest.matchers.shouldBe
+import smirnov.oleg.json.schema.JsonSchema
+import smirnov.oleg.json.schema.KEY
+
+fun FunSpec.testInvalidSchemaInArray(name: String) {
+  test("reports empty array") {
+    shouldThrow<IllegalArgumentException> {
+      JsonSchema.fromDescription(
+        """
+        {
+          "${KEY}schema": "http://json-schema.org/draft-07/schema#",
+          "$name": []
+        }
+        """.trimIndent()
+      )
+    }.message shouldBe "$name must have at least one element"
+  }
+
+  test("reports not array") {
+    shouldThrow<IllegalArgumentException> {
+      JsonSchema.fromDescription(
+        """
+        {
+          "${KEY}schema": "http://json-schema.org/draft-07/schema#",
+          "$name": {}
+        }
+        """.trimIndent()
+      )
+    }.message shouldBe "$name must be an array"
+  }
+
+  test("reports element in array is not a valid JSON schema") {
+    shouldThrow<IllegalArgumentException> {
+      JsonSchema.fromDescription(
+        """
+        {
+          "${KEY}schema": "http://json-schema.org/draft-07/schema#",
+          "$name": [42]
+        }
+        """.trimIndent()
+      )
+    }.message shouldBe "each element in $name must be a valid JSON schema"
+  }
+}

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

@@ -14,6 +14,7 @@ import smirnov.oleg.json.schema.ValidationError
 @Suppress("unused")
 class JsonSchemaAllOfValidationTest : FunSpec() {
   init {
+    testInvalidSchemaInArray("allOf")
     JsonSchema.fromDescription(
       """
       {

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

@@ -16,6 +16,7 @@ import smirnov.oleg.json.schema.ValidationError
 @Suppress("unused")
 class JsonSchemaAnyOfValidationTest : FunSpec() {
   init {
+    testInvalidSchemaInArray("anyOf")
     JsonSchema.fromDescription(
       """
       {