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

Run Details

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

97.04

/tests/test_testing_client.py

from __future__ import annotations

from copy import deepcopy
from inspect import cleandoc
from typing import Any

import pytest
from _pytest.outcomes import Failed  # noqa: PLC2701
from django.core.files.uploadedfile import InMemoryUploadedFile

from pytest_undine.client import GraphQLClient
from tests.helpers import create_png, exact
from undine import Entrypoint, GQLInfo, RootType, create_schema
from undine.scalars import GraphQLFile


def test_testing_client(undine_settings) -> None:
    class Query(RootType):
        @Entrypoint
        def greeting(self) -> str:
            return "Hello, World!"

    undine_settings.SCHEMA = create_schema(query=Query)

    query = """
        query {
          greeting
        }
    """

    client = GraphQLClient()

    response = client(query, count_queries=True)
    assert response.has_errors is False
    assert response.json == {"data": {"greeting": "Hello, World!"}}
    assert response.data == {"greeting": "Hello, World!"}
    assert response.results == "Hello, World!"

    assert response.queries == []
    assert cleandoc(response.query_log) == cleandoc(
        """
        ---------------------------------------------------------------------------

        >>> Queries: (0)
        """,
    )


def test_testing_client__operation_name(undine_settings) -> None:
    class Query(RootType):
        @Entrypoint
        def greeting(self) -> str:
            return "Hello, World!"

    undine_settings.SCHEMA = create_schema(query=Query)

    query = """
        query Greet {
          greeting
        }
    """

    client = GraphQLClient()

    response = client(query, operation_name="Greet")
    assert response.has_errors is False


def test_testing_client__connection(undine_settings) -> None:
    class Query(RootType):
        @Entrypoint
        def stuff(self) -> dict[str, Any]:
            return {
                "edges": [
                    {"node": {"foo": "bar"}},
                    {"node": {"foo": "baz"}},
                ],
            }

    undine_settings.SCHEMA = create_schema(query=Query)

    query = """
        query {
          stuff
        }
    """

    client = GraphQLClient()

    response = client(query)

    assert response.json == {
        "data": {
            "stuff": {
                "edges": [
                    {"node": {"foo": "bar"}},
                    {"node": {"foo": "baz"}},
                ],
            },
        },
    }
    assert response.data == {
        "stuff": {
            "edges": [
                {"node": {"foo": "bar"}},
                {"node": {"foo": "baz"}},
            ],
        },
    }
    assert response.results == {
        "edges": [
            {"node": {"foo": "bar"}},
            {"node": {"foo": "baz"}},
        ],
    }
    assert response.edges == [
        {"node": {"foo": "bar"}},
        {"node": {"foo": "baz"}},
    ]
    assert response.node(0) == {"foo": "bar"}
    assert response.node(1) == {"foo": "baz"}


def test_testing_client__error(undine_settings) -> None:
    class Query(RootType):
        @Entrypoint
        def greeting(self) -> str:
            return "Hello, World!"

    undine_settings.SCHEMA = create_schema(query=Query)

    query = """
        query {
          hello
        }
    """

    client = GraphQLClient()

    response = client(query)

    assert response.has_errors is True
    assert response.json == {
        "data": None,
        "errors": [
            {
                "message": "Cannot query field 'hello' on type 'Query'.",
                "extensions": {"status_code": 400},
            },
        ],
    }

    assert response.error_message(0) == "Cannot query field 'hello' on type 'Query'."


def test_testing_client__error__no_results(undine_settings) -> None:
    class Query(RootType):
        @Entrypoint
        def greeting(self) -> str:
            return "Hello, World!"

    undine_settings.SCHEMA = create_schema(query=Query)

    query = """
        query {
          hello
        }
    """

    client = GraphQLClient()

    response = client(query)

    msg = f"No query object not found in response content\nContent: {response.json}"
    with pytest.raises(Failed, match=exact(msg)):
        assert response.results


def test_testing_client__error__no_edges(undine_settings) -> None:
    class Query(RootType):
        @Entrypoint
        def greeting(self) -> str:
            return "Hello, World!"

    undine_settings.SCHEMA = create_schema(query=Query)

    query = """
        query {
          greeting
        }
    """

    client = GraphQLClient()

    response = client(query)

    msg = f"Edges not found in response content\nContent: {response.json}"
    with pytest.raises(Failed, match=exact(msg)):
        assert response.edges


