adds dynamicPath to Const, False, MaxLength, PropertyNames, If-Then-E…

…lse schema validation failures
erosb · Dec 8, 2024 · 25ed6a5 · 25ed6a5
1 parent cd1f033
commit 25ed6a5
Show file tree

Hide file tree

Showing 8 changed files with 70 additions and 19 deletions.
diff --git a/src/main/kotlin/com/github/erosb/jsonsKema/Const.kt b/src/main/kotlin/com/github/erosb/jsonsKema/Const.kt
@@ -8,7 +8,8 @@ internal val constLoader: KeywordLoader = { ctx -> ConstSchema(ctx.keywordValue,
 
 data class ConstValidationFailure(
     override val schema: ConstSchema,
-    override val instance: IJsonValue
+    override val instance: IJsonValue,
+    val dynamicPath: JsonPointer
 ) : ValidationFailure(
     "actual instance is not the same as expected constant value",
     schema,

diff --git a/src/main/kotlin/com/github/erosb/jsonsKema/False.kt b/src/main/kotlin/com/github/erosb/jsonsKema/False.kt
@@ -6,6 +6,7 @@ data class FalseSchema(override val location: SourceLocation) : Schema(location)
 
 data class FalseValidationFailure(
     override val schema: FalseSchema,
-    override val instance: IJsonValue
+    override val instance: IJsonValue,
+    val dynamicPath: JsonPointer
 ) : ValidationFailure("false schema always fails", schema, instance, Keyword.FALSE)
 
diff --git a/src/main/kotlin/com/github/erosb/jsonsKema/MaxLength.kt b/src/main/kotlin/com/github/erosb/jsonsKema/MaxLength.kt
@@ -10,7 +10,8 @@ internal val maxLengthLoader: KeywordLoader = { ctx ->
 
 data class MaxLengthValidationFailure(
     override val schema: MaxLengthSchema,
-    override val instance: IJsonString
+    override val instance: IJsonString,
+    val dynamicPath: JsonPointer
 ) : ValidationFailure(
     "actual string length ${instance.value.length} exceeds maxLength ${schema.maxLength}",
     schema,

diff --git a/src/main/kotlin/com/github/erosb/jsonsKema/PropertyNames.kt b/src/main/kotlin/com/github/erosb/jsonsKema/PropertyNames.kt
@@ -15,7 +15,8 @@ internal val propertyNamesLoader: KeywordLoader = {ctx ->
 data class PropertyNamesValidationFailure(
     override val schema: PropertyNamesSchema,
     override val instance: IJsonObj,
-    val causesByProperties: Map<IJsonString, ValidationFailure>
+    val causesByProperties: Map<IJsonString, ValidationFailure>,
+    val dynamicPath: JsonPointer
 ) : ValidationFailure(
     message = "",
     schema = schema,

diff --git a/src/main/kotlin/com/github/erosb/jsonsKema/Validator.kt b/src/main/kotlin/com/github/erosb/jsonsKema/Validator.kt
@@ -276,12 +276,12 @@ private class DefaultValidator(
         }
     }
 
-    override fun visitConstSchema(schema: ConstSchema): ValidationFailure? {
+    override fun visitConstSchema(schema: ConstSchema): ValidationFailure? = inPathSegment(Keyword.CONST) {
         val isValid = schema.constant == instance
-        return if (isValid) {
+        if (isValid) {
             null
         } else {
-            ConstValidationFailure(schema, instance)
+            ConstValidationFailure(schema, instance, dynamicPath())
         }
     }
 
@@ -342,8 +342,8 @@ private class DefaultValidator(
         }
     }
 
-    override fun visitPropertyNamesSchema(propertyNamesSchema: PropertyNamesSchema): ValidationFailure? {
-        return instance.maybeObject { obj ->
+    override fun visitPropertyNamesSchema(propertyNamesSchema: PropertyNamesSchema): ValidationFailure? = inPathSegment(Keyword.PROPERTY_NAMES) {
+        instance.maybeObject { obj ->
             val failures: Map<IJsonString, ValidationFailure> = obj.properties.keys.map {
                 it to withOtherInstance(it) {
                     propertyNamesSchema.propertyNamesSchema.accept(this)
@@ -353,7 +353,7 @@ private class DefaultValidator(
                 .map { it as Pair<IJsonString, ValidationFailure> }
                 .toMap()
             return@maybeObject if (failures.isNotEmpty()) {
-                PropertyNamesValidationFailure(schema = propertyNamesSchema, instance = obj, causesByProperties = failures)
+                PropertyNamesValidationFailure(schema = propertyNamesSchema, instance = obj, causesByProperties = failures, dynamicPath())
             } else {
                 null
             }
@@ -395,11 +395,11 @@ private class DefaultValidator(
             endResult
         }
 
-    override fun visitMaxLengthSchema(schema: MaxLengthSchema): ValidationFailure? {
-        return instance.maybeString {
+    override fun visitMaxLengthSchema(schema: MaxLengthSchema): ValidationFailure? = inPathSegment(Keyword.MAX_LENGTH) {
+        instance.maybeString {
             val length = it.value.codePointCount(0, it.value.length)
             if (length > schema.maxLength) {
-                MaxLengthValidationFailure(schema, it)
+                MaxLengthValidationFailure(schema, it, dynamicPath())
             } else {
                 null
             }
@@ -511,8 +511,9 @@ private class DefaultValidator(
         }
     }
 
-    override fun visitFalseSchema(schema: FalseSchema): ValidationFailure =
-        FalseValidationFailure(schema, instance)
+    override fun visitFalseSchema(schema: FalseSchema): ValidationFailure? = inPathSegment(Keyword.FALSE) {
+        FalseValidationFailure(schema, instance, dynamicPath())
+    }
 
     override fun visitUniqueItemsSchema(schema: UniqueItemsSchema): ValidationFailure? = inPathSegment(Keyword.UNIQUE_ITEMS) {
         if (schema.unique) {
@@ -631,11 +632,15 @@ private class DefaultValidator(
     }
 
     override fun visitIfThenElseSchema(schema: IfThenElseSchema): ValidationFailure? {
-        val ifFailure = schema.ifSchema.accept(this)
+        val ifFailure = inPathSegment(Keyword.IF) { schema.ifSchema.accept(this) }
         return if (ifFailure == null) {
-            schema.thenSchema?.accept(this)
+            inPathSegment(Keyword.THEN) {
+                schema.thenSchema?.accept(this)
+            }
         } else {
-            schema.elseSchema?.accept(this)
+            inPathSegment(Keyword.ELSE) {
+                schema.elseSchema?.accept(this)
+            }
         }
     }
 

diff --git a/src/test/kotlin/com/github/erosb/jsonsKema/IfThenElseSchemaTest.kt b/src/test/kotlin/com/github/erosb/jsonsKema/IfThenElseSchemaTest.kt
@@ -20,4 +20,23 @@ class IfThenElseSchemaTest {
         val subject = IfThenElseSchema(ifSchema, thenSchema, null, UnknownSource)
         assertEquals(listOf(ifSchema, thenSchema), subject.subschemas())
     }
+
+    @Test
+    fun `dynamic path for then`() {
+        val subject = IfThenElseSchema(ifSchema, thenSchema, elseSchema, UnknownSource)
+
+        val actual = Validator.forSchema(subject).validate(JsonParser("null")()) as FalseValidationFailure
+
+        assertEquals(JsonPointer("then", "false"), actual.dynamicPath)
+    }
+
+
+    @Test
+    fun `dynamic path for else`() {
+        val subject = IfThenElseSchema(FalseSchema(UnknownSource), thenSchema, elseSchema, UnknownSource)
+
+        val actual = Validator.forSchema(subject).validate(JsonParser("4")()) as ConstValidationFailure
+
+        assertEquals(JsonPointer("else", "const"), actual.dynamicPath)
+    }
 }
diff --git a/src/test/kotlin/com/github/erosb/jsonsKema/PropertyNamesTest.kt b/src/test/kotlin/com/github/erosb/jsonsKema/PropertyNamesTest.kt
@@ -0,0 +1,23 @@
+package com.github.erosb.jsonsKema
+
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Test
+
+class PropertyNamesTest {
+
+    @Test
+    fun test() {
+        val schema = SchemaLoader(JsonParser("""
+            {
+                "propertyNames": {"maxLength": 2}
+            }
+        """.trimIndent())())()
+
+        val actual = Validator.forSchema(schema).validate(JsonParser("""
+            {"aaa":"x"}
+        """.trimIndent())()) as PropertyNamesValidationFailure
+        assertEquals("#/propertyNames", actual.dynamicPath.toString())
+        val cause = actual.causesByProperties.values.first() as MaxLengthValidationFailure
+        assertEquals("#/propertyNames/maxLength", cause.dynamicPath.toString())
+    }
+}
diff --git a/src/test/kotlin/com/github/erosb/jsonsKema/ValidationFailureTest.kt b/src/test/kotlin/com/github/erosb/jsonsKema/ValidationFailureTest.kt
@@ -105,7 +105,7 @@ class ValidationFailureTest {
     @Test
     fun flattenRecursive() {
         val falseSubschema = FalseSchema(UnknownSource)
-        val falseFailure = FalseValidationFailure(falseSubschema, JsonNull(UnknownSource))
+        val falseFailure = FalseValidationFailure(falseSubschema, JsonNull(UnknownSource), JsonPointer("false"))
         val subject = AggregatingValidationFailure(
             CompositeSchema(
                 subschemas = setOf(