graphql-python / graphene-mongo / 387

pending completion

Build # 387

Build Type

Pull #156

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/graphql-python/graphene-mongo/commit/<a class=hub.com/graphql-python/graphene-mongo/commit/50b7bbf6ac22f459990a57c83405f4916c478e66">50b7bbf6a<a href="https://github.com/graphql-python/graphene-mongo/commit/50b7bbf6ac22f459990a57c83405f4916c478e66">">Merge </a><a class="double-link" href="https://github.com/graphql-python/graphene-mongo/commit/<a class="double-link" href="https://github.com/graphql-python/graphene-mongo/commit/3b443754e66d39cbd55ddadd90afc2c36110f294">3b443754e</a>">3b443754e</a><a href="https://github.com/graphql-python/graphene-mongo/commit/50b7bbf6ac22f459990a57c83405f4916c478e66"> into 7ca0925bd">7ca0925bd</a>

Pull Request Pull Request #156: Feat retrieving queried fields only

Run Details

48 of 48 new or added lines in 3 files covered. (100.0%)

489 of 519 relevant lines covered (94.22%)

0.94 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

80.72

/graphene_mongo/utils.py

from __future__ import unicode_literals

import inspect
from collections import OrderedDict

import mongoengine
from graphene import Node
from graphene.utils.trim_docstring import trim_docstring
from graphql.utils.ast_to_dict import ast_to_dict


def get_model_fields(model, excluding=None):
    excluding = excluding or []
    attributes = dict()
    for attr_name, attr in model._fields.items():
        if attr_name in excluding:
            continue
        attributes[attr_name] = attr
    return OrderedDict(sorted(attributes.items()))


def get_model_reference_fields(model, excluding=None):
    excluding = excluding or []
    attributes = dict()
    for attr_name, attr in model._fields.items():
        if attr_name in excluding or not isinstance(
                attr,
                (mongoengine.fields.ReferenceField, mongoengine.fields.LazyReferenceField),
        ):
            continue
        attributes[attr_name] = attr
    return attributes


def is_valid_mongoengine_model(model):
    return inspect.isclass(model) and (
            issubclass(model, mongoengine.Document)
            or issubclass(model, mongoengine.EmbeddedDocument)
    )


def import_single_dispatch():
    try:
        from functools import singledispatch
    except ImportError:
        singledispatch = None

    if not singledispatch:
        try:
            from singledispatch import singledispatch
        except ImportError:
            pass

    if not singledispatch:
        raise Exception(
            "It seems your python version does not include "
            "functools.singledispatch. Please install the 'singledispatch' "
            "package. More information here: "
            "https://pypi.python.org/pypi/singledispatch"
        )

    return singledispatch


# noqa
def get_type_for_document(schema, document):
    types = schema.types.values()
    for _type in types:
        type_document = hasattr(_type, "_meta") and getattr(
            _type._meta, "document", None
        )
        if document == type_document:
            return _type


def get_field_description(field, registry=None):
    """
    Common metadata includes verbose_name and help_text.

    http://docs.mongoengine.org/apireference.html#fields
    """
    parts = []
    if hasattr(field, "document_type"):
        doc = trim_docstring(field.document_type.__doc__)
        if doc:
            parts.append(doc)
    if hasattr(field, "verbose_name"):
        parts.append(field.verbose_name.title())
    if hasattr(field, "help_text"):
        parts.append(field.help_text)
    if field.db_field != field.name:
        name_format = "(%s)" if parts else "%s"
        parts.append(name_format % field.db_field)

    return "\n".join(parts)


def get_node_from_global_id(node, info, global_id):
    try:
        for interface in node._meta.interfaces:
            if issubclass(interface, Node):
                return interface.get_node_from_global_id(info, global_id)
    except AttributeError:
        return Node.get_node_from_global_id(info, global_id)


def collect_query_fields(node, fragments):
    """Recursively collects fields from the AST

    Args:
        node (dict): A node in the AST
        fragments (dict): Fragment definitions

    Returns:
        A dict mapping each field found, along with their sub fields.
        {
            'name': {},
            'image': {
                        'id': {},
                        'name': {},
                        'description': {}
                    },
            'slug': {}
        }
    """

    field = {}

    if node.get('selection_set'):
        for leaf in node['selection_set']['selections']:
            if leaf['kind'] == 'Field':
                field.update({
                    leaf['name']['value']: collect_query_fields(leaf, fragments)
                })
            elif leaf['kind'] == 'FragmentSpread':
                field.update(collect_query_fields(fragments[leaf['name']['value']],
                                                  fragments))

    return field


def get_query_fields(info):
    """A convenience function to call collect_query_fields with info

    Args:
        info (ResolveInfo)

    Returns:
        dict: Returned from collect_query_fields
    """

    fragments = {}
    node = ast_to_dict(info.field_asts[0])

    for name, value in info.fragments.items():
        fragments[name] = ast_to_dict(value)

    query = collect_query_fields(node, fragments)
    if "edges" in query:
        return query["edges"]["node"].keys()
    return query