def test_testing_client__error__no_node(undine_settings) -> None:
    class Query(RootType):
        @Entrypoint
        def stuff(self) -> dict[str, Any]:
            return {
                "edges": [
                    {"node": {"foo": "bar"}},
                    {"node": {"foo": "baz"}},
                ],
            }

    undine_settings.SCHEMA = create_schema(query=Query)

    query = """
        query {
          stuff
        }
    """

    client = GraphQLClient()

    response = client(query)

    msg = f"Node 3 not found in response content\nContent: {response.json}"
    with pytest.raises(Failed, match=exact(msg)):
        assert response.node(3)


def test_testing_client__error__no_error_message__index(undine_settings) -> None:
    class Query(RootType):
        @Entrypoint
        def greeting(self) -> str:
            return "Hello, World!"

    undine_settings.SCHEMA = create_schema(query=Query)

    query = """
        query {
          hello
        }
    """

    client = GraphQLClient()

    response = client(query)

    msg = f"Errors message not found from index 1\nContent: {response.json}"
    with pytest.raises(Failed, match=exact(msg)):
        assert response.error_message(1)


def test_testing_client__error__no_error_message__path(undine_settings) -> None:
    class Query(RootType):
        @Entrypoint
        def greeting(self) -> str:
            return "Hello, World!"

    undine_settings.SCHEMA = create_schema(query=Query)

    query = """
        query {
          hello
        }
    """

    client = GraphQLClient()

    response = client(query)

    msg = f"Errors message not found from path 'foo'\nContent: {response.json}"
    with pytest.raises(Failed, match=exact(msg)):
        assert response.error_message("foo")


def test_testing_client__assert_query_count(undine_settings) -> None:
    class Query(RootType):
        @Entrypoint
        def greeting(self) -> str:
            return "Hello, World!"

    undine_settings.SCHEMA = create_schema(query=Query)

    query = """
        query {
          hello
        }
    """

    client = GraphQLClient()

    response = client(query, count_queries=True)

    response.assert_query_count(0)

    msg = (
        "Expected 1 queries, got 0.\n"
        "\n"
        "---------------------------------------------------------------------------\n"
        "\n"
        ">>> Queries: (0)"
    )
    with pytest.raises(Failed, match=exact(msg)):
        response.assert_query_count(1)


def test_testing_client__queries_not_counted(undine_settings) -> None:
    class Query(RootType):
        @Entrypoint
        def greeting(self) -> str:
            return "Hello, World!"

    undine_settings.SCHEMA = create_schema(query=Query)

    query = """
        query {
          hello
        }
    """

    client = GraphQLClient()

    response = client(query, count_queries=False)

    msg = (
        "Database queries have not been captured. "
        "Enable them using the `count_queries` parameter when calling the client."
    )
    with pytest.raises(Failed, match=exact(msg)):
        response.assert_query_count(0)


@pytest.mark.django_db
def test_testing_client__login_with_superuser(undine_settings) -> None:
    request_user = None

    class Query(RootType):
        @Entrypoint
        def greeting(self, info: GQLInfo) -> str:
            nonlocal request_user
            request_user = info.context.user
            return "Hello, World!"

    undine_settings.SCHEMA = create_schema(query=Query)

    query = """
        query {
          greeting
        }
    """

    client = GraphQLClient()
    user = client.login_with_superuser()
    assert user.is_superuser is True
    assert user.is_staff is True

    response = client(query)
    assert response.has_errors is False

    assert request_user == user


@pytest.mark.django_db
def test_testing_client__login_with_regular_user(undine_settings) -> None:
    request_user = None

    class Query(RootType):
        @Entrypoint
        def greeting(self, info: GQLInfo) -> str:
            nonlocal request_user
            request_user = info.context.user
            return "Hello, World!"

    undine_settings.SCHEMA = create_schema(query=Query)

    query = """
        query {
          greeting
        }
    """

    client = GraphQLClient()
    user = client.login_with_regular_user()
    assert user.is_superuser is False
    assert user.is_staff is False

    response = client(query)
    assert response.has_errors is False

    assert request_user == user


