Fixed argument output name. Fixed #490

Author: syrusakbary

graphene/tests/issues/test_490.py

@@ -0,0 +1,25 @@
+# https://github.com/graphql-python/graphene/issues/313
+
+import graphene
+from graphene import resolve_only_args
+
+
+class Query(graphene.ObjectType):
+    some_field = graphene.String(from_=graphene.String(name="from"))
+
+    def resolve_some_field(_, args, context, infos):
+        return args.get("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'

graphene/types/tests/test_datetime.py

@@ -11,11 +11,12 @@ class Query(ObjectType):
     time = Time(_at=Time(name='at'))
 
     def resolve_datetime(self, args, context, info):
-        _in = args.get('in')
+        _in = args.get('_in')
         return _in
 
     def resolve_time(self, args, context, info):
-        return args.get('at')
+        return args.get('_at')
+
 
 schema = Schema(query=Query)
 
@@ -24,48 +25,41 @@ def test_datetime_query():
     now = datetime.datetime.now().replace(tzinfo=pytz.utc)
     isoformat = now.isoformat()
 
-    result = schema.execute('''{ datetime(in: "%s") }'''%isoformat)
+    result = schema.execute('''{ datetime(in: "%s") }''' % isoformat)
     assert not result.errors
-    assert result.data == {
-        'datetime': isoformat
-    }
+    assert result.data == {'datetime': isoformat}
 
 
 def test_time_query():
     now = datetime.datetime.now().replace(tzinfo=pytz.utc)
-    time = datetime.time(now.hour, now.minute, now.second, now.microsecond, now.tzinfo)
+    time = datetime.time(now.hour, now.minute, now.second, now.microsecond,
+                         now.tzinfo)
     isoformat = time.isoformat()
 
-    result = schema.execute('''{ time(at: "%s") }'''%isoformat)
+    result = schema.execute('''{ time(at: "%s") }''' % isoformat)
     assert not result.errors
-    assert result.data == {
-        'time': isoformat
-    }
+    assert result.data == {'time': isoformat}
+
 
 def test_datetime_query_variable():
     now = datetime.datetime.now().replace(tzinfo=pytz.utc)
     isoformat = now.isoformat()
 
     result = schema.execute(
         '''query Test($date: DateTime){ datetime(in: $date) }''',
-        variable_values={'date': isoformat}
-    )
+        variable_values={'date': isoformat})
     assert not result.errors
-    assert result.data == {
-        'datetime': isoformat
-    }
+    assert result.data == {'datetime': isoformat}
 
 
 def test_time_query_variable():
     now = datetime.datetime.now().replace(tzinfo=pytz.utc)
-    time = datetime.time(now.hour, now.minute, now.second, now.microsecond, now.tzinfo)
+    time = datetime.time(now.hour, now.minute, now.second, now.microsecond,
+                         now.tzinfo)
     isoformat = time.isoformat()
 
     result = schema.execute(
         '''query Test($time: Time){ time(at: $time) }''',
-        variable_values={'time': isoformat}
-    )
+        variable_values={'time': isoformat})
     assert not result.errors
-    assert result.data == {
-        'time': isoformat
-    }
+    assert result.data == {'time': isoformat}

graphene/types/typemap.py

@@ -31,7 +31,9 @@
 def is_graphene_type(_type):
     if isinstance(_type, (List, NonNull)):
         return True
-    if inspect.isclass(_type) and issubclass(_type, (ObjectType, InputObjectType, Scalar, Interface, Union, Enum)):
+    if inspect.isclass(_type) and issubclass(_type,
+                                             (ObjectType, InputObjectType,
+                                              Scalar, Interface, Union, Enum)):
         return True
 
 
@@ -57,7 +59,6 @@ def is_type_of_from_possible_types(possible_types, root, context, info):
 
 
 class TypeMap(GraphQLTypeMap):
-
     def __init__(self, types, auto_camelcase=True, schema=None):
         self.auto_camelcase = auto_camelcase
         self.schema = schema
@@ -96,7 +97,8 @@ def graphene_reducer(self, map, type):
         elif issubclass(type, Union):
             internal_type = self.construct_union(map, type)
         else:
-            raise Exception("Expected Graphene type, but received: {}.".format(type))
+            raise Exception(
+                "Expected Graphene type, but received: {}.".format(type))
 
         return GraphQLTypeMap.reducer(map, internal_type)
 
@@ -117,11 +119,9 @@ def construct_scalar(self, map, type):
             graphene_type=type,
             name=type._meta.name,
             description=type._meta.description,
-
             serialize=getattr(type, 'serialize', None),
             parse_value=getattr(type, 'parse_value', None),
-            parse_literal=getattr(type, 'parse_literal', None),
-        )
+            parse_literal=getattr(type, 'parse_literal', None), )
 
     def construct_enum(self, map, type):
         values = OrderedDict()
