Debian Codegraph @

tests/field_deconstruction/tests.py

raw
1 from django.apps import apps
2 from django.db import models
3 from django.test import SimpleTestCase, override_settings
4 from django.test.utils import isolate_lru_cache
5 from django.utils.choices import normalize_choices
6
7
8 class FieldDeconstructionTests(SimpleTestCase):
9 """
10 Tests the deconstruct() method on all core fields.
11 """
12
13 def test_name(self):
14 """
15 Tests the outputting of the correct name if assigned one.
16 """
17 # First try using a "normal" field
18 field = models.CharField(max_length=65)
19 name, path, args, kwargs = field.deconstruct()
20 self.assertIsNone(name)
21 field.set_attributes_from_name("is_awesome_test")
22 name, path, args, kwargs = field.deconstruct()
23 self.assertEqual(name, "is_awesome_test")
24 # Now try with a ForeignKey
25 field = models.ForeignKey("some_fake.ModelName", models.CASCADE)
26 name, path, args, kwargs = field.deconstruct()
27 self.assertIsNone(name)
28 field.set_attributes_from_name("author")
29 name, path, args, kwargs = field.deconstruct()
30 self.assertEqual(name, "author")
31
32 def test_db_tablespace(self):
33 field = models.Field()
34 _, _, args, kwargs = field.deconstruct()
35 self.assertEqual(args, [])
36 self.assertEqual(kwargs, {})
37 # With a DEFAULT_DB_TABLESPACE.
38 with self.settings(DEFAULT_DB_TABLESPACE="foo"):
39 _, _, args, kwargs = field.deconstruct()
40 self.assertEqual(args, [])
41 self.assertEqual(kwargs, {})
42 # With a db_tablespace.
43 field = models.Field(db_tablespace="foo")
44 _, _, args, kwargs = field.deconstruct()
45 self.assertEqual(args, [])
46 self.assertEqual(kwargs, {"db_tablespace": "foo"})
47 # With a db_tablespace equal to DEFAULT_DB_TABLESPACE.
48 with self.settings(DEFAULT_DB_TABLESPACE="foo"):
49 _, _, args, kwargs = field.deconstruct()
50 self.assertEqual(args, [])
51 self.assertEqual(kwargs, {"db_tablespace": "foo"})
52
53 def test_auto_field(self):
54 field = models.AutoField(primary_key=True)
55 field.set_attributes_from_name("id")
56 name, path, args, kwargs = field.deconstruct()
57 self.assertEqual(path, "django.db.models.AutoField")
58 self.assertEqual(args, [])
59 self.assertEqual(kwargs, {"primary_key": True})
60
61 def test_big_integer_field(self):
62 field = models.BigIntegerField()
63 name, path, args, kwargs = field.deconstruct()
64 self.assertEqual(path, "django.db.models.BigIntegerField")
65 self.assertEqual(args, [])
66 self.assertEqual(kwargs, {})
67
68 def test_boolean_field(self):
69 field = models.BooleanField()
70 name, path, args, kwargs = field.deconstruct()
71 self.assertEqual(path, "django.db.models.BooleanField")
72 self.assertEqual(args, [])
73 self.assertEqual(kwargs, {})
74 field = models.BooleanField(default=True)
75 name, path, args, kwargs = field.deconstruct()
76 self.assertEqual(path, "django.db.models.BooleanField")
77 self.assertEqual(args, [])
78 self.assertEqual(kwargs, {"default": True})
79
80 def test_char_field(self):
81 field = models.CharField(max_length=65)
82 name, path, args, kwargs = field.deconstruct()
83 self.assertEqual(path, "django.db.models.CharField")
84 self.assertEqual(args, [])
85 self.assertEqual(kwargs, {"max_length": 65})
86 field = models.CharField(max_length=65, null=True, blank=True)
87 name, path, args, kwargs = field.deconstruct()
88 self.assertEqual(path, "django.db.models.CharField")
89 self.assertEqual(args, [])
90 self.assertEqual(kwargs, {"max_length": 65, "null": True, "blank": True})
91
92 def test_char_field_choices(self):
93 field = models.CharField(max_length=1, choices=(("A", "One"), ("B", "Two")))
94 name, path, args, kwargs = field.deconstruct()
95 self.assertEqual(path, "django.db.models.CharField")
96 self.assertEqual(args, [])
97 self.assertEqual(
98 kwargs, {"choices": [("A", "One"), ("B", "Two")], "max_length": 1}
99 )
100
101 def test_choices_iterator(self):
102 field = models.IntegerField(choices=((i, str(i)) for i in range(3)))
103 name, path, args, kwargs = field.deconstruct()
104 self.assertEqual(path, "django.db.models.IntegerField")
105 self.assertEqual(args, [])
106 self.assertEqual(kwargs, {"choices": [(0, "0"), (1, "1"), (2, "2")]})
107
108 def test_choices_iterable(self):
109 # Pass an iterable (but not an iterator) to choices.
110 field = models.IntegerField(choices="012345")
111 name, path, args, kwargs = field.deconstruct()
112 self.assertEqual(path, "django.db.models.IntegerField")
113 self.assertEqual(args, [])
114 self.assertEqual(kwargs, {"choices": normalize_choices("012345")})
115
116 def test_choices_callable(self):
117 def get_choices():
118 return [(i, str(i)) for i in range(3)]
119
120 field = models.IntegerField(choices=get_choices)
121 name, path, args, kwargs = field.deconstruct()
122 self.assertEqual(path, "django.db.models.IntegerField")
123 self.assertEqual(args, [])
124 self.assertEqual(kwargs, {"choices": get_choices})
125
126 def test_csi_field(self):
127 field = models.CommaSeparatedIntegerField(max_length=100)
128 name, path, args, kwargs = field.deconstruct()
129 self.assertEqual(path, "django.db.models.CommaSeparatedIntegerField")
130 self.assertEqual(args, [])
131 self.assertEqual(kwargs, {"max_length": 100})
132
133 def test_date_field(self):
134 field = models.DateField()
135 name, path, args, kwargs = field.deconstruct()
136 self.assertEqual(path, "django.db.models.DateField")
137 self.assertEqual(args, [])
138 self.assertEqual(kwargs, {})
139 field = models.DateField(auto_now=True)
140 name, path, args, kwargs = field.deconstruct()
141 self.assertEqual(path, "django.db.models.DateField")
142 self.assertEqual(args, [])
143 self.assertEqual(kwargs, {"auto_now": True})
144
145 def test_datetime_field(self):
146 field = models.DateTimeField()
147 name, path, args, kwargs = field.deconstruct()
148 self.assertEqual(path, "django.db.models.DateTimeField")
149 self.assertEqual(args, [])
150 self.assertEqual(kwargs, {})
151 field = models.DateTimeField(auto_now_add=True)
152 name, path, args, kwargs = field.deconstruct()
153 self.assertEqual(path, "django.db.models.DateTimeField")
154 self.assertEqual(args, [])
155 self.assertEqual(kwargs, {"auto_now_add": True})
156 # Bug #21785
157 field = models.DateTimeField(auto_now=True, auto_now_add=True)
158 name, path, args, kwargs = field.deconstruct()
159 self.assertEqual(path, "django.db.models.DateTimeField")
160 self.assertEqual(args, [])
161 self.assertEqual(kwargs, {"auto_now_add": True, "auto_now": True})
162
163 def test_decimal_field(self):
164 field = models.DecimalField(max_digits=5, decimal_places=2)
165 name, path, args, kwargs = field.deconstruct()
166 self.assertEqual(path, "django.db.models.DecimalField")
167 self.assertEqual(args, [])
168 self.assertEqual(kwargs, {"max_digits": 5, "decimal_places": 2})
169
170 def test_decimal_field_0_decimal_places(self):
171 """
172 A DecimalField with decimal_places=0 should work (#22272).
173 """
174 field = models.DecimalField(max_digits=5, decimal_places=0)
175 name, path, args, kwargs = field.deconstruct()
176 self.assertEqual(path, "django.db.models.DecimalField")
177 self.assertEqual(args, [])
178 self.assertEqual(kwargs, {"max_digits": 5, "decimal_places": 0})
179
180 def test_email_field(self):
181 field = models.EmailField()
182 name, path, args, kwargs = field.deconstruct()
183 self.assertEqual(path, "django.db.models.EmailField")
184 self.assertEqual(args, [])
185 self.assertEqual(kwargs, {"max_length": 254})
186 field = models.EmailField(max_length=255)
187 name, path, args, kwargs = field.deconstruct()
188 self.assertEqual(path, "django.db.models.EmailField")
189 self.assertEqual(args, [])
190 self.assertEqual(kwargs, {"max_length": 255})
191
192 def test_file_field(self):
193 field = models.FileField(upload_to="foo/bar")
194 name, path, args, kwargs = field.deconstruct()
195 self.assertEqual(path, "django.db.models.FileField")
196 self.assertEqual(args, [])
197 self.assertEqual(kwargs, {"upload_to": "foo/bar"})
198 # Test max_length
199 field = models.FileField(upload_to="foo/bar", max_length=200)
200 name, path, args, kwargs = field.deconstruct()
201 self.assertEqual(path, "django.db.models.FileField")
202 self.assertEqual(args, [])
203 self.assertEqual(kwargs, {"upload_to": "foo/bar", "max_length": 200})
204
205 def test_file_path_field(self):
206 field = models.FilePathField(match=r".*\.txt$")
207 name, path, args, kwargs = field.deconstruct()
208 self.assertEqual(path, "django.db.models.FilePathField")
209 self.assertEqual(args, [])
210 self.assertEqual(kwargs, {"match": r".*\.txt$"})
211 field = models.FilePathField(recursive=True, allow_folders=True, max_length=123)
212 name, path, args, kwargs = field.deconstruct()
213 self.assertEqual(path, "django.db.models.FilePathField")
214 self.assertEqual(args, [])
215 self.assertEqual(
216 kwargs, {"recursive": True, "allow_folders": True, "max_length": 123}
217 )
218
219 def test_float_field(self):
220 field = models.FloatField()
221 name, path, args, kwargs = field.deconstruct()
222 self.assertEqual(path, "django.db.models.FloatField")
223 self.assertEqual(args, [])
224 self.assertEqual(kwargs, {})
225
226 def test_foreign_key(self):
227 # Test basic pointing
228 from django.contrib.auth.models import Permission
229
230 field = models.ForeignKey("auth.Permission", models.CASCADE)
231 field.remote_field.model = Permission
232 field.remote_field.field_name = "id"
233 name, path, args, kwargs = field.deconstruct()
234 self.assertEqual(path, "django.db.models.ForeignKey")
235 self.assertEqual(args, [])
236 self.assertEqual(kwargs, {"to": "auth.permission", "on_delete": models.CASCADE})
237 self.assertFalse(hasattr(kwargs["to"], "setting_name"))
238 # Test swap detection for swappable model
239 field = models.ForeignKey("auth.User", models.CASCADE)
240 name, path, args, kwargs = field.deconstruct()
241 self.assertEqual(path, "django.db.models.ForeignKey")
242 self.assertEqual(args, [])
243 self.assertEqual(kwargs, {"to": "auth.user", "on_delete": models.CASCADE})
244 self.assertEqual(kwargs["to"].setting_name, "AUTH_USER_MODEL")
245 # Swap detection for lowercase swappable model.
246 field = models.ForeignKey("auth.user", models.CASCADE)
247 name, path, args, kwargs = field.deconstruct()
248 self.assertEqual(path, "django.db.models.ForeignKey")
249 self.assertEqual(args, [])
250 self.assertEqual(kwargs, {"to": "auth.user", "on_delete": models.CASCADE})
251 self.assertEqual(kwargs["to"].setting_name, "AUTH_USER_MODEL")
252 # Test nonexistent (for now) model
253 field = models.ForeignKey("something.Else", models.CASCADE)
254 name, path, args, kwargs = field.deconstruct()
255 self.assertEqual(path, "django.db.models.ForeignKey")
256 self.assertEqual(args, [])
257 self.assertEqual(kwargs, {"to": "something.else", "on_delete": models.CASCADE})
258 # Test on_delete
259 field = models.ForeignKey("auth.User", models.SET_NULL)
260 name, path, args, kwargs = field.deconstruct()
261 self.assertEqual(path, "django.db.models.ForeignKey")
262 self.assertEqual(args, [])
263 self.assertEqual(kwargs, {"to": "auth.user", "on_delete": models.SET_NULL})
264 # Test to_field preservation
265 field = models.ForeignKey("auth.Permission", models.CASCADE, to_field="foobar")
266 name, path, args, kwargs = field.deconstruct()
267 self.assertEqual(path, "django.db.models.ForeignKey")
268 self.assertEqual(args, [])
269 self.assertEqual(
270 kwargs,
271 {
272 "to": "auth.permission",
273 "to_field": "foobar",
274 "on_delete": models.CASCADE,
275 },
276 )
277 # Test related_name preservation
278 field = models.ForeignKey(
279 "auth.Permission", models.CASCADE, related_name="foobar"
280 )
281 name, path, args, kwargs = field.deconstruct()
282 self.assertEqual(path, "django.db.models.ForeignKey")
283 self.assertEqual(args, [])
284 self.assertEqual(
285 kwargs,
286 {
287 "to": "auth.permission",
288 "related_name": "foobar",
289 "on_delete": models.CASCADE,
290 },
291 )
292 # Test related_query_name
293 field = models.ForeignKey(
294 "auth.Permission", models.CASCADE, related_query_name="foobar"
295 )
296 name, path, args, kwargs = field.deconstruct()
297 self.assertEqual(path, "django.db.models.ForeignKey")
298 self.assertEqual(args, [])
299 self.assertEqual(
300 kwargs,
301 {
302 "to": "auth.permission",
303 "related_query_name": "foobar",
304 "on_delete": models.CASCADE,
305 },
306 )
307 # Test limit_choices_to
308 field = models.ForeignKey(
309 "auth.Permission", models.CASCADE, limit_choices_to={"foo": "bar"}
310 )
311 name, path, args, kwargs = field.deconstruct()
312 self.assertEqual(path, "django.db.models.ForeignKey")
313 self.assertEqual(args, [])
314 self.assertEqual(
315 kwargs,
316 {
317 "to": "auth.permission",
318 "limit_choices_to": {"foo": "bar"},
319 "on_delete": models.CASCADE,
320 },
321 )
322 # Test unique
323 field = models.ForeignKey("auth.Permission", models.CASCADE, unique=True)
324 name, path, args, kwargs = field.deconstruct()
325 self.assertEqual(path, "django.db.models.ForeignKey")
326 self.assertEqual(args, [])
327 self.assertEqual(
328 kwargs,
329 {"to": "auth.permission", "unique": True, "on_delete": models.CASCADE},
330 )
331
332 @override_settings(AUTH_USER_MODEL="auth.Permission")
333 def test_foreign_key_swapped(self):
334 with isolate_lru_cache(apps.get_swappable_settings_name):
335 # It doesn't matter that we swapped out user for permission;
336 # there's no validation. We just want to check the setting stuff works.
337 field = models.ForeignKey("auth.Permission", models.CASCADE)
338 name, path, args, kwargs = field.deconstruct()
339
340 self.assertEqual(path, "django.db.models.ForeignKey")
341 self.assertEqual(args, [])
342 self.assertEqual(kwargs, {"to": "auth.permission", "on_delete": models.CASCADE})
343 self.assertEqual(kwargs["to"].setting_name, "AUTH_USER_MODEL")
344
345 # Model names are case-insensitive.
346 with isolate_lru_cache(apps.get_swappable_settings_name):
347 # It doesn't matter that we swapped out user for permission;
348 # there's no validation. We just want to check the setting stuff
349 # works.
350 field = models.ForeignKey("auth.permission", models.CASCADE)
351 name, path, args, kwargs = field.deconstruct()
352
353 self.assertEqual(path, "django.db.models.ForeignKey")
354 self.assertEqual(args, [])
355 self.assertEqual(kwargs, {"to": "auth.permission", "on_delete": models.CASCADE})
356 self.assertEqual(kwargs["to"].setting_name, "AUTH_USER_MODEL")
357
358 def test_one_to_one(self):
359 # Test basic pointing
360 from django.contrib.auth.models import Permission
361
362 field = models.OneToOneField("auth.Permission", models.CASCADE)
363 field.remote_field.model = Permission
364 field.remote_field.field_name = "id"
365 name, path, args, kwargs = field.deconstruct()
366 self.assertEqual(path, "django.db.models.OneToOneField")
367 self.assertEqual(args, [])
368 self.assertEqual(kwargs, {"to": "auth.permission", "on_delete": models.CASCADE})
369 self.assertFalse(hasattr(kwargs["to"], "setting_name"))
370 # Test swap detection for swappable model
371 field = models.OneToOneField("auth.User", models.CASCADE)
372 name, path, args, kwargs = field.deconstruct()
373 self.assertEqual(path, "django.db.models.OneToOneField")
374 self.assertEqual(args, [])
375 self.assertEqual(kwargs, {"to": "auth.user", "on_delete": models.CASCADE})
376 self.assertEqual(kwargs["to"].setting_name, "AUTH_USER_MODEL")
377 # Test nonexistent (for now) model
378 field = models.OneToOneField("something.Else", models.CASCADE)
379 name, path, args, kwargs = field.deconstruct()
380 self.assertEqual(path, "django.db.models.OneToOneField")
381 self.assertEqual(args, [])
382 self.assertEqual(kwargs, {"to": "something.else", "on_delete": models.CASCADE})
383 # Test on_delete
384 field = models.OneToOneField("auth.User", models.SET_NULL)
385 name, path, args, kwargs = field.deconstruct()
386 self.assertEqual(path, "django.db.models.OneToOneField")
387 self.assertEqual(args, [])
388 self.assertEqual(kwargs, {"to": "auth.user", "on_delete": models.SET_NULL})
389 # Test to_field
390 field = models.OneToOneField(
391 "auth.Permission", models.CASCADE, to_field="foobar"
392 )
393 name, path, args, kwargs = field.deconstruct()
394 self.assertEqual(path, "django.db.models.OneToOneField")
395 self.assertEqual(args, [])
396 self.assertEqual(
397 kwargs,
398 {
399 "to": "auth.permission",
400 "to_field": "foobar",
401 "on_delete": models.CASCADE,
402 },
403 )
404 # Test related_name
405 field = models.OneToOneField(
406 "auth.Permission", models.CASCADE, related_name="foobar"
407 )
408 name, path, args, kwargs = field.deconstruct()
409 self.assertEqual(path, "django.db.models.OneToOneField")
410 self.assertEqual(args, [])
411 self.assertEqual(
412 kwargs,
413 {
414 "to": "auth.permission",
415 "related_name": "foobar",
416 "on_delete": models.CASCADE,
417 },
418 )
419 # Test related_query_name
420 field = models.OneToOneField(
421 "auth.Permission", models.CASCADE, related_query_name="foobar"
422 )
423 name, path, args, kwargs = field.deconstruct()
424 self.assertEqual(path, "django.db.models.OneToOneField")
425 self.assertEqual(args, [])
426 self.assertEqual(
427 kwargs,
428 {
429 "to": "auth.permission",
430 "related_query_name": "foobar",
431 "on_delete": models.CASCADE,
432 },
433 )
434 # Test limit_choices_to
435 field = models.OneToOneField(
436 "auth.Permission", models.CASCADE, limit_choices_to={"foo": "bar"}
437 )
438 name, path, args, kwargs = field.deconstruct()
439 self.assertEqual(path, "django.db.models.OneToOneField")
440 self.assertEqual(args, [])
441 self.assertEqual(
442 kwargs,
443 {
444 "to": "auth.permission",
445 "limit_choices_to": {"foo": "bar"},
446 "on_delete": models.CASCADE,
447 },
448 )
449 # Test unique
450 field = models.OneToOneField("auth.Permission", models.CASCADE, unique=True)
451 name, path, args, kwargs = field.deconstruct()
452 self.assertEqual(path, "django.db.models.OneToOneField")
453 self.assertEqual(args, [])
454 self.assertEqual(kwargs, {"to": "auth.permission", "on_delete": models.CASCADE})
455
456 def test_image_field(self):
457 field = models.ImageField(
458 upload_to="foo/barness", width_field="width", height_field="height"
459 )
460 name, path, args, kwargs = field.deconstruct()
461 self.assertEqual(path, "django.db.models.ImageField")
462 self.assertEqual(args, [])
463 self.assertEqual(
464 kwargs,
465 {
466 "upload_to": "foo/barness",
467 "width_field": "width",
468 "height_field": "height",
469 },
470 )
471
472 def test_integer_field(self):
473 field = models.IntegerField()
474 name, path, args, kwargs = field.deconstruct()
475 self.assertEqual(path, "django.db.models.IntegerField")
476 self.assertEqual(args, [])
477 self.assertEqual(kwargs, {})
478
479 def test_ip_address_field(self):
480 field = models.IPAddressField()
481 name, path, args, kwargs = field.deconstruct()
482 self.assertEqual(path, "django.db.models.IPAddressField")
483 self.assertEqual(args, [])
484 self.assertEqual(kwargs, {})
485
486 def test_generic_ip_address_field(self):
487 field = models.GenericIPAddressField()
488 name, path, args, kwargs = field.deconstruct()
489 self.assertEqual(path, "django.db.models.GenericIPAddressField")
490 self.assertEqual(args, [])
491 self.assertEqual(kwargs, {})
492 field = models.GenericIPAddressField(protocol="IPv6")
493 name, path, args, kwargs = field.deconstruct()
494 self.assertEqual(path, "django.db.models.GenericIPAddressField")
495 self.assertEqual(args, [])
496 self.assertEqual(kwargs, {"protocol": "IPv6"})
497
498 def test_many_to_many_field(self):
499 # Test normal
500 field = models.ManyToManyField("auth.Permission")
501 name, path, args, kwargs = field.deconstruct()
502 self.assertEqual(path, "django.db.models.ManyToManyField")
503 self.assertEqual(args, [])
504 self.assertEqual(kwargs, {"to": "auth.permission"})
505 self.assertFalse(hasattr(kwargs["to"], "setting_name"))
506 # Test swappable
507 field = models.ManyToManyField("auth.User")
508 name, path, args, kwargs = field.deconstruct()
509 self.assertEqual(path, "django.db.models.ManyToManyField")
510 self.assertEqual(args, [])
511 self.assertEqual(kwargs, {"to": "auth.user"})
512 self.assertEqual(kwargs["to"].setting_name, "AUTH_USER_MODEL")
513 # Test through
514 field = models.ManyToManyField("auth.Permission", through="auth.Group")
515 name, path, args, kwargs = field.deconstruct()
516 self.assertEqual(path, "django.db.models.ManyToManyField")
517 self.assertEqual(args, [])
518 self.assertEqual(kwargs, {"to": "auth.permission", "through": "auth.Group"})
519 # Test through_fields
520 field = models.ManyToManyField(
521 "auth.Permission",
522 through="auth.Group",
523 through_fields=("foo", "permissions"),
524 )
525 name, path, args, kwargs = field.deconstruct()
526 self.assertEqual(path, "django.db.models.ManyToManyField")
527 self.assertEqual(args, [])
528 self.assertEqual(
529 kwargs,
530 {
531 "to": "auth.permission",
532 "through": "auth.Group",
533 "through_fields": ("foo", "permissions"),
534 },
535 )
536 # Test custom db_table
537 field = models.ManyToManyField("auth.Permission", db_table="custom_table")
538 name, path, args, kwargs = field.deconstruct()
539 self.assertEqual(path, "django.db.models.ManyToManyField")
540 self.assertEqual(args, [])
541 self.assertEqual(kwargs, {"to": "auth.permission", "db_table": "custom_table"})
542 # Test related_name
543 field = models.ManyToManyField("auth.Permission", related_name="custom_table")
544 name, path, args, kwargs = field.deconstruct()
545 self.assertEqual(path, "django.db.models.ManyToManyField")
546 self.assertEqual(args, [])
547 self.assertEqual(
548 kwargs, {"to": "auth.permission", "related_name": "custom_table"}
549 )
550 # Test related_query_name
551 field = models.ManyToManyField("auth.Permission", related_query_name="foobar")
552 name, path, args, kwargs = field.deconstruct()
553 self.assertEqual(path, "django.db.models.ManyToManyField")
554 self.assertEqual(args, [])
555 self.assertEqual(
556 kwargs, {"to": "auth.permission", "related_query_name": "foobar"}
557 )
558 # Test limit_choices_to
559 field = models.ManyToManyField(
560 "auth.Permission", limit_choices_to={"foo": "bar"}
561 )
562 name, path, args, kwargs = field.deconstruct()
563 self.assertEqual(path, "django.db.models.ManyToManyField")
564 self.assertEqual(args, [])
565 self.assertEqual(
566 kwargs, {"to": "auth.permission", "limit_choices_to": {"foo": "bar"}}
567 )
568
569 @override_settings(AUTH_USER_MODEL="auth.Permission")
570 def test_many_to_many_field_swapped(self):
571 with isolate_lru_cache(apps.get_swappable_settings_name):
572 # It doesn't matter that we swapped out user for permission;
573 # there's no validation. We just want to check the setting stuff works.
574 field = models.ManyToManyField("auth.Permission")
575 name, path, args, kwargs = field.deconstruct()
576
577 self.assertEqual(path, "django.db.models.ManyToManyField")
578 self.assertEqual(args, [])
579 self.assertEqual(kwargs, {"to": "auth.permission"})
580 self.assertEqual(kwargs["to"].setting_name, "AUTH_USER_MODEL")
581
582 def test_many_to_many_field_related_name(self):
583 class MyModel(models.Model):
584 flag = models.BooleanField(default=True)
585 m2m = models.ManyToManyField("self")
586 m2m_related_name = models.ManyToManyField(
587 "self",
588 related_query_name="custom_query_name",
589 limit_choices_to={"flag": True},
590 )
591
592 name, path, args, kwargs = MyModel.m2m.field.deconstruct()
593 self.assertEqual(path, "django.db.models.ManyToManyField")
594 self.assertEqual(args, [])
595 # deconstruct() should not include attributes which were not passed to
596 # the field during initialization.
597 self.assertEqual(kwargs, {"to": "field_deconstruction.mymodel"})
598 # Passed attributes.
599 name, path, args, kwargs = MyModel.m2m_related_name.field.deconstruct()
600 self.assertEqual(path, "django.db.models.ManyToManyField")
601 self.assertEqual(args, [])
602 self.assertEqual(
603 kwargs,
604 {
605 "to": "field_deconstruction.mymodel",
606 "related_query_name": "custom_query_name",
607 "limit_choices_to": {"flag": True},
608 },
609 )
610
611 def test_positive_integer_field(self):
612 field = models.PositiveIntegerField()
613 name, path, args, kwargs = field.deconstruct()
614 self.assertEqual(path, "django.db.models.PositiveIntegerField")
615 self.assertEqual(args, [])
616 self.assertEqual(kwargs, {})
617
618 def test_positive_small_integer_field(self):
619 field = models.PositiveSmallIntegerField()
620 name, path, args, kwargs = field.deconstruct()
621 self.assertEqual(path, "django.db.models.PositiveSmallIntegerField")
622 self.assertEqual(args, [])
623 self.assertEqual(kwargs, {})
624
625 def test_positive_big_integer_field(self):
626 field = models.PositiveBigIntegerField()
627 name, path, args, kwargs = field.deconstruct()
628 self.assertEqual(path, "django.db.models.PositiveBigIntegerField")
629 self.assertEqual(args, [])
630 self.assertEqual(kwargs, {})
631
632 def test_slug_field(self):
633 field = models.SlugField()
634 name, path, args, kwargs = field.deconstruct()
635 self.assertEqual(path, "django.db.models.SlugField")
636 self.assertEqual(args, [])
637 self.assertEqual(kwargs, {})
638 field = models.SlugField(db_index=False, max_length=231)
639 name, path, args, kwargs = field.deconstruct()
640 self.assertEqual(path, "django.db.models.SlugField")
641 self.assertEqual(args, [])
642 self.assertEqual(kwargs, {"db_index": False, "max_length": 231})
643
644 def test_small_integer_field(self):
645 field = models.SmallIntegerField()
646 name, path, args, kwargs = field.deconstruct()
647 self.assertEqual(path, "django.db.models.SmallIntegerField")
648 self.assertEqual(args, [])
649 self.assertEqual(kwargs, {})
650
651 def test_text_field(self):
652 field = models.TextField()
653 name, path, args, kwargs = field.deconstruct()
654 self.assertEqual(path, "django.db.models.TextField")
655 self.assertEqual(args, [])
656 self.assertEqual(kwargs, {})
657
658 def test_time_field(self):
659 field = models.TimeField()
660 name, path, args, kwargs = field.deconstruct()
661 self.assertEqual(path, "django.db.models.TimeField")
662 self.assertEqual(args, [])
663 self.assertEqual(kwargs, {})
664
665 field = models.TimeField(auto_now=True)
666 name, path, args, kwargs = field.deconstruct()
667 self.assertEqual(args, [])
668 self.assertEqual(kwargs, {"auto_now": True})
669
670 field = models.TimeField(auto_now_add=True)
671 name, path, args, kwargs = field.deconstruct()
672 self.assertEqual(args, [])
673 self.assertEqual(kwargs, {"auto_now_add": True})
674
675 def test_url_field(self):
676 field = models.URLField()
677 name, path, args, kwargs = field.deconstruct()
678 self.assertEqual(path, "django.db.models.URLField")
679 self.assertEqual(args, [])
680 self.assertEqual(kwargs, {})
681 field = models.URLField(max_length=231)
682 name, path, args, kwargs = field.deconstruct()
683 self.assertEqual(path, "django.db.models.URLField")
684 self.assertEqual(args, [])
685 self.assertEqual(kwargs, {"max_length": 231})
686
687 def test_binary_field(self):
688 field = models.BinaryField()
689 name, path, args, kwargs = field.deconstruct()
690 self.assertEqual(path, "django.db.models.BinaryField")
691 self.assertEqual(args, [])
692 self.assertEqual(kwargs, {})
693 field = models.BinaryField(editable=True)
694 name, path, args, kwargs = field.deconstruct()
695 self.assertEqual(args, [])
696 self.assertEqual(kwargs, {"editable": True})