Debian Codegraph @

tests/model_fields/test_generatedfield.py

raw
1 import uuid
2 from decimal import Decimal
3
4 from django.apps import apps
5 from django.core.exceptions import ValidationError
6 from django.db import IntegrityError, connection
7 from django.db.models import (
8 CharField,
9 F,
10 FloatField,
11 GeneratedField,
12 IntegerField,
13 Model,
14 )
15 from django.db.models.functions import Lower
16 from django.test import SimpleTestCase, TestCase, skipUnlessDBFeature
17 from django.test.utils import isolate_apps
18
19 from .models import (
20 Foo,
21 GeneratedModel,
22 GeneratedModelCheckConstraint,
23 GeneratedModelCheckConstraintVirtual,
24 GeneratedModelFieldWithConverters,
25 GeneratedModelNonAutoPk,
26 GeneratedModelNull,
27 GeneratedModelNullVirtual,
28 GeneratedModelOutputFieldDbCollation,
29 GeneratedModelOutputFieldDbCollationVirtual,
30 GeneratedModelParams,
31 GeneratedModelParamsVirtual,
32 GeneratedModelUniqueConstraint,
33 GeneratedModelUniqueConstraintVirtual,
34 GeneratedModelVirtual,
35 )
36
37
38 class BaseGeneratedFieldTests(SimpleTestCase):
39 def test_editable_unsupported(self):
40 with self.assertRaisesMessage(ValueError, "GeneratedField cannot be editable."):
41 GeneratedField(
42 expression=Lower("name"),
43 output_field=CharField(max_length=255),
44 editable=True,
45 db_persist=False,
46 )
47
48 @isolate_apps("model_fields")
49 def test_contribute_to_class(self):
50 class BareModel(Model):
51 pass
52
53 new_field = GeneratedField(
54 expression=Lower("nonexistent"),
55 output_field=IntegerField(),
56 db_persist=True,
57 )
58 apps.models_ready = False
59 try:
60 # GeneratedField can be added to the model even when apps are not
61 # fully loaded.
62 new_field.contribute_to_class(BareModel, "name")
63 self.assertEqual(BareModel._meta.get_field("name"), new_field)
64 finally:
65 apps.models_ready = True
66
67 def test_blank_unsupported(self):
68 with self.assertRaisesMessage(ValueError, "GeneratedField must be blank."):
69 GeneratedField(
70 expression=Lower("name"),
71 output_field=CharField(max_length=255),
72 blank=False,
73 db_persist=False,
74 )
75
76 def test_default_unsupported(self):
77 msg = "GeneratedField cannot have a default."
78 with self.assertRaisesMessage(ValueError, msg):
79 GeneratedField(
80 expression=Lower("name"),
81 output_field=CharField(max_length=255),
82 default="",
83 db_persist=False,
84 )
85
86 def test_database_default_unsupported(self):
87 msg = "GeneratedField cannot have a database default."
88 with self.assertRaisesMessage(ValueError, msg):
89 GeneratedField(
90 expression=Lower("name"),
91 output_field=CharField(max_length=255),
92 db_default="",
93 db_persist=False,
94 )
95
96 def test_db_persist_required(self):
97 msg = "GeneratedField.db_persist must be True or False."
98 with self.assertRaisesMessage(ValueError, msg):
99 GeneratedField(
100 expression=Lower("name"), output_field=CharField(max_length=255)
101 )
102 with self.assertRaisesMessage(ValueError, msg):
103 GeneratedField(
104 expression=Lower("name"),
105 output_field=CharField(max_length=255),
106 db_persist=None,
107 )
108
109 def test_deconstruct(self):
110 field = GeneratedField(
111 expression=F("a") + F("b"), output_field=IntegerField(), db_persist=True
112 )
113 _, path, args, kwargs = field.deconstruct()
114 self.assertEqual(path, "django.db.models.GeneratedField")
115 self.assertEqual(args, [])
116 self.assertEqual(kwargs["db_persist"], True)
117 self.assertEqual(kwargs["expression"], F("a") + F("b"))
118 self.assertEqual(
119 kwargs["output_field"].deconstruct(), IntegerField().deconstruct()
120 )
121
122 @isolate_apps("model_fields")
123 def test_get_col(self):
124 class Square(Model):
125 side = IntegerField()
126 area = GeneratedField(
127 expression=F("side") * F("side"),
128 output_field=IntegerField(),
129 db_persist=True,
130 )
131
132 field = Square._meta.get_field("area")
133
134 col = field.get_col("alias")
135 self.assertIsInstance(col.output_field, IntegerField)
136
137 col = field.get_col("alias", field)
138 self.assertIsInstance(col.output_field, IntegerField)
139
140 class FloatSquare(Model):
141 side = IntegerField()
142 area = GeneratedField(
143 expression=F("side") * F("side"),
144 db_persist=True,
145 output_field=FloatField(),
146 )
147
148 field = FloatSquare._meta.get_field("area")
149
150 col = field.get_col("alias")
151 self.assertIsInstance(col.output_field, FloatField)
152
153 col = field.get_col("alias", field)
154 self.assertIsInstance(col.output_field, FloatField)
155
156 @isolate_apps("model_fields")
157 def test_cached_col(self):
158 class Sum(Model):
159 a = IntegerField()
160 b = IntegerField()
161 total = GeneratedField(
162 expression=F("a") + F("b"), output_field=IntegerField(), db_persist=True
163 )
164
165 field = Sum._meta.get_field("total")
166 cached_col = field.cached_col
167 self.assertIs(field.get_col(Sum._meta.db_table), cached_col)
168 self.assertIs(field.get_col(Sum._meta.db_table, field), cached_col)
169 self.assertIsNot(field.get_col("alias"), cached_col)
170 self.assertIsNot(field.get_col(Sum._meta.db_table, IntegerField()), cached_col)
171 self.assertIs(cached_col.target, field)
172 self.assertIsInstance(cached_col.output_field, IntegerField)
173
174
175 class GeneratedFieldTestMixin:
176 def _refresh_if_needed(self, m):
177 if not connection.features.can_return_columns_from_insert:
178 m.refresh_from_db()
179 return m
180
181 def test_unsaved_error(self):
182 m = self.base_model(a=1, b=2)
183 msg = "Cannot read a generated field from an unsaved model."
184 with self.assertRaisesMessage(AttributeError, msg):
185 m.field
186
187 def test_full_clean(self):
188 m = self.base_model(a=1, b=2)
189 # full_clean() ignores GeneratedFields.
190 m.full_clean()
191 m.save()
192 m = self._refresh_if_needed(m)
193 self.assertEqual(m.field, 3)
194
195 @skipUnlessDBFeature("supports_table_check_constraints")
196 def test_full_clean_with_check_constraint(self):
197 model_name = self.check_constraint_model._meta.verbose_name.capitalize()
198
199 m = self.check_constraint_model(a=2)
200 m.full_clean()
201 m.save()
202 m = self._refresh_if_needed(m)
203 self.assertEqual(m.a_squared, 4)
204
205 m = self.check_constraint_model(a=-1)
206 with self.assertRaises(ValidationError) as cm:
207 m.full_clean()
208 self.assertEqual(
209 cm.exception.message_dict,
210 {"__all__": [f"Constraint “{model_name} a > 0” is violated."]},
211 )
212
213 @skipUnlessDBFeature("supports_expression_indexes")
214 def test_full_clean_with_unique_constraint_expression(self):
215 model_name = self.unique_constraint_model._meta.verbose_name.capitalize()
216
217 m = self.unique_constraint_model(a=2)
218 m.full_clean()
219 m.save()
220 m = self._refresh_if_needed(m)
221 self.assertEqual(m.a_squared, 4)
222
223 m = self.unique_constraint_model(a=2)
224 with self.assertRaises(ValidationError) as cm:
225 m.full_clean()
226 self.assertEqual(
227 cm.exception.message_dict,
228 {"__all__": [f"Constraint “{model_name} a” is violated."]},
229 )
230
231 def test_create(self):
232 m = self.base_model.objects.create(a=1, b=2)
233 m = self._refresh_if_needed(m)
234 self.assertEqual(m.field, 3)
235
236 def test_non_nullable_create(self):
237 with self.assertRaises(IntegrityError):
238 self.base_model.objects.create()
239
240 def test_save(self):
241 # Insert.
242 m = self.base_model(a=2, b=4)
243 m.save()
244 m = self._refresh_if_needed(m)
245 self.assertEqual(m.field, 6)
246 # Update.
247 m.a = 4
248 m.save()
249 m.refresh_from_db()
250 self.assertEqual(m.field, 8)
251
252 def test_save_model_with_pk(self):
253 m = self.base_model(pk=1, a=1, b=2)
254 m.save()
255 m = self._refresh_if_needed(m)
256 self.assertEqual(m.field, 3)
257
258 def test_save_model_with_foreign_key(self):
259 fk_object = Foo.objects.create(a="abc", d=Decimal("12.34"))
260 m = self.base_model(a=1, b=2, fk=fk_object)
261 m.save()
262 m = self._refresh_if_needed(m)
263 self.assertEqual(m.field, 3)
264
265 def test_generated_fields_can_be_deferred(self):
266 fk_object = Foo.objects.create(a="abc", d=Decimal("12.34"))
267 m = self.base_model.objects.create(a=1, b=2, fk=fk_object)
268 m = self.base_model.objects.defer("field").get(id=m.id)
269 self.assertEqual(m.get_deferred_fields(), {"field"})
270
271 def test_update(self):
272 m = self.base_model.objects.create(a=1, b=2)
273 self.base_model.objects.update(b=3)
274 m = self.base_model.objects.get(pk=m.pk)
275 self.assertEqual(m.field, 4)
276
277 def test_bulk_create(self):
278 m = self.base_model(a=3, b=4)
279 (m,) = self.base_model.objects.bulk_create([m])
280 if not connection.features.can_return_rows_from_bulk_insert:
281 m = self.base_model.objects.get()
282 self.assertEqual(m.field, 7)
283
284 def test_bulk_update(self):
285 m = self.base_model.objects.create(a=1, b=2)
286 m.a = 3
287 self.base_model.objects.bulk_update([m], fields=["a"])
288 m = self.base_model.objects.get(pk=m.pk)
289 self.assertEqual(m.field, 5)
290
291 def test_output_field_lookups(self):
292 """Lookups from the output_field are available on GeneratedFields."""
293 internal_type = IntegerField().get_internal_type()
294 min_value, max_value = connection.ops.integer_field_range(internal_type)
295 if min_value is None:
296 self.skipTest("Backend doesn't define an integer min value.")
297 if max_value is None:
298 self.skipTest("Backend doesn't define an integer max value.")
299
300 does_not_exist = self.base_model.DoesNotExist
301 underflow_value = min_value - 1
302 with self.assertNumQueries(0), self.assertRaises(does_not_exist):
303 self.base_model.objects.get(field=underflow_value)
304 with self.assertNumQueries(0), self.assertRaises(does_not_exist):
305 self.base_model.objects.get(field__lt=underflow_value)
306 with self.assertNumQueries(0), self.assertRaises(does_not_exist):
307 self.base_model.objects.get(field__lte=underflow_value)
308
309 overflow_value = max_value + 1
310 with self.assertNumQueries(0), self.assertRaises(does_not_exist):
311 self.base_model.objects.get(field=overflow_value)
312 with self.assertNumQueries(0), self.assertRaises(does_not_exist):
313 self.base_model.objects.get(field__gt=overflow_value)
314 with self.assertNumQueries(0), self.assertRaises(does_not_exist):
315 self.base_model.objects.get(field__gte=overflow_value)
316
317 def test_output_field_db_collation(self):
318 collation = connection.features.test_collations["virtual"]
319 m = self.output_field_db_collation_model.objects.create(name="NAME")
320 field = m._meta.get_field("lower_name")
321 db_parameters = field.db_parameters(connection)
322 self.assertEqual(db_parameters["collation"], collation)
323 self.assertEqual(db_parameters["type"], field.output_field.db_type(connection))
324
325 def test_db_type_parameters(self):
326 db_type_parameters = self.output_field_db_collation_model._meta.get_field(
327 "lower_name"
328 ).db_type_parameters(connection)
329 self.assertEqual(db_type_parameters["max_length"], 11)
330
331 def test_model_with_params(self):
332 m = self.params_model.objects.create()
333 m = self._refresh_if_needed(m)
334 self.assertEqual(m.field, "Constant")
335
336 def test_nullable(self):
337 m1 = self.nullable_model.objects.create()
338 m1 = self._refresh_if_needed(m1)
339 none_val = "" if connection.features.interprets_empty_strings_as_nulls else None
340 self.assertEqual(m1.lower_name, none_val)
341 m2 = self.nullable_model.objects.create(name="NaMe")
342 m2 = self._refresh_if_needed(m2)
343 self.assertEqual(m2.lower_name, "name")
344
345
346 @skipUnlessDBFeature("supports_stored_generated_columns")
347 class StoredGeneratedFieldTests(GeneratedFieldTestMixin, TestCase):
348 base_model = GeneratedModel
349 nullable_model = GeneratedModelNull
350 check_constraint_model = GeneratedModelCheckConstraint
351 unique_constraint_model = GeneratedModelUniqueConstraint
352 output_field_db_collation_model = GeneratedModelOutputFieldDbCollation
353 params_model = GeneratedModelParams
354
355 def test_create_field_with_db_converters(self):
356 obj = GeneratedModelFieldWithConverters.objects.create(field=uuid.uuid4())
357 obj = self._refresh_if_needed(obj)
358 self.assertEqual(obj.field, obj.field_copy)
359
360 def test_create_with_non_auto_pk(self):
361 obj = GeneratedModelNonAutoPk.objects.create(id=1, a=2)
362 self.assertEqual(obj.id, 1)
363 self.assertEqual(obj.a, 2)
364 self.assertEqual(obj.b, 2)
365
366
367 @skipUnlessDBFeature("supports_virtual_generated_columns")
368 class VirtualGeneratedFieldTests(GeneratedFieldTestMixin, TestCase):
369 base_model = GeneratedModelVirtual
370 nullable_model = GeneratedModelNullVirtual
371 check_constraint_model = GeneratedModelCheckConstraintVirtual
372 unique_constraint_model = GeneratedModelUniqueConstraintVirtual
373 output_field_db_collation_model = GeneratedModelOutputFieldDbCollationVirtual
374 params_model = GeneratedModelParamsVirtual