Debian Codegraph @

tests/async/test_async_queryset.py

raw
1 import json
2 import xml.etree.ElementTree
3 from datetime import datetime
4
5 from asgiref.sync import async_to_sync, sync_to_async
6
7 from django.db import NotSupportedError, connection
8 from django.db.models import Prefetch, Sum
9 from django.test import TestCase, skipIfDBFeature, skipUnlessDBFeature
10
11 from .models import RelatedModel, SimpleModel
12
13
14 class AsyncQuerySetTest(TestCase):
15 @classmethod
16 def setUpTestData(cls):
17 cls.s1 = SimpleModel.objects.create(
18 field=1,
19 created=datetime(2022, 1, 1, 0, 0, 0),
20 )
21 cls.s2 = SimpleModel.objects.create(
22 field=2,
23 created=datetime(2022, 1, 1, 0, 0, 1),
24 )
25 cls.s3 = SimpleModel.objects.create(
26 field=3,
27 created=datetime(2022, 1, 1, 0, 0, 2),
28 )
29 cls.r1 = RelatedModel.objects.create(simple=cls.s1)
30 cls.r2 = RelatedModel.objects.create(simple=cls.s2)
31 cls.r3 = RelatedModel.objects.create(simple=cls.s3)
32
33 @staticmethod
34 def _get_db_feature(connection_, feature_name):
35 # Wrapper to avoid accessing connection attributes until inside
36 # coroutine function. Connection access is thread sensitive and cannot
37 # be passed across sync/async boundaries.
38 return getattr(connection_.features, feature_name)
39
40 async def test_async_iteration(self):
41 results = []
42 async for m in SimpleModel.objects.order_by("pk"):
43 results.append(m)
44 self.assertEqual(results, [self.s1, self.s2, self.s3])
45
46 async def test_aiterator(self):
47 qs = SimpleModel.objects.aiterator()
48 results = []
49 async for m in qs:
50 results.append(m)
51 self.assertCountEqual(results, [self.s1, self.s2, self.s3])
52
53 async def test_aiterator_prefetch_related(self):
54 results = []
55 async for s in SimpleModel.objects.prefetch_related(
56 Prefetch("relatedmodel_set", to_attr="prefetched_relatedmodel")
57 ).aiterator():
58 results.append(s.prefetched_relatedmodel)
59 self.assertCountEqual(results, [[self.r1], [self.r2], [self.r3]])
60
61 async def test_aiterator_invalid_chunk_size(self):
62 msg = "Chunk size must be strictly positive."
63 for size in [0, -1]:
64 qs = SimpleModel.objects.aiterator(chunk_size=size)
65 with self.subTest(size=size), self.assertRaisesMessage(ValueError, msg):
66 async for m in qs:
67 pass
68
69 async def test_acount(self):
70 count = await SimpleModel.objects.acount()
71 self.assertEqual(count, 3)
72
73 async def test_acount_cached_result(self):
74 qs = SimpleModel.objects.all()
75 # Evaluate the queryset to populate the query cache.
76 [x async for x in qs]
77 count = await qs.acount()
78 self.assertEqual(count, 3)
79
80 await sync_to_async(SimpleModel.objects.create)(
81 field=4,
82 created=datetime(2022, 1, 1, 0, 0, 0),
83 )
84 # The query cache is used.
85 count = await qs.acount()
86 self.assertEqual(count, 3)
87
88 async def test_aget(self):
89 instance = await SimpleModel.objects.aget(field=1)
90 self.assertEqual(instance, self.s1)
91
92 async def test_acreate(self):
93 await SimpleModel.objects.acreate(field=4)
94 self.assertEqual(await SimpleModel.objects.acount(), 4)
95
96 async def test_aget_or_create(self):
97 instance, created = await SimpleModel.objects.aget_or_create(field=4)
98 self.assertEqual(await SimpleModel.objects.acount(), 4)
99 self.assertIs(created, True)
100
101 async def test_aupdate_or_create(self):
102 instance, created = await SimpleModel.objects.aupdate_or_create(
103 id=self.s1.id, defaults={"field": 2}
104 )
105 self.assertEqual(instance, self.s1)
106 self.assertEqual(instance.field, 2)
107 self.assertIs(created, False)
108 instance, created = await SimpleModel.objects.aupdate_or_create(field=4)
109 self.assertEqual(await SimpleModel.objects.acount(), 4)
110 self.assertIs(created, True)
111 instance, created = await SimpleModel.objects.aupdate_or_create(
112 field=5, defaults={"field": 7}, create_defaults={"field": 6}
113 )
114 self.assertEqual(await SimpleModel.objects.acount(), 5)
115 self.assertIs(created, True)
116 self.assertEqual(instance.field, 6)
117
118 @skipUnlessDBFeature("has_bulk_insert")
119 @async_to_sync
120 async def test_abulk_create(self):
121 instances = [SimpleModel(field=i) for i in range(10)]
122 qs = await SimpleModel.objects.abulk_create(instances)
123 self.assertEqual(len(qs), 10)
124
125 @skipUnlessDBFeature("has_bulk_insert", "supports_update_conflicts")
126 @skipIfDBFeature("supports_update_conflicts_with_target")
127 @async_to_sync
128 async def test_update_conflicts_unique_field_unsupported(self):
129 msg = (
130 "This database backend does not support updating conflicts with specifying "
131 "unique fields that can trigger the upsert."
132 )
133 with self.assertRaisesMessage(NotSupportedError, msg):
134 await SimpleModel.objects.abulk_create(
135 [SimpleModel(field=1), SimpleModel(field=2)],
136 update_conflicts=True,
137 update_fields=["field"],
138 unique_fields=["created"],
139 )
140
141 async def test_abulk_update(self):
142 instances = SimpleModel.objects.all()
143 async for instance in instances:
144 instance.field = instance.field * 10
145
146 await SimpleModel.objects.abulk_update(instances, ["field"])
147
148 qs = [(o.pk, o.field) async for o in SimpleModel.objects.all()]
149 self.assertCountEqual(
150 qs,
151 [(self.s1.pk, 10), (self.s2.pk, 20), (self.s3.pk, 30)],
152 )
153
154 async def test_ain_bulk(self):
155 res = await SimpleModel.objects.ain_bulk()
156 self.assertEqual(
157 res,
158 {self.s1.pk: self.s1, self.s2.pk: self.s2, self.s3.pk: self.s3},
159 )
160
161 res = await SimpleModel.objects.ain_bulk([self.s2.pk])
162 self.assertEqual(res, {self.s2.pk: self.s2})
163
164 res = await SimpleModel.objects.ain_bulk([self.s2.pk], field_name="id")
165 self.assertEqual(res, {self.s2.pk: self.s2})
166
167 async def test_alatest(self):
168 instance = await SimpleModel.objects.alatest("created")
169 self.assertEqual(instance, self.s3)
170
171 instance = await SimpleModel.objects.alatest("-created")
172 self.assertEqual(instance, self.s1)
173
174 async def test_aearliest(self):
175 instance = await SimpleModel.objects.aearliest("created")
176 self.assertEqual(instance, self.s1)
177
178 instance = await SimpleModel.objects.aearliest("-created")
179 self.assertEqual(instance, self.s3)
180
181 async def test_afirst(self):
182 instance = await SimpleModel.objects.afirst()
183 self.assertEqual(instance, self.s1)
184
185 instance = await SimpleModel.objects.filter(field=4).afirst()
186 self.assertIsNone(instance)
187
188 async def test_alast(self):
189 instance = await SimpleModel.objects.alast()
190 self.assertEqual(instance, self.s3)
191
192 instance = await SimpleModel.objects.filter(field=4).alast()
193 self.assertIsNone(instance)
194
195 async def test_aaggregate(self):
196 total = await SimpleModel.objects.aaggregate(total=Sum("field"))
197 self.assertEqual(total, {"total": 6})
198
199 async def test_aexists(self):
200 check = await SimpleModel.objects.filter(field=1).aexists()
201 self.assertIs(check, True)
202
203 check = await SimpleModel.objects.filter(field=4).aexists()
204 self.assertIs(check, False)
205
206 async def test_acontains(self):
207 check = await SimpleModel.objects.acontains(self.s1)
208 self.assertIs(check, True)
209 # Unsaved instances are not allowed, so use an ID known not to exist.
210 check = await SimpleModel.objects.acontains(
211 SimpleModel(id=self.s3.id + 1, field=4)
212 )
213 self.assertIs(check, False)
214
215 async def test_aupdate(self):
216 await SimpleModel.objects.aupdate(field=99)
217 qs = [o async for o in SimpleModel.objects.all()]
218 values = [instance.field for instance in qs]
219 self.assertEqual(set(values), {99})
220
221 async def test_adelete(self):
222 await SimpleModel.objects.filter(field=2).adelete()
223 qs = [o async for o in SimpleModel.objects.all()]
224 self.assertCountEqual(qs, [self.s1, self.s3])
225
226 @skipUnlessDBFeature("supports_explaining_query_execution")
227 @async_to_sync
228 async def test_aexplain(self):
229 supported_formats = await sync_to_async(self._get_db_feature)(
230 connection, "supported_explain_formats"
231 )
232 all_formats = (None, *supported_formats)
233 for format_ in all_formats:
234 with self.subTest(format=format_):
235 # TODO: Check the captured query when async versions of
236 # self.assertNumQueries/CaptureQueriesContext context
237 # processors are available.
238 result = await SimpleModel.objects.filter(field=1).aexplain(
239 format=format_
240 )
241 self.assertIsInstance(result, str)
242 self.assertTrue(result)
243 if not format_:
244 continue
245 if format_.lower() == "xml":
246 try:
247 xml.etree.ElementTree.fromstring(result)
248 except xml.etree.ElementTree.ParseError as e:
249 self.fail(f"QuerySet.aexplain() result is not valid XML: {e}")
250 elif format_.lower() == "json":
251 try:
252 json.loads(result)
253 except json.JSONDecodeError as e:
254 self.fail(f"QuerySet.aexplain() result is not valid JSON: {e}")
255
256 async def test_raw(self):
257 sql = "SELECT id, field FROM async_simplemodel WHERE created=%s"
258 qs = SimpleModel.objects.raw(sql, [self.s1.created])
259 self.assertEqual([o async for o in qs], [self.s1])