Debian Codegraph @

tests/model_fields/test_field_flags.py

raw
1 from django import test
2 from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation
3 from django.db import models
4
5 from .models import AllFieldsModel
6
7 NON_CONCRETE_FIELDS = (
8 models.ForeignObject,
9 GenericForeignKey,
10 GenericRelation,
11 )
12
13 NON_EDITABLE_FIELDS = (
14 models.BinaryField,
15 GenericForeignKey,
16 GenericRelation,
17 )
18
19 RELATION_FIELDS = (
20 models.ForeignKey,
21 models.ForeignObject,
22 models.ManyToManyField,
23 models.OneToOneField,
24 GenericForeignKey,
25 GenericRelation,
26 )
27
28 MANY_TO_MANY_CLASSES = {
29 models.ManyToManyField,
30 }
31
32 MANY_TO_ONE_CLASSES = {
33 models.ForeignObject,
34 models.ForeignKey,
35 GenericForeignKey,
36 }
37
38 ONE_TO_MANY_CLASSES = {
39 models.ForeignObjectRel,
40 models.ManyToOneRel,
41 GenericRelation,
42 }
43
44 ONE_TO_ONE_CLASSES = {
45 models.OneToOneField,
46 }
47
48 FLAG_PROPERTIES = (
49 "concrete",
50 "editable",
51 "is_relation",
52 "model",
53 "hidden",
54 "one_to_many",
55 "many_to_one",
56 "many_to_many",
57 "one_to_one",
58 "related_model",
59 )
60
61 FLAG_PROPERTIES_FOR_RELATIONS = (
62 "one_to_many",
63 "many_to_one",
64 "many_to_many",
65 "one_to_one",
66 )
67
68
69 class FieldFlagsTests(test.SimpleTestCase):
70 @classmethod
71 def setUpClass(cls):
72 super().setUpClass()
73 cls.fields = [
74 *AllFieldsModel._meta.fields,
75 *AllFieldsModel._meta.private_fields,
76 ]
77
78 cls.all_fields = [
79 *cls.fields,
80 *AllFieldsModel._meta.many_to_many,
81 *AllFieldsModel._meta.private_fields,
82 ]
83
84 cls.fields_and_reverse_objects = [
85 *cls.all_fields,
86 *AllFieldsModel._meta.related_objects,
87 ]
88
89 def test_each_field_should_have_a_concrete_attribute(self):
90 self.assertTrue(all(f.concrete.__class__ == bool for f in self.fields))
91
92 def test_each_field_should_have_an_editable_attribute(self):
93 self.assertTrue(all(f.editable.__class__ == bool for f in self.all_fields))
94
95 def test_each_field_should_have_a_has_rel_attribute(self):
96 self.assertTrue(all(f.is_relation.__class__ == bool for f in self.all_fields))
97
98 def test_each_object_should_have_auto_created(self):
99 self.assertTrue(
100 all(
101 f.auto_created.__class__ == bool
102 for f in self.fields_and_reverse_objects
103 )
104 )
105
106 def test_non_concrete_fields(self):
107 for field in self.fields:
108 if type(field) in NON_CONCRETE_FIELDS:
109 self.assertFalse(field.concrete)
110 else:
111 self.assertTrue(field.concrete)
112
113 def test_non_editable_fields(self):
114 for field in self.all_fields:
115 if type(field) in NON_EDITABLE_FIELDS:
116 self.assertFalse(field.editable)
117 else:
118 self.assertTrue(field.editable)
119
120 def test_related_fields(self):
121 for field in self.all_fields:
122 if type(field) in RELATION_FIELDS:
123 self.assertTrue(field.is_relation)
124 else:
125 self.assertFalse(field.is_relation)
126
127 def test_field_names_should_always_be_available(self):
128 for field in self.fields_and_reverse_objects:
129 self.assertTrue(field.name)
130
131 def test_all_field_types_should_have_flags(self):
132 for field in self.fields_and_reverse_objects:
133 for flag in FLAG_PROPERTIES:
134 self.assertTrue(
135 hasattr(field, flag),
136 "Field %s does not have flag %s" % (field, flag),
137 )
138 if field.is_relation:
139 true_cardinality_flags = sum(
140 getattr(field, flag) is True
141 for flag in FLAG_PROPERTIES_FOR_RELATIONS
142 )
143 # If the field has a relation, there should be only one of the
144 # 4 cardinality flags available.
145 self.assertEqual(1, true_cardinality_flags)
146
147 def test_cardinality_m2m(self):
148 m2m_type_fields = [
149 f for f in self.all_fields if f.is_relation and f.many_to_many
150 ]
151 # Test classes are what we expect
152 self.assertEqual(MANY_TO_MANY_CLASSES, {f.__class__ for f in m2m_type_fields})
153
154 # Ensure all m2m reverses are m2m
155 for field in m2m_type_fields:
156 reverse_field = field.remote_field
157 self.assertTrue(reverse_field.is_relation)
158 self.assertTrue(reverse_field.many_to_many)
159 self.assertTrue(reverse_field.related_model)
160
161 def test_cardinality_o2m(self):
162 o2m_type_fields = [
163 f
164 for f in self.fields_and_reverse_objects
165 if f.is_relation and f.one_to_many
166 ]
167 # Test classes are what we expect
168 self.assertEqual(ONE_TO_MANY_CLASSES, {f.__class__ for f in o2m_type_fields})
169
170 # Ensure all o2m reverses are m2o
171 for field in o2m_type_fields:
172 if field.concrete:
173 reverse_field = field.remote_field
174 self.assertTrue(reverse_field.is_relation and reverse_field.many_to_one)
175
176 def test_cardinality_m2o(self):
177 m2o_type_fields = [
178 f
179 for f in self.fields_and_reverse_objects
180 if f.is_relation and f.many_to_one
181 ]
182 # Test classes are what we expect
183 self.assertEqual(MANY_TO_ONE_CLASSES, {f.__class__ for f in m2o_type_fields})
184
185 # Ensure all m2o reverses are o2m
186 for obj in m2o_type_fields:
187 if hasattr(obj, "field"):
188 reverse_field = obj.field
189 self.assertTrue(reverse_field.is_relation and reverse_field.one_to_many)
190
191 def test_cardinality_o2o(self):
192 o2o_type_fields = [f for f in self.all_fields if f.is_relation and f.one_to_one]
193 # Test classes are what we expect
194 self.assertEqual(ONE_TO_ONE_CLASSES, {f.__class__ for f in o2o_type_fields})
195
196 # Ensure all o2o reverses are o2o
197 for obj in o2o_type_fields:
198 if hasattr(obj, "field"):
199 reverse_field = obj.field
200 self.assertTrue(reverse_field.is_relation and reverse_field.one_to_one)
201
202 def test_hidden_flag(self):
203 incl_hidden = set(AllFieldsModel._meta.get_fields(include_hidden=True))
204 no_hidden = set(AllFieldsModel._meta.get_fields())
205 fields_that_should_be_hidden = incl_hidden - no_hidden
206 for f in incl_hidden:
207 self.assertEqual(f in fields_that_should_be_hidden, f.hidden)
208
209 def test_model_and_reverse_model_should_equal_on_relations(self):
210 for field in AllFieldsModel._meta.get_fields():
211 is_concrete_forward_field = field.concrete and field.related_model
212 if is_concrete_forward_field:
213 reverse_field = field.remote_field
214 self.assertEqual(field.model, reverse_field.related_model)
215 self.assertEqual(field.related_model, reverse_field.model)
216
217 def test_null(self):
218 # null isn't well defined for a ManyToManyField, but changing it to
219 # True causes backwards compatibility problems (#25320).
220 self.assertFalse(AllFieldsModel._meta.get_field("m2m").null)
221 self.assertTrue(AllFieldsModel._meta.get_field("reverse2").null)