def builds_a_schema_aware_of_deprecation():
        schema = GraphQLSchema(
            GraphQLObjectType('Simple', {
                'shinyString':
                GraphQLField(GraphQLString,
                             description='This is a shiny string field'),
                'deprecatedString':
                GraphQLField(GraphQLString,
                             description='This is a deprecated string field',
                             deprecation_reason='Use shinyString'),
                'color':
                GraphQLField(
                    GraphQLEnumType(
                        'Color', {
                            'RED':
                            GraphQLEnumValue(description='So rosy'),
                            'GREEN':
                            GraphQLEnumValue(description='So grassy'),
                            'BLUE':
                            GraphQLEnumValue(description='So calming'),
                            'MAUVE':
                            GraphQLEnumValue(
                                description='So sickening',
                                deprecation_reason='No longer in fashion')
                        }))
            },
                              description='This is a simple type'))

        check_schema(schema)
def test_identifies_deprecated_enum_values():
    TestEnum = GraphQLEnumType('TestEnum', OrderedDict([
        ('NONDEPRECATED', GraphQLEnumValue(0)),
        ('DEPRECATED', GraphQLEnumValue(1, deprecation_reason='Removed in 1.0')),
        ('ALSONONDEPRECATED', GraphQLEnumValue(2))
    ]))
    TestType = GraphQLObjectType('TestType', {
        'testEnum': GraphQLField(TestEnum)
    })
    schema = GraphQLSchema(TestType)
    request = '''{__type(name: "TestEnum") {
        name
        enumValues(includeDeprecated: true) {
            name
            isDeprecated
            deprecationReason
        }
    } }'''
    result = graphql(schema, request)
    assert not result.errors
    assert result.data == {'__type': {
        'name': 'TestEnum',
        'enumValues': [
            {'name': 'NONDEPRECATED', 'isDeprecated': False, 'deprecationReason': None},
            {'name': 'DEPRECATED', 'isDeprecated': True, 'deprecationReason': 'Removed in 1.0'},
            {'name': 'ALSONONDEPRECATED', 'isDeprecated': False, 'deprecationReason': None},
        ]}}
def test_respects_the_includedeprecated_parameter_for_enum_values():
    TestEnum = GraphQLEnumType('TestEnum', OrderedDict([
        ('NONDEPRECATED', GraphQLEnumValue(0)),
        ('DEPRECATED', GraphQLEnumValue(1, deprecation_reason='Removed in 1.0')),
        ('ALSONONDEPRECATED', GraphQLEnumValue(2))
    ]))
    TestType = GraphQLObjectType('TestType', {
        'testEnum': GraphQLField(TestEnum)
    })
    schema = GraphQLSchema(TestType)
    request = '''{__type(name: "TestEnum") {
        name
        trueValues: enumValues(includeDeprecated: true) { name }
        falseValues: enumValues(includeDeprecated: false) { name }
        omittedValues: enumValues { name }
    } }'''
    result = graphql(schema, request)
    assert not result.errors
    assert result.data == {'__type': {
        'name': 'TestEnum',
        'trueValues': [{'name': 'NONDEPRECATED'}, {'name': 'DEPRECATED'},
                       {'name': 'ALSONONDEPRECATED'}],
        'falseValues': [{'name': 'NONDEPRECATED'},
                        {'name': 'ALSONONDEPRECATED'}],
        'omittedValues': [{'name': 'NONDEPRECATED'},
                          {'name': 'ALSONONDEPRECATED'}],
    }}
Exemple #4
0
def test_enum():
    class MyEnum(Enum):
        """Description"""

        foo = 1
        bar = 2

        @property
        def description(self):
            return "Description {}={}".format(self.name, self.value)

        @property
        def deprecation_reason(self):
            if self == MyEnum.foo:
                return "Is deprecated"

    type_map = create_type_map([MyEnum])
    assert "MyEnum" in type_map
    graphql_enum = type_map["MyEnum"]
    assert isinstance(graphql_enum, GraphQLEnumType)
    assert graphql_enum.name == "MyEnum"
    assert graphql_enum.description == "Description"
    assert graphql_enum.values == {
        "foo":
        GraphQLEnumValue(value=1,
                         description="Description foo=1",
                         deprecation_reason="Is deprecated"),
        "bar":
        GraphQLEnumValue(value=2, description="Description bar=2"),
    }
