Add an extension field to the ExecutionResult (#107)

Also make ExecutionResult a class instead of a NamedTuple,
but do it as backward compatible as possible.

Replicates graphql/graphql-js@fb042fc

Author: Cito

src/graphql/execution/execute.py

@@ -7,7 +7,6 @@
     Dict,
     Iterable,
     List,
-    NamedTuple,
     Optional,
     Set,
     Union,
@@ -95,19 +94,66 @@
 # 3) inline fragment "spreads" e.g. "...on Type { a }"
 
 
-class ExecutionResult(NamedTuple):
+class ExecutionResult:
     """The result of GraphQL execution.
 
     - ``data`` is the result of a successful execution of the query.
     - ``errors`` is included when any errors occurred as a non-empty list.
+    - ``extensions`` is reserved for adding non-standard properties.
     """
 
+    __slots__ = "data", "errors", "extensions"
+
     data: Optional[Dict[str, Any]]
     errors: Optional[List[GraphQLError]]
+    extensions: Optional[Dict[str, Any]]
+
+    def __init__(
+        self,
+        data: Optional[Dict[str, Any]] = None,
+        errors: Optional[List[GraphQLError]] = None,
+        extensions: Optional[Dict[str, Any]] = None,
+    ):
+        self.data = data
+        self.errors = errors
+        self.extensions = extensions
+
+    def __repr__(self) -> str:
+        name = self.__class__.__name__
+        ext = "" if self.extensions is None else f", extensions={self.extensions}"
+        return f"{name}(data={self.data!r}, errors={self.errors!r}{ext})"
+
+    def __iter__(self) -> Iterable[Any]:
+        return iter((self.data, self.errors))
+
+    @property
+    def formatted(self) -> Dict[str, Any]:
+        """Get execution result formatted according to the specification."""
+        if self.extensions is None:
+            return dict(data=self.data, errors=self.errors)
+        return dict(data=self.data, errors=self.errors, extensions=self.extensions)
+
+    def __eq__(self, other: Any) -> bool:
+        if isinstance(other, dict):
+            if "extensions" not in other:
+                return other == dict(data=self.data, errors=self.errors)
+            return other == dict(
+                data=self.data, errors=self.errors, extensions=self.extensions
+            )
+        if isinstance(other, tuple):
+            if len(other) == 2:
+                return other == (self.data, self.errors)
+            return other == (self.data, self.errors, self.extensions)
+        return (
+            isinstance(other, self.__class__)
+            and other.data == self.data
+            and other.errors == self.errors
+            and other.extensions == self.extensions
+        )
 
+    def __ne__(self, other: Any) -> bool:
+        return not self == other
 
-# noinspection PyTypeHints
-ExecutionResult.__new__.__defaults__ = (None, None)  # type: ignore
 
 Middleware = Optional[Union[Tuple, List, MiddlewareManager]]
 

tests/execution/test_execution_result.py

@@ -0,0 +1,106 @@
+from pytest import raises  # type: ignore
+
+from graphql.error import GraphQLError
+from graphql.execution import ExecutionResult
+
+
+def describe_execution_result():
+
+    data = {"foo": "Some data"}
+    error = GraphQLError("Some error")
+    errors = [error]
+    extensions = {"bar": "Some extension"}
+
+    def initializes_properly():
+        res = ExecutionResult(data, errors)
+        assert res.data is data
+        assert res.errors is errors
+        assert res.extensions is None
+        res = ExecutionResult(data, errors, extensions)
+        assert res.data is data
+        assert res.errors is errors
+        assert res.extensions is extensions
+
+    def prints_a_representation():
+        assert repr(ExecutionResult(data, errors)) == (
+            "ExecutionResult(data={'foo': 'Some data'},"
+            " errors=[GraphQLError('Some error')])"
+        )
+        assert repr(ExecutionResult(data, errors, extensions)) == (
+            "ExecutionResult(data={'foo': 'Some data'},"
+            " errors=[GraphQLError('Some error')],"
+            " extensions={'bar': 'Some extension'})"
+        )
+
+    def formats_properly():
+        res = ExecutionResult(data, errors)
+        assert res.formatted == {"data": data, "errors": errors}
+        res = ExecutionResult(data, errors, extensions)
+        assert res.formatted == {
+            "data": data,
+            "errors": errors,
+            "extensions": extensions,
+        }
+
+    def compares_to_dict():
+        res = ExecutionResult(data, errors)
+        assert res == {"data": data, "errors": errors}
+        assert res == {"data": data, "errors": errors, "extensions": None}
+        assert res != {"data": data, "errors": None}
+        assert res != {"data": None, "errors": errors}
+        assert res != {"data": data, "errors": errors, "extensions": extensions}
+        res = ExecutionResult(data, errors, extensions)
+        assert res == {"data": data, "errors": errors}
+        assert res == {"data": data, "errors": errors, "extensions": extensions}
+        assert res != {"data": data, "errors": None}
+        assert res != {"data": None, "errors": errors}
+        assert res != {"data": data, "errors": errors, "extensions": None}
+
+    def compares_to_tuple():
+        res = ExecutionResult(data, errors)
+        assert res == (data, errors)
+        assert res == (data, errors, None)
+        assert res != (data, None)
+        assert res != (None, errors)
+        assert res != (data, errors, extensions)
+        res = ExecutionResult(data, errors, extensions)
+        assert res == (data, errors)
+        assert res == (data, errors, extensions)
+        assert res != (data, None)
+        assert res != (None, errors)
+        assert res != (data, errors, None)
+
+    def does_not_compare_to_list():
+        res = ExecutionResult(data, errors)
+        assert res != [data, errors]
+        res = ExecutionResult(data, errors, extensions)
+        assert res != [data, errors, extensions]
+
+    def compares_to_another_execution_result():
+        res1 = ExecutionResult(data, errors)
+        res2 = ExecutionResult(data, errors)
+        assert res1 == res2
+        res2 = ExecutionResult({"foo": "other data"}, errors)
+        assert res1 != res2
+        res2 = ExecutionResult(data, [GraphQLError("Another error")])
+        assert res1 != res2
+        res2 = ExecutionResult(data, errors, extensions)
+        assert res1 != res2
+        res1 = ExecutionResult(data, errors, extensions)
+        res2 = ExecutionResult(data, errors, extensions)
+        assert res1 == res2
+        res2 = ExecutionResult({"foo": "other data"}, errors, extensions)
+        assert res1 != res2
+        res2 = ExecutionResult(data, [GraphQLError("Another error")], extensions)
+        assert res1 != res2
+        res2 = ExecutionResult(data, errors, {"bar": "Another extension"})
+        assert res1 != res2
+
+    def unpacks_as_two_tuple():
+        res = ExecutionResult(data, errors)
+        res_data, res_errors = res  # type: ignore
+        assert res_data == data  # type: ignore
+        assert res_errors == errors  # type: ignore
+        with raises(ValueError):
+            res = ExecutionResult(data, errors, extensions)
+            _res_data, _res_errors, _res_extensions = res  # type: ignore