star

venv/lib/python3.9/site-packages/graphene/tests/issues/test_1293.py

@@ -0,0 +1,41 @@
+# https://github.com/graphql-python/graphene/issues/1293
+
+from datetime import datetime, timezone
+
+import graphene
+from graphql.utilities import print_schema
+
+
+class Filters(graphene.InputObjectType):
+    datetime_after = graphene.DateTime(
+        required=False,
+        default_value=datetime.fromtimestamp(1434549820.776, timezone.utc),
+    )
+    datetime_before = graphene.DateTime(
+        required=False,
+        default_value=datetime.fromtimestamp(1444549820.776, timezone.utc),
+    )
+
+
+class SetDatetime(graphene.Mutation):
+    class Arguments:
+        filters = Filters(required=True)
+
+    ok = graphene.Boolean()
+
+    def mutate(root, info, filters):
+        return SetDatetime(ok=True)
+
+
+class Query(graphene.ObjectType):
+    goodbye = graphene.String()
+
+
+class Mutations(graphene.ObjectType):
+    set_datetime = SetDatetime.Field()
+
+
+def test_schema_printable_with_default_datetime_value():
+    schema = graphene.Schema(query=Query, mutation=Mutations)
+    schema_str = print_schema(schema.graphql_schema)
+    assert schema_str, "empty schema printed"

venv/lib/python3.9/site-packages/graphene/tests/issues/test_1394.py

@@ -0,0 +1,36 @@
+from ...types import ObjectType, Schema, String, NonNull
+
+
+class Query(ObjectType):
+    hello = String(input=NonNull(String))
+
+    def resolve_hello(self, info, input):
+        if input == "nothing":
+            return None
+        return f"Hello {input}!"
+
+
+schema = Schema(query=Query)
+
+
+def test_required_input_provided():
+    """
+    Test that a required argument works when provided.
+    """
+    input_value = "Potato"
+    result = schema.execute('{ hello(input: "%s") }' % input_value)
+    assert not result.errors
+    assert result.data == {"hello": "Hello Potato!"}
+
+
+def test_required_input_missing():
+    """
+    Test that a required argument raised an error if not provided.
+    """
+    result = schema.execute("{ hello }")
+    assert result.errors
+    assert len(result.errors) == 1
+    assert (
+        result.errors[0].message
+        == "Field 'hello' argument 'input' of type 'String!' is required, but it was not provided."
+    )

venv/lib/python3.9/site-packages/graphene/tests/issues/test_1419.py

@@ -0,0 +1,53 @@
+import pytest
+
+from ...types.base64 import Base64
+from ...types.datetime import Date, DateTime
+from ...types.decimal import Decimal
+from ...types.generic import GenericScalar
+from ...types.json import JSONString
+from ...types.objecttype import ObjectType
+from ...types.scalars import ID, BigInt, Boolean, Float, Int, String
+from ...types.schema import Schema
+from ...types.uuid import UUID
+
+
+@pytest.mark.parametrize(
+    "input_type,input_value",
+    [
+        (Date, '"2022-02-02"'),
+        (GenericScalar, '"foo"'),
+        (Int, "1"),
+        (BigInt, "12345678901234567890"),
+        (Float, "1.1"),
+        (String, '"foo"'),
+        (Boolean, "true"),
+        (ID, "1"),
+        (DateTime, '"2022-02-02T11:11:11"'),
+        (UUID, '"cbebbc62-758e-4f75-a890-bc73b5017d81"'),
+        (Decimal, '"1.1"'),
+        (JSONString, '"{\\"key\\":\\"foo\\",\\"value\\":\\"bar\\"}"'),
+        (Base64, '"Q2hlbG8gd29ycmxkCg=="'),
+    ],
+)
+def test_parse_literal_with_variables(input_type, input_value):
+    # input_b needs to be evaluated as literal while the variable dict for
+    # input_a is passed along.
+
+    class Query(ObjectType):
+        generic = GenericScalar(input_a=GenericScalar(), input_b=input_type())
+
+        def resolve_generic(self, info, input_a=None, input_b=None):
+            return input
+
+    schema = Schema(query=Query)
+
+    query = f"""
+        query Test($a: GenericScalar){{
+            generic(inputA: $a, inputB: {input_value})
+        }}
+    """
+    result = schema.execute(
+        query,
+        variables={"a": "bar"},
+    )
+    assert not result.errors

venv/lib/python3.9/site-packages/graphene/tests/issues/test_313.py

