17680768688

Committed 12 Sep 2025 04:49PM UTC coverage: 96.866% (-0.5%) from 97.325%

Build # 17680768688

Build Type

push

github

Committed by

MrThearMan

Commit Message

Update CI templates

Coverage Stats

1805 of 1907 branches covered (94.65%)

Branch coverage included in aggregate %.

29687 of 30604 relevant lines covered (97.0%)

2.91 hits per line

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

98.6

/tests/test_entrypoint/test_query.py

from __future__ import annotations

from inspect import cleandoc

import pytest
from graphql import (
    DirectiveLocation,
    GraphQLArgument,
    GraphQLEnumType,
    GraphQLInputObjectType,
    GraphQLInt,
    GraphQLList,
    GraphQLNonNull,
    GraphQLObjectType,
    GraphQLString,
)

from example_project.app.models import Task
from undine import Entrypoint, FilterSet, GQLInfo, OrderSet, QueryType, RootType
from undine.directives import Directive, DirectiveArgument
from undine.exceptions import MissingEntrypointRefError
from undine.optimizer.optimizer import optimize_sync
from undine.resolvers import EntrypointFunctionResolver, QueryTypeManyResolver, QueryTypeSingleResolver


def test_entrypoint__missing_reference() -> None:
    with pytest.raises(MissingEntrypointRefError):

        class Query(RootType):
            foo = Entrypoint()


def test_entrypoint__description_in_entrypoint() -> None:
    class TaskType(QueryType[Task]):
        """Description."""

    class Query(RootType):
        foo = Entrypoint(TaskType, description="Actual description.")

    assert Query.foo.description == "Actual description."


def test_entrypoint__deprecation_reason() -> None:
    class TaskType(QueryType[Task]): ...

    class Query(RootType):
        foo = Entrypoint(TaskType, deprecation_reason="Use something else.")

    assert Query.foo.deprecation_reason == "Use something else."


def test_entrypoint__query_type__repr() -> None:
    class TaskType(QueryType[Task]):
        """Description."""

    class Query(RootType):
        task = Entrypoint(TaskType)

    assert repr(Query.task) == f"<undine.entrypoint.Entrypoint(ref={TaskType!r})>"


def test_entrypoint__query_type__str() -> None:
    class TaskType(QueryType[Task]): ...

    class Query(RootType):
        task = Entrypoint(TaskType)

    assert str(Query.task) == cleandoc(
        """
        task(
          pk: Int!
        ): TaskType!
        """
    )


def test_entrypoint__query_type__attributes() -> None:
    class TaskType(QueryType[Task]):
        """Description."""

    class Query(RootType):
        task = Entrypoint(TaskType)

    assert Query.task.ref == TaskType
    assert Query.task.many is False
    assert Query.task.description == "Description."
    assert Query.task.deprecation_reason is None
    assert Query.task.extensions == {"undine_entrypoint": Query.task}
    assert Query.task.root_type == Query
    assert Query.task.name == "task"


def test_entrypoint__query_type__get_field_type() -> None:
    class TaskType(QueryType[Task]):
        """Description."""

    class Query(RootType):
        task = Entrypoint(TaskType)

    field_type = Query.task.get_field_type()
    assert isinstance(field_type, GraphQLNonNull)
    assert isinstance(field_type.of_type, GraphQLObjectType)


def test_entrypoint__query_type__get_field_arguments() -> None:
    class TaskType(QueryType[Task]):
        """Description."""

    class Query(RootType):
        task = Entrypoint(TaskType)

    arguments = Query.task.get_field_arguments()

    assert arguments == {"pk": GraphQLArgument(GraphQLNonNull(GraphQLInt), out_name="pk")}


def test_entrypoint__query_type__get_resolver() -> None:
    class TaskType(QueryType[Task]):
        """Description."""

    class Query(RootType):
        task = Entrypoint(TaskType)

    resolver = Query.task.get_resolver()
    assert isinstance(resolver, QueryTypeSingleResolver)


def test_entrypoint__query_type__as_graphql_field() -> None:
    class TaskType(QueryType[Task]):
        """Description."""

    class Query(RootType):
        task = Entrypoint(TaskType)

    graphql_field = Query.task.as_graphql_field()

    assert isinstance(graphql_field.type, GraphQLNonNull)
    assert isinstance(graphql_field.type.of_type, GraphQLObjectType)

    assert graphql_field.args == {"pk": GraphQLArgument(GraphQLNonNull(GraphQLInt), out_name="pk")}
    assert isinstance(graphql_field.resolve, QueryTypeSingleResolver)
    assert graphql_field.description == "Description."
    assert graphql_field.deprecation_reason is None
    assert graphql_field.extensions == {"undine_entrypoint": Query.task}


def test_entrypoint__query_type__many__attributes() -> None:
    class TaskType(QueryType[Task]):
        """Description."""

    class Query(RootType):
        task = Entrypoint(TaskType, many=True)

    assert Query.task.ref == TaskType
    assert Query.task.many is True
    assert Query.task.description == "Description."
    assert Query.task.deprecation_reason is None
    assert Query.task.extensions == {"undine_entrypoint": Query.task}
    assert Query.task.root_type == Query
    assert Query.task.name == "task"


def test_entrypoint__query_type__many__get_field_type() -> None:
    class TaskType(QueryType[Task]):
        """Description."""

    class Query(RootType):
        task = Entrypoint(TaskType, many=True)

    field_type = Query.task.get_field_type()
    assert isinstance(field_type, GraphQLNonNull)
    assert isinstance(field_type.of_type, GraphQLList)
    assert isinstance(field_type.of_type.of_type, GraphQLNonNull)
    assert isinstance(field_type.of_type.of_type.of_type, GraphQLObjectType)


def test_entrypoint__query_type__many__get_field_arguments() -> None:
    class TaskFilterSet(FilterSet[Task]): ...

    class TaskOrderSet(OrderSet[Task]): ...

    class TaskType(QueryType[Task], filterset=TaskFilterSet, orderset=TaskOrderSet):
        """Description."""

    class Query(RootType):
        task = Entrypoint(TaskType, many=True)

    arguments = Query.task.get_field_arguments()
    assert sorted(arguments) == ["filter", "orderBy"]

    assert isinstance(arguments["filter"], GraphQLArgument)
    assert isinstance(arguments["filter"].type, GraphQLInputObjectType)

    assert isinstance(arguments["orderBy"], GraphQLArgument)
    assert isinstance(arguments["orderBy"].type, GraphQLList)
    assert isinstance(arguments["orderBy"].type.of_type, GraphQLNonNull)
    assert isinstance(arguments["orderBy"].type.of_type.of_type, GraphQLEnumType)


def test_entrypoint__query_type__many__get_resolver() -> None:
    class TaskType(QueryType[Task]): ...

    class Query(RootType):
        task = Entrypoint(TaskType, many=True)

    resolver = Query.task.get_resolver()
    assert isinstance(resolver, QueryTypeManyResolver)


def test_entrypoint__query_type__custom_resolver() -> None:
    class TaskType(QueryType[Task]): ...

    class Query(RootType):
        task = Entrypoint(TaskType)

        @task.resolve
        def resolve_task(self, info: GQLInfo, name: str) -> list[Task]:
            qs = Task.objects.filter(name__icontains=name)
            return optimize_sync(qs, info)

    resolver = Query.task.get_resolver()
    assert isinstance(resolver, EntrypointFunctionResolver)

    args = Query.task.get_field_arguments()
    assert args == {"name": GraphQLArgument(GraphQLNonNull(GraphQLString), out_name="name")}


def test_entrypoint__query_type__directive() -> None:
    class ValueDirective(Directive, locations=[DirectiveLocation.FIELD_DEFINITION], schema_name="value"):
        value = DirectiveArgument(GraphQLNonNull(GraphQLString))

    class TaskType(QueryType[Task]): ...

    class Query(RootType):
        task = Entrypoint(TaskType) @ ValueDirective(value="foo")

    assert Query.task.directives == [ValueDirective(value="foo")]

    assert str(Query) == cleandoc(
        """
        type Query {
          task(
            pk: Int!
          ): TaskType! @value(value: "foo")
        }
        """
    )

