Add traceback to GraphQLErrors

Should solve issue #23

Also replicates graphql/graphql-js@f0ae3f4

Author: Cito

graphql/error/graphql_error.py

@@ -1,3 +1,4 @@
+from sys import exc_info
 from typing import Any, Dict, List, Optional, Sequence, Union, TYPE_CHECKING
 
 from .format_error import format_error
@@ -118,12 +119,21 @@ def __init__(
             path = list(path)
         self.path = path or None  # type: ignore
         self.original_error = original_error
-        if not extensions and original_error:
-            try:
-                extensions = original_error.extensions  # type: ignore
-            except AttributeError:
-                pass
+        if original_error:
+            if not self.__traceback__:
+                self.__traceback__ = original_error.__traceback__
+            if original_error.__cause__:
+                self.__cause__ = original_error.__cause__
+            elif original_error.__context__:
+                self.__context__ = original_error.__context__
+            if not extensions:
+                try:
+                    extensions = original_error.extensions  # type: ignore
+                except AttributeError:
+                    pass
         self.extensions = extensions or {}
+        if not self.__traceback__:
+            self.__traceback__ = exc_info()[2]
 
     def __str__(self):
         return print_error(self)

tests/error/test_graphql_error.py

@@ -1,98 +1,123 @@
+from typing import cast
+
 from graphql.error import GraphQLError, format_error
-from graphql.language import parse, Source
+from graphql.language import parse, OperationDefinitionNode, Source
+from graphql.pyutils import dedent
+
+
+source = Source(
+    dedent(
+        """
+    {
+      field
+    }
+    """
+    )
+)
+
+ast = parse(source)
+operation_node = ast.definitions[0]
+operation_node = cast(OperationDefinitionNode, operation_node)
+assert operation_node and operation_node.kind == "operation_definition"
+field_node = operation_node.selection_set.selections[0]
+assert field_node
 
 
 def describe_graphql_error():
     def is_a_class_and_is_a_subclass_of_exception():
+        assert type(GraphQLError) is type
         assert issubclass(GraphQLError, Exception)
-        assert isinstance(GraphQLError("msg"), GraphQLError)
+        assert isinstance(GraphQLError("str"), Exception)
+        assert isinstance(GraphQLError("str"), GraphQLError)
 
     def has_a_name_message_and_stack_trace():
         e = GraphQLError("msg")
         assert e.__class__.__name__ == "GraphQLError"
         assert e.message == "msg"
 
-    def stores_the_original_error():
-        original = Exception("original")
+    def uses_the_stack_of_an_original_error():
+        try:
+            raise RuntimeError("original")
+        except RuntimeError as e:
+            original = e
         e = GraphQLError("msg", original_error=original)
         assert e.__class__.__name__ == "GraphQLError"
+        assert e.__traceback__ is original.__traceback__
         assert e.message == "msg"
-        assert e.original_error == original
+        assert e.original_error is original
+        assert str(e.original_error) == "original"
+
+    def creates_new_stack_if_original_error_has_no_stack():
+        try:
+            raise RuntimeError
+        except RuntimeError as original_with_traceback:
+            original_traceback = original_with_traceback.__traceback__
+            original = RuntimeError("original")
+            e = GraphQLError("msg", original_error=original)
+        assert e.__class__.__name__ == "GraphQLError"
+        assert original.__traceback__ is None
+        assert original_traceback is not None
+        assert e.__traceback__ is original_traceback
+        assert e.message == "msg"
+        assert e.original_error is original
+        assert str(e.original_error) == "original"
 
     def converts_nodes_to_positions_and_locations():
-        source = Source("{\n      field\n}")
-        ast = parse(source)
-        # noinspection PyUnresolvedReferences
-        field_node = ast.definitions[0].selection_set.selections[0]
         e = GraphQLError("msg", [field_node])
         assert e.nodes == [field_node]
         assert e.source is source
-        assert e.positions == [8]
-        assert e.locations == [(2, 7)]
+        assert e.positions == [4]
+        assert e.locations == [(2, 3)]
 
     def converts_single_node_to_positions_and_locations():
-        source = Source("{\n      field\n}")
-        ast = parse(source)
-        # noinspection PyUnresolvedReferences
-        field_node = ast.definitions[0].selection_set.selections[0]
         e = GraphQLError("msg", field_node)  # Non-array value.
         assert e.nodes == [field_node]
         assert e.source is source
-        assert e.positions == [8]
-        assert e.locations == [(2, 7)]
+        assert e.positions == [4]
+        assert e.locations == [(2, 3)]
 
     def converts_node_with_loc_start_zero_to_positions_and_locations():
-        source = Source("{\n      field\n}")
-        ast = parse(source)
-        operations_node = ast.definitions[0]
-        e = GraphQLError("msg", [operations_node])
-        assert e.nodes == [operations_node]
+        e = GraphQLError("msg", [operation_node])
+        assert e.nodes == [operation_node]
         assert e.source is source
         assert e.positions == [0]
         assert e.locations == [(1, 1)]
 
     def converts_source_and_positions_to_locations():
-        source = Source("{\n      field\n}")
-        # noinspection PyArgumentEqualDefault
-        e = GraphQLError("msg", None, source, [10])
+        e = GraphQLError("msg", None, source, [6])
         assert e.nodes is None
         assert e.source is source
-        assert e.positions == [10]
-        assert e.locations == [(2, 9)]
+        assert e.positions == [6]
+        assert e.locations == [(2, 5)]
 
     def serializes_to_include_message():
         e = GraphQLError("msg")
         assert str(e) == "msg"
         assert repr(e) == "GraphQLError('msg')"
 
     def serializes_to_include_message_and_locations():
-        # noinspection PyUnresolvedReferences
-        node = parse("{ field }").definitions[0].selection_set.selections[0]
-        e = GraphQLError("msg", [node])
+        e = GraphQLError("msg", [field_node])
         assert "msg" in str(e)
-        assert "(1:3)" in str(e)
+        assert "(2:3)" in str(e)
         assert repr(e) == (
-            "GraphQLError('msg', locations=[SourceLocation(line=1, column=3)])"
+            "GraphQLError('msg', locations=[SourceLocation(line=2, column=3)])"
         )
 
     def serializes_to_include_path():
         path = ["path", 3, "to", "field"]
-        # noinspection PyArgumentEqualDefault
-        e = GraphQLError("msg", None, None, None, path)
+        e = GraphQLError("msg", path=path)
         assert e.path is path
         assert repr(e) == "GraphQLError('msg', path=['path', 3, 'to', 'field'])"
 
     def default_error_formatter_includes_path():
         path = ["path", 3, "to", "field"]
-        # noinspection PyArgumentEqualDefault
-        e = GraphQLError("msg", None, None, None, path)
+        e = GraphQLError("msg", path=path)
         formatted = format_error(e)
         assert formatted == e.formatted
         assert formatted == {"message": "msg", "locations": None, "path": path}
 
     def default_error_formatter_includes_extension_fields():
-        # noinspection PyArgumentEqualDefault
-        e = GraphQLError("msg", None, None, None, None, None, {"foo": "bar"})
+        e = GraphQLError("msg", extensions={"foo": "bar"})
         formatted = format_error(e)
         assert formatted == e.formatted
         assert formatted == {

tests/error/test_print_error.py

@@ -44,7 +44,7 @@ def prints_line_numbers_with_correct_padding():
         )
 
     def prints_an_error_with_nodes_from_different_sources():
-        source_a = parse(
+        doc_a = parse(
             Source(
                 dedent(
                     """
@@ -56,10 +56,11 @@ def prints_an_error_with_nodes_from_different_sources():
                 "SourceA",
             )
         )
-        field_type_a = (
-            cast(ObjectTypeDefinitionNode, source_a.definitions[0]).fields[0].type
-        )
-        source_b = parse(
+        op_a = doc_a.definitions[0]
+        op_a = cast(ObjectTypeDefinitionNode, op_a)
+        assert op_a and op_a.kind == "object_type_definition" and op_a.fields
+        field_a = op_a.fields[0]
+        doc_b = parse(
             Source(
                 dedent(
                     """
@@ -71,12 +72,15 @@ def prints_an_error_with_nodes_from_different_sources():
                 "SourceB",
             )
         )
-        field_type_b = (
-            cast(ObjectTypeDefinitionNode, source_b.definitions[0]).fields[0].type
-        )
+        op_b = doc_b.definitions[0]
+        op_b = cast(ObjectTypeDefinitionNode, op_b)
+        assert op_b and op_b.kind == "object_type_definition" and op_b.fields
+        field_b = op_b.fields[0]
+        assert field_a and field_b
         error = GraphQLError(
-            "Example error with two nodes", [field_type_a, field_type_b]
+            "Example error with two nodes", [field_a.type, field_b.type]
         )
+
         printed_error = print_error(error)
         assert printed_error == dedent(
             """