@@ -0,0 +1,57 @@
+# https://github.com/graphql-python/graphene/issues/313
+
+import graphene
+
+
+class Query(graphene.ObjectType):
+    rand = graphene.String()
+
+
+class Success(graphene.ObjectType):
+    yeah = graphene.String()
+
+
+class Error(graphene.ObjectType):
+    message = graphene.String()
+
+
+class CreatePostResult(graphene.Union):
+    class Meta:
+        types = [Success, Error]
+
+
+class CreatePost(graphene.Mutation):
+    class Arguments:
+        text = graphene.String(required=True)
+
+    result = graphene.Field(CreatePostResult)
+
+    def mutate(self, info, text):
+        result = Success(yeah="yeah")
+
+        return CreatePost(result=result)
+
+
+class Mutations(graphene.ObjectType):
+    create_post = CreatePost.Field()
+
+
+# tests.py
+
+
+def test_create_post():
+    query_string = """
+    mutation {
+      createPost(text: "Try this out") {
+        result {
+          __typename
+        }
+      }
+    }
+    """
+
+    schema = graphene.Schema(query=Query, mutation=Mutations)
+    result = schema.execute(query_string)
+
+    assert not result.errors
+    assert result.data["createPost"]["result"]["__typename"] == "Success"

venv/lib/python3.9/site-packages/graphene/tests/issues/test_356.py

@@ -0,0 +1,33 @@
+# https://github.com/graphql-python/graphene/issues/356
+
+from pytest import raises
+
+import graphene
+from graphene import relay
+
+
+class SomeTypeOne(graphene.ObjectType):
+    pass
+
+
+class SomeTypeTwo(graphene.ObjectType):
+    pass
+
+
+class MyUnion(graphene.Union):
+    class Meta:
+        types = (SomeTypeOne, SomeTypeTwo)
+
+
+def test_issue():
+    class Query(graphene.ObjectType):
+        things = relay.ConnectionField(MyUnion)
+
+    with raises(Exception) as exc_info:
+        graphene.Schema(query=Query)
+
+    assert str(exc_info.value) == (
+        "Query fields cannot be resolved."
+        " IterableConnectionField type has to be a subclass of Connection."
+        ' Received "MyUnion".'
+    )

venv/lib/python3.9/site-packages/graphene/tests/issues/test_425.py

@@ -0,0 +1,117 @@
+# https://github.com/graphql-python/graphene/issues/425
+# Adapted for Graphene 2.0
+
+from graphene.types.enum import Enum, EnumOptions
+from graphene.types.inputobjecttype import InputObjectType
+from graphene.types.objecttype import ObjectType, ObjectTypeOptions
+
+
+# ObjectType
+class SpecialOptions(ObjectTypeOptions):
+    other_attr = None
+
+
+class SpecialObjectType(ObjectType):
+    @classmethod
+    def __init_subclass_with_meta__(cls, other_attr="default", **options):
+        _meta = SpecialOptions(cls)
+        _meta.other_attr = other_attr
+        super(SpecialObjectType, cls).__init_subclass_with_meta__(
+            _meta=_meta, **options
+        )
+
+
+def test_special_objecttype_could_be_subclassed():
+    class MyType(SpecialObjectType):
+        class Meta:
+            other_attr = "yeah!"
+
+    assert MyType._meta.other_attr == "yeah!"
+
+
+def test_special_objecttype_could_be_subclassed_default():
+    class MyType(SpecialObjectType):
+        pass
+
+    assert MyType._meta.other_attr == "default"
+
+
+def test_special_objecttype_inherit_meta_options():
+    class MyType(SpecialObjectType):
+        pass
+
+    assert MyType._meta.name == "MyType"
+    assert MyType._meta.default_resolver is None
+    assert MyType._meta.interfaces == ()
+
+
+# InputObjectType
+class SpecialInputObjectTypeOptions(ObjectTypeOptions):
+    other_attr = None
+
+
+class SpecialInputObjectType(InputObjectType):
+    @classmethod
+    def __init_subclass_with_meta__(cls, other_attr="default", **options):
+        _meta = SpecialInputObjectTypeOptions(cls)
+        _meta.other_attr = other_attr
+        super(SpecialInputObjectType, cls).__init_subclass_with_meta__(
+            _meta=_meta, **options
+        )
+
+
+def test_special_inputobjecttype_could_be_subclassed():
+    class MyInputObjectType(SpecialInputObjectType):
+        class Meta:
+            other_attr = "yeah!"
+
+    assert MyInputObjectType._meta.other_attr == "yeah!"
+
+
+def test_special_inputobjecttype_could_be_subclassed_default():
+    class MyInputObjectType(SpecialInputObjectType):
+        pass
+
+    assert MyInputObjectType._meta.other_attr == "default"
+
+
+def test_special_inputobjecttype_inherit_meta_options():
+    class MyInputObjectType(SpecialInputObjectType):
+        pass
+
+    assert MyInputObjectType._meta.name == "MyInputObjectType"
+
+
+# Enum
+class SpecialEnumOptions(EnumOptions):
+    other_attr = None
+
+
+class SpecialEnum(Enum):
+    @classmethod
+    def __init_subclass_with_meta__(cls, other_attr="default", **options):
+        _meta = SpecialEnumOptions(cls)
+        _meta.other_attr = other_attr
+        super(SpecialEnum, cls).__init_subclass_with_meta__(_meta=_meta, **options)
+
+
+def test_special_enum_could_be_subclassed():
+    class MyEnum(SpecialEnum):
+        class Meta:
+            other_attr = "yeah!"
+
+    assert MyEnum._meta.other_attr == "yeah!"
+
+
+def test_special_enum_could_be_subclassed_default():
+    class MyEnum(SpecialEnum):
+        pass
+
+    assert MyEnum._meta.other_attr == "default"
+
+
+def test_special_enum_inherit_meta_options():
+    class MyEnum(SpecialEnum):
+        pass
+
+    assert MyEnum._meta.name == "MyEnum"

venv/lib/python3.9/site-packages/graphene/tests/issues/test_490.py

@@ -0,0 +1,24 @@
+# https://github.com/graphql-python/graphene/issues/313
+
+import graphene
+
+
+class Query(graphene.ObjectType):
+    some_field = graphene.String(from_=graphene.String(name="from"))
+
+    def resolve_some_field(self, info, from_=None):
+        return from_
+
+
+def test_issue():
+    query_string = """
+    query myQuery {
+      someField(from: "Oh")
+    }
+    """
+
+    schema = graphene.Schema(query=Query)
+    result = schema.execute(query_string)
+
+    assert not result.errors
+    assert result.data["someField"] == "Oh"

venv/lib/python3.9/site-packages/graphene/tests/issues/test_720.py

@@ -0,0 +1,44 @@
+# https://github.com/graphql-python/graphene/issues/720
+# InputObjectTypes overwrite the "fields" attribute of the provided
+# _meta object, so even if dynamic fields are provided with a standard
+# InputObjectTypeOptions, they are ignored.
+
+import graphene
+
+
+class MyInputClass(graphene.InputObjectType):
+    @classmethod
+    def __init_subclass_with_meta__(
+        cls, container=None, _meta=None, fields=None, **options
+    ):
+        if _meta is None:
+            _meta = graphene.types.inputobjecttype.InputObjectTypeOptions(cls)
+        _meta.fields = fields
+        super(MyInputClass, cls).__init_subclass_with_meta__(
+            container=container, _meta=_meta, **options
+        )
+
+
+class MyInput(MyInputClass):
+    class Meta:
+        fields = dict(x=graphene.Field(graphene.Int))
+
+
+class Query(graphene.ObjectType):
+    myField = graphene.Field(graphene.String, input=graphene.Argument(MyInput))
+
+    def resolve_myField(parent, info, input):
+        return "ok"
+
+
+def test_issue():
+    query_string = """
+    query myQuery {
+      myField(input: {x: 1})
+    }
+    """
+
+    schema = graphene.Schema(query=Query)
+    result = schema.execute(query_string)
+
+    assert not result.errors

venv/lib/python3.9/site-packages/graphene/tests/issues/test_881.py

@@ -0,0 +1,27 @@
+import pickle
+
+from ...types.enum import Enum
+
+
+class PickleEnum(Enum):
+    # is defined outside of test because pickle unable to dump class inside ot pytest function
+    A = "a"
+    B = 1
+
+
+def test_enums_pickling():
+    a = PickleEnum.A
+    pickled = pickle.dumps(a)
+    restored = pickle.loads(pickled)
+    assert type(a) is type(restored)
+    assert a == restored
+    assert a.value == restored.value
+    assert a.name == restored.name
+
+    b = PickleEnum.B
+    pickled = pickle.dumps(b)
+    restored = pickle.loads(pickled)
+    assert type(a) is type(restored)
+    assert b == restored
+    assert b.value == restored.value
+    assert b.name == restored.name

venv/lib/python3.9/site-packages/graphene/tests/issues/test_956.py

@@ -0,0 +1,8 @@
+import graphene
+
+
+def test_issue():
+    options = {"description": "This my enum", "deprecation_reason": "For the funs"}
+    new_enum = graphene.Enum("MyEnum", [("some", "data")], **options)
+    assert new_enum._meta.description == options["description"]
+    assert new_enum._meta.deprecation_reason == options["deprecation_reason"]