1	from __future__ import unicode_literals	1✔
2
3	import inspect	1✔
4	from collections import OrderedDict	1✔
5
6	import mongoengine	1✔
7	from graphene import Node	1✔
8	from graphene.utils.trim_docstring import trim_docstring	1✔
9	from graphql.utils.ast_to_dict import ast_to_dict	1✔
10
11
12	def get_model_fields(model, excluding=None):	1✔
13	excluding = excluding or []	1✔
14	attributes = dict()	1✔
15	for attr_name, attr in model._fields.items():	1✔
16	if attr_name in excluding:	1✔
17	continue	1✔
18	attributes[attr_name] = attr	1✔
19	return OrderedDict(sorted(attributes.items()))	1✔
20
21
22	def get_model_reference_fields(model, excluding=None):	1✔
23	excluding = excluding or []	1✔
24	attributes = dict()	1✔
25	for attr_name, attr in model._fields.items():	1✔
26	if attr_name in excluding or not isinstance(	1✔
27	attr,
28	(mongoengine.fields.ReferenceField, mongoengine.fields.LazyReferenceField),
29	):
30	continue	1✔
31	attributes[attr_name] = attr	1✔
32	return attributes	1✔
33
34
35	def is_valid_mongoengine_model(model):	1✔
36	return inspect.isclass(model) and (	1✔
37	issubclass(model, mongoengine.Document)
38	or issubclass(model, mongoengine.EmbeddedDocument)
39	)
40
41
42	def import_single_dispatch():	1✔
43	try:	1✔
44	from functools import singledispatch	1✔
45	except ImportError:	×
46	singledispatch = None	×
47
48	if not singledispatch:	1✔
49	try:	×
50	from singledispatch import singledispatch	×
51	except ImportError:	×
52	pass	×
53
54	if not singledispatch:	1✔
55	raise Exception(	×
56	"It seems your python version does not include "
57	"functools.singledispatch. Please install the 'singledispatch' "
58	"package. More information here: "
59	"https://pypi.python.org/pypi/singledispatch"
60	)
61
62	return singledispatch	1✔
63
64
65	# noqa
66	def get_type_for_document(schema, document):	1✔
67	types = schema.types.values()	×
68	for _type in types:	×
69	type_document = hasattr(_type, "_meta") and getattr(	×
70	_type._meta, "document", None
71	)
72	if document == type_document:	×
73	return _type	×
74
75
76	def get_field_description(field, registry=None):	1✔
77	"""
78	Common metadata includes verbose_name and help_text.
79
80	http://docs.mongoengine.org/apireference.html#fields
81	"""
82	parts = []	1✔
83	if hasattr(field, "document_type"):	1✔
84	doc = trim_docstring(field.document_type.__doc__)	1✔
85	if doc:	1✔
86	parts.append(doc)	1✔
87	if hasattr(field, "verbose_name"):	1✔
88	parts.append(field.verbose_name.title())	1✔
89	if hasattr(field, "help_text"):	1✔
90	parts.append(field.help_text)	1✔
91	if field.db_field != field.name:	1✔
92	name_format = "(%s)" if parts else "%s"	1✔
93	parts.append(name_format % field.db_field)	1✔
94
95	return "\n".join(parts)	1✔
96
97
98	def get_node_from_global_id(node, info, global_id):	1✔
99	try:	1✔
100	for interface in node._meta.interfaces:	1✔
101	if issubclass(interface, Node):	×
102	return interface.get_node_from_global_id(info, global_id)	×
103	except AttributeError:	1✔
104	return Node.get_node_from_global_id(info, global_id)	1✔
105
106
107	def collect_query_fields(node, fragments):	1✔
108	"""Recursively collects fields from the AST
109
110	Args:
111	node (dict): A node in the AST
112	fragments (dict): Fragment definitions
113
114	Returns:
115	A dict mapping each field found, along with their sub fields.
116	{
117	'name': {},
118	'image': {
119	'id': {},
120	'name': {},
121	'description': {}
122	},
123	'slug': {}
124	}
125	"""
126
127	field = {}	1✔
128
129	if node.get('selection_set'):	1✔
130	for leaf in node['selection_set']['selections']:	1✔
131	if leaf['kind'] == 'Field':	1✔
132	field.update({	1✔
133	leaf['name']['value']: collect_query_fields(leaf, fragments)
134	})
135	elif leaf['kind'] == 'FragmentSpread':	1✔
136	field.update(collect_query_fields(fragments[leaf['name']['value']],	×
137	fragments))
138
139	return field	1✔
140
141
142	def get_query_fields(info):	1✔
143	"""A convenience function to call collect_query_fields with info
144
145	Args:
146	info (ResolveInfo)
147
148	Returns:
149	dict: Returned from collect_query_fields
150	"""
151
152	fragments = {}	1✔
153	node = ast_to_dict(info.field_asts[0])	1✔
154
155	for name, value in info.fragments.items():	1✔
156	fragments[name] = ast_to_dict(value)	×
157
158	query = collect_query_fields(node, fragments)	1✔
159	if "edges" in query:	1✔
160	return query["edges"]["node"].keys()	1✔
161	return query	1✔

graphql-python / graphene-mongo / 387

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous