Fix AbsoluteGraphQLError source location bug.

tinnou · bbakerman · commit fa8915d7dc5a · 2018-04-02T18:09:45.000+10:00
diff --git a/src/main/java/graphql/execution/AbsoluteGraphQLError.java b/src/main/java/graphql/execution/AbsoluteGraphQLError.java
@@ -1,18 +1,18 @@
 package graphql.execution;
 
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
 import graphql.ErrorType;
 import graphql.GraphQLError;
 import graphql.language.Field;
 import graphql.language.SourceLocation;
 import graphql.schema.DataFetcher;
-
-import java.util.ArrayList;
-import java.util.Collections;
 import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
-import java.util.Optional;
-import java.util.stream.Collectors;
 
 import static graphql.Assert.assertNotNull;
 
@@ -67,6 +67,15 @@ public Map<String, Object> getExtensions() {
         return extentions;
     }
 
+    /**
+     * Creating absolute paths follows the following logic:
+     *  Relative path is null -> Absolute path null
+     *  Relative path is empty -> Absolute paths is path up to the field.
+     *  Relative path is not empty -> Absolute paths [base Path, relative Path]
+     * @param relativeError relative error
+     * @param executionStrategyParameters execution strategy params.
+     * @return List of paths from the root.
+     */
     private List<Object> createAbsolutePath(ExecutionStrategyParameters executionStrategyParameters,
                                             GraphQLError relativeError) {
         return Optional.ofNullable(relativeError.getPath())
@@ -80,13 +89,28 @@ private List<Object> createAbsolutePath(ExecutionStrategyParameters executionStr
                 .orElse(null);
     }
 
+    /**
+     * Creating absolute locations follows the following logic:
+     *  Relative locations is null -> Absolute locations null
+     *  Relative locations is empty -> Absolute locations base locations of the field.
+     *  Relative locations is not empty -> Absolute locations [base line + relative line location]
+     * @param relativeError relative error
+     * @param fields fields on the current field.
+     * @return List of locations from the root.
+     */
     private List<SourceLocation> createAbsoluteLocations(GraphQLError relativeError, List<Field> fields) {
         Optional<SourceLocation> baseLocation;
         if (!fields.isEmpty()) {
             baseLocation = Optional.ofNullable(fields.get(0).getSourceLocation());
         } else {
             baseLocation = Optional.empty();
         }
+
+        // relative error empty path should yield an absolute error with the base path
+        if (relativeError.getLocations() != null && relativeError.getLocations().isEmpty()) {
+            return baseLocation.map(Collections::singletonList).orElse(null);
+        }
+
         return Optional.ofNullable(
                 relativeError.getLocations())
                 .map(locations -> locations.stream()
diff --git a/src/test/groovy/graphql/execution/AbsoluteGraphQLErrorTest.groovy b/src/test/groovy/graphql/execution/AbsoluteGraphQLErrorTest.groovy
@@ -82,6 +82,32 @@ class AbsoluteGraphQLErrorTest extends Specification {
         error.getPath() == null
     }
 
+    def "when constructor receives empty path it should return the base field path"() {
+        given:
+
+        def field = new Field("test")
+        field.setSourceLocation(new SourceLocation(4, 5))
+
+        def parameters = newParameters()
+                .typeInfo(ExecutionTypeInfo.newTypeInfo().type(objectType))
+                .source(new Object())
+                .fields(["fld": [new Field()]])
+                .field([field])
+                .path(ExecutionPath.fromList(["foo", "bar"]))
+                .build()
+
+        def relativeError = new DataFetchingErrorGraphQLError("blah")
+        relativeError.path = []
+
+        when:
+
+        def error = new AbsoluteGraphQLError(parameters, relativeError)
+
+        then:
+
+        error.getPath() == ["foo", "bar"]
+    }
+
     def "constructor handles missing locations as null"() {
         given:
 
@@ -106,6 +132,32 @@ class AbsoluteGraphQLErrorTest extends Specification {
         error.getLocations() == null
     }
 
+    def "when constructor receives empty locations it should return the base field locations"() {
+        given:
+
+        def field = new Field("test")
+        def expectedSourceLocation = new SourceLocation(1, 2)
+        field.setSourceLocation(expectedSourceLocation)
+
+        def parameters = newParameters()
+                .typeInfo(ExecutionTypeInfo.newTypeInfo().type(objectType))
+                .source(new Object())
+                .fields(["fld": [new Field()]])
+                .field([field])
+                .path(ExecutionPath.fromList(["foo", "bar"]))
+                .build()
+
+        def relativeError = new DataFetchingErrorGraphQLError("blah")
+        relativeError.locations = []
+
+        when:
+        def error = new AbsoluteGraphQLError(parameters, relativeError)
+
+        then:
+
+        error.getLocations() == [expectedSourceLocation]
+    }
+
     def "constructor transforms multiple source locations"() {
         given:
 
