more tests

Author: simbo1905

json-java21-schema/json-schema-core-202012.txt

@@ -0,0 +1,74 @@
+package io.github.simbo1905.json.schema;
+
+import jdk.sandbox.java.util.json.Json;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.*;
+
+/**
+ * Covers annotation-only keywords from JSON Schema such as
+ * title, description, $comment, and examples. These MUST NOT
+ * affect validation (they are informational).
+ */
+class JsonSchemaAnnotationsTest extends JsonSchemaLoggingConfig {
+
+    @Test
+    void examplesDoNotAffectValidation() {
+        String schemaJson = """
+            {
+              "type": "object",
+              "title": "User",
+              "description": "A simple user object",
+              "$comment": "Examples are informational only",
+              "examples": [
+                {"id": 1, "name": "Alice"},
+                {"id": 2, "name": "Bob"}
+              ],
+              "properties": {
+                "id":   {"type": "integer", "minimum": 0},
+                "name": {"type": "string", "minLength": 1}
+              },
+              "required": ["id", "name"]
+            }
+            """;
+
+        JsonSchema schema = JsonSchema.compile(Json.parse(schemaJson));
+
+        // Valid instance should pass regardless of examples
+        var ok = schema.validate(Json.parse("""
+            {"id": 10, "name": "Jane"}
+        """));
+        assertThat(ok.valid()).isTrue();
+
+        // Invalid instance should still fail regardless of examples
+        var bad = schema.validate(Json.parse("""
+            {"id": -1}
+        """));
+        assertThat(bad.valid()).isFalse();
+        assertThat(bad.errors()).isNotEmpty();
+        assertThat(bad.errors().get(0).message())
+            .satisfiesAnyOf(
+                m -> assertThat(m).contains("Missing required property: name"),
+                m -> assertThat(m).contains("Below minimum")
+            );
+    }
+
+    @Test
+    void unknownAnnotationKeywordsAreIgnored() {
+        String schemaJson = """
+            {
+              "type": "string",
+              "description": "A labeled string",
+              "title": "Label",
+              "$comment": "Arbitrary annotations should be ignored by validation",
+              "x-internal": true
+            }
+            """;
+
+        JsonSchema schema = JsonSchema.compile(Json.parse(schemaJson));
+        assertThat(schema.validate(Json.parse("\"hello\""))).isNotNull();
+        assertThat(schema.validate(Json.parse("\"hello\""))).extracting("valid").isEqualTo(true);
+        assertThat(schema.validate(Json.parse("123"))).extracting("valid").isEqualTo(false);
+    }
+}
+

json-java21-schema/src/test/java/io/github/simbo1905/json/schema/JsonSchemaAnnotationsTest.java

@@ -0,0 +1,74 @@
+package io.github.simbo1905.json.schema;
+
+import jdk.sandbox.java.util.json.Json;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.*;
+
+class JsonSchemaCombinatorsTest extends JsonSchemaLoggingConfig {
+
+    @Test
+    void anyOfRequiresOneBranchValid() {
+        String schemaJson = """
+            {
+              "anyOf": [
+                {"type": "string", "minLength": 3},
+                {"type": "number", "minimum": 10}
+              ]
+            }
+            """;
+        JsonSchema schema = JsonSchema.compile(Json.parse(schemaJson));
+
+        assertThat(schema.validate(Json.parse("\"abc\""))).extracting("valid").isEqualTo(true);
+        assertThat(schema.validate(Json.parse("12"))).extracting("valid").isEqualTo(true);
+
+        var bad = schema.validate(Json.parse("\"x\""));
+        assertThat(bad.valid()).isFalse();
+        assertThat(bad.errors()).isNotEmpty();
+    }
+
+    @Test
+    void notInvertsValidation() {
+        String schemaJson = """
+            { "not": {"type": "integer"} }
+            """;
+        JsonSchema schema = JsonSchema.compile(Json.parse(schemaJson));
+
+        assertThat(schema.validate(Json.parse("\"ok\""))).extracting("valid").isEqualTo(true);
+        assertThat(schema.validate(Json.parse("1"))).extracting("valid").isEqualTo(false);
+    }
+
+    @Test
+    void unresolvedRefFailsCompilation() {
+        String schemaJson = """
+            {"$ref": "#/$defs/missing"}
+            """;
+        assertThatThrownBy(() -> JsonSchema.compile(Json.parse(schemaJson)))
+            .isInstanceOf(IllegalArgumentException.class)
+            .hasMessageContaining("Unresolved $ref");
+    }
+
+    @Test
+    void nestedErrorPathsAreClear() {
+        String schemaJson = """
+            {
+              "type": "object",
+              "properties": {
+                "user": {
+                  "type": "object",
+                  "properties": {"name": {"type": "string"}},
+                  "required": ["name"]
+                }
+              }
+            }
+            """;
+        JsonSchema schema = JsonSchema.compile(Json.parse(schemaJson));
+
+        var bad = schema.validate(Json.parse("""
+            {"user": {}}
+        """));
+        assertThat(bad.valid()).isFalse();
+        assertThat(bad.errors().get(0).path()).isEqualTo("user");
+        assertThat(bad.errors().get(0).message()).contains("Missing required property: name");
+    }
+}

