Debian Codegraph @

tests/model_fields/test_integerfield.py

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