Make is_specified_directive/scalar stricter

Also improve unit tests for the predicates.

Pull request for graphql/graphql-js is pending.

Author: Cito

README.md

@@ -13,7 +13,7 @@ a query language for APIs created by Facebook.
 [![Code Style](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)
 
 The current version 1.0.2 of GraphQL-core-next is up-to-date with GraphQL.js version
-14.2.1. All parts of the API are covered by an extensive test suite of currently 1731
+14.2.1. All parts of the API are covered by an extensive test suite of currently 1742
 unit tests.
 
 

graphql/type/directives.py

@@ -173,9 +173,9 @@ def assert_directive(directive: Any) -> GraphQLDirective:
 )
 
 
-def is_specified_directive(directive: GraphQLDirective):
+def is_specified_directive(directive: Any) -> bool:
     """Check whether the given directive is one of the specified directives."""
-    return isinstance(directive, GraphQLDirective) and any(
+    return is_directive(directive) and any(
         specified_directive.name == directive.name
         for specified_directive in specified_directives
     )

graphql/type/scalars.py

@@ -9,7 +9,7 @@
     IntValueNode,
     StringValueNode,
 )
-from .definition import GraphQLScalarType, is_named_type
+from .definition import GraphQLScalarType, is_scalar_type
 
 __all__ = [
     "is_specified_scalar_type",
@@ -248,4 +248,4 @@ def parse_id_literal(ast, _variables=None):
 
 
 def is_specified_scalar_type(type_: Any) -> bool:
-    return is_named_type(type_) and type_.name in specified_scalar_types
+    return is_scalar_type(type_) and type_.name in specified_scalar_types

tests/type/test_predicate.py

@@ -4,11 +4,16 @@
 from graphql.type import (
     GraphQLArgument,
     GraphQLDeprecatedDirective,
+    GraphQLBoolean,
     GraphQLDirective,
     GraphQLEnumType,
+    GraphQLField,
+    GraphQLFloat,
+    GraphQLID,
     GraphQLIncludeDirective,
     GraphQLInputField,
     GraphQLInputObjectType,
+    GraphQLInt,
     GraphQLInterfaceType,
     GraphQLList,
     GraphQLNonNull,
@@ -19,6 +24,7 @@
     GraphQLUnionType,
     assert_abstract_type,
     assert_composite_type,
+    assert_directive,
     assert_enum_type,
     assert_input_object_type,
     assert_input_type,
@@ -54,6 +60,7 @@
     is_output_type,
     is_scalar_type,
     is_specified_directive,
+    is_specified_scalar_type,
     is_type,
     is_union_type,
     is_wrapping_type,
@@ -64,9 +71,8 @@
 UnionType = GraphQLUnionType("Union", types=[ObjectType])
 EnumType = GraphQLEnumType("Enum", values={"foo": {}})
 InputObjectType = GraphQLInputObjectType("InputObject", {})
-ScalarType = GraphQLScalarType(
-    "Scalar", serialize=lambda: {}, parse_value=lambda: {}, parse_literal=lambda: {}
-)
+ScalarType = GraphQLScalarType("Scalar", lambda: None)
+Directive = GraphQLDirective("Directive", [DirectiveLocation.QUERY])
 
 
 def describe_type_predicates():
@@ -100,10 +106,65 @@ def returns_true_for_custom_scalar():
             assert is_scalar_type(ScalarType) is True
             assert_scalar_type(ScalarType)
 
+        def returns_fals_for_scalar_class_rather_than_instance():
+            assert is_scalar_type(GraphQLScalarType) is False
+            with raises(TypeError):
+                assert_scalar_type(GraphQLScalarType)
+
+        def returns_false_for_wrapped_scalar():
+            assert is_scalar_type(GraphQLList(ScalarType)) is False
+            with raises(TypeError):
+                assert_scalar_type(GraphQLList(ScalarType))
+
         def returns_false_for_non_scalar():
             assert is_scalar_type(EnumType) is False
             with raises(TypeError):
                 assert_scalar_type(EnumType)
+            assert is_scalar_type(Directive) is False
+            with raises(TypeError):
+                assert_scalar_type(Directive)
+
+        def returns_false_for_random_garbage():
+            assert is_scalar_type(None) is False
+            with raises(TypeError):
+                assert_scalar_type(None)
+            assert is_scalar_type({"what": "is this"}) is False
+            with raises(TypeError):
+                assert_scalar_type({"what": "is this"})
+
+    def describe_is_specified_scalar_type():
+        def returns_true_for_specified_scalars():
+            assert is_specified_scalar_type(GraphQLString) is True
+            assert is_specified_scalar_type(GraphQLInt) is True
+            assert is_specified_scalar_type(GraphQLFloat) is True
+            assert is_specified_scalar_type(GraphQLBoolean) is True
+            assert is_specified_scalar_type(GraphQLID) is True
+
+        def returns_false_for_custom_scalar():
+            assert is_specified_scalar_type(ScalarType) is False
+
+        def returns_fals_for_scalar_class_rather_than_specified_instance():
+            assert is_specified_scalar_type(GraphQLScalarType) is False
+
+        def returns_false_for_wrapped_specified_scalar():
+            assert is_scalar_type(GraphQLList(GraphQLString)) is False
+
+        def returns_false_for_non_scalar():
+            assert is_specified_scalar_type(EnumType) is False
+            assert is_specified_scalar_type(Directive) is False
+
+        def returns_false_for_spec_defined_directive():
+            assert is_specified_scalar_type(GraphQLSkipDirective) is False
+
+        def returns_false_for_object_type_named_like_specified_directive():
+            ObjectNamedLikeScalar = GraphQLObjectType(
+                "String", {"serialize": GraphQLField(GraphQLString)}
+            )
+            assert is_specified_scalar_type(ObjectNamedLikeScalar) is False
+
+        def returns_false_for_random_garbage():
+            assert is_specified_scalar_type(None) is False
+            assert is_specified_scalar_type({"what": "is this"}) is False
 
     def describe_is_object_type():
         def returns_true_for_object_type():
@@ -463,23 +524,34 @@ def returns_false_for_optional_input_field():
 
     def describe_directive_predicates():
         def describe_is_directive():
-            def returns_true_for_directives():
-                directive = GraphQLDirective("Foo", [DirectiveLocation.QUERY])
-                assert is_directive(directive) is True
+            def returns_true_for_spec_defined_directive():
                 assert is_directive(GraphQLSkipDirective) is True
+                assert_directive(GraphQLSkipDirective)
+
+            def returns_true_for_custom_directive():
+                assert is_directive(Directive) is True
+                assert_directive(Directive)
 
             def returns_false_for_directive_class_rather_than_instance():
                 assert is_directive(GraphQLDirective) is False
+                with raises(TypeError):
+                    assert_directive(GraphQLScalarType)
 
-            def returns_false_for_object_type():
-                assert is_directive(ObjectType) is False
-
-            def returns_false_for_scalar_type():
-                assert is_directive(GraphQLString) is False
+            def returns_false_for_non_directive():
+                assert is_directive(EnumType) is False
+                with raises(TypeError):
+                    assert_directive(EnumType)
+                assert is_directive(ScalarType) is False
+                with raises(TypeError):
+                    assert_directive(ScalarType)
 
             def returns_false_for_random_garbage():
                 assert is_directive(None) is False
+                with raises(TypeError):
+                    assert_directive(None)
                 assert is_directive({"what": "is this"}) is False
+                with raises(TypeError):
+                    assert_directive({"what": "is this"})
 
         def describe_is_specified_directive():
             def returns_true_for_specified_directives():
@@ -488,25 +560,21 @@ def returns_true_for_specified_directives():
                 assert is_specified_directive(GraphQLDeprecatedDirective) is True
 
             def returns_false_for_custom_directive():
-                directive = GraphQLDirective("Foo", [DirectiveLocation.QUERY])
-                assert is_specified_directive(directive) is False
+                assert is_specified_directive(Directive) is False
 
-            def returns_false_for_directive_class_rather_than_instance():
+            def returns_false_for_directive_class_rather_than_specified_instance():
                 assert is_specified_directive(GraphQLDirective) is False
 
-            def returns_false_for_object_type():
-                assert is_specified_directive(ObjectType) is False
+            def returns_false_for_non_directive():
+                assert is_specified_directive(EnumType) is False
+                assert is_specified_directive(ScalarType) is False
 
             def returns_false_for_spec_defined_scalar_type():
                 assert is_specified_directive(GraphQLString) is False
 
-            def returns_false_for_scalar_type_with_name_of_specified_directive():
-                assert (
-                    is_specified_directive(
-                        GraphQLScalarType("deprecated", lambda: None)
-                    )
-                    is False
-                )
+            def returns_false_for_scalar_type_named_like_specified_directive():
+                ScalarNamedLikeDirective = GraphQLScalarType("deprecated", lambda: None)
+                assert is_specified_directive(ScalarNamedLikeDirective) is False
 
             def returns_false_for_random_garbage():
                 assert is_specified_directive(None) is False