json-java21-schema/src/test/java/io/github/simbo1905/json/schema/JsonSchemaCombinatorsTest.java

@@ -0,0 +1,84 @@
+package io.github.simbo1905.json.schema;
+
+import jdk.sandbox.java.util.json.Json;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.*;
+
+class JsonSchemaErrorMessagesTest extends JsonSchemaLoggingConfig {
+
+    @Test
+    void typeMismatchMessages() {
+        JsonSchema sString = JsonSchema.compile(Json.parse("""
+            {"type":"string"}
+        """));
+        var r1 = sString.validate(Json.parse("123"));
+        assertThat(r1.valid()).isFalse();
+        assertThat(r1.errors().get(0).message()).contains("Expected string");
+
+        JsonSchema sArray = JsonSchema.compile(Json.parse("""
+            {"type":"array"}
+        """));
+        var r2 = sArray.validate(Json.parse("{}"));
+        assertThat(r2.valid()).isFalse();
+        assertThat(r2.errors().get(0).message()).contains("Expected array");
+
+        JsonSchema sObject = JsonSchema.compile(Json.parse("""
+            {"type":"object"}
+        """));
+        var r3 = sObject.validate(Json.parse("[]"));
+        assertThat(r3.valid()).isFalse();
+        assertThat(r3.errors().get(0).message()).contains("Expected object");
+    }
+
+    @Test
+    void numericConstraintMessages() {
+        String schemaJson = """
+            {"type":"number","minimum":1,"maximum":2,"multipleOf": 2}
+            """;
+        JsonSchema s = JsonSchema.compile(Json.parse(schemaJson));
+
+        var below = s.validate(Json.parse("0"));
+        assertThat(below.valid()).isFalse();
+        assertThat(below.errors().get(0).message()).contains("Below minimum");
+
+        var above = s.validate(Json.parse("3"));
+        assertThat(above.valid()).isFalse();
+        assertThat(above.errors().get(0).message()).contains("Above maximum");
+
+        var notMultiple = s.validate(Json.parse("1"));
+        assertThat(notMultiple.valid()).isFalse();
+        assertThat(notMultiple.errors().get(0).message()).contains("Not multiple of");
+    }
+
+    @Test
+    void arrayIndexAppearsInPath() {
+        String schemaJson = """
+            {"type":"array","items":{"type":"integer"}}
+            """;
+        JsonSchema s = JsonSchema.compile(Json.parse(schemaJson));
+
+        var bad = s.validate(Json.parse("""
+            [1, "two", 3]
+        """));
+        assertThat(bad.valid()).isFalse();
+        // Expect failing path to point to the non-integer element
+        assertThat(bad.errors().get(0).path()).isEqualTo("[1]");
+        assertThat(bad.errors().get(0).message()).contains("Expected number");
+    }
+
+    @Test
+    void patternAndEnumMessages() {
+        String schemaJson = """
+            {"type":"string","pattern":"^x+$","enum":["x","xx","xxx"]}
+            """;
+        JsonSchema s = JsonSchema.compile(Json.parse(schemaJson));
+
+        var badEnum = s.validate(Json.parse("\"xxxx\""));
+        assertThat(badEnum.valid()).isFalse();
+        assertThat(badEnum.errors().get(0).message()).satisfiesAnyOf(
+            m -> assertThat(m).contains("Not in enum"),
+            m -> assertThat(m).contains("Pattern mismatch")
+        );
+    }
+}

json-java21-schema/src/test/java/io/github/simbo1905/json/schema/JsonSchemaErrorMessagesTest.java

