Debian Codegraph @

tests/model_fields/test_uuid.py

raw
1 import json
2 import uuid
3
4 from django.core import exceptions, serializers
5 from django.db import IntegrityError, connection, models
6 from django.db.models import CharField, F, Value
7 from django.db.models.functions import Concat, Repeat
8 from django.test import (
9 SimpleTestCase,
10 TestCase,
11 TransactionTestCase,
12 skipUnlessDBFeature,
13 )
14
15 from .models import (
16 NullableUUIDModel,
17 PrimaryKeyUUIDModel,
18 RelatedToUUIDModel,
19 UUIDGrandchild,
20 UUIDModel,
21 )
22
23
24 class TestSaveLoad(TestCase):
25 def test_uuid_instance(self):
26 instance = UUIDModel.objects.create(field=uuid.uuid4())
27 loaded = UUIDModel.objects.get()
28 self.assertEqual(loaded.field, instance.field)
29
30 def test_str_instance_no_hyphens(self):
31 UUIDModel.objects.create(field="550e8400e29b41d4a716446655440000")
32 loaded = UUIDModel.objects.get()
33 self.assertEqual(loaded.field, uuid.UUID("550e8400e29b41d4a716446655440000"))
34
35 def test_str_instance_hyphens(self):
36 UUIDModel.objects.create(field="550e8400-e29b-41d4-a716-446655440000")
37 loaded = UUIDModel.objects.get()
38 self.assertEqual(loaded.field, uuid.UUID("550e8400e29b41d4a716446655440000"))
39
40 def test_str_instance_bad_hyphens(self):
41 UUIDModel.objects.create(field="550e84-00-e29b-41d4-a716-4-466-55440000")
42 loaded = UUIDModel.objects.get()
43 self.assertEqual(loaded.field, uuid.UUID("550e8400e29b41d4a716446655440000"))
44
45 def test_null_handling(self):
46 NullableUUIDModel.objects.create(field=None)
47 loaded = NullableUUIDModel.objects.get()
48 self.assertIsNone(loaded.field)
49
50 def test_pk_validated(self):
51 with self.assertRaisesMessage(
52 exceptions.ValidationError, "is not a valid UUID"
53 ):
54 PrimaryKeyUUIDModel.objects.get(pk={})
55
56 with self.assertRaisesMessage(
57 exceptions.ValidationError, "is not a valid UUID"
58 ):
59 PrimaryKeyUUIDModel.objects.get(pk=[])
60
61 def test_wrong_value(self):
62 with self.assertRaisesMessage(
63 exceptions.ValidationError, "is not a valid UUID"
64 ):
65 UUIDModel.objects.get(field="not-a-uuid")
66
67 with self.assertRaisesMessage(
68 exceptions.ValidationError, "is not a valid UUID"
69 ):
70 UUIDModel.objects.create(field="not-a-uuid")
71
72
73 class TestMethods(SimpleTestCase):
74 def test_deconstruct(self):
75 field = models.UUIDField()
76 name, path, args, kwargs = field.deconstruct()
77 self.assertEqual(kwargs, {})
78
79 def test_to_python(self):
80 self.assertIsNone(models.UUIDField().to_python(None))
81
82 def test_to_python_int_values(self):
83 self.assertEqual(
84 models.UUIDField().to_python(0),
85 uuid.UUID("00000000-0000-0000-0000-000000000000"),
86 )
87 # Works for integers less than 128 bits.
88 self.assertEqual(
89 models.UUIDField().to_python((2**128) - 1),
90 uuid.UUID("ffffffff-ffff-ffff-ffff-ffffffffffff"),
91 )
92
93 def test_to_python_int_too_large(self):
94 # Fails for integers larger than 128 bits.
95 with self.assertRaises(exceptions.ValidationError):
96 models.UUIDField().to_python(2**128)
97
98
99 class TestQuerying(TestCase):
100 @classmethod
101 def setUpTestData(cls):
102 cls.objs = [
103 NullableUUIDModel.objects.create(
104 field=uuid.UUID("25d405be-4895-4d50-9b2e-d6695359ce47"),
105 ),
106 NullableUUIDModel.objects.create(field="550e8400e29b41d4a716446655440000"),
107 NullableUUIDModel.objects.create(field=None),
108 ]
109
110 def assertSequenceEqualWithoutHyphens(self, qs, result):
111 """
112 Backends with a native datatype for UUID don't support fragment lookups
113 without hyphens because they store values with them.
114 """
115 self.assertSequenceEqual(
116 qs,
117 [] if connection.features.has_native_uuid_field else result,
118 )
119
120 def test_exact(self):
121 self.assertSequenceEqual(
122 NullableUUIDModel.objects.filter(
123 field__exact="550e8400e29b41d4a716446655440000"
124 ),
125 [self.objs[1]],
126 )
127 self.assertSequenceEqual(
128 NullableUUIDModel.objects.filter(
129 field__exact="550e8400-e29b-41d4-a716-446655440000"
130 ),
131 [self.objs[1]],
132 )
133
134 def test_iexact(self):
135 self.assertSequenceEqualWithoutHyphens(
136 NullableUUIDModel.objects.filter(
137 field__iexact="550E8400E29B41D4A716446655440000"
138 ),
139 [self.objs[1]],
140 )
141 self.assertSequenceEqual(
142 NullableUUIDModel.objects.filter(
143 field__iexact="550E8400-E29B-41D4-A716-446655440000"
144 ),
145 [self.objs[1]],
146 )
147
148 def test_isnull(self):
149 self.assertSequenceEqual(
150 NullableUUIDModel.objects.filter(field__isnull=True), [self.objs[2]]
151 )
152
153 def test_contains(self):
154 self.assertSequenceEqualWithoutHyphens(
155 NullableUUIDModel.objects.filter(field__contains="8400e29b"),
156 [self.objs[1]],
157 )
158 self.assertSequenceEqual(
159 NullableUUIDModel.objects.filter(field__contains="8400-e29b"),
160 [self.objs[1]],
161 )
162
163 def test_icontains(self):
164 self.assertSequenceEqualWithoutHyphens(
165 NullableUUIDModel.objects.filter(field__icontains="8400E29B"),
166 [self.objs[1]],
167 )
168 self.assertSequenceEqual(
169 NullableUUIDModel.objects.filter(field__icontains="8400-E29B"),
170 [self.objs[1]],
171 )
172
173 def test_startswith(self):
174 self.assertSequenceEqualWithoutHyphens(
175 NullableUUIDModel.objects.filter(field__startswith="550e8400e29b4"),
176 [self.objs[1]],
177 )
178 self.assertSequenceEqual(
179 NullableUUIDModel.objects.filter(field__startswith="550e8400-e29b-4"),
180 [self.objs[1]],
181 )
182
183 def test_istartswith(self):
184 self.assertSequenceEqualWithoutHyphens(
185 NullableUUIDModel.objects.filter(field__istartswith="550E8400E29B4"),
186 [self.objs[1]],
187 )
188 self.assertSequenceEqual(
189 NullableUUIDModel.objects.filter(field__istartswith="550E8400-E29B-4"),
190 [self.objs[1]],
191 )
192
193 def test_endswith(self):
194 self.assertSequenceEqualWithoutHyphens(
195 NullableUUIDModel.objects.filter(field__endswith="a716446655440000"),
196 [self.objs[1]],
197 )
198 self.assertSequenceEqual(
199 NullableUUIDModel.objects.filter(field__endswith="a716-446655440000"),
200 [self.objs[1]],
201 )
202
203 def test_iendswith(self):
204 self.assertSequenceEqualWithoutHyphens(
205 NullableUUIDModel.objects.filter(field__iendswith="A716446655440000"),
206 [self.objs[1]],
207 )
208 self.assertSequenceEqual(
209 NullableUUIDModel.objects.filter(field__iendswith="A716-446655440000"),
210 [self.objs[1]],
211 )
212
213 def test_filter_with_expr(self):
214 self.assertSequenceEqualWithoutHyphens(
215 NullableUUIDModel.objects.annotate(
216 value=Concat(Value("8400"), Value("e29b"), output_field=CharField()),
217 ).filter(field__contains=F("value")),
218 [self.objs[1]],
219 )
220 self.assertSequenceEqual(
221 NullableUUIDModel.objects.annotate(
222 value=Concat(
223 Value("8400"), Value("-"), Value("e29b"), output_field=CharField()
224 ),
225 ).filter(field__contains=F("value")),
226 [self.objs[1]],
227 )
228 self.assertSequenceEqual(
229 NullableUUIDModel.objects.annotate(
230 value=Repeat(Value("0"), 4, output_field=CharField()),
231 ).filter(field__contains=F("value")),
232 [self.objs[1]],
233 )
234
235
236 class TestSerialization(SimpleTestCase):
237 test_data = (
238 '[{"fields": {"field": "550e8400-e29b-41d4-a716-446655440000"}, '
239 '"model": "model_fields.uuidmodel", "pk": null}]'
240 )
241 nullable_test_data = (
242 '[{"fields": {"field": null}, '
243 '"model": "model_fields.nullableuuidmodel", "pk": null}]'
244 )
245
246 def test_dumping(self):
247 instance = UUIDModel(field=uuid.UUID("550e8400e29b41d4a716446655440000"))
248 data = serializers.serialize("json", [instance])
249 self.assertEqual(json.loads(data), json.loads(self.test_data))
250
251 def test_loading(self):
252 instance = list(serializers.deserialize("json", self.test_data))[0].object
253 self.assertEqual(
254 instance.field, uuid.UUID("550e8400-e29b-41d4-a716-446655440000")
255 )
256
257 def test_nullable_loading(self):
258 instance = list(serializers.deserialize("json", self.nullable_test_data))[
259 0
260 ].object
261 self.assertIsNone(instance.field)
262
263
264 class TestValidation(SimpleTestCase):
265 def test_invalid_uuid(self):
266 field = models.UUIDField()
267 with self.assertRaises(exceptions.ValidationError) as cm:
268 field.clean("550e8400", None)
269 self.assertEqual(cm.exception.code, "invalid")
270 self.assertEqual(
271 cm.exception.message % cm.exception.params,
272 "“550e8400” is not a valid UUID.",
273 )
274
275 def test_uuid_instance_ok(self):
276 field = models.UUIDField()
277 field.clean(uuid.uuid4(), None) # no error
278
279
280 class TestAsPrimaryKey(TestCase):
281 def test_creation(self):
282 PrimaryKeyUUIDModel.objects.create()
283 loaded = PrimaryKeyUUIDModel.objects.get()
284 self.assertIsInstance(loaded.pk, uuid.UUID)
285
286 def test_uuid_pk_on_save(self):
287 saved = PrimaryKeyUUIDModel.objects.create(id=None)
288 loaded = PrimaryKeyUUIDModel.objects.get()
289 self.assertIsNotNone(loaded.id, None)
290 self.assertEqual(loaded.id, saved.id)
291
292 def test_uuid_pk_on_bulk_create(self):
293 u1 = PrimaryKeyUUIDModel()
294 u2 = PrimaryKeyUUIDModel(id=None)
295 PrimaryKeyUUIDModel.objects.bulk_create([u1, u2])
296 # The two objects were correctly created.
297 u1_found = PrimaryKeyUUIDModel.objects.filter(id=u1.id).exists()
298 u2_found = PrimaryKeyUUIDModel.objects.exclude(id=u1.id).exists()
299 self.assertTrue(u1_found)
300 self.assertTrue(u2_found)
301 self.assertEqual(PrimaryKeyUUIDModel.objects.count(), 2)
302
303 def test_underlying_field(self):
304 pk_model = PrimaryKeyUUIDModel.objects.create()
305 RelatedToUUIDModel.objects.create(uuid_fk=pk_model)
306 related = RelatedToUUIDModel.objects.get()
307 self.assertEqual(related.uuid_fk.pk, related.uuid_fk_id)
308
309 def test_update_with_related_model_instance(self):
310 # regression for #24611
311 u1 = PrimaryKeyUUIDModel.objects.create()
312 u2 = PrimaryKeyUUIDModel.objects.create()
313 r = RelatedToUUIDModel.objects.create(uuid_fk=u1)
314 RelatedToUUIDModel.objects.update(uuid_fk=u2)
315 r.refresh_from_db()
316 self.assertEqual(r.uuid_fk, u2)
317
318 def test_update_with_related_model_id(self):
319 u1 = PrimaryKeyUUIDModel.objects.create()
320 u2 = PrimaryKeyUUIDModel.objects.create()
321 r = RelatedToUUIDModel.objects.create(uuid_fk=u1)
322 RelatedToUUIDModel.objects.update(uuid_fk=u2.pk)
323 r.refresh_from_db()
324 self.assertEqual(r.uuid_fk, u2)
325
326 def test_two_level_foreign_keys(self):
327 gc = UUIDGrandchild()
328 # exercises ForeignKey.get_db_prep_value()
329 gc.save()
330 self.assertIsInstance(gc.uuidchild_ptr_id, uuid.UUID)
331 gc.refresh_from_db()
332 self.assertIsInstance(gc.uuidchild_ptr_id, uuid.UUID)
333
334
335 class TestAsPrimaryKeyTransactionTests(TransactionTestCase):
336 # Need a TransactionTestCase to avoid deferring FK constraint checking.
337 available_apps = ["model_fields"]
338
339 @skipUnlessDBFeature("supports_foreign_keys")
340 def test_unsaved_fk(self):
341 u1 = PrimaryKeyUUIDModel()
342 with self.assertRaises(IntegrityError):
343 RelatedToUUIDModel.objects.create(uuid_fk=u1)