Add test for pickling schemas

Note that this is not yet supported

Author: Cito

tests/language/test_schema_parser.py

@@ -796,18 +796,18 @@ def directive_with_incorrect_locations():
     def parses_kitchen_sink_schema(kitchen_sink_sdl):  # noqa: F811
         assert parse(kitchen_sink_sdl)
 
-    def can_pickle_and_unpickle_kitchen_sink_schema(kitchen_sink_sdl):  # noqa: F811
+    def can_pickle_and_unpickle_kitchen_sink_schema_ast(kitchen_sink_sdl):  # noqa: F811
         import pickle
 
-        # create a schema from the kitchen sink SDL
+        # create a schema AST from the kitchen sink SDL
         doc = parse(kitchen_sink_sdl)
-        # check that the schema can be pickled
+        # check that the schema AST can be pickled
         # (particularly, there should be no recursion error)
         dumped = pickle.dumps(doc)
         # check that the pickle size is reasonable
         assert len(dumped) < 50 * len(kitchen_sink_sdl)
         loaded = pickle.loads(dumped)
-        # check that the un-pickled schema is still the same
+        # check that the un-pickled schema AST is still the same
         assert loaded == doc
         # check that pickling again creates the same result
         dumped_again = pickle.dumps(doc)

tests/utilities/test_build_ast_schema.py

@@ -1,7 +1,7 @@
 from collections import namedtuple
 from typing import Union
 
-from pytest import raises
+from pytest import mark, raises
 
 from graphql import graphql_sync
 from graphql.language import parse, print_ast, DocumentNode, InterfaceTypeDefinitionNode
@@ -34,6 +34,7 @@
 )
 from graphql.utilities import build_ast_schema, build_schema, print_schema, print_type
 
+from ..fixtures import big_schema_sdl  # noqa: F401
 from ..utils import dedent
 
 
@@ -42,7 +43,7 @@ def cycle_sdl(sdl: str) -> str:
 
     This function does a full cycle of going from a string with the contents of the SDL,
     parsed in a schema AST, materializing that schema AST into an in-memory
-    GraphQLSchema, and then finally printing that GraphQL into the SDÖ.
+    GraphQLSchema, and then finally printing that GraphQL into the SDL.
     """
     ast = parse(sdl)
     schema = build_ast_schema(ast)
@@ -1184,3 +1185,27 @@ def rejects_invalid_ast():
         with raises(TypeError) as exc_info:
             build_ast_schema({})  # type: ignore
         assert str(exc_info.value) == "Must provide valid Document AST."
+
+    # This currently does not work because of how extend_schema is implemented
+    @mark.skip(reason="pickling of schemas is not yet supported")
+    def can_pickle_and_unpickle_big_schema(big_schema_sdl):  # noqa: F811
+        import pickle
+
+        # create a schema from the kitchen sink SDL
+        schema = build_schema(big_schema_sdl, assume_valid_sdl=True)
+        # check that the schema can be pickled
+        # (particularly, there should be no recursion error,
+        # or errors because of trying to pickle lambdas or local functions)
+        dumped = pickle.dumps(schema)
+        # check that the pickle size is reasonable
+        assert len(dumped) < 50 * len(big_schema_sdl)
+        loaded = pickle.loads(dumped)
+
+        # check that the un-pickled schema is still the same
+        assert loaded == schema
+        # check that pickling again creates the same result
+        dumped_again = pickle.dumps(schema)
+        assert dumped_again == dumped
+
+        # check that printing the unpickled schema gives the same SDL
+        assert cycle_sdl(print_schema(schema)) == cycle_sdl(big_schema_sdl)

tests/utilities/test_extend_schema.py

@@ -970,29 +970,29 @@ def extends_different_types_multiple_times():
             extended_schema,
             dedent(
                 """