@@ -0,0 +1,42 @@
+package io.github.simbo1905.json.schema;
+
+import jdk.sandbox.java.util.json.Json;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.*;
+
+class JsonSchemaNumberKeywordsTest extends JsonSchemaLoggingConfig {
+
+    @Test
+    void exclusiveMinimumAndMaximumAreHonored() {
+        String schemaJson = """
+            {
+              "type": "number",
+              "minimum": 0,
+              "maximum": 10,
+              "exclusiveMinimum": true,
+              "exclusiveMaximum": true
+            }
+            """;
+        JsonSchema schema = JsonSchema.compile(Json.parse(schemaJson));
+
+        // Boundary values should fail when exclusive
+        assertThat(schema.validate(Json.parse("0")).valid()).isFalse();
+        assertThat(schema.validate(Json.parse("10")).valid()).isFalse();
+
+        // Inside range should pass
+        assertThat(schema.validate(Json.parse("5")).valid()).isTrue();
+    }
+
+    @Test
+    void multipleOfForDecimals() {
+        String schemaJson = """
+            {"type":"number", "multipleOf": 0.1}
+            """;
+        JsonSchema schema = JsonSchema.compile(Json.parse(schemaJson));
+
+        assertThat(schema.validate(Json.parse("0.3")).valid()).isTrue();
+        assertThat(schema.validate(Json.parse("0.25")).valid()).isFalse();
+    }
+}
+

json-java21-schema/src/test/java/io/github/simbo1905/json/schema/JsonSchemaNumberKeywordsTest.java

@@ -0,0 +1,103 @@
+package io.github.simbo1905.json.schema;
+
+import jdk.sandbox.java.util.json.Json;
+import org.junit.jupiter.api.Test;
+
+import static org.assertj.core.api.Assertions.*;
+
+class JsonSchemaObjectKeywordsTest extends JsonSchemaLoggingConfig {
+
+    @Test
+    void additionalPropertiesFalseDisallowsUnknown() {
+        String schemaJson = """
+            {
+              "type": "object",
+              "properties": {"name": {"type": "string"}},
+              "additionalProperties": false
+            }
+            """;
+        JsonSchema schema = JsonSchema.compile(Json.parse(schemaJson));
+
+        var result = schema.validate(Json.parse("""
+            {"name":"Alice","extra": 123}
+        """));
+        assertThat(result.valid()).isFalse();
+        assertThat(result.errors()).isNotEmpty();
+        assertThat(result.errors().get(0).path()).isEqualTo("extra");
+    }
+
+    @Test
+    void additionalPropertiesSchemaValidatesUnknown() {
+        String schemaJson = """
+            {
+              "type": "object",
+              "properties": {"id": {"type": "integer"}},
+              "additionalProperties": {"type": "string"}
+            }
+            """;
+        JsonSchema schema = JsonSchema.compile(Json.parse(schemaJson));
+
+        // invalid because extra is not a string
+        var bad = schema.validate(Json.parse("""
+            {"id": 1, "extra": 999}
+        """));
+        assertThat(bad.valid()).isFalse();
+        assertThat(bad.errors().get(0).path()).isEqualTo("extra");
+        assertThat(bad.errors().get(0).message()).contains("Expected string");
+
+        // valid because extra is a string
+        var ok = schema.validate(Json.parse("""
+            {"id": 1, "extra": "note"}
+        """));
+        assertThat(ok.valid()).isTrue();
+    }
+
+    @Test
+    void minAndMaxPropertiesAreEnforced() {
+        String schemaJson = """
+            {
+              "type": "object",
+              "minProperties": 2,
+              "maxProperties": 3
+            }
+            """;
+        JsonSchema schema = JsonSchema.compile(Json.parse(schemaJson));
+
+        var tooFew = schema.validate(Json.parse("""
+            {"a": 1}
+        """));
+        assertThat(tooFew.valid()).isFalse();
+        assertThat(tooFew.errors().get(0).message()).contains("Too few properties");
+
+        var ok = schema.validate(Json.parse("""
+            {"a": 1, "b": 2}
+        """));
+        assertThat(ok.valid()).isTrue();
+
+        var tooMany = schema.validate(Json.parse("""
+            {"a":1, "b":2, "c":3, "d":4}
+        """));
+        assertThat(tooMany.valid()).isFalse();
+        assertThat(tooMany.errors().get(0).message()).contains("Too many properties");
+    }
+
+    @Test
+    void objectKeywordsWithoutExplicitTypeAreTreatedAsObject() {
+        String schemaJson = """
+            {
+              "properties": {"name": {"type": "string"}},
+              "required": ["name"]
+            }
+            """;
+        JsonSchema schema = JsonSchema.compile(Json.parse(schemaJson));
+
+        var bad = schema.validate(Json.parse("{}"));
+        assertThat(bad.valid()).isFalse();
+        assertThat(bad.errors().get(0).message()).contains("Missing required property: name");
+
+        var ok = schema.validate(Json.parse("""
+            {"name":"x"}
+        """));
+        assertThat(ok.valid()).isTrue();
+    }
+}