Exemple #5
0
 def define_generic_order_types(self):
     self._gql_ordertypes['directionEnum'] = GraphQLEnumType(
         'directionEnum',
         values=OrderedDict(
             ASC=GraphQLEnumValue(),
             DESC=GraphQLEnumValue()
         )
     )
     self._gql_ordertypes['nullsOrderingEnum'] = GraphQLEnumType(
         'nullsOrderingEnum',
         values=OrderedDict(
             SMALLEST=GraphQLEnumValue(),
             BIGGEST=GraphQLEnumValue(),
         )
     )
     self._gql_ordertypes['Ordering'] = GraphQLInputObjectType(
         'Ordering',
         fields=OrderedDict(
             dir=GraphQLInputObjectField(
                 GraphQLNonNull(self._gql_ordertypes['directionEnum']),
             ),
             nulls=GraphQLInputObjectField(
                 self._gql_ordertypes['nullsOrderingEnum'],
                 default_value='SMALLEST',
             ),
         )
     )
Exemple #6
0
    def prints_enum():
        RGBType = GraphQLEnumType(
            name="RGB",
            values={
                "RED": GraphQLEnumValue(0),
                "GREEN": GraphQLEnumValue(1),
                "BLUE": GraphQLEnumValue(2),
            },
        )

        Root = GraphQLObjectType(name="Root", fields={"rgb": GraphQLField(RGBType)})

        Schema = GraphQLSchema(Root)
        output = print_for_test(Schema)
        assert output == dedent(
            """
            schema {
              query: Root
            }

            enum RGB {
              RED
              GREEN
              BLUE
            }

            type Root {
              rgb: RGB
            }
            """
        )
Exemple #7
0
def test_enum():
    class MyEnum(Enum):
        '''Description'''
        foo = 1
        bar = 2

        @property
        def description(self):
            return 'Description {}={}'.format(self.name, self.value)

        @property
        def deprecation_reason(self):
            if self == MyEnum.foo:
                return 'Is deprecated'

    typemap = TypeMap([MyEnum])
    assert 'MyEnum' in typemap
    graphql_enum = typemap['MyEnum']
    assert isinstance(graphql_enum, GraphQLEnumType)
    assert graphql_enum.name == 'MyEnum'
    assert graphql_enum.description == 'Description'
    values = graphql_enum.values
    assert values == [
        GraphQLEnumValue(name='foo',
                         value=1,
                         description='Description foo=1',
                         deprecation_reason='Is deprecated'),
        GraphQLEnumValue(name='bar', value=2, description='Description bar=2'),
    ]
    def prints_enum():
        rgb_type = GraphQLEnumType(
            name="RGB",
            values={
                "RED": GraphQLEnumValue(0),
                "GREEN": GraphQLEnumValue(1),
                "BLUE": GraphQLEnumValue(2),
            },
        )

        query = GraphQLObjectType(name="Query",
                                  fields={"rgb": GraphQLField(rgb_type)})

        schema = GraphQLSchema(query)
        output = print_for_test(schema)
        assert output == dedent("""
            type Query {
              rgb: RGB
            }

            enum RGB {
              RED
              GREEN
              BLUE
            }
            """)
Exemple #9
0
    def define_enums(self):
        self._gql_enums['directionEnum'] = GraphQLEnumType(
            'directionEnum',
            values=OrderedDict(
                ASC=GraphQLEnumValue(),
                DESC=GraphQLEnumValue()
            )
        )
        self._gql_enums['nullsOrderingEnum'] = GraphQLEnumType(
            'nullsOrderingEnum',
            values=OrderedDict(
                SMALLEST=GraphQLEnumValue(),
                BIGGEST=GraphQLEnumValue(),
            )
        )

        scalar_types = list(
            self.edb_schema.get_objects(modules=self.modules,
                                        type=s_scalars.ScalarType))
        for st in scalar_types:
            if st.is_enum(self.edb_schema):

                name = self.get_gql_name(st.get_name(self.edb_schema))
                self._gql_enums[name] = GraphQLEnumType(
                    name,
                    values=OrderedDict(
                        (key, GraphQLEnumValue()) for key in
                        st.get_enum_values(self.edb_schema)
                    )
                )
Exemple #10
0
    def define_enums(self):
        self._gql_enums['directionEnum'] = GraphQLEnumType(
            'directionEnum',
            values=OrderedDict(ASC=GraphQLEnumValue(),
                               DESC=GraphQLEnumValue()),
            description='Enum value used to specify ordering direction.',
        )
        self._gql_enums['nullsOrderingEnum'] = GraphQLEnumType(
            'nullsOrderingEnum',
            values=OrderedDict(
                SMALLEST=GraphQLEnumValue(),
                BIGGEST=GraphQLEnumValue(),
            ),
            description='Enum value used to specify how nulls are ordered.',
        )

        scalar_types = list(
            self.edb_schema.get_objects(included_modules=self.modules,
                                        type=s_scalars.ScalarType))
        for st in scalar_types:
            if st.is_enum(self.edb_schema):

                t_name = st.get_name(self.edb_schema)
                gql_name = self.get_gql_name(t_name)
                enum_type = GraphQLEnumType(
                    gql_name,
                    values=OrderedDict(
                        (key, GraphQLEnumValue())
                        for key in st.get_enum_values(self.edb_schema)),
                    description=self._get_description(st),
                )

                self._gql_enums[gql_name] = enum_type
                self._gql_inobjtypes[f'Insert{t_name}'] = enum_type
Exemple #11
0
def test_builds_a_schema_aware_of_deprecation():
    schema = GraphQLSchema(query=GraphQLObjectType(
        name='Simple',
        description='This is a simple type',
        fields=OrderedDict(
            [('shinyString',
              GraphQLField(type=GraphQLString,
                           description='This is a shiny string field')),
             ('deprecatedString',
              GraphQLField(type=GraphQLString,
                           description='This is a deprecated string field',
                           deprecation_reason='Use shinyString')),
             ('color',
              GraphQLField(type=GraphQLEnumType(
                  name='Color',
                  values=OrderedDict([
                      ('RED', GraphQLEnumValue(description='So rosy')),
                      ('GREEN', GraphQLEnumValue(description='So grassy')),
                      ('BLUE',
                       GraphQLEnumValue(description='So calming')),
                      ('MAUVE',
                       GraphQLEnumValue(
                           description='So sickening',
                           deprecation_reason='No longer in fashion')),
                  ]))))])))

    _test_schema(schema)
Exemple #12
0
    def prints_enum():
        RGBType = GraphQLEnumType(name='RGB',
                                  values={
                                      'RED': GraphQLEnumValue(0),
                                      'GREEN': GraphQLEnumValue(1),
                                      'BLUE': GraphQLEnumValue(2)
                                  })

        Root = GraphQLObjectType(name='Root',
                                 fields={'rgb': GraphQLField(RGBType)})

        Schema = GraphQLSchema(Root)
        output = print_for_test(Schema)
        assert output == dedent("""
            schema {
              query: Root
            }

            enum RGB {
              RED
              GREEN
              BLUE
            }

            type Root {
              rgb: RGB
            }
            """)
Exemple #13
0
    def builds_a_schema_with_an_enum():
        food_enum = GraphQLEnumType(
            "Food",
            {
                "VEGETABLES": GraphQLEnumValue(
                    1, description="Foods that are vegetables."
                ),
                "FRUITS": GraphQLEnumValue(2, description="Foods that are fruits."),
                "OILS": GraphQLEnumValue(3, description="Foods that are oils."),
                "DAIRY": GraphQLEnumValue(4, description="Foods that are dairy."),
                "MEAT": GraphQLEnumValue(5, description="Foods that are meat."),
            },
            description="Varieties of food stuffs",
        )

        schema = GraphQLSchema(
            GraphQLObjectType(
                "EnumFields",
                {
                    "food": GraphQLField(
                        food_enum,
                        args={
                            "kind": GraphQLArgument(
                                food_enum, description="what kind of food?"
                            )
                        },
                        description="Repeats the arg you give it",
                    )
                },
            )
        )

        introspection = introspection_from_schema(schema)
        client_schema = build_client_schema(introspection)
        second_introspection = introspection_from_schema(client_schema)

        hack_to_remove_standard_types(second_introspection)
        hack_to_remove_standard_types(introspection)
        assert second_introspection == introspection

        client_food_enum = client_schema.get_type("Food")

        # It's also an Enum type on the client.
        assert is_enum_type(client_food_enum)

        values = client_food_enum.values
        descriptions = {name: value.description for name, value in values.items()}
        assert descriptions == {
            "VEGETABLES": "Foods that are vegetables.",
            "FRUITS": "Foods that are fruits.",
            "OILS": "Foods that are oils.",
            "DAIRY": "Foods that are dairy.",
            "MEAT": "Foods that are meat.",
        }
        values = values.values()
        assert all(value.value is None for value in values)
        assert all(value.is_deprecated is False for value in values)
        assert all(value.deprecation_reason is None for value in values)
        assert all(value.ast_node is None for value in values)
Exemple #14
0
def test_builds_a_schema_aware_of_deprecation():
    schema = GraphQLSchema(
        query=GraphQLObjectType(
            name="Simple",
            description="This is a simple type",
            fields=OrderedDict(
                [
                    (
                        "shinyString",
                        GraphQLField(
                            type=GraphQLString,
                            description="This is a shiny string field",
                        ),
                    ),
                    (
                        "deprecatedString",
                        GraphQLField(
                            type=GraphQLString,
                            description="This is a deprecated string field",
                            deprecation_reason="Use shinyString",
                        ),
                    ),
                    (
                        "color",
                        GraphQLField(
                            type=GraphQLEnumType(
                                name="Color",
                                values=OrderedDict(
                                    [
                                        (
                                            "RED",
                                            GraphQLEnumValue(description="So rosy"),
                                        ),
                                        (
                                            "GREEN",
                                            GraphQLEnumValue(description="So grassy"),
                                        ),
                                        (
                                            "BLUE",
                                            GraphQLEnumValue(description="So calming"),
                                        ),
                                        (
                                            "MAUVE",
                                            GraphQLEnumValue(
                                                description="So sickening",
                                                deprecation_reason="No longer in fashion",
                                            ),
                                        ),
                                    ]
                                ),
                            )
                        ),
                    ),
                ]
            ),
        )
    )

    _test_schema(schema)
 def create_type():
     return GraphQLEnumType(
         name='MedicareUtilizationLevel',
         values={
             'NONE': GraphQLEnumValue(),
             'LOW': GraphQLEnumValue(),
             'FULL': GraphQLEnumValue(),
         },
     )
Exemple #16
0
 def accepts_a_well_defined_enum_type_with_internal_value_definition():
     enum_type = GraphQLEnumType("SomeEnum", {"FOO": 10, "BAR": 20})
     assert enum_type.values["FOO"].value == 10
     assert enum_type.values["BAR"].value == 20
     enum_type = GraphQLEnumType(
         "SomeEnum", {"FOO": GraphQLEnumValue(10), "BAR": GraphQLEnumValue(20)}
     )
     assert enum_type.values["FOO"].value == 10
     assert enum_type.values["BAR"].value == 20
def test_does_not_sort_values_when_using_ordered_dict():
    enum = GraphQLEnumType(name='Test', values=OrderedDict([
        ('c', GraphQLEnumValue()),
        ('b', GraphQLEnumValue()),
        ('a', GraphQLEnumValue()),
        ('d', GraphQLEnumValue()),
    ]))

    assert [v.name for v in enum.values] == ['c', 'b', 'a', 'd']
def test_sorts_values_if_not_using_ordered_dict():
    enum = GraphQLEnumType(name='Test', values={
        'c': GraphQLEnumValue(),
        'b': GraphQLEnumValue(),
        'a': GraphQLEnumValue(),
        'd': GraphQLEnumValue()
    })

    assert [v.name for v in enum.values] == ['a', 'b', 'c', 'd']
Exemple #19
0
 def accepts_a_well_defined_enum_type_with_internal_value_definition():
     enum_type = GraphQLEnumType('SomeEnum', {'FOO': 10, 'BAR': 20})
     assert enum_type.values['FOO'].value == 10
     assert enum_type.values['BAR'].value == 20
     enum_type = GraphQLEnumType('SomeEnum', {
         'FOO': GraphQLEnumValue(10),
         'BAR': GraphQLEnumValue(20)
     })
     assert enum_type.values['FOO'].value == 10
     assert enum_type.values['BAR'].value == 20
    def builds_a_schema_with_an_enum():
        food_enum = GraphQLEnumType('Food', {
            'VEGETABLES':
            GraphQLEnumValue(1, description='Foods that are vegetables.'),
            'FRUITS':
            GraphQLEnumValue(2, description='Foods that are fruits.'),
            'OILS':
            GraphQLEnumValue(3, description='Foods that are oils.'),
            'DAIRY':
            GraphQLEnumValue(4, description='Foods that are dairy.'),
            'MEAT':
            GraphQLEnumValue(5, description='Foods that are meat.')
        },
                                    description='Varieties of food stuffs')

        schema = GraphQLSchema(
            GraphQLObjectType(
                'EnumFields', {
                    'food':
                    GraphQLField(food_enum,
                                 args={
                                     'kind':
                                     GraphQLArgument(
                                         food_enum,
                                         description='what kind of food?')
                                 },
                                 description='Repeats the arg you give it')
                }))

        check_schema(schema)

        introspection = introspection_from_schema(schema)
        client_schema = build_client_schema(introspection)
        client_food_enum = client_schema.get_type('Food')

        # It's also an Enum type on the client.
        assert isinstance(client_food_enum, GraphQLEnumType)

        values = client_food_enum.values
        descriptions = {
            name: value.description
            for name, value in values.items()
        }
        assert descriptions == {
            'VEGETABLES': 'Foods that are vegetables.',
            'FRUITS': 'Foods that are fruits.',
            'OILS': 'Foods that are oils.',
            'DAIRY': 'Foods that are dairy.',
            'MEAT': 'Foods that are meat.'
        }
        values = values.values()
        assert all(value.value is None for value in values)
        assert all(value.is_deprecated is False for value in values)
        assert all(value.deprecation_reason is None for value in values)
        assert all(value.ast_node is None for value in values)
Exemple #21
0
    def respects_the_include_deprecated_parameter_for_enum_values():
        TestEnum = GraphQLEnumType(
            'TestEnum', {
                'NONDEPRECATED':
                GraphQLEnumValue(0),
                'DEPRECATED':
                GraphQLEnumValue(1, deprecation_reason='Removed in 1.0'),
                'ALSONONDEPRECATED':
                GraphQLEnumValue(2)
            })

        TestType = GraphQLObjectType('TestType',
                                     {'testEnum': GraphQLField(TestEnum)})

        schema = GraphQLSchema(TestType)
        request = """
            {
              __type(name: "TestEnum") {
                  name
                trueValues: enumValues(includeDeprecated: true) {
                  name
                }
                falseValues: enumValues(includeDeprecated: false) {
                  name
                }
                omittedValues: enumValues {
                  name
                }
              }
            }
            """

        assert graphql_sync(schema, request) == ({
            '__type': {
                'name':
                'TestEnum',
                'trueValues': [{
                    'name': 'NONDEPRECATED'
                }, {
                    'name': 'DEPRECATED'
                }, {
                    'name': 'ALSONONDEPRECATED'
                }],
                'falseValues': [{
                    'name': 'NONDEPRECATED'
                }, {
                    'name': 'ALSONONDEPRECATED'
                }],
                'omittedValues': [{
                    'name': 'NONDEPRECATED'
                }, {
                    'name': 'ALSONONDEPRECATED'
                }]
            }
        }, None)
Exemple #22
0
def test_builds_a_schema_with_an_enum():
    FoodEnum = GraphQLEnumType(
        name='Food',
        description='Varieties of food stuffs',
        values=OrderedDict([
            ('VEGETABLES',
             GraphQLEnumValue(1, description='Foods that are vegetables.')),
            ('FRUITS', GraphQLEnumValue(2,
                                        description='Foods that are fruits.')),
            ('OILS', GraphQLEnumValue(3, description='Foods that are oils.')),
            ('DAIRY', GraphQLEnumValue(4,
                                       description='Foods that are dairy.')),
            ('MEAT', GraphQLEnumValue(5, description='Foods that are meat.')),
        ]))

    schema = GraphQLSchema(query=GraphQLObjectType(
        name='EnumFields',
        fields={
            'food':
            GraphQLField(FoodEnum,
                         description='Repeats the arg you give it',
                         args={
                             'kind':
                             GraphQLArgument(FoodEnum,
                                             description='what kind of food?')
                         })
        }))

    client_schema = _test_schema(schema)
    clientFoodEnum = client_schema.get_type('Food')
    assert isinstance(clientFoodEnum, GraphQLEnumType)

    assert clientFoodEnum.values == [
        GraphQLEnumValue(name='VEGETABLES',
                         value='VEGETABLES',
                         description='Foods that are vegetables.',
                         deprecation_reason=None),
        GraphQLEnumValue(name='FRUITS',
                         value='FRUITS',
                         description='Foods that are fruits.',
                         deprecation_reason=None),
        GraphQLEnumValue(name='OILS',
                         value='OILS',
                         description='Foods that are oils.',
                         deprecation_reason=None),
        GraphQLEnumValue(name='DAIRY',
                         value='DAIRY',
                         description='Foods that are dairy.',
                         deprecation_reason=None),
        GraphQLEnumValue(name='MEAT',
                         value='MEAT',
                         description='Foods that are meat.',
                         deprecation_reason=None)
    ]
 def create_type():
     return GraphQLEnumType(
         name='ProviderStatus',
         values={
             'AS_SUBMITTED': GraphQLEnumValue(),
             'SETTLED': GraphQLEnumValue(),
             'AMENDED': GraphQLEnumValue(),
             'SETTLED_WITH_AUDIT': GraphQLEnumValue(),
             'REOPENED': GraphQLEnumValue(),
         },
     )
Exemple #24
0
    def defines_an_enum_type_with_deprecated_value():
        EnumTypeWithDeprecatedValue = GraphQLEnumType(
            name="EnumWithDeprecatedValue",
            values={"foo": GraphQLEnumValue(deprecation_reason="Just because")},
        )

        deprecated_value = EnumTypeWithDeprecatedValue.values["foo"]
        assert deprecated_value == GraphQLEnumValue(deprecation_reason="Just because")
        assert deprecated_value.is_deprecated is True
        assert deprecated_value.deprecation_reason == "Just because"
        assert deprecated_value.value is None
        assert deprecated_value.ast_node is None
def test_does_not_sort_values_when_using_ordered_dict():
    enum = GraphQLEnumType(
        name="Test",
        values=OrderedDict([
            ("c", GraphQLEnumValue()),
            ("b", GraphQLEnumValue()),
            ("a", GraphQLEnumValue()),
            ("d", GraphQLEnumValue()),
        ]),
    )

    assert [v.name for v in enum.values] == ["c", "b", "a", "d"]
def test_sorts_values_if_not_using_ordered_dict():
    enum = GraphQLEnumType(
        name="Test",
        values={
            "c": GraphQLEnumValue(),
            "b": GraphQLEnumValue(),
            "a": GraphQLEnumValue(),
            "d": GraphQLEnumValue(),
        },
    )

    assert [v.name for v in enum.values] == ["a", "b", "c", "d"]
Exemple #27
0
    def defines_an_enum_type_with_deprecated_value():
        EnumTypeWithDeprecatedValue = GraphQLEnumType(
            name='EnumWithDeprecatedValue',
            values={
                'foo': GraphQLEnumValue(deprecation_reason='Just because')
            })

        deprecated_value = EnumTypeWithDeprecatedValue.values['foo']
        assert deprecated_value == GraphQLEnumValue(
            deprecation_reason='Just because')
        assert deprecated_value.is_deprecated is True
        assert deprecated_value.deprecation_reason == 'Just because'
        assert deprecated_value.value is None
        assert deprecated_value.ast_node is None
def test_respects_the_includedeprecated_parameter_for_enum_values():
    TestEnum = GraphQLEnumType(
        "TestEnum",
        OrderedDict([
            ("NONDEPRECATED", GraphQLEnumValue(0)),
            (
                "DEPRECATED",
                GraphQLEnumValue(1, deprecation_reason="Removed in 1.0"),
            ),
            ("ALSONONDEPRECATED", GraphQLEnumValue(2)),
        ]),
    )
    TestType = GraphQLObjectType("TestType",
                                 {"testEnum": GraphQLField(TestEnum)})
    schema = GraphQLSchema(TestType)
    request = """{__type(name: "TestEnum") {
        name
        trueValues: enumValues(includeDeprecated: true) { name }
        falseValues: enumValues(includeDeprecated: false) { name }
        omittedValues: enumValues { name }
    } }"""
    result = graphql(schema, request)
    assert not result.errors
    assert result.data == {
        "__type": {
            "name":
            "TestEnum",
            "trueValues": [
                {
                    "name": "NONDEPRECATED"
                },
                {
                    "name": "DEPRECATED"
                },
                {
                    "name": "ALSONONDEPRECATED"
                },
            ],
            "falseValues": [{
                "name": "NONDEPRECATED"
            }, {
                "name": "ALSONONDEPRECATED"
            }],
            "omittedValues": [{
                "name": "NONDEPRECATED"
            }, {
                "name": "ALSONONDEPRECATED"
            }],
        }
    }
def describe_find_deprecated_usages():

    enum_type = GraphQLEnumType(
        "EnumType",
        {
            "ONE": GraphQLEnumValue(),
            "TWO": GraphQLEnumValue(deprecation_reason="Some enum reason."),
        },
    )

    schema = GraphQLSchema(
        GraphQLObjectType(
            "Query",
            {
                "normalField":
                GraphQLField(GraphQLString,
                             args={"enumArg": GraphQLArgument(enum_type)}),
                "deprecatedField":
                GraphQLField(GraphQLString,
                             deprecation_reason="Some field reason."),
            },
        ))

    def should_report_empty_set_for_no_deprecated_usages():
        errors = find_deprecated_usages(schema,
                                        parse("{ normalField(enumArg: ONE) }"))

        assert errors == []

    def should_report_usage_of_deprecated_fields():
        errors = find_deprecated_usages(
            schema, parse("{ normalField, deprecatedField }"))

        error_messages = [err.message for err in errors]

        assert error_messages == [
            "The field Query.deprecatedField is deprecated. Some field reason."
        ]

    def should_report_usage_of_deprecated_enums():
        errors = find_deprecated_usages(schema,
                                        parse("{ normalField(enumArg: TWO) }"))

        error_messages = [err.message for err in errors]

        assert error_messages == [
            "The enum value EnumType.TWO is deprecated. Some enum reason."
        ]
def test_identifies_deprecated_enum_values():
    TestEnum = GraphQLEnumType(
        "TestEnum",
        OrderedDict([
            ("NONDEPRECATED", GraphQLEnumValue(0)),
            (
                "DEPRECATED",
                GraphQLEnumValue(1, deprecation_reason="Removed in 1.0"),
            ),
            ("ALSONONDEPRECATED", GraphQLEnumValue(2)),
        ]),
    )
    TestType = GraphQLObjectType("TestType",
                                 {"testEnum": GraphQLField(TestEnum)})
    schema = GraphQLSchema(TestType)
    request = """{__type(name: "TestEnum") {
        name
        enumValues(includeDeprecated: true) {
            name
            isDeprecated
            deprecationReason
        }
    } }"""
    result = graphql(schema, request)
    assert not result.errors
    assert result.data == {
        "__type": {
            "name":
            "TestEnum",
            "enumValues": [
                {
                    "name": "NONDEPRECATED",
                    "isDeprecated": False,
                    "deprecationReason": None,
                },
                {
                    "name": "DEPRECATED",
                    "isDeprecated": True,
                    "deprecationReason": "Removed in 1.0",
                },
                {
                    "name": "ALSONONDEPRECATED",
                    "isDeprecated": False,
                    "deprecationReason": None,
                },
            ],
        }
    }