16775575630

Committed 06 Aug 2025 11:25AM UTC coverage: 97.364% (-0.02%) from 97.386%

Build # 16775575630

Build Type

push

github

Committed by

matti-lamppu

Commit Message

Bump version to 0.0.19

Run Details

1719 of 1777 branches covered (96.74%)

Branch coverage included in aggregate %.

27348 of 28077 relevant lines covered (97.4%)

8.76 hits per line

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

97.38

/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)
    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)

    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)


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

MrThearMan / undine / 16775575630

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