Support loading main schema and relative refs from URLs (#443)

Remove schemaRoot config, resolutionScope is now set to base path

Author: fsteeg

metafacture-json/src/main/java/org/metafacture/json/JsonValidator.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2021, 2022 Fabian Steeg, hbz
+ * Copyright 2021, 2023 Fabian Steeg, hbz
  *
  * Licensed under the Apache License, Version 2.0 the "License";
  * you may not use this file except in compliance with the License.
@@ -28,6 +28,7 @@
 import org.everit.json.schema.ValidationException;
 import org.everit.json.schema.loader.SchemaClient;
 import org.everit.json.schema.loader.SchemaLoader;
+import org.everit.json.schema.loader.SchemaLoader.SchemaLoaderBuilder;
 import org.json.JSONException;
 import org.json.JSONObject;
 import org.json.JSONTokener;
@@ -37,14 +38,14 @@
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.InputStream;
+import java.net.URL;
 
 /**
  * Validate JSON against a given schema, pass only valid input to the receiver.
  *
  * @author Fabian Steeg (fsteeg)
  */
 @Description("Validate JSON against a given schema, send only valid input to the receiver. Pass the schema location to validate against. " +
-        "Set `schemaRoot` for resolving sub-schemas referenced in `$id` or `$ref` (defaults to the classpath root: `/`). " +
         "Write valid and/or invalid output to locations specified with `writeValid` and `writeInvalid`. " +
         "Set the JSON key for the record ID value with `idKey` (for logging output, defaults to `id`).")
 @In(String.class)
@@ -53,15 +54,13 @@
 public final class JsonValidator extends DefaultObjectPipe<String, ObjectReceiver<String>> {
 
     private static final Logger LOG = LoggerFactory.getLogger(JsonValidator.class);
-    private static final String DEFAULT_SCHEMA_ROOT = "/";
     private static final String DEFAULT_ID_KEY = "id";
     private String schemaUrl;
     private Schema schema;
     private long fail;
     private long success;
     private FileWriter writeInvalid;
     private FileWriter writeValid;
-    private String schemaRoot = DEFAULT_SCHEMA_ROOT;
     private String idKey = DEFAULT_ID_KEY;
 
     /**
@@ -71,13 +70,6 @@ public JsonValidator(final String url) {
         this.schemaUrl = url;
     }
 
-    /**
-     * @param schemaRoot The root location for resolving sub-schemas referenced in '$id' or '$ref'.
-     */
-    public void setSchemaRoot(final String schemaRoot) {
-        this.schemaRoot = schemaRoot;
-    }
-
     /**
      * @param writeValid The location to write valid data to.
      */
@@ -134,18 +126,34 @@ private void initSchema() {
         if (schema != null) {
             return;
         }
-        try (InputStream inputStream = getClass().getResourceAsStream(schemaUrl)) {
-            schema = SchemaLoader.builder()
-                    .schemaJson(new JSONObject(new JSONTokener(inputStream)))
-                    .schemaClient(SchemaClient.classPathAwareClient())
-                    .resolutionScope("classpath://" + schemaRoot)
-                    .build().load().build();
+        SchemaLoaderBuilder schemaLoader = SchemaLoader.builder();
+        try {
+            final URL url = new URL(schemaUrl);
+            schemaLoader = schemaLoader.schemaJson(jsonFrom(url.openStream()))
+                    .resolutionScope(baseFor(url.toString()));
+        }
+        catch (final IOException e) {
+            LOG.info("Could not read as URL: {}, trying to load from class path", schemaUrl);
+            schemaLoader = schemaLoader.schemaClient(SchemaClient.classPathAwareClient())
+                    .schemaJson(jsonFrom(getClass().getResourceAsStream(schemaUrl)))
+                    .resolutionScope("classpath://" + baseFor(schemaUrl));
+        }
+        schema = schemaLoader.build().load().build();
+    }
+
+    private JSONObject jsonFrom(final InputStream inputStream) {
+        try {
+            return new JSONObject(new JSONTokener(inputStream));
         }
-        catch (final IOException | JSONException e) {
+        catch (final JSONException e) {
             throw new MetafactureException(e.getMessage(), e);
         }
     }
 
+    private String baseFor(final String path) {
+        return path.substring(0, path.lastIndexOf('/') + 1);
+    }
+
     private FileWriter fileWriter(final String fileLocation) {
         try {
             return new FileWriter(fileLocation);

metafacture-json/src/test/java/org/metafacture/json/JsonValidatorTest.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2021, 2022 Fabian Steeg, hbz
+ * Copyright 2021, 2023 Fabian Steeg, hbz
  *
  * Licensed under the Apache License, Version 2.0 the "License";
  * you may not use this file except in compliance with the License.
@@ -18,19 +18,26 @@
 import static org.hamcrest.CoreMatchers.both;
 import static org.hamcrest.CoreMatchers.containsString;
 import static org.junit.Assert.assertThat;
+import static com.github.tomakehurst.wiremock.client.WireMock.stubFor;
+import static com.github.tomakehurst.wiremock.client.WireMock.request;
 
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.net.MalformedURLException;
 import java.net.URL;
 import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.function.Function;
 import java.util.stream.Collectors;
 
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
 import org.metafacture.framework.MetafactureException;
 import org.metafacture.framework.ObjectReceiver;
 import org.mockito.InOrder;
@@ -49,9 +56,11 @@
  * @author Fabian Steeg
  *
  */
+@RunWith(Parameterized.class)
 public final class JsonValidatorTest {
 
-    private static final String SCHEMA = "/schemas/schema.json";
+    private static final String MAIN_SCHEMA = "/schemas/schema.json";
+    private static final String ID_SCHEMA = "/schemas/id.json";
     private static final String JSON_VALID = "{\"id\":\"http://example.org/\"}";
     private static final String JSON_INVALID_MISSING_REQUIRED = "{}";
     private static final String JSON_INVALID_URI_FORMAT= "{\"id\":\"example.org/\"}";
@@ -63,30 +72,51 @@ public final class JsonValidatorTest {
     @Mock
     private ObjectReceiver<String> receiver;
     private InOrder inOrder;
+    private Function<Object, String> schemaLocationGetter;
 
     @Rule
     public WireMockRule wireMockRule = new WireMockRule(WireMockConfiguration.wireMockConfig()
             .jettyAcceptors(Runtime.getRuntime().availableProcessors()).dynamicPort());
 
+    @Parameterized.Parameters(name = "{index}")
+    public static Collection<Object[]> siteMaps() {
+        return Arrays.asList((Object[][]) (new Function[][] { //
+                // Pass the schema to each test as path on classpath, file url, and http url:
+                { (Object rule) -> MAIN_SCHEMA },
+                { (Object rule) -> JsonValidatorTest.class.getResource(MAIN_SCHEMA).toString() },
+                { (Object rule) -> ((WireMockRule) rule).baseUrl() + MAIN_SCHEMA } }));
+    }
+
+    public JsonValidatorTest(Function<Object, String> schemaLocationGetter) {
+        this.schemaLocationGetter = schemaLocationGetter;
+    }
+
     @Before
     public void setup() throws IOException {
         MockitoAnnotations.initMocks(this);
-        WireMock.stubFor(WireMock.request("GET", WireMock.urlEqualTo("/schema"))
-                .willReturn(WireMock.ok().withBody(readToString(getClass().getResource(SCHEMA)))));
-        validator = new JsonValidator(SCHEMA);
-        validator.setSchemaRoot("/schemas/");
+        wireMock(MAIN_SCHEMA, ID_SCHEMA);
+        String schemaLocation = schemaLocationGetter.apply(wireMockRule);
+        validator = new JsonValidator(schemaLocation);
         validator.setReceiver(receiver);
         inOrder = Mockito.inOrder(receiver);
     }
 
+    private void wireMock(final String... schemaLocations) throws IOException {
+        for (String schemaLocation : schemaLocations) {
+            stubFor(request("GET", WireMock.urlEqualTo(schemaLocation)).willReturn(
+                    WireMock.ok().withBody(readToString(getClass().getResource(schemaLocation)))
+                            .withHeader("Content-type", "application/json")));
+        }
+    }
+
     private String readToString(final URL url) throws IOException {
         return new BufferedReader(new InputStreamReader(url.openStream(), StandardCharsets.UTF_8))
                 .lines().collect(Collectors.joining("\n"));
     }
 
     @Test
     public void callWireMockSchema() throws MalformedURLException, IOException {
-        final String schemaContent = readToString(new URL(wireMockRule.baseUrl() + "/schema"));
+        final String schemaContent = readToString(new URL(wireMockRule.baseUrl() + MAIN_SCHEMA));
         assertThat(schemaContent, both(containsString("$schema")).and(containsString("$ref")));
     }