fix(incremental): prevent error completions for unannounced fragments

Replicates graphql/graphql-js@4a9b312

Author: Cito

src/graphql/execution/incremental/work_queue.py

@@ -392,16 +392,25 @@ def _add_group(
             return
         visited.add(group)
         parent = group.parent
-        if parent is not None and parent in group_set:
-            self._add_group(parent, group_set, new_root_groups, visited, parent_task)
+        if parent is not None:
+            if parent in group_set:
+                self._add_group(
+                    parent, group_set, new_root_groups, visited, parent_task
+                )
+
+            # Discard newly discovered children of removed parents.
+            if parent not in self._group_nodes:
+                return
 
         self._group_nodes[group] = _GroupNode()
 
         if parent_task is None and not parent:
             new_root_groups.append(group)
         elif parent:
             parent_node = self._group_nodes.get(parent)
-            if parent_node:
+            # defensive guard mirroring the JS version; children of
+            # removed parents have already been discarded above
+            if parent_node:  # pragma: no branch
                 parent_node.child_groups.append(group)
 
     def _add_task(self, task: WorkTask) -> None:
@@ -421,7 +430,9 @@ def _add_streams(
         if not parent_task:
             return streams
         task_node = self._task_nodes.get(parent_task)
-        if task_node:
+        # defensive guard mirroring the JS version; work of removed
+        # tasks is ignored before it is integrated
+        if task_node:  # pragma: no branch
             task_node.child_streams.extend(streams)
         return []
 
@@ -485,14 +496,18 @@ def _start_group(self, group: Group) -> None:
     def _start_task(self, task: WorkTask) -> None:
         """Start a task, pushing a graph event when its computation settles."""
         task_nodes = self._task_nodes
-        if task in task_nodes:
-            return
-        task_nodes[task] = _TaskNode()
+        already_started = task in task_nodes
+        if not already_started:
+            task_nodes[task] = _TaskNode()
         try:
             result = task.computation.result()
-        except Exception as error:
+        except (Exception, CancelledError) as error:
             self._push(_TaskFailure(task, error))
             return
+        if already_started:
+            # Pending tasks already have a result handler. Successful results are
+            # handled once for all owning groups, including those not yet started.
+            return
         if is_awaitable(result):
             future: Future[WorkResult] = ensure_future(result)
 
@@ -560,8 +575,9 @@ def _task_success(
         task, result = graph_event
         value, work = result
         task_node = self._task_nodes.get(task)
-        if task_node:
-            task_node.value = value
+        if not task_node:
+            return []
+        task_node.value = value
         self._maybe_integrate_work(work, task)
 
         group_events: list[GroupValuesEvent | GroupSuccessEvent] = []
@@ -604,11 +620,13 @@ def _maybe_finish_group(
     def _task_failure(self, graph_event: _TaskFailure) -> Sequence[GroupFailureEvent]:
         """Handle a task failure, removing all groups it belongs to."""
         task, error = graph_event
-        self._task_nodes.pop(task, None)
+        if task not in self._task_nodes:
+            return []
         group_failure_events: list[GroupFailureEvent] = []
+        root_groups = self._root_groups
         for group in task.groups:
             group_node = self._group_nodes.get(group)
-            if group_node:
+            if group_node and group in root_groups:
                 group_failure_events.append(
                     self._finish_group_failure(group, group_node, error)
                 )
@@ -676,19 +694,21 @@ def _finish_group_failure(
     ) -> GroupFailureEvent:
         """Finish a failed group, removing its whole subtree."""
         self._remove_group(group, group_node)
-        self._root_groups.pop(group, None)
         return GroupFailureEvent(group, error)
 
     def _remove_group(self, group: Group, group_node: _GroupNode) -> None:
         """Remove a group with its tasks and child groups from the graph."""
+        self._root_groups.pop(group, None)
         group_nodes = self._group_nodes
         del group_nodes[group]
         for task in list(group_node.tasks):
             if all(task_group not in group_nodes for task_group in task.groups):
                 self._remove_task(task)
         for child_group in group_node.child_groups:
             child_group_node = group_nodes.get(child_group)
-            if child_group_node:
+            # defensive guard mirroring the JS version; only root groups
+            # fail, so the children of a removed group still exist
+            if child_group_node:  # pragma: no branch
                 self._remove_group(child_group, child_group_node)
 
     def _remove_task(self, task: WorkTask) -> None: