Avoid warnings in latest pytest version

Shared functions in describe blocks that should not be treated as tests
should start with an underscore (do not use the fixture decorator here).

Author: Cito

tests/execution/test_nonnull.py

@@ -1,6 +1,6 @@
 import re
 from inspect import isawaitable
-from pytest import fixture, mark
+from pytest import mark
 
 from graphql.execution import execute
 from graphql.language import parse
@@ -533,8 +533,7 @@ async def throws():
     def describe_handles_non_null_argument():
 
         # noinspection PyPep8Naming
-        @fixture
-        def resolve(_obj, _info, cannotBeNull):
+        def _resolve(_obj, _info, cannotBeNull):
             if isinstance(cannotBeNull, str):
                 return f"Passed: {cannotBeNull}"
 
@@ -549,7 +548,7 @@ def resolve(_obj, _info, cannotBeNull):
                                 GraphQLNonNull(GraphQLString)
                             )
                         },
-                        resolve=resolve,
+                        resolve=_resolve,
                     )
                 },
             )

tests/execution/test_resolve.py

@@ -1,7 +1,5 @@
 from json import dumps
 
-from pytest import fixture
-
 from graphql import graphql_sync
 from graphql.type import (
     GraphQLArgument,
@@ -14,12 +12,11 @@
 
 
 def describe_execute_resolve_function():
-    @fixture
-    def test_schema(test_field):
+    def _test_schema(test_field):
         return GraphQLSchema(GraphQLObjectType("Query", {"test": test_field}))
 
     def default_function_accesses_attributes():
-        schema = test_schema(GraphQLField(GraphQLString))
+        schema = _test_schema(GraphQLField(GraphQLString))
 
         class Source:
             test = "testValue"
@@ -30,14 +27,14 @@ class Source:
         )
 
     def default_function_accesses_keys():
-        schema = test_schema(GraphQLField(GraphQLString))
+        schema = _test_schema(GraphQLField(GraphQLString))
 
         source = {"test": "testValue"}
 
         assert graphql_sync(schema, "{ test }", source) == ({"test": "testValue"}, None)
 
     def default_function_calls_methods():
-        schema = test_schema(GraphQLField(GraphQLString))
+        schema = _test_schema(GraphQLField(GraphQLString))
 
         class Source:
             _secret = "testValue"
@@ -51,7 +48,7 @@ def test(self, _info):
         )
 
     def default_function_passes_args_and_context():
-        schema = test_schema(
+        schema = _test_schema(
             GraphQLField(GraphQLInt, args={"addend1": GraphQLArgument(GraphQLInt)})
         )
 
@@ -73,7 +70,7 @@ class Context:
         )
 
     def uses_provided_resolve_function():
-        schema = test_schema(
+        schema = _test_schema(
             GraphQLField(
                 GraphQLString,
                 args={

tests/execution/test_sync.py

@@ -1,6 +1,6 @@
 from inspect import isawaitable
 
-from pytest import fixture, mark, raises
+from pytest import mark, raises
 
 from graphql import graphql_sync
 from graphql.execution import execute
@@ -9,25 +9,23 @@
 
 
 def describe_execute_synchronously_when_possible():
-    @fixture
-    def resolve_sync(root_value, info_):
+    def _resolve_sync(root_value, info_):
         return root_value
 
-    @fixture
-    async def resolve_async(root_value, info_):
+    async def _resolve_async(root_value, info_):
         return root_value
 
     schema = GraphQLSchema(
         GraphQLObjectType(
             "Query",
             {
-                "syncField": GraphQLField(GraphQLString, resolve=resolve_sync),
-                "asyncField": GraphQLField(GraphQLString, resolve=resolve_async),
+                "syncField": GraphQLField(GraphQLString, resolve=_resolve_sync),
+                "asyncField": GraphQLField(GraphQLString, resolve=_resolve_async),
             },
         ),
         GraphQLObjectType(
             "Mutation",
-            {"syncMutationField": GraphQLField(GraphQLString, resolve=resolve_sync)},
+            {"syncMutationField": GraphQLField(GraphQLString, resolve=_resolve_sync)},
         ),
     )
 

tests/type/test_definition.py

@@ -1,6 +1,6 @@
 from typing import cast, Dict
 
-from pytest import fixture, mark, raises
+from pytest import mark, raises
 
 from graphql.error import INVALID
 from graphql.type import (
@@ -514,8 +514,7 @@ def rejects_object_type_with_incorrectly_typed_interfaces_as_a_function():
 
 
 def describe_type_system_object_fields_must_have_valid_resolve_values():
-    @fixture
-    def schema_with_object_with_field_resolver(resolve_value):
+    def _schema_with_object_with_field_resolver(resolve_value):
         BadResolverType = GraphQLObjectType(
             "BadResolver",
             {"bad_field": GraphQLField(GraphQLString, resolve=resolve_value)},
@@ -525,17 +524,17 @@ def schema_with_object_with_field_resolver(resolve_value):
         )
 
     def accepts_a_lambda_as_an_object_field_resolver():
-        schema_with_object_with_field_resolver(lambda _obj, _info: {})
+        _schema_with_object_with_field_resolver(lambda _obj, _info: {})
 
     def rejects_an_empty_object_field_resolver():
         with raises(TypeError) as exc_info:
-            schema_with_object_with_field_resolver({})
+            _schema_with_object_with_field_resolver({})
         msg = str(exc_info.value)
         assert msg == "Field resolver must be a function if provided,  but got: {}."
 
     def rejects_a_constant_scalar_value_resolver():
         with raises(TypeError) as exc_info:
-            schema_with_object_with_field_resolver(0)
+            _schema_with_object_with_field_resolver(0)
         msg = str(exc_info.value)
         assert msg == "Field resolver must be a function if provided,  but got: 0."
 

tests/type/test_validation.py

@@ -1,6 +1,6 @@
 from typing import cast
 
-from pytest import fixture, mark, raises
+from pytest import mark, raises
 
 from graphql.language import parse
 from graphql.type import (
@@ -784,8 +784,7 @@ def schema_with_enum(name):
 
 
 def describe_type_system_object_fields_must_have_output_types():
-    @fixture
-    def schema_with_object_field_of_type(field_type):
+    def _schema_with_object_field_of_type(field_type):
         BadObjectType = GraphQLObjectType(
             "BadObject", {"badField": GraphQLField(field_type)}
         )
@@ -796,29 +795,29 @@ def schema_with_object_field_of_type(field_type):
 
     @mark.parametrize("type_", output_types)
     def accepts_an_output_type_as_an_object_field_type(type_):
-        schema = schema_with_object_field_of_type(type_)
+        schema = _schema_with_object_field_of_type(type_)
         assert validate_schema(schema) == []
 
     def rejects_an_empty_object_field_type():
         # invalid schema cannot be built with Python
         with raises(TypeError) as exc_info:
-            schema_with_object_field_of_type(None)
+            _schema_with_object_field_of_type(None)
         msg = str(exc_info.value)
         assert msg == "Field type must be an output type."
 
     @mark.parametrize("type_", not_output_types)
     def rejects_a_non_output_type_as_an_object_field_type(type_):
         # invalid schema cannot be built with Python
         with raises(TypeError) as exc_info:
-            schema_with_object_field_of_type(type_)
+            _schema_with_object_field_of_type(type_)
         msg = str(exc_info.value)
         assert msg == "Field type must be an output type."
 
     @mark.parametrize("type_", [int, float, str])
     def rejects_a_non_type_value_as_an_object_field_type(type_):
         # invalid schema cannot be built with Python
         with raises(TypeError) as exc_info:
-            schema_with_object_field_of_type(type_)
+            _schema_with_object_field_of_type(type_)
         msg = str(exc_info.value)
         assert msg == "Field type must be an output type."
 
@@ -1064,8 +1063,7 @@ def rejects_object_implementing_extended_interface_due_to_type_mismatch():
 
 
 def describe_type_system_interface_fields_must_have_output_types():
-    @fixture
-    def schema_with_interface_field_of_type(field_type):
+    def _schema_with_interface_field_of_type(field_type):
         BadInterfaceType = GraphQLInterfaceType(
             "BadInterface", {"badField": GraphQLField(field_type)}
         )
@@ -1081,29 +1079,29 @@ def schema_with_interface_field_of_type(field_type):
 
     @mark.parametrize("type_", output_types)
     def accepts_an_output_type_as_an_interface_field_type(type_):
-        schema = schema_with_interface_field_of_type(type_)
+        schema = _schema_with_interface_field_of_type(type_)
         assert validate_schema(schema) == []
 
     def rejects_an_empty_interface_field_type():
         # invalid schema cannot be built with Python
         with raises(TypeError) as exc_info:
-            schema_with_interface_field_of_type(None)
+            _schema_with_interface_field_of_type(None)
         msg = str(exc_info.value)
         assert msg == "Field type must be an output type."
 
     @mark.parametrize("type_", not_output_types)
     def rejects_a_non_output_type_as_an_interface_field_type(type_):
         # invalid schema cannot be built with Python
         with raises(TypeError) as exc_info:
-            schema_with_interface_field_of_type(type_)
+            _schema_with_interface_field_of_type(type_)
         msg = str(exc_info.value)
         assert msg == "Field type must be an output type."
 
     @mark.parametrize("type_", [int, float, str])
     def rejects_a_non_type_value_as_an_interface_field_type(type_):
         # invalid schema cannot be built with Python
         with raises(TypeError) as exc_info:
-            schema_with_interface_field_of_type(type_)
+            _schema_with_interface_field_of_type(type_)
         msg = str(exc_info.value)
         assert msg == "Field type must be an output type."
 
@@ -1151,8 +1149,7 @@ def accepts_an_interface_not_implemented_by_at_least_one_object():
 
 
 def describe_type_system_field_arguments_must_have_input_types():
-    @fixture
-    def schema_with_arg_of_type(arg_type):
+    def _schema_with_arg_of_type(arg_type):
         BadObjectType = GraphQLObjectType(
             "BadObject",
             {
@@ -1167,29 +1164,29 @@ def schema_with_arg_of_type(arg_type):
 
     @mark.parametrize("type_", input_types)
     def accepts_an_input_type_as_a_field_arg_type(type_):
-        schema = schema_with_arg_of_type(type_)
+        schema = _schema_with_arg_of_type(type_)
         assert validate_schema(schema) == []
 
     def rejects_an_empty_field_arg_type():
         # invalid schema cannot be built with Python
         with raises(TypeError) as exc_info:
-            schema_with_arg_of_type(None)
+            _schema_with_arg_of_type(None)
         msg = str(exc_info.value)
         assert msg == "Argument type must be a GraphQL input type."
 
     @mark.parametrize("type_", not_input_types)
     def rejects_a_non_input_type_as_a_field_arg_type(type_):
         # invalid schema cannot be built with Python
         with raises(TypeError) as exc_info:
-            schema_with_arg_of_type(type_)
+            _schema_with_arg_of_type(type_)
         msg = str(exc_info.value)
         assert msg == "Argument type must be a GraphQL input type."
 
     @mark.parametrize("type_", [int, float, str])
     def rejects_a_non_type_value_as_a_field_arg_type(type_):
         # invalid schema cannot be built with Python
         with raises(TypeError) as exc_info:
-            schema_with_arg_of_type(type_)
+            _schema_with_arg_of_type(type_)
         msg = str(exc_info.value)
         assert msg == "Argument type must be a GraphQL input type."
 
@@ -1215,8 +1212,7 @@ def rejects_a_non_input_type_as_a_field_arg_with_locations():
 
 
 def describe_type_system_input_object_fields_must_have_input_types():
-    @fixture
-    def schema_with_input_field_of_type(input_field_type):
+    def _schema_with_input_field_of_type(input_field_type):
         BadInputObjectType = GraphQLInputObjectType(
             "BadInputObject", {"badField": GraphQLInputField(input_field_type)}
         )
@@ -1234,29 +1230,29 @@ def schema_with_input_field_of_type(input_field_type):
 
     @mark.parametrize("type_", input_types)
     def accepts_an_input_type_as_an_input_fieldtype(type_):
-        schema = schema_with_input_field_of_type(type_)
+        schema = _schema_with_input_field_of_type(type_)
         assert validate_schema(schema) == []
 
     def rejects_an_empty_input_field_type():
         # invalid schema cannot be built with Python
         with raises(TypeError) as exc_info:
-            schema_with_input_field_of_type(None)
+            _schema_with_input_field_of_type(None)
         msg = str(exc_info.value)
         assert msg == "Input field type must be a GraphQL input type."
 
     @mark.parametrize("type_", not_input_types)
     def rejects_a_non_input_type_as_an_input_field_type(type_):
         # invalid schema cannot be built with Python
         with raises(TypeError) as exc_info:
-            schema_with_input_field_of_type(type_)
+            _schema_with_input_field_of_type(type_)
         msg = str(exc_info.value)
         assert msg == "Input field type must be a GraphQL input type."
 
     @mark.parametrize("type_", [int, float, str])
     def rejects_a_non_type_value_as_an_input_field_type(type_):
         # invalid schema cannot be built with Python
         with raises(TypeError) as exc_info:
-            schema_with_input_field_of_type(type_)
+            _schema_with_input_field_of_type(type_)
         msg = str(exc_info.value)
         assert msg == "Input field type must be a GraphQL input type."