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