| 1 |
from unittest import SkipTest |
| 2 |
|
| 3 |
from django.core import validators |
| 4 |
from django.core.exceptions import ValidationError |
| 5 |
from django.db import IntegrityError, connection, models |
| 6 |
from django.test import SimpleTestCase, TestCase |
| 7 |
|
| 8 |
from .models import ( |
| 9 |
BigIntegerModel, |
| 10 |
IntegerModel, |
| 11 |
PositiveBigIntegerModel, |
| 12 |
PositiveIntegerModel, |
| 13 |
PositiveSmallIntegerModel, |
| 14 |
SmallIntegerModel, |
| 15 |
) |
| 16 |
|
| 17 |
|
| 18 |
class IntegerFieldTests(TestCase): |
| 19 |
model = IntegerModel |
| 20 |
documented_range = (-2147483648, 2147483647) |
| 21 |
rel_db_type_class = models.IntegerField |
| 22 |
|
| 23 |
@property |
| 24 |
def backend_range(self): |
| 25 |
field = self.model._meta.get_field("value") |
| 26 |
internal_type = field.get_internal_type() |
| 27 |
return connection.ops.integer_field_range(internal_type) |
| 28 |
|
| 29 |
def test_documented_range(self): |
| 30 |
""" |
| 31 |
Values within the documented safe range pass validation, and can be |
| 32 |
saved and retrieved without corruption. |
| 33 |
""" |
| 34 |
min_value, max_value = self.documented_range |
| 35 |
|
| 36 |
instance = self.model(value=min_value) |
| 37 |
instance.full_clean() |
| 38 |
instance.save() |
| 39 |
qs = self.model.objects.filter(value__lte=min_value) |
| 40 |
self.assertEqual(qs.count(), 1) |
| 41 |
self.assertEqual(qs[0].value, min_value) |
| 42 |
|
| 43 |
instance = self.model(value=max_value) |
| 44 |
instance.full_clean() |
| 45 |
instance.save() |
| 46 |
qs = self.model.objects.filter(value__gte=max_value) |
| 47 |
self.assertEqual(qs.count(), 1) |
| 48 |
self.assertEqual(qs[0].value, max_value) |
| 49 |
|
| 50 |
def test_backend_range_save(self): |
| 51 |
""" |
| 52 |
Backend specific ranges can be saved without corruption. |
| 53 |
""" |
| 54 |
min_value, max_value = self.backend_range |
| 55 |
|
| 56 |
if min_value is not None: |
| 57 |
instance = self.model(value=min_value) |
| 58 |
instance.full_clean() |
| 59 |
instance.save() |
| 60 |
qs = self.model.objects.filter(value__lte=min_value) |
| 61 |
self.assertEqual(qs.count(), 1) |
| 62 |
self.assertEqual(qs[0].value, min_value) |
| 63 |
|
| 64 |
if max_value is not None: |
| 65 |
instance = self.model(value=max_value) |
| 66 |
instance.full_clean() |
| 67 |
instance.save() |
| 68 |
qs = self.model.objects.filter(value__gte=max_value) |
| 69 |
self.assertEqual(qs.count(), 1) |
| 70 |
self.assertEqual(qs[0].value, max_value) |
| 71 |
|
| 72 |
def test_backend_range_validation(self): |
| 73 |
""" |
| 74 |
Backend specific ranges are enforced at the model validation level |
| 75 |
(#12030). |
| 76 |
""" |
| 77 |
min_value, max_value = self.backend_range |
| 78 |
|
| 79 |
if min_value is not None: |
| 80 |
instance = self.model(value=min_value - 1) |
| 81 |
expected_message = validators.MinValueValidator.message % { |
| 82 |
"limit_value": min_value, |
| 83 |
} |
| 84 |
with self.assertRaisesMessage(ValidationError, expected_message): |
| 85 |
instance.full_clean() |
| 86 |
instance.value = min_value |
| 87 |
instance.full_clean() |
| 88 |
|
| 89 |
if max_value is not None: |
| 90 |
instance = self.model(value=max_value + 1) |
| 91 |
expected_message = validators.MaxValueValidator.message % { |
| 92 |
"limit_value": max_value, |
| 93 |
} |
| 94 |
with self.assertRaisesMessage(ValidationError, expected_message): |
| 95 |
instance.full_clean() |
| 96 |
instance.value = max_value |
| 97 |
instance.full_clean() |
| 98 |
|
| 99 |
def test_backend_range_min_value_lookups(self): |
| 100 |
min_value = self.backend_range[0] |
| 101 |
if min_value is None: |
| 102 |
raise SkipTest("Backend doesn't define an integer min value.") |
| 103 |
underflow_value = min_value - 1 |
| 104 |
self.model.objects.create(value=min_value) |
| 105 |
# A refresh of obj is necessary because last_insert_id() is bugged |
| 106 |
# on MySQL and returns invalid values. |
| 107 |
obj = self.model.objects.get(value=min_value) |
| 108 |
with self.assertNumQueries(0), self.assertRaises(self.model.DoesNotExist): |
| 109 |
self.model.objects.get(value=underflow_value) |
| 110 |
with self.assertNumQueries(1): |
| 111 |
self.assertEqual(self.model.objects.get(value__gt=underflow_value), obj) |
| 112 |
with self.assertNumQueries(1): |
| 113 |
self.assertEqual(self.model.objects.get(value__gte=underflow_value), obj) |
| 114 |
with self.assertNumQueries(0), self.assertRaises(self.model.DoesNotExist): |
| 115 |
self.model.objects.get(value__lt=underflow_value) |
| 116 |
with self.assertNumQueries(0), self.assertRaises(self.model.DoesNotExist): |
| 117 |
self.model.objects.get(value__lte=underflow_value) |
| 118 |
|
| 119 |
def test_backend_range_max_value_lookups(self): |
| 120 |
max_value = self.backend_range[-1] |
| 121 |
if max_value is None: |
| 122 |
raise SkipTest("Backend doesn't define an integer max value.") |
| 123 |
overflow_value = max_value + 1 |
| 124 |
obj = self.model.objects.create(value=max_value) |
| 125 |
with self.assertNumQueries(0), self.assertRaises(self.model.DoesNotExist): |
| 126 |
self.model.objects.get(value=overflow_value) |
| 127 |
with self.assertNumQueries(0), self.assertRaises(self.model.DoesNotExist): |
| 128 |
self.model.objects.get(value__gt=overflow_value) |
| 129 |
with self.assertNumQueries(0), self.assertRaises(self.model.DoesNotExist): |
| 130 |
self.model.objects.get(value__gte=overflow_value) |
| 131 |
with self.assertNumQueries(1): |
| 132 |
self.assertEqual(self.model.objects.get(value__lt=overflow_value), obj) |
| 133 |
with self.assertNumQueries(1): |
| 134 |
self.assertEqual(self.model.objects.get(value__lte=overflow_value), obj) |
| 135 |
|
| 136 |
def test_redundant_backend_range_validators(self): |
| 137 |
""" |
| 138 |
If there are stricter validators than the ones from the database |
| 139 |
backend then the backend validators aren't added. |
| 140 |
""" |
| 141 |
min_backend_value, max_backend_value = self.backend_range |
| 142 |
|
| 143 |
for callable_limit in (True, False): |
| 144 |
with self.subTest(callable_limit=callable_limit): |
| 145 |
if min_backend_value is not None: |
| 146 |
min_custom_value = min_backend_value + 1 |
| 147 |
limit_value = ( |
| 148 |
(lambda: min_custom_value) |
| 149 |
if callable_limit |
| 150 |
else min_custom_value |
| 151 |
) |
| 152 |
ranged_value_field = self.model._meta.get_field("value").__class__( |
| 153 |
validators=[validators.MinValueValidator(limit_value)] |
| 154 |
) |
| 155 |
field_range_message = validators.MinValueValidator.message % { |
| 156 |
"limit_value": min_custom_value, |
| 157 |
} |
| 158 |
with self.assertRaisesMessage( |
| 159 |
ValidationError, "[%r]" % field_range_message |
| 160 |
): |
| 161 |
ranged_value_field.run_validators(min_backend_value - 1) |
| 162 |
|
| 163 |
if max_backend_value is not None: |
| 164 |
max_custom_value = max_backend_value - 1 |
| 165 |
limit_value = ( |
| 166 |
(lambda: max_custom_value) |
| 167 |
if callable_limit |
| 168 |
else max_custom_value |
| 169 |
) |
| 170 |
ranged_value_field = self.model._meta.get_field("value").__class__( |
| 171 |
validators=[validators.MaxValueValidator(limit_value)] |
| 172 |
) |
| 173 |
field_range_message = validators.MaxValueValidator.message % { |
| 174 |
"limit_value": max_custom_value, |
| 175 |
} |
| 176 |
with self.assertRaisesMessage( |
| 177 |
ValidationError, "[%r]" % field_range_message |
| 178 |
): |
| 179 |
ranged_value_field.run_validators(max_backend_value + 1) |
| 180 |
|
| 181 |
def test_types(self): |
| 182 |
instance = self.model(value=1) |
| 183 |
self.assertIsInstance(instance.value, int) |
| 184 |
instance.save() |
| 185 |
self.assertIsInstance(instance.value, int) |
| 186 |
instance = self.model.objects.get() |
| 187 |
self.assertIsInstance(instance.value, int) |
| 188 |
|
| 189 |
def test_coercing(self): |
| 190 |
self.model.objects.create(value="10") |
| 191 |
instance = self.model.objects.get(value="10") |
| 192 |
self.assertEqual(instance.value, 10) |
| 193 |
|
| 194 |
def test_invalid_value(self): |
| 195 |
tests = [ |
| 196 |
(TypeError, ()), |
| 197 |
(TypeError, []), |
| 198 |
(TypeError, {}), |
| 199 |
(TypeError, set()), |
| 200 |
(TypeError, object()), |
| 201 |
(TypeError, complex()), |
| 202 |
(ValueError, "non-numeric string"), |
| 203 |
(ValueError, b"non-numeric byte-string"), |
| 204 |
] |
| 205 |
for exception, value in tests: |
| 206 |
with self.subTest(value): |
| 207 |
msg = "Field 'value' expected a number but got %r." % (value,) |
| 208 |
with self.assertRaisesMessage(exception, msg): |
| 209 |
self.model.objects.create(value=value) |
| 210 |
|
| 211 |
def test_rel_db_type(self): |
| 212 |
field = self.model._meta.get_field("value") |
| 213 |
rel_db_type = field.rel_db_type(connection) |
| 214 |
self.assertEqual(rel_db_type, self.rel_db_type_class().db_type(connection)) |
| 215 |
|
| 216 |
|
| 217 |
class SmallIntegerFieldTests(IntegerFieldTests): |
| 218 |
model = SmallIntegerModel |
| 219 |
documented_range = (-32768, 32767) |
| 220 |
rel_db_type_class = models.SmallIntegerField |
| 221 |
|
| 222 |
|
| 223 |
class BigIntegerFieldTests(IntegerFieldTests): |
| 224 |
model = BigIntegerModel |
| 225 |
documented_range = (-9223372036854775808, 9223372036854775807) |
| 226 |
rel_db_type_class = models.BigIntegerField |
| 227 |
|
| 228 |
|
| 229 |
class PositiveSmallIntegerFieldTests(IntegerFieldTests): |
| 230 |
model = PositiveSmallIntegerModel |
| 231 |
documented_range = (0, 32767) |
| 232 |
rel_db_type_class = ( |
| 233 |
models.PositiveSmallIntegerField |
| 234 |
if connection.features.related_fields_match_type |
| 235 |
else models.SmallIntegerField |
| 236 |
) |
| 237 |
|
| 238 |
|
| 239 |
class PositiveIntegerFieldTests(IntegerFieldTests): |
| 240 |
model = PositiveIntegerModel |
| 241 |
documented_range = (0, 2147483647) |
| 242 |
rel_db_type_class = ( |
| 243 |
models.PositiveIntegerField |
| 244 |
if connection.features.related_fields_match_type |
| 245 |
else models.IntegerField |
| 246 |
) |
| 247 |
|
| 248 |
def test_negative_values(self): |
| 249 |
p = PositiveIntegerModel.objects.create(value=0) |
| 250 |
p.value = models.F("value") - 1 |
| 251 |
with self.assertRaises(IntegrityError): |
| 252 |
p.save() |
| 253 |
|
| 254 |
|
| 255 |
class PositiveBigIntegerFieldTests(IntegerFieldTests): |
| 256 |
model = PositiveBigIntegerModel |
| 257 |
documented_range = (0, 9223372036854775807) |
| 258 |
rel_db_type_class = ( |
| 259 |
models.PositiveBigIntegerField |
| 260 |
if connection.features.related_fields_match_type |
| 261 |
else models.BigIntegerField |
| 262 |
) |
| 263 |
|
| 264 |
|
| 265 |
class ValidationTests(SimpleTestCase): |
| 266 |
class Choices(models.IntegerChoices): |
| 267 |
A = 1 |
| 268 |
|
| 269 |
def test_integerfield_cleans_valid_string(self): |
| 270 |
f = models.IntegerField() |
| 271 |
self.assertEqual(f.clean("2", None), 2) |
| 272 |
|
| 273 |
def test_integerfield_raises_error_on_invalid_intput(self): |
| 274 |
f = models.IntegerField() |
| 275 |
with self.assertRaises(ValidationError): |
| 276 |
f.clean("a", None) |
| 277 |
|
| 278 |
def test_choices_validation_supports_named_groups(self): |
| 279 |
f = models.IntegerField(choices=(("group", ((10, "A"), (20, "B"))), (30, "C"))) |
| 280 |
self.assertEqual(10, f.clean(10, None)) |
| 281 |
|
| 282 |
def test_choices_validation_supports_named_groups_dicts(self): |
| 283 |
f = models.IntegerField(choices={"group": ((10, "A"), (20, "B")), 30: "C"}) |
| 284 |
self.assertEqual(10, f.clean(10, None)) |
| 285 |
|
| 286 |
def test_choices_validation_supports_named_groups_nested_dicts(self): |
| 287 |
f = models.IntegerField(choices={"group": {10: "A", 20: "B"}, 30: "C"}) |
| 288 |
self.assertEqual(10, f.clean(10, None)) |
| 289 |
|
| 290 |
def test_nullable_integerfield_raises_error_with_blank_false(self): |
| 291 |
f = models.IntegerField(null=True, blank=False) |
| 292 |
with self.assertRaises(ValidationError): |
| 293 |
f.clean(None, None) |
| 294 |
|
| 295 |
def test_nullable_integerfield_cleans_none_on_null_and_blank_true(self): |
| 296 |
f = models.IntegerField(null=True, blank=True) |
| 297 |
self.assertIsNone(f.clean(None, None)) |
| 298 |
|
| 299 |
def test_integerfield_raises_error_on_empty_input(self): |
| 300 |
f = models.IntegerField(null=False) |
| 301 |
with self.assertRaises(ValidationError): |
| 302 |
f.clean(None, None) |
| 303 |
with self.assertRaises(ValidationError): |
| 304 |
f.clean("", None) |
| 305 |
|
| 306 |
def test_integerfield_validates_zero_against_choices(self): |
| 307 |
f = models.IntegerField(choices=((1, 1),)) |
| 308 |
with self.assertRaises(ValidationError): |
| 309 |
f.clean("0", None) |
| 310 |
|
| 311 |
def test_enum_choices_cleans_valid_string(self): |
| 312 |
f = models.IntegerField(choices=self.Choices) |
| 313 |
self.assertEqual(f.clean("1", None), 1) |
| 314 |
|
| 315 |
def test_enum_choices_invalid_input(self): |
| 316 |
f = models.IntegerField(choices=self.Choices) |
| 317 |
with self.assertRaises(ValidationError): |
| 318 |
f.clean("A", None) |
| 319 |
with self.assertRaises(ValidationError): |
| 320 |
f.clean("3", None) |
| 321 |
|
| 322 |
def test_callable_choices(self): |
| 323 |
def get_choices(): |
| 324 |
return {i: str(i) for i in range(3)} |
| 325 |
|
| 326 |
f = models.IntegerField(choices=get_choices) |
| 327 |
|
| 328 |
for i in get_choices(): |
| 329 |
with self.subTest(i=i): |
| 330 |
self.assertEqual(i, f.clean(i, None)) |
| 331 |
|
| 332 |
with self.assertRaises(ValidationError): |
| 333 |
f.clean("A", None) |
| 334 |
with self.assertRaises(ValidationError): |
| 335 |
f.clean("3", None) |