improving error handling in LoadingState#childFor()

Properly handling nonexistent map keys and invalid array indices:
    * added hashCode - equals to SchemaException, for asserts
    * added #getRawChildOfObject() and #getRawElemOfArray() to LoadingState
    * a bunch of unittests

Author: erosb

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

@@ -1,15 +1,13 @@
 package org.everit.json.schema;
 
-import org.json.JSONPointer;
-
-import java.util.Collection;
-import java.util.List;
-
 import static java.lang.String.format;
 import static java.util.Arrays.asList;
 import static java.util.Objects.requireNonNull;
 import static java.util.stream.Collectors.joining;
 
+import java.util.Collection;
+import java.util.List;
+
 /**
  * Thrown by {@link org.everit.json.schema.loader.SchemaLoader#load()} when it encounters
  * un-parseable schema JSON definition.
@@ -102,6 +100,21 @@ public SchemaException(String message, Throwable cause) {
         this.schemaLocation = null;
     }
 
+    @Override public boolean equals(Object o) {
+        if (this == o)
+            return true;
+        if (o == null || getClass() != o.getClass())
+            return false;
+
+        SchemaException that = (SchemaException) o;
+
+        return toString().equals(that.toString());
+    }
+
+    @Override public int hashCode() {
+        return toString().hashCode();
+    }
+
     public String getSchemaLocation() {
         return schemaLocation;
     }

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

@@ -142,6 +142,7 @@ static final JsonPointerEvaluator forURL(SchemaClient schemaClient, String url,
      */
     public QueryResult query() {
         JsonObject document = documentProvider.get();
+        System.out.println(document);
         if (fragment.isEmpty()) {
             return new QueryResult(document, document);
         }
@@ -174,10 +175,12 @@ private String unescape(String token) {
 
     private JsonValue queryFrom(JsonValue document, LinkedList<String> tokens) {
         String key = unescape(tokens.poll());
+        System.out.println(key + " , " + document);
         JsonValue next = document.canBeMappedTo(JsonObject.class, obj -> obj.childFor(key))
                 .orMappedTo(JsonArray.class, arr -> arr.at(Integer.parseInt(key)))
                 .requireAny();
 
+        System.out.println("next: " + next);
         if (tokens.isEmpty()) {
             return next;
         }

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

@@ -1,5 +1,6 @@
 package org.everit.json.schema.loader;
 
+import static java.lang.String.format;
 import static java.util.Objects.requireNonNull;
 import static org.apache.commons.collections.ListUtils.unmodifiableList;
 import static org.everit.json.schema.loader.SpecificationVersion.DRAFT_6;
@@ -84,14 +85,34 @@ SchemaLoader.SchemaLoaderBuilder initChildLoader() {
         return rval;
     }
 
+    private Object getRawChildOfObject(JsonObject obj, String key) {
+        if (!((Map<String, Object>) obj.unwrap()).containsKey(key)) {
+            throw createSchemaException(format("key [%s] not found", key));
+        }
+        return ((Map<String, Object>) obj.unwrap()).get(key);
+    }
+
+    private Object getRawElemOfArray(JsonArray array, String rawIndex) {
+        List<?> raw = (List<?>) array.unwrap();
+        try {
+            int index = Integer.parseInt(rawIndex);
+            if (raw.size() <= index) {
+                throw createSchemaException(format("array index [%d] is out of bounds", index));
+            }
+            return raw.get(index);
+        } catch (NumberFormatException e) {
+            throw createSchemaException(format("[%s] is not an array index", rawIndex));
+        }
+    }
+
     JsonValue childFor(String key) {
         List<String> newPtr = new ArrayList<>(pointerToCurrentObj.size() + 1);
         newPtr.addAll(pointerToCurrentObj);
         newPtr.add(key);
 
         Object rawChild = schemaJson
-                .canBeMappedTo(JsonObject.class, schemaJsonObj -> ((Map<String, Object>) schemaJsonObj.unwrap()).get(key))
-                .orMappedTo(JsonArray.class, schemaJsonArray -> ((List<?>) schemaJsonArray.unwrap()).get(Integer.parseInt(key)))
+                .canBeMappedTo(JsonObject.class, obj -> getRawChildOfObject(obj, key))
+                .orMappedTo(JsonArray.class, array -> getRawElemOfArray(array, key))
                 .requireAny();
 
         LoadingState childLs = new LoadingState(

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

@@ -117,6 +117,7 @@ private JsonObject lookupObjById(JsonValue val, String idAttrVal) {
      * Returns a schema builder instance after looking up the JSON pointer.
      */
     Schema.Builder<?> lookup(String relPointerString, JsonObject ctx) {
+        System.out.println(ls.rootSchemaJson());
         if (isSameDocumentRef(relPointerString)) {
             if (ls.pointerSchemas.containsKey(relPointerString)) {
                 return ls.pointerSchemas.get(relPointerString);
@@ -132,6 +133,7 @@ Schema.Builder<?> lookup(String relPointerString, JsonObject ctx) {
             ReferenceSchema.Builder refBuilder = ReferenceSchema.builder()
                     .refValue(relPointerString);
             ls.pointerSchemas.put(relPointerString, refBuilder);
+            System.out.println(rawInternalReferenced);
             Schema referredSchema = new SchemaLoader(rawInternalReferenced.ls).load().build();
             refBuilder.build().setReferredSchema(referredSchema);
             return refBuilder;

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

@@ -5,6 +5,7 @@
 import static java.util.Collections.emptyMap;
 import static org.everit.json.schema.loader.JsonValueTest.withLs;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.fail;
 
 import java.util.HashMap;
 import java.util.Map;
@@ -27,27 +28,31 @@ private LoadingState emptySubject() {
 
     @Test
     public void childForString() {
-        LoadingState ls = emptySubject();
+        LoadingState ls = helloWorldObjState();
         LoadingState actual = ls.childFor("hello").ls;
         assertEquals(asList("hello"), actual.pointerToCurrentObj);
     }
 
     @Test
     public void childForSecond() {
+        LoadingState ls = helloWorldObjState();
+        LoadingState actual = ls.childFor("hello").requireObject().childFor("world").ls;
+        assertEquals(asList("hello", "world"), actual.pointerToCurrentObj);
+    }
+
+    protected LoadingState helloWorldObjState() {
         Map<String, Object> rawObj = new HashMap<>();
         Map<String, Object> worldObj = new HashMap<>();
         worldObj.put("world", true);
         rawObj.put("hello", worldObj);
-        LoadingState ls = withLs(JsonValue.of(rawObj)).ls;
-        LoadingState actual = ls.childFor("hello").requireObject().childFor("world").ls;
-        assertEquals(asList("hello", "world"), actual.pointerToCurrentObj);
+        return withLs(JsonValue.of(rawObj)).ls;
     }
 
     @Test
     public void childForArrayIndex() {
-        LoadingState ls = emptySubject();
-        LoadingState actual = ls.childFor(42).ls;
-        assertEquals(asList("42"), actual.pointerToCurrentObj);
+        LoadingState subject = singleElemArrayState();
+        LoadingState actual = subject.childFor(0).ls;
+        assertEquals(asList("0"), actual.pointerToCurrentObj);
     }
 
     @Test
@@ -58,4 +63,43 @@ public void testCreateSchemaException() {
         assertEquals(JSONPointer.builder().build().toURIFragment(), actual.getSchemaLocation());
     }
 
+    @Test
+    public void testChildForFailure_NotFound() {
+        LoadingState ls = helloWorldObjState();
+        try {
+            ls.childFor("nonexistent");
+            fail("did not throw exception for nonexistent key");
+        } catch (SchemaException e) {
+            SchemaException expected = new SchemaException("#", "key [nonexistent] not found");
+            assertEquals(expected, e);
+        }
+    }
+
+    @Test
+    public void testChildForArrayFailure_NotFound() {
+        LoadingState subject = singleElemArrayState();
+        try {
+            subject.childFor(1);
+            fail("did not throw exception");
+        } catch (SchemaException e) {
+            SchemaException expected = new SchemaException("#", "array index [1] is out of bounds");
+            assertEquals(expected, e);
+        }
+    }
+
+    @Test
+    public void invalidArrayIndex() {
+        try {
+            singleElemArrayState().childFor("key");
+            fail("did not throw exception");
+        } catch (SchemaException e) {
+            SchemaException expected = new SchemaException("#", "[key] is not an array index");
+            assertEquals(expected, e);
+        }
+    }
+
+    protected LoadingState singleElemArrayState() {
+        return withLs(JsonValue.of(asList("elem"))).ls;
+    }
+
 }