relax root schema constraint, add tests

Author: harrel56

src/main/java/dev/harrel/jsonschema/Validator.java

@@ -150,22 +150,24 @@ public Result validate(URI schemaUri, JsonNode instanceNode) {
     }
 
     private Schema getRootSchema(URI uri) {
-        if (UriUtil.hasNonEmptyFragment(uri)) {
-            throw new IllegalArgumentException(String.format("Root schema [%s] cannot contain non-empty fragments", uri));
-        }
+        CompoundUri compoundUri = CompoundUri.fromString(uri.toString());
         return OptionalUtil.firstPresent(
-                        () -> Optional.ofNullable(schemaRegistry.get(UriUtil.getUriWithoutFragment(uri))),
-                        () -> resolveExternalSchema(uri)
+                        () -> Optional.ofNullable(schemaRegistry.get(compoundUri)),
+                        () -> resolveExternalSchema(compoundUri)
                 )
-                .orElseThrow(() -> new SchemaNotFoundException(new CompoundUri(uri, "")));
+                .orElseThrow(() -> new SchemaNotFoundException(compoundUri));
     }
 
-    private Optional<Schema> resolveExternalSchema(URI uri) {
-        return schemaResolver.resolve(uri.toString())
+    private Optional<Schema> resolveExternalSchema(CompoundUri compoundUri) {
+        if (schemaRegistry.get(compoundUri.uri) != null) {
+            return Optional.empty();
+        }
+
+        return schemaResolver.resolve(compoundUri.uri.toString())
                 .toJsonNode(schemaNodeFactory)
                 .map(node -> {
-                    jsonParser.parseRootSchema(uri, node);
-                    return schemaRegistry.get(uri);
+                    jsonParser.parseRootSchema(compoundUri.uri, node);
+                    return schemaRegistry.get(compoundUri);
                 });
     }
 

src/test/java/dev/harrel/jsonschema/ValidatorTest.java

@@ -35,17 +35,46 @@ void failsForUriWithNonEmptyFragments() {
         Validator validator = new ValidatorFactory().createValidator();
         URI uri = URI.create("https://test.com/x#/$def/x");
         assertThatThrownBy(() -> validator.validate(uri, "{}"))
-                .isInstanceOf(IllegalArgumentException.class)
-                .hasMessage("Root schema [https://test.com/x#/$def/x] cannot contain non-empty fragments");
+                .isInstanceOf(SchemaNotFoundException.class)
+                .hasMessage("Couldn't find schema with uri [https://test.com/x#/$def/x]");
     }
 
     @Test
-    void registersUriWithEmptyFragments() {
+    void failsForNonExistentSchemaWithEmptyFragment() {
         Validator validator = new ValidatorFactory().createValidator();
         URI uri = URI.create("https://test.com/x#");
         assertThatThrownBy(() -> validator.validate(uri, "{}"))
                 .isInstanceOf(SchemaNotFoundException.class)
-                .hasMessage("Couldn't find schema with uri [https://test.com/x#]");
+                .hasMessage("Couldn't find schema with uri [https://test.com/x]");
+    }
+
+    @Test
+    void findsSchemaByGeneratedUri() {
+        Validator validator = new ValidatorFactory().createValidator();
+        URI uri = validator.registerSchema("{}");
+        Validator.Result result = validator.validate(uri, "{}");
+        assertThat(result.isValid()).isTrue();
+    }
+
+    @Test
+    void findsSchemaByProvidedUri() {
+        Validator validator = new ValidatorFactory().createValidator();
+        URI uri = URI.create("https://test.com/schema");
+        validator.registerSchema(URI.create("https://test.com/schema"), "{}");
+        Validator.Result result = validator.validate(uri, "{}");
+        assertThat(result.isValid()).isTrue();
+    }
+
+    @Test
+    void findsSchemaByIdKeyword() {
+        Validator validator = new ValidatorFactory().createValidator();
+        URI uri = URI.create("https://test.com/schema/id");
+        validator.registerSchema("""
+                {
+                  "$id": "https://test.com/schema/id"
+                }""");
+        Validator.Result result = validator.validate(uri, "{}");
+        assertThat(result.isValid()).isTrue();
     }
 
     @Test
@@ -184,6 +213,72 @@ void shouldFallbackToSchemaResolver() {
         );
     }
 
+    @Test
+    void shouldFallbackToSchemaResolverWithFragment() {
+        Validator validator = new ValidatorFactory()
+                .withDisabledSchemaValidation(true)
+                .withSchemaResolver(uri -> SchemaResolver.Result.fromString("""
+                        {
+                          "$defs": {
+                            "sub": {
+                              "type": "string"
+                            }
+                          }
+                        }"""))
+                .createValidator();
+
+        Validator.Result result = validator.validate(URI.create("urn:test#/$defs/sub"), "{}");
+        assertThat(result.isValid()).isFalse();
+
+        List<Error> errors = result.getErrors();
+        assertThat(errors).hasSize(1);
+        assertError(
+                errors.get(0),
+                "/$defs/sub/type",
+                "urn:test#/$defs/sub",
+                "",
+                "type",
+                "Value is [object] but should be [string]"
+        );
+    }
+
+    @Test
+    void shouldFailResolvingExternalSchemaWithInvalidFragment() {
+        Validator validator = new ValidatorFactory()
+                .withDisabledSchemaValidation(true)
+                .withSchemaResolver(uri -> SchemaResolver.Result.fromString("""
+                        {
+                          "$defs": {
+                            "sub": {
+                              "type": "string"
+                            }
+                          }
+                        }"""))
+                .createValidator();
+
+        URI uri = URI.create("urn:test#/$defs/non-existent");
+        assertThatThrownBy(() -> validator.validate(uri, "{}"))
+                .isInstanceOf(SchemaNotFoundException.class)
+                .hasMessage("Couldn't find schema with uri [urn:test#/$defs/non-existent]");
+    }
+
+    @Test
+    void shouldFailResolvingSchemaWithInvalidFragment() {
+        Validator validator = new ValidatorFactory().createValidator();
+        URI uri = URI.create("urn:test#/$defs/non-existent");
+        validator.registerSchema(uri, """
+                        {
+                          "$defs": {
+                            "sub": {
+                              "type": "string"
+                            }
+                          }
+                        }""");
+        assertThatThrownBy(() -> validator.validate(uri, "{}"))
+                .isInstanceOf(SchemaNotFoundException.class)
+                .hasMessage("Couldn't find schema with uri [urn:test#/$defs/non-existent]");
+    }
+
     @Test
     void allowsEmptyFragmentsInIdRootSchema() {
         // with disabled schema validation
@@ -312,4 +407,35 @@ void disallowsNonEmptyFragmentsInIdSubSchema() {
                 .isInstanceOf(InvalidSchemaException.class)
                 .hasMessage("Schema [urn:sub] failed to validate against meta-schema [https://json-schema.org/draft/2020-12/schema]");
     }
+
+    @Test
+    void supportsMultipleWaysOfReferencing() {
+        String schema = """
+                {
+                  "$defs": {
+                    "x": {
+                      "$id": "urn:sub#"
+                    }
+                  }
+                }""";
+        Validator validator = new ValidatorFactory()
+                .withDisabledSchemaValidation(true)
+                .createValidator();
+
+        validator.registerSchema(URI.create("https://test.com/schema"), schema);
+        Validator.Result result = validator.validate(URI.create("https://test.com/schema"), "true");
+        assertThat(result.isValid()).isTrue();
+
+        result = validator.validate(URI.create("https://test.com/schema#"), "true");
+        assertThat(result.isValid()).isTrue();
+
+        result = validator.validate(URI.create("https://test.com/schema#/$defs/x"), "true");
+        assertThat(result.isValid()).isTrue();
+
+        result = validator.validate(URI.create("urn:sub"), "true");
+        assertThat(result.isValid()).isTrue();
+
+        result = validator.validate(URI.create("urn:sub#"), "true");
+        assertThat(result.isValid()).isTrue();
+    }
 }