def test_testing_client__files(undine_settings) -> None:
    captured: InMemoryUploadedFile | None = None

    class Query(RootType):
        @Entrypoint
        def greeting(self, file: GraphQLFile) -> str:
            nonlocal captured
            captured = deepcopy(file)
            return "Hello, World!"

    undine_settings.SCHEMA = create_schema(query=Query)

    png = create_png()
    png_bytes = bytes(png.file.read())
    png.file.seek(0)

    query = """
        query ($file: File!) {
          greeting(file: $file)
        }
    """

    client = GraphQLClient()

    response = client(query, variables={"file": png})
    assert response.has_errors is False

    assert isinstance(captured, InMemoryUploadedFile)
    assert captured.name == "image.png"
    assert captured.size == png.size
    assert captured.content_type == "image/png"
    assert captured.charset is None

    assert bytes(captured.read()) == png_bytes

1	from __future__ import annotations	3✔
2
3	from copy import deepcopy	3✔
4	from inspect import cleandoc	3✔
5	from typing import Any	3✔
6
7	import pytest	3✔
8	from _pytest.outcomes import Failed # noqa: PLC2701	3✔
9	from django.core.files.uploadedfile import InMemoryUploadedFile	3✔
10
11	from pytest_undine.client import GraphQLClient	3✔
12	from tests.helpers import create_png, exact	3✔
13	from undine import Entrypoint, GQLInfo, RootType, create_schema	3✔
14	from undine.scalars import GraphQLFile	3✔
15
16
17	def test_testing_client(undine_settings) -> None:	3✔
18	class Query(RootType):	3✔
19	@Entrypoint	3✔
20	def greeting(self) -> str:	3✔
21	return "Hello, World!"	3✔
22
23	undine_settings.SCHEMA = create_schema(query=Query)	3✔
24
25	query = """	3✔
26	query {
27	greeting
28	}
29	"""
30
31	client = GraphQLClient()	3✔
32
33	response = client(query, count_queries=True)	3✔
34	assert response.has_errors is False	3✔
35	assert response.json == {"data": {"greeting": "Hello, World!"}}	3✔
36	assert response.data == {"greeting": "Hello, World!"}	3✔
37	assert response.results == "Hello, World!"	3✔
38
39	assert response.queries == []	3✔
40	assert cleandoc(response.query_log) == cleandoc(	3✔
41	"""
42	---------------------------------------------------------------------------
43
44	>>> Queries: (0)
45	""",
46	)
47
48
49	def test_testing_client__operation_name(undine_settings) -> None:	3✔
50	class Query(RootType):	3✔
51	@Entrypoint	3✔
52	def greeting(self) -> str:	3✔
53	return "Hello, World!"	3✔
54
55	undine_settings.SCHEMA = create_schema(query=Query)	3✔
56
57	query = """	3✔
58	query Greet {
59	greeting
60	}
61	"""
62
63	client = GraphQLClient()	3✔
64
65	response = client(query, operation_name="Greet")	3✔
66	assert response.has_errors is False	3✔
67
68
69	def test_testing_client__connection(undine_settings) -> None:	3✔
70	class Query(RootType):	3✔
71	@Entrypoint	3✔
72	def stuff(self) -> dict[str, Any]:	3✔
73	return {	3✔
74	"edges": [
75	{"node": {"foo": "bar"}},
76	{"node": {"foo": "baz"}},
77	],
78	}
79
80	undine_settings.SCHEMA = create_schema(query=Query)	3✔
81
82	query = """	3✔
83	query {
84	stuff
85	}
86	"""
87
88	client = GraphQLClient()	3✔
89
90	response = client(query)	3✔
91
92	assert response.json == {	3✔
93	"data": {
94	"stuff": {
95	"edges": [
96	{"node": {"foo": "bar"}},
97	{"node": {"foo": "baz"}},
98	],
99	},
100	},
101	}
102	assert response.data == {	3✔
103	"stuff": {
104	"edges": [
105	{"node": {"foo": "bar"}},
106	{"node": {"foo": "baz"}},
107	],
108	},
109	}
110	assert response.results == {	3✔
111	"edges": [
112	{"node": {"foo": "bar"}},
113	{"node": {"foo": "baz"}},
114	],
115	}
116	assert response.edges == [	3✔
117	{"node": {"foo": "bar"}},
118	{"node": {"foo": "baz"}},
119	]
120	assert response.node(0) == {"foo": "bar"}	3✔
121	assert response.node(1) == {"foo": "baz"}	3✔
122
123
124	def test_testing_client__error(undine_settings) -> None:	3✔
125	class Query(RootType):	3✔
126	@Entrypoint	3✔
127	def greeting(self) -> str:	3✔
128	return "Hello, World!"	×
129
130	undine_settings.SCHEMA = create_schema(query=Query)	3✔
131
132	query = """	3✔
133	query {
134	hello
135	}
136	"""
137
138	client = GraphQLClient()	3✔
139
140	response = client(query)	3✔
141
142	assert response.has_errors is True	3✔
143	assert response.json == {	3✔
144	"data": None,
145	"errors": [
146	{
147	"message": "Cannot query field 'hello' on type 'Query'.",
148	"extensions": {"status_code": 400},
149	},
150	],
151	}
152
153	assert response.error_message(0) == "Cannot query field 'hello' on type 'Query'."	3✔
154
155
156	def test_testing_client__error__no_results(undine_settings) -> None:	3✔
157	class Query(RootType):	3✔
158	@Entrypoint	3✔
159	def greeting(self) -> str:	3✔
160	return "Hello, World!"	×
161
162	undine_settings.SCHEMA = create_schema(query=Query)	3✔
163
164	query = """	3✔
165	query {
166	hello
167	}
168	"""
169
170	client = GraphQLClient()	3✔
171
172	response = client(query)	3✔
173
174	msg = f"No query object not found in response content\nContent: {response.json}"	3✔
175	with pytest.raises(Failed, match=exact(msg)):	3✔
176	assert response.results	3✔
177
178
179	def test_testing_client__error__no_edges(undine_settings) -> None:	3✔
180	class Query(RootType):	3✔
181	@Entrypoint	3✔
182	def greeting(self) -> str:	3✔
183	return "Hello, World!"	3✔
184
185	undine_settings.SCHEMA = create_schema(query=Query)	3✔
186
187	query = """	3✔
188	query {
189	greeting
190	}
191	"""
192
193	client = GraphQLClient()	3✔
194
195	response = client(query)	3✔
196
197	msg = f"Edges not found in response content\nContent: {response.json}"	3✔
198	with pytest.raises(Failed, match=exact(msg)):	3✔
199	assert response.edges	3✔
200
201
202	def test_testing_client__error__no_node(undine_settings) -> None:	3✔
203	class Query(RootType):	3✔
204	@Entrypoint	3✔
205	def stuff(self) -> dict[str, Any]:	3✔
206	return {	3✔
207	"edges": [
208	{"node": {"foo": "bar"}},
209	{"node": {"foo": "baz"}},
210	],
211	}
212
213	undine_settings.SCHEMA = create_schema(query=Query)	3✔
214
215	query = """	3✔
216	query {
217	stuff
218	}
219	"""
220
221	client = GraphQLClient()	3✔
222
223	response = client(query)	3✔
224
225	msg = f"Node 3 not found in response content\nContent: {response.json}"	3✔
226	with pytest.raises(Failed, match=exact(msg)):	3✔
227	assert response.node(3)	3✔
228
229
230	def test_testing_client__error__no_error_message__index(undine_settings) -> None:	3✔
231	class Query(RootType):	3✔
232	@Entrypoint	3✔
233	def greeting(self) -> str:	3✔
234	return "Hello, World!"	×
235
236	undine_settings.SCHEMA = create_schema(query=Query)	3✔
237
238	query = """	3✔
239	query {
240	hello
241	}
242	"""
243
244	client = GraphQLClient()	3✔
245
246	response = client(query)	3✔
247
248	msg = f"Errors message not found from index 1\nContent: {response.json}"	3✔
249	with pytest.raises(Failed, match=exact(msg)):	3✔
250	assert response.error_message(1)	3✔
251
252
253	def test_testing_client__error__no_error_message__path(undine_settings) -> None:	3✔
254	class Query(RootType):	3✔
255	@Entrypoint	3✔
256	def greeting(self) -> str:	3✔
257	return "Hello, World!"	×
258
259	undine_settings.SCHEMA = create_schema(query=Query)	3✔
260
261	query = """	3✔
262	query {
263	hello
264	}
265	"""
266
267	client = GraphQLClient()	3✔
268
269	response = client(query)	3✔
270
271	msg = f"Errors message not found from path 'foo'\nContent: {response.json}"	3✔
272	with pytest.raises(Failed, match=exact(msg)):	3✔
273	assert response.error_message("foo")	3✔
274
275
276	def test_testing_client__assert_query_count(undine_settings) -> None:	3✔
277	class Query(RootType):	3✔
278	@Entrypoint	3✔
279	def greeting(self) -> str:	3✔
280	return "Hello, World!"	×
281
282	undine_settings.SCHEMA = create_schema(query=Query)	3✔
283
284	query = """	3✔
285	query {
286	hello
287	}
288	"""
289
290	client = GraphQLClient()	3✔
291
292	response = client(query, count_queries=True)	3✔
293
294	response.assert_query_count(0)	3✔
295
296	msg = (	3✔
297	"Expected 1 queries, got 0.\n"
298	"\n"
299	"---------------------------------------------------------------------------\n"
300	"\n"
301	">>> Queries: (0)"
302	)
303	with pytest.raises(Failed, match=exact(msg)):	3✔
304	response.assert_query_count(1)	3✔
305
306
307	def test_testing_client__queries_not_counted(undine_settings) -> None:	3✔
308	class Query(RootType):	3✔
309	@Entrypoint	3✔
310	def greeting(self) -> str:	3✔
311	return "Hello, World!"	×
312
313	undine_settings.SCHEMA = create_schema(query=Query)	3✔
314
315	query = """	3✔
316	query {
317	hello
318	}
319	"""
320
321	client = GraphQLClient()	3✔
322
323	response = client(query, count_queries=False)	3✔
324
325	msg = (	3✔
326	"Database queries have not been captured. "
327	"Enable them using the `count_queries` parameter when calling the client."
328	)
329	with pytest.raises(Failed, match=exact(msg)):	3✔
330	response.assert_query_count(0)	3✔
331
332
333	@pytest.mark.django_db	3✔
334	def test_testing_client__login_with_superuser(undine_settings) -> None:	3✔
335	request_user = None	3✔
336
337	class Query(RootType):	3✔
338	@Entrypoint	3✔
339	def greeting(self, info: GQLInfo) -> str:	3✔
340	nonlocal request_user
341	request_user = info.context.user	3✔
342	return "Hello, World!"	3✔
343
344	undine_settings.SCHEMA = create_schema(query=Query)	3✔
345
346	query = """	3✔
347	query {
348	greeting
349	}
350	"""
351
352	client = GraphQLClient()	3✔
353	user = client.login_with_superuser()	3✔
354	assert user.is_superuser is True	3✔
355	assert user.is_staff is True	3✔
356
357	response = client(query)	3✔
358	assert response.has_errors is False	3✔
359
360	assert request_user == user	3✔
361
362
363	@pytest.mark.django_db	3✔
364	def test_testing_client__login_with_regular_user(undine_settings) -> None:	3✔
365	request_user = None	3✔
366
367	class Query(RootType):	3✔
368	@Entrypoint	3✔
369	def greeting(self, info: GQLInfo) -> str:	3✔
370	nonlocal request_user
371	request_user = info.context.user	3✔
372	return "Hello, World!"	3✔
373
374	undine_settings.SCHEMA = create_schema(query=Query)	3✔
375
376	query = """	3✔
377	query {
378	greeting
379	}
380	"""
381
382	client = GraphQLClient()	3✔
383	user = client.login_with_regular_user()	3✔
384	assert user.is_superuser is False	3✔
385	assert user.is_staff is False	3✔
386
387	response = client(query)	3✔
388	assert response.has_errors is False	3✔
389
390	assert request_user == user	3✔
391
392
393	def test_testing_client__files(undine_settings) -> None:	3✔
394	captured: InMemoryUploadedFile \| None = None	3✔
395
396	class Query(RootType):	3✔
397	@Entrypoint	3✔
398	def greeting(self, file: GraphQLFile) -> str:	3✔
399	nonlocal captured
400	captured = deepcopy(file)	3✔
401	return "Hello, World!"	3✔
402
403	undine_settings.SCHEMA = create_schema(query=Query)	3✔
404
405	png = create_png()	3✔
406	png_bytes = bytes(png.file.read())	3✔
407	png.file.seek(0)	3✔
408
409	query = """	3✔
410	query ($file: File!) {
411	greeting(file: $file)
412	}
413	"""
414
415	client = GraphQLClient()	3✔
416
417	response = client(query, variables={"file": png})	3✔
418	assert response.has_errors is False	3✔
419
420	assert isinstance(captured, InMemoryUploadedFile)	3✔
421	assert captured.name == "image.png"	3✔
422	assert captured.size == png.size	3✔
423	assert captured.content_type == "image/png"	3✔
424	assert captured.charset is None	3✔
425
426	assert bytes(captured.read()) == png_bytes	3✔

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