Alignments with changes for branch coverage

Replicates graphql/graphql-js@e590dd2

Author: Cito

src/graphql/utilities/extend_schema.py

@@ -380,8 +380,7 @@ def get_operation_types(
         return {
             operation_type.operation: get_named_type(operation_type.type)
             for node in nodes
-            if node.operation_types
-            for operation_type in node.operation_types
+            for operation_type in node.operation_types or []
         }
 
     # noinspection PyShadowingNames
@@ -426,38 +425,34 @@ def build_field_map(
     ) -> GraphQLFieldMap:
         field_map: GraphQLFieldMap = {}
         for node in nodes:
-            if node.fields:
-                for field in node.fields:
-                    # Note: While this could make assertions to get the correctly typed
-                    # value, that would throw immediately while type system validation
-                    # with validate_schema() will produce more actionable results.
-                    field_map[field.name.value] = GraphQLField(
-                        type_=cast(GraphQLOutputType, get_wrapped_type(field.type)),
-                        description=field.description.value
-                        if field.description
-                        else None,
-                        args=build_argument_map(field.arguments),
-                        deprecation_reason=get_deprecation_reason(field),
-                        ast_node=field,
-                    )
+            for field in node.fields or []:
+                # Note: While this could make assertions to get the correctly typed
+                # value, that would throw immediately while type system validation
+                # with validate_schema() will produce more actionable results.
+                field_map[field.name.value] = GraphQLField(
+                    type_=cast(GraphQLOutputType, get_wrapped_type(field.type)),
+                    description=field.description.value if field.description else None,
+                    args=build_argument_map(field.arguments),
+                    deprecation_reason=get_deprecation_reason(field),
+                    ast_node=field,
+                )
         return field_map
 
     def build_argument_map(
         args: Optional[Collection[InputValueDefinitionNode]],
     ) -> GraphQLArgumentMap:
         arg_map: GraphQLArgumentMap = {}
-        if args:
-            for arg in args:
-                # Note: While this could make assertions to get the correctly typed
-                # value, that would throw immediately while type system validation
-                # with validate_schema() will produce more actionable results.
-                type_ = cast(GraphQLInputType, get_wrapped_type(arg.type))
-                arg_map[arg.name.value] = GraphQLArgument(
-                    type_=type_,
-                    description=arg.description.value if arg.description else None,
-                    default_value=value_from_ast(arg.default_value, type_),
-                    ast_node=arg,
-                )
+        for arg in args or []:
+            # Note: While this could make assertions to get the correctly typed
+            # value, that would throw immediately while type system validation
+            # with validate_schema() will produce more actionable results.
+            type_ = cast(GraphQLInputType, get_wrapped_type(arg.type))
+            arg_map[arg.name.value] = GraphQLArgument(
+                type_=type_,
+                description=arg.description.value if arg.description else None,
+                default_value=value_from_ast(arg.default_value, type_),
+                ast_node=arg,
+            )
         return arg_map
 
     def build_input_field_map(
@@ -467,39 +462,33 @@ def build_input_field_map(
     ) -> GraphQLInputFieldMap:
         input_field_map: GraphQLInputFieldMap = {}
         for node in nodes:
-            if node.fields:
-                for field in node.fields:
-                    # Note: While this could make assertions to get the correctly typed
-                    # value, that would throw immediately while type system validation
-                    # with validate_schema() will produce more actionable results.
-                    type_ = cast(GraphQLInputType, get_wrapped_type(field.type))
-                    input_field_map[field.name.value] = GraphQLInputField(
-                        type_=type_,
-                        description=field.description.value
-                        if field.description
-                        else None,
-                        default_value=value_from_ast(field.default_value, type_),
-                        ast_node=field,
-                    )
+            for field in node.fields or []:
+                # Note: While this could make assertions to get the correctly typed
+                # value, that would throw immediately while type system validation
+                # with validate_schema() will produce more actionable results.
+                type_ = cast(GraphQLInputType, get_wrapped_type(field.type))
+                input_field_map[field.name.value] = GraphQLInputField(
+                    type_=type_,
+                    description=field.description.value if field.description else None,
+                    default_value=value_from_ast(field.default_value, type_),
+                    ast_node=field,
+                )
         return input_field_map
 
     def build_enum_value_map(
         nodes: Collection[Union[EnumTypeDefinitionNode, EnumTypeExtensionNode]]
     ) -> GraphQLEnumValueMap:
         enum_value_map: GraphQLEnumValueMap = {}
         for node in nodes:
-            if node.values:
-                for value in node.values:
-                    # Note: While this could make assertions to get the correctly typed
-                    # value, that would throw immediately while type system validation
-                    # with validate_schema() will produce more actionable results.
-                    enum_value_map[value.name.value] = GraphQLEnumValue(
-                        description=value.description.value
-                        if value.description
-                        else None,
-                        deprecation_reason=get_deprecation_reason(value),
-                        ast_node=value,
-                    )
+            for value in node.values or []:
+                # Note: While this could make assertions to get the correctly typed
+                # value, that would throw immediately while type system validation
+                # with validate_schema() will produce more actionable results.
+                enum_value_map[value.name.value] = GraphQLEnumValue(
+                    description=value.description.value if value.description else None,
+                    deprecation_reason=get_deprecation_reason(value),
+                    ast_node=value,
+                )
         return enum_value_map
 
     def build_interfaces(
@@ -514,25 +503,23 @@ def build_interfaces(
     ) -> List[GraphQLInterfaceType]:
         interfaces: List[GraphQLInterfaceType] = []
         for node in nodes:
-            if node.interfaces:
-                for type_ in node.interfaces:
-                    # Note: While this could make assertions to get the correctly typed
-                    # value, that would throw immediately while type system validation
-                    # with validate_schema() will produce more actionable results.
-                    interfaces.append(cast(GraphQLInterfaceType, get_named_type(type_)))
+            for type_ in node.interfaces or []:
+                # Note: While this could make assertions to get the correctly typed
+                # value, that would throw immediately while type system validation
+                # with validate_schema() will produce more actionable results.
+                interfaces.append(cast(GraphQLInterfaceType, get_named_type(type_)))
         return interfaces
 
     def build_union_types(
         nodes: Collection[Union[UnionTypeDefinitionNode, UnionTypeExtensionNode]],
     ) -> List[GraphQLObjectType]:
         types: List[GraphQLObjectType] = []
         for node in nodes:
-            if node.types:
-                for type_ in node.types:
-                    # Note: While this could make assertions to get the correctly typed
-                    # value, that would throw immediately while type system validation
-                    # with validate_schema() will produce more actionable results.
-                    types.append(cast(GraphQLObjectType, get_named_type(type_)))
+            for type_ in node.types or []:
+                # Note: While this could make assertions to get the correctly typed
+                # value, that would throw immediately while type system validation
+                # with validate_schema() will produce more actionable results.
+                types.append(cast(GraphQLObjectType, get_named_type(type_)))
         return types
 
     def build_object_type(ast_node: ObjectTypeDefinitionNode) -> GraphQLObjectType:

src/graphql/validation/rules/known_argument_names.py

@@ -31,9 +31,9 @@ def __init__(self, context: Union[ValidationContext, SDLValidationContext]):
         ast_definitions = context.document.definitions
         for def_ in ast_definitions:
             if isinstance(def_, DirectiveDefinitionNode):
-                directive_args[def_.name.value] = (
-                    [arg.name.value for arg in def_.arguments] if def_.arguments else []
-                )
+                directive_args[def_.name.value] = [
+                    arg.name.value for arg in def_.arguments or []
+                ]
 
         self.directive_args = directive_args
 

src/graphql/validation/rules/provided_required_arguments.py

@@ -46,14 +46,10 @@ def __init__(self, context: Union[ValidationContext, SDLValidationContext]):
         ast_definitions = context.document.definitions
         for def_ in ast_definitions:
             if isinstance(def_, DirectiveDefinitionNode):
-                required_args_map[def_.name.value] = (
-                    {
-                        arg.name.value: arg
-                        for arg in filter(is_required_argument_node, def_.arguments)
-                    }
-                    if def_.arguments
-                    else {}
-                )
+                required_args_map[def_.name.value] = {
+                    arg.name.value: arg
+                    for arg in filter(is_required_argument_node, def_.arguments or [])
+                }
 
         self.required_args_map = required_args_map
 

src/graphql/validation/rules/unique_enum_value_names.py

@@ -22,37 +22,36 @@ def __init__(self, context: SDLValidationContext):
         self.known_value_names: Dict[str, Dict[str, NameNode]] = defaultdict(dict)
 
     def check_value_uniqueness(self, node: EnumTypeDefinitionNode, *_args):
-        if node.values:
-            type_name = node.name.value
-            value_names = self.known_value_names[type_name]
-            existing_type_map = self.existing_type_map
-
-            for value_def in node.values:
-                value_name = value_def.name.value
-
-                existing_type = existing_type_map.get(type_name)
-                if (
-                    is_enum_type(existing_type)
-                    and value_name in cast(GraphQLEnumType, existing_type).values
-                ):
-                    self.report_error(
-                        GraphQLError(
-                            f"Enum value '{type_name}.{value_name}'"
-                            " already exists in the schema."
-                            " It cannot also be defined in this type extension.",
-                            value_def.name,
-                        )
+        existing_type_map = self.existing_type_map
+        type_name = node.name.value
+        value_names = self.known_value_names[type_name]
+
+        for value_def in node.values or []:
+            value_name = value_def.name.value
+
+            existing_type = existing_type_map.get(type_name)
+            if (
+                is_enum_type(existing_type)
+                and value_name in cast(GraphQLEnumType, existing_type).values
+            ):
+                self.report_error(
+                    GraphQLError(
+                        f"Enum value '{type_name}.{value_name}'"
+                        " already exists in the schema."
+                        " It cannot also be defined in this type extension.",
+                        value_def.name,
                     )
-                elif value_name in value_names:
-                    self.report_error(
-                        GraphQLError(
-                            f"Enum value '{type_name}.{value_name}'"
-                            " can only be defined once.",
-                            [value_names[value_name], value_def.name],
-                        )
+                )
+            elif value_name in value_names:
+                self.report_error(
+                    GraphQLError(
+                        f"Enum value '{type_name}.{value_name}'"
+                        " can only be defined once.",
+                        [value_names[value_name], value_def.name],
                     )
-                else:
-                    value_names[value_name] = value_def.name
+                )
+            else:
+                value_names[value_name] = value_def.name
 
         return self.SKIP
 

src/graphql/validation/rules/unique_field_definition_names.py

@@ -22,33 +22,32 @@ def __init__(self, context: SDLValidationContext):
         self.known_field_names: Dict[str, Dict[str, NameNode]] = defaultdict(dict)
 
     def check_field_uniqueness(self, node: ObjectTypeDefinitionNode, *_args):
-        if node.fields:
-            type_name = node.name.value
-            field_names = self.known_field_names[type_name]
-            existing_type_map = self.existing_type_map
+        existing_type_map = self.existing_type_map
+        type_name = node.name.value
+        field_names = self.known_field_names[type_name]
 
-            for field_def in node.fields:
-                field_name = field_def.name.value
+        for field_def in node.fields or []:
+            field_name = field_def.name.value
 
-                if has_field(existing_type_map.get(type_name), field_name):
-                    self.report_error(
-                        GraphQLError(
-                            f"Field '{type_name}.{field_name}'"
-                            " already exists in the schema."
-                            " It cannot also be defined in this type extension.",
-                            field_def.name,
-                        )
+            if has_field(existing_type_map.get(type_name), field_name):
+                self.report_error(
+                    GraphQLError(
+                        f"Field '{type_name}.{field_name}'"
+                        " already exists in the schema."
+                        " It cannot also be defined in this type extension.",
+                        field_def.name,
                     )
-                elif field_name in field_names:
-                    self.report_error(
-                        GraphQLError(
-                            f"Field '{type_name}.{field_name}'"
-                            " can only be defined once.",
-                            [field_names[field_name], field_def.name],
-                        )
+                )
+            elif field_name in field_names:
+                self.report_error(
+                    GraphQLError(
+                        f"Field '{type_name}.{field_name}'"
+                        " can only be defined once.",
+                        [field_names[field_name], field_def.name],
                     )
-                else:
-                    field_names[field_name] = field_def.name
+                )
+            else:
+                field_names[field_name] = field_def.name
 
         return self.SKIP