-            scalar SomeScalar @specifiedBy(url: "http://example.com/foo_spec")
-
-            type SomeObject implements SomeInterface & NewInterface & AnotherNewInterface {
-              oldField: String
-              newField: String
-              anotherNewField: String
-            }
-
-            enum SomeEnum {
-              OLD_VALUE
-              NEW_VALUE
-              ANOTHER_NEW_VALUE
-            }
-
-            union SomeUnion = SomeObject | NewObject | AnotherNewObject
-
-            input SomeInput {
-              oldField: String
-              newField: String
-              anotherNewField: String
-            }
-
-            """  # noqa: E501
+                scalar SomeScalar @specifiedBy(url: "http://example.com/foo_spec")
+    
+                type SomeObject implements SomeInterface & NewInterface & AnotherNewInterface {
+                  oldField: String
+                  newField: String
+                  anotherNewField: String
+                }
+    
+                enum SomeEnum {
+                  OLD_VALUE
+                  NEW_VALUE
+                  ANOTHER_NEW_VALUE
+                }
+    
+                union SomeUnion = SomeObject | NewObject | AnotherNewObject
+    
+                input SomeInput {
+                  oldField: String
+                  newField: String
+                  anotherNewField: String
+                }
+    
+                """  # noqa: E501
             )
             + "\n\n"
             + new_types_sdl,
@@ -1041,21 +1041,21 @@ def extends_interfaces_by_adding_new_fields():
             extended_schema,
             dedent(
                 """
-            interface SomeInterface {
-              oldField: String
-              newField: String
-            }
-
-            interface AnotherInterface implements SomeInterface {
-              oldField: String
-              newField: String
-            }
-
-            type SomeObject implements SomeInterface & AnotherInterface {
-              oldField: String
-              newField: String
-            }
-            """
+                interface SomeInterface {
+                  oldField: String
+                  newField: String
+                }
+    
+                interface AnotherInterface implements SomeInterface {
+                  oldField: String
+                  newField: String
+                }
+    
+                type SomeObject implements SomeInterface & AnotherInterface {
+                  oldField: String
+                  newField: String
+                }
+                """
             ),
         )
 
@@ -1102,20 +1102,20 @@ def extends_interfaces_by_adding_new_implemented_interfaces():
             extended_schema,
             dedent(
                 """
-            interface AnotherInterface implements SomeInterface & NewInterface {
-              oldField: String
-              newField: String
-            }
-
-            type SomeObject implements SomeInterface & AnotherInterface & NewInterface {
-              oldField: String
-              newField: String
-            }
-
-            interface NewInterface {
-              newField: String
-            }
-            """
+                interface AnotherInterface implements SomeInterface & NewInterface {
+                  oldField: String
+                  newField: String
+                }
+    
+                type SomeObject implements SomeInterface & AnotherInterface & NewInterface {
+                  oldField: String
+                  newField: String
+                }
+    
+                interface NewInterface {
+                  newField: String
+                }
+                """
             ),
         )
 
@@ -1150,11 +1150,11 @@ def allows_extension_of_interface_with_missing_object_fields():
             extended_schema,
             dedent(
                 """
-            interface SomeInterface {
-              oldField: SomeInterface
-              newField: String
-            }
-            """
+                interface SomeInterface {
+                  oldField: SomeInterface
+                  newField: String
+                }
+                """
             ),
         )
 
@@ -1189,12 +1189,12 @@ def extends_interfaces_multiple_times():
             extended_schema,
             dedent(
                 """
-            interface SomeInterface {
-              some: SomeInterface
-              newFieldA: Int
-              newFieldB(test: Boolean): String
-            }
-            """
+                interface SomeInterface {
+                  some: SomeInterface
+                  newFieldA: Int
+                  newFieldB(test: Boolean): String
+                }
+                """
             ),
         )
 
@@ -1491,15 +1491,15 @@ def schema_extension_ast_are_available_from_schema_object():
                 extended_twice_schema,
                 dedent(
                     """
-                extend schema {
-                  mutation: Mutation
-                }
-
-                extend schema {
-                  subscription: Subscription
-                }
-
-                extend schema @foo
-                """
+                    extend schema {
+                      mutation: Mutation
+                    }
+    
+                    extend schema {
+                      subscription: Subscription
+                    }
+    
+                    extend schema @foo
+                    """
                 ),
             )