adding unittest for exception handling for invalid URIs

 * also adding `SchemaException#toJSON()` with `"schemaLocation"` and `"message"` keys

Author: erosb

core/src/main/java/org/everit/json/schema/SchemaException.java

@@ -8,6 +8,8 @@
 import java.util.Collection;
 import java.util.List;
 
+import org.json.JSONObject;
+
 /**
  * Thrown by {@link org.everit.json.schema.loader.SchemaLoader#load()} when it encounters
  * un-parseable schema JSON definition.
@@ -76,6 +78,11 @@ public SchemaException(String schemaLocation, Class<?> actualType, Collection<Cl
         this.schemaLocation = schemaLocation;
     }
 
+    public SchemaException(String schemaLocation, Exception cause) {
+        super(cause.getMessage(), cause);
+        this.schemaLocation = schemaLocation;
+    }
+
     @Deprecated
     public SchemaException(String message) {
         this((String) null, message);
@@ -118,4 +125,11 @@ public SchemaException(String message, Throwable cause) {
     public String getSchemaLocation() {
         return schemaLocation;
     }
+
+    public JSONObject toJSON() {
+        JSONObject rval = new JSONObject();
+        rval.put("schemaLocation", schemaLocation);
+        rval.put("message", getMessage());
+        return rval;
+    }
 }

core/src/main/java/org/everit/json/schema/loader/JsonPointerEvaluator.java

@@ -109,12 +109,10 @@ static final JsonPointerEvaluator forDocument(JsonObject document, String fragme
     }
 
     private static JsonObject configureBasedOnState(JsonObject obj, LoadingState callingState, String id) {
-        try {
-            URI uri = new URI(id);
-            obj.ls = new LoadingState(callingState.config, callingState.pointerSchemas, obj, obj, uri, SchemaLocation.empty());
-        } catch (URISyntaxException e) {
-            throw callingState.createSchemaException("invalid URI: " + e.getMessage());
-        }
+        obj.ls = new LoadingState(callingState.config,
+                callingState.pointerSchemas, obj, obj,
+                validateURI(callingState, id),
+                SchemaLocation.empty());
         return obj;
     }
 
@@ -129,10 +127,19 @@ static final JsonPointerEvaluator forURL(SchemaClient schemaClient, String url,
             fragment = url.substring(poundIdx);
             toBeQueried = url.substring(0, poundIdx);
         }
+        validateURI(callingState, toBeQueried);
         return new JsonPointerEvaluator(() -> configureBasedOnState(executeWith(schemaClient, toBeQueried), callingState, toBeQueried),
                 fragment);
     }
 
+    private static URI validateURI(LoadingState callingState, String toBeQueried) {
+        try {
+            return new URI(toBeQueried);
+        } catch (URISyntaxException e) {
+            throw callingState.createSchemaException(e);
+        }
+    }
+
     private final Supplier<JsonObject> documentProvider;
 
     private final String fragment;

core/src/main/java/org/everit/json/schema/loader/LoadingState.java

@@ -145,6 +145,10 @@ SchemaException createSchemaException(String message) {
         return new SchemaException(locationOfCurrentObj(), message);
     }
 
+    SchemaException createSchemaException(Exception cause) {
+        return new SchemaException(locationOfCurrentObj(), cause);
+    }
+
     SchemaException createSchemaException(Class<?> actualType, Class<?> expectedType, Class<?>... furtherExpectedTypes) {
         return new SchemaException(locationOfCurrentObj(), actualType, expectedType, furtherExpectedTypes);
     }

core/src/test/java/org/everit/json/schema/loader/JsonPointerEvaluatorTest.java

@@ -2,10 +2,13 @@
 
 import static java.util.Arrays.asList;
 import static java.util.Collections.emptyMap;
+import static org.everit.json.schema.JSONMatcher.sameJsonAs;
 import static org.everit.json.schema.TestSupport.asStream;
 import static org.everit.json.schema.loader.JsonValueTest.withLs;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertThat;
+import static org.junit.Assert.fail;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
@@ -24,7 +27,10 @@ public class JsonPointerEvaluatorTest {
     private static final JsonObject rootSchemaJson = withLs(JsonValue.of(ResourceLoader.DEFAULT.readObj("testschemas.json")
             .getJSONObject("refPointerDerivatedFromPointer").toMap())).requireObject();
 
+    private static final ResourceLoader LOADER = ResourceLoader.DEFAULT;
+
     @Test
+
     public void sameDocumentSuccess() {
         JsonPointerEvaluator pointer = JsonPointerEvaluator.forDocument(rootSchemaJson, "#/definitions/Bar");
         JsonObject actual = pointer.query().getQueryResult().requireObject();
@@ -77,14 +83,29 @@ public void remoteDocumentSuccess() {
         SchemaClient schemaClient = mock(SchemaClient.class);
         when(schemaClient.get("http://localhost:1234/hello")).thenReturn(rootSchemaJsonAsStream());
         JsonPointerEvaluator pointer = JsonPointerEvaluator
-                .forURL(schemaClient, "http://localhost:1234/hello#/definitions/Bar", createLoadingState(schemaClient, "#/definitions/Foo"));
+                .forURL(schemaClient, "http://localhost:1234/hello#/definitions/Bar",
+                        createLoadingState(schemaClient, "#/definitions/Foo"));
         JsonObject actual = pointer.query().getQueryResult().requireObject();
         assertEquals("dummy schema at #/definitions/Bar", actual.require("description").requireString());
         assertEquals("http://localhost:1234/folder/", actual.ls.id.toString());
         assertEquals(new SchemaLocation(asList("definitions", "Bar")), actual.ls.pointerToCurrentObj);
     }
 
+    @Test
+    public void schemaExceptionForInvalidURI() {
+        try {
+            SchemaClient schemaClient = mock(SchemaClient.class);
+            JsonPointerEvaluator subject = JsonPointerEvaluator.forURL(schemaClient, "||||",
+                    createLoadingState(schemaClient, "#/definitions/Foo"));
+            subject.query();
+            fail("did not throw exception");
+        } catch (SchemaException e) {
+            assertThat(e.toJSON(), sameJsonAs(LOADER.readObj("pointer-eval-non-uri-failure.json")));
+        }
+    }
+
     protected InputStream rootSchemaJsonAsStream() {
         return asStream(new JSONObject(rootSchemaJson.toMap()).toString());
     }
 }
+

core/src/test/resources/org/everit/jsonvalidator/pointer-eval-non-uri-failure.json

@@ -0,0 +1,4 @@
+{
+  "schemaLocation": "#",
+  "message": "Illegal character in path at index 0: ||||"
+}