1	from __future__ import annotations	3✔
2
3	from inspect import cleandoc	3✔
4
5	import pytest	3✔
6	from graphql import (	3✔
7	DirectiveLocation,
8	GraphQLArgument,
9	GraphQLEnumType,
10	GraphQLInputObjectType,
11	GraphQLInt,
12	GraphQLList,
13	GraphQLNonNull,
14	GraphQLObjectType,
15	GraphQLString,
16	)
17
18	from example_project.app.models import Task	3✔
19	from undine import Entrypoint, FilterSet, GQLInfo, OrderSet, QueryType, RootType	3✔
20	from undine.directives import Directive, DirectiveArgument	3✔
21	from undine.exceptions import MissingEntrypointRefError	3✔
22	from undine.optimizer.optimizer import optimize_sync	3✔
23	from undine.resolvers import EntrypointFunctionResolver, QueryTypeManyResolver, QueryTypeSingleResolver	3✔
24
25
26	def test_entrypoint__missing_reference() -> None:	3✔
27	with pytest.raises(MissingEntrypointRefError):	3✔
28
29	class Query(RootType):	3✔
30	foo = Entrypoint()	3✔
31
32
33	def test_entrypoint__description_in_entrypoint() -> None:	3✔
34	class TaskType(QueryType[Task]):	3✔
35	"""Description."""
36
37	class Query(RootType):	3✔
38	foo = Entrypoint(TaskType, description="Actual description.")	3✔
39
40	assert Query.foo.description == "Actual description."	3✔
41
42
43	def test_entrypoint__deprecation_reason() -> None:	3✔
44	class TaskType(QueryType[Task]): ...	3✔
45
46	class Query(RootType):	3✔
47	foo = Entrypoint(TaskType, deprecation_reason="Use something else.")	3✔
48
49	assert Query.foo.deprecation_reason == "Use something else."	3✔
50
51
52	def test_entrypoint__query_type__repr() -> None:	3✔
53	class TaskType(QueryType[Task]):	3✔
54	"""Description."""
55
56	class Query(RootType):	3✔
57	task = Entrypoint(TaskType)	3✔
58
59	assert repr(Query.task) == f"<undine.entrypoint.Entrypoint(ref={TaskType!r})>"	3✔
60
61
62	def test_entrypoint__query_type__str() -> None:	3✔
63	class TaskType(QueryType[Task]): ...	3✔
64
65	class Query(RootType):	3✔
66	task = Entrypoint(TaskType)	3✔
67
68	assert str(Query.task) == cleandoc(	3✔
69	"""
70	task(
71	pk: Int!
72	): TaskType!
73	"""
74	)
75
76
77	def test_entrypoint__query_type__attributes() -> None:	3✔
78	class TaskType(QueryType[Task]):	3✔
79	"""Description."""
80
81	class Query(RootType):	3✔
82	task = Entrypoint(TaskType)	3✔
83
84	assert Query.task.ref == TaskType	3✔
85	assert Query.task.many is False	3✔
86	assert Query.task.description == "Description."	3✔
87	assert Query.task.deprecation_reason is None	3✔
88	assert Query.task.extensions == {"undine_entrypoint": Query.task}	3✔
89	assert Query.task.root_type == Query	3✔
90	assert Query.task.name == "task"	3✔
91
92
93	def test_entrypoint__query_type__get_field_type() -> None:	3✔
94	class TaskType(QueryType[Task]):	3✔
95	"""Description."""
96
97	class Query(RootType):	3✔
98	task = Entrypoint(TaskType)	3✔
99
100	field_type = Query.task.get_field_type()	3✔
101	assert isinstance(field_type, GraphQLNonNull)	3✔
102	assert isinstance(field_type.of_type, GraphQLObjectType)	3✔
103
104
105	def test_entrypoint__query_type__get_field_arguments() -> None:	3✔
106	class TaskType(QueryType[Task]):	3✔
107	"""Description."""
108
109	class Query(RootType):	3✔
110	task = Entrypoint(TaskType)	3✔
111
112	arguments = Query.task.get_field_arguments()	3✔
113
114	assert arguments == {"pk": GraphQLArgument(GraphQLNonNull(GraphQLInt), out_name="pk")}	3✔
115
116
117	def test_entrypoint__query_type__get_resolver() -> None:	3✔
118	class TaskType(QueryType[Task]):	3✔
119	"""Description."""
120
121	class Query(RootType):	3✔
122	task = Entrypoint(TaskType)	3✔
123
124	resolver = Query.task.get_resolver()	3✔
125	assert isinstance(resolver, QueryTypeSingleResolver)	3✔
126
127
128	def test_entrypoint__query_type__as_graphql_field() -> None:	3✔
129	class TaskType(QueryType[Task]):	3✔
130	"""Description."""
131
132	class Query(RootType):	3✔
133	task = Entrypoint(TaskType)	3✔
134
135	graphql_field = Query.task.as_graphql_field()	3✔
136
137	assert isinstance(graphql_field.type, GraphQLNonNull)	3✔
138	assert isinstance(graphql_field.type.of_type, GraphQLObjectType)	3✔
139
140	assert graphql_field.args == {"pk": GraphQLArgument(GraphQLNonNull(GraphQLInt), out_name="pk")}	3✔
141	assert isinstance(graphql_field.resolve, QueryTypeSingleResolver)	3✔
142	assert graphql_field.description == "Description."	3✔
143	assert graphql_field.deprecation_reason is None	3✔
144	assert graphql_field.extensions == {"undine_entrypoint": Query.task}	3✔
145
146
147	def test_entrypoint__query_type__many__attributes() -> None:	3✔
148	class TaskType(QueryType[Task]):	3✔
149	"""Description."""
150
151	class Query(RootType):	3✔
152	task = Entrypoint(TaskType, many=True)	3✔
153
154	assert Query.task.ref == TaskType	3✔
155	assert Query.task.many is True	3✔
156	assert Query.task.description == "Description."	3✔
157	assert Query.task.deprecation_reason is None	3✔
158	assert Query.task.extensions == {"undine_entrypoint": Query.task}	3✔
159	assert Query.task.root_type == Query	3✔
160	assert Query.task.name == "task"	3✔
161
162
163	def test_entrypoint__query_type__many__get_field_type() -> None:	3✔
164	class TaskType(QueryType[Task]):	3✔
165	"""Description."""
166
167	class Query(RootType):	3✔
168	task = Entrypoint(TaskType, many=True)	3✔
169
170	field_type = Query.task.get_field_type()	3✔
171	assert isinstance(field_type, GraphQLNonNull)	3✔
172	assert isinstance(field_type.of_type, GraphQLList)	3✔
173	assert isinstance(field_type.of_type.of_type, GraphQLNonNull)	3✔
174	assert isinstance(field_type.of_type.of_type.of_type, GraphQLObjectType)	3✔
175
176
177	def test_entrypoint__query_type__many__get_field_arguments() -> None:	3✔
178	class TaskFilterSet(FilterSet[Task]): ...	3✔
179
180	class TaskOrderSet(OrderSet[Task]): ...	3✔
181
182	class TaskType(QueryType[Task], filterset=TaskFilterSet, orderset=TaskOrderSet):	3✔
183	"""Description."""
184
185	class Query(RootType):	3✔
186	task = Entrypoint(TaskType, many=True)	3✔
187
188	arguments = Query.task.get_field_arguments()	3✔
189	assert sorted(arguments) == ["filter", "orderBy"]	3✔
190
191	assert isinstance(arguments["filter"], GraphQLArgument)	3✔
192	assert isinstance(arguments["filter"].type, GraphQLInputObjectType)	3✔
193
194	assert isinstance(arguments["orderBy"], GraphQLArgument)	3✔
195	assert isinstance(arguments["orderBy"].type, GraphQLList)	3✔
196	assert isinstance(arguments["orderBy"].type.of_type, GraphQLNonNull)	3✔
197	assert isinstance(arguments["orderBy"].type.of_type.of_type, GraphQLEnumType)	3✔
198
199
200	def test_entrypoint__query_type__many__get_resolver() -> None:	3✔
201	class TaskType(QueryType[Task]): ...	3✔
202
203	class Query(RootType):	3✔
204	task = Entrypoint(TaskType, many=True)	3✔
205
206	resolver = Query.task.get_resolver()	3✔
207	assert isinstance(resolver, QueryTypeManyResolver)	3✔
208
209
210	def test_entrypoint__query_type__custom_resolver() -> None:	3✔
211	class TaskType(QueryType[Task]): ...	3✔
212
213	class Query(RootType):	3✔
214	task = Entrypoint(TaskType)	3✔
215
216	@task.resolve	3✔
217	def resolve_task(self, info: GQLInfo, name: str) -> list[Task]:	3✔
218	qs = Task.objects.filter(name__icontains=name)	×
219	return optimize_sync(qs, info)	×
220
221	resolver = Query.task.get_resolver()	3✔
222	assert isinstance(resolver, EntrypointFunctionResolver)	3✔
223
224	args = Query.task.get_field_arguments()	3✔
225	assert args == {"name": GraphQLArgument(GraphQLNonNull(GraphQLString), out_name="name")}	3✔
226
227
228	def test_entrypoint__query_type__directive() -> None:	3✔
229	class ValueDirective(Directive, locations=[DirectiveLocation.FIELD_DEFINITION], schema_name="value"):	3✔
230	value = DirectiveArgument(GraphQLNonNull(GraphQLString))	3✔
231
232	class TaskType(QueryType[Task]): ...	3✔
233
234	class Query(RootType):	3✔
235	task = Entrypoint(TaskType) @ ValueDirective(value="foo")	3✔
236
237	assert Query.task.directives == [ValueDirective(value="foo")]	3✔
238
239	assert str(Query) == cleandoc(	3✔
240	"""
241	type Query {
242	task(
243	pk: Int!
244	): TaskType! @value(value: "foo")
245	}
246	"""
247	)

MrThearMan / undine / 17680768688

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