@@ -130,14 +130,12 @@ def construct_enum(self, map, type):
                 name=name,
                 value=value.value,
                 description=getattr(value, 'description', None),
-                deprecation_reason=getattr(value, 'deprecation_reason', None)
-            )
+                deprecation_reason=getattr(value, 'deprecation_reason', None))
         return GrapheneEnumType(
             graphene_type=type,
             values=values,
             name=type._meta.name,
-            description=type._meta.description,
-        )
+            description=type._meta.description, )
 
     def construct_objecttype(self, map, type):
         if type._meta.name in map:
@@ -158,7 +156,8 @@ def interfaces():
             return interfaces
 
         if type._meta.possible_types:
-            is_type_of = partial(is_type_of_from_possible_types, type._meta.possible_types)
+            is_type_of = partial(is_type_of_from_possible_types,
+                                 type._meta.possible_types)
         else:
             is_type_of = type.is_type_of
 
@@ -168,8 +167,7 @@ def interfaces():
             description=type._meta.description,
             fields=partial(self.construct_fields_for_type, map, type),
             is_type_of=is_type_of,
-            interfaces=interfaces
-        )
+            interfaces=interfaces)
 
     def construct_interface(self, map, type):
         if type._meta.name in map:
@@ -182,27 +180,29 @@ def construct_interface(self, map, type):
 
         _resolve_type = None
         if type.resolve_type:
-            _resolve_type = partial(resolve_type, type.resolve_type, map, type._meta.name)
+            _resolve_type = partial(resolve_type, type.resolve_type, map,
+                                    type._meta.name)
         return GrapheneInterfaceType(
             graphene_type=type,
             name=type._meta.name,
             description=type._meta.description,
             fields=partial(self.construct_fields_for_type, map, type),
-            resolve_type=_resolve_type,
-        )
+            resolve_type=_resolve_type, )
 
     def construct_inputobjecttype(self, map, type):
         return GrapheneInputObjectType(
             graphene_type=type,
             name=type._meta.name,
             description=type._meta.description,
-            fields=partial(self.construct_fields_for_type, map, type, is_input_type=True),
+            fields=partial(
+                self.construct_fields_for_type, map, type, is_input_type=True),
         )
 
     def construct_union(self, map, type):
         _resolve_type = None
         if type.resolve_type:
-            _resolve_type = partial(resolve_type, type.resolve_type, map, type._meta.name)
+            _resolve_type = partial(resolve_type, type.resolve_type, map,
+                                    type._meta.name)
 
         def types():
             union_types = []
@@ -217,8 +217,7 @@ def types():
             graphene_type=type,
             name=type._meta.name,
             types=types,
-            resolve_type=_resolve_type,
-        )
+            resolve_type=_resolve_type, )
 
     def get_name(self, name):
         if self.auto_camelcase:
@@ -239,8 +238,7 @@ def construct_fields_for_type(self, map, type, is_input_type=False):
                     field_type,
                     default_value=field.default_value,
                     out_name=field.name or name,
-                    description=field.description
-                )
+                    description=field.description)
             else:
                 args = OrderedDict()
                 for arg_name, arg in field.args.items():
@@ -249,17 +247,17 @@ def construct_fields_for_type(self, map, type, is_input_type=False):
                     processed_arg_name = arg.name or self.get_name(arg_name)
                     args[processed_arg_name] = GraphQLArgument(
                         arg_type,
-                        out_name=arg.name or arg_name,
+                        out_name=arg_name,
                         description=arg.description,
-                        default_value=arg.default_value
-                    )
+                        default_value=arg.default_value)
                 _field = GraphQLField(
                     field_type,
                     args=args,
-                    resolver=field.get_resolver(self.get_resolver_for_type(type, name, field.default_value)),
+                    resolver=field.get_resolver(
+                        self.get_resolver_for_type(type, name,
+                                                   field.default_value)),
                     deprecation_reason=field.deprecation_reason,
-                    description=field.description
-                )
+                    description=field.description)
             field_name = field.name or self.get_name(name)
             fields[field_name] = _field
         return fields
@@ -275,7 +273,8 @@ def get_resolver_for_type(self, type, name, default_value):
             for interface in type._meta.interfaces:
                 if name not in interface._meta.fields:
                     continue
-                interface_resolver = getattr(interface, 'resolve_{}'.format(name), None)
+                interface_resolver = getattr(interface,
+                                             'resolve_{}'.format(name), None)
                 if interface_resolver:
                     break
             resolver = interface_resolver
@@ -284,7 +283,8 @@ def get_resolver_for_type(self, type, name, default_value):
         if resolver:
             return get_unbound_function(resolver)
 
-        default_resolver = type._meta.default_resolver or get_default_resolver()
+        default_resolver = type._meta.default_resolver or get_default_resolver(
+        )
         return partial(default_resolver, name, default_value)
 
     def get_field_type(self, map, type):