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