Debian Codegraph @

tests/model_meta/tests.py

raw
1 from django.apps import apps
2 from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation
3 from django.core.exceptions import FieldDoesNotExist
4 from django.db.models import CharField, Field, ForeignObjectRel, ManyToManyField
5 from django.db.models.options import EMPTY_RELATION_TREE, IMMUTABLE_WARNING
6 from django.test import SimpleTestCase, override_settings
7
8 from .models import (
9 AbstractPerson,
10 BasePerson,
11 Child,
12 CommonAncestor,
13 FirstParent,
14 Person,
15 ProxyPerson,
16 Relating,
17 Relation,
18 SecondParent,
19 Swappable,
20 )
21 from .results import TEST_RESULTS
22
23
24 class OptionsBaseTests(SimpleTestCase):
25 def _map_related_query_names(self, res):
26 return tuple((o.name, m) for o, m in res)
27
28 def _map_names(self, res):
29 return tuple((f.name, m) for f, m in res)
30
31 def _model(self, current_model, field):
32 model = field.model._meta.concrete_model
33 return None if model == current_model else model
34
35 def _details(self, current_model, relation):
36 direct = isinstance(relation, (Field, GenericForeignKey))
37 model = relation.model._meta.concrete_model
38 if model == current_model:
39 model = None
40
41 field = relation if direct else relation.field
42 return (
43 relation,
44 model,
45 direct,
46 bool(field.many_to_many),
47 ) # many_to_many can be None
48
49
50 class GetFieldsTests(OptionsBaseTests):
51 def test_get_fields_is_immutable(self):
52 msg = IMMUTABLE_WARNING % "get_fields()"
53 for _ in range(2):
54 # Running unit test twice to ensure both non-cached and cached result
55 # are immutable.
56 fields = Person._meta.get_fields()
57 with self.assertRaisesMessage(AttributeError, msg):
58 fields += ["errors"]
59
60
61 class LabelTests(OptionsBaseTests):
62 def test_label(self):
63 for model, expected_result in TEST_RESULTS["labels"].items():
64 self.assertEqual(model._meta.label, expected_result)
65
66 def test_label_lower(self):
67 for model, expected_result in TEST_RESULTS["lower_labels"].items():
68 self.assertEqual(model._meta.label_lower, expected_result)
69
70
71 class DataTests(OptionsBaseTests):
72 def test_fields(self):
73 for model, expected_result in TEST_RESULTS["fields"].items():
74 fields = model._meta.fields
75 self.assertEqual([f.attname for f in fields], expected_result)
76
77 def test_local_fields(self):
78 def is_data_field(f):
79 return isinstance(f, Field) and not f.many_to_many
80
81 for model, expected_result in TEST_RESULTS["local_fields"].items():
82 fields = model._meta.local_fields
83 self.assertEqual([f.attname for f in fields], expected_result)
84 for f in fields:
85 self.assertEqual(f.model, model)
86 self.assertTrue(is_data_field(f))
87
88 def test_local_concrete_fields(self):
89 for model, expected_result in TEST_RESULTS["local_concrete_fields"].items():
90 fields = model._meta.local_concrete_fields
91 self.assertEqual([f.attname for f in fields], expected_result)
92 for f in fields:
93 self.assertIsNotNone(f.column)
94
95
96 class M2MTests(OptionsBaseTests):
97 def test_many_to_many(self):
98 for model, expected_result in TEST_RESULTS["many_to_many"].items():
99 fields = model._meta.many_to_many
100 self.assertEqual([f.attname for f in fields], expected_result)
101 for f in fields:
102 self.assertTrue(f.many_to_many and f.is_relation)
103
104 def test_many_to_many_with_model(self):
105 for model, expected_result in TEST_RESULTS["many_to_many_with_model"].items():
106 models = [self._model(model, field) for field in model._meta.many_to_many]
107 self.assertEqual(models, expected_result)
108
109
110 class RelatedObjectsTests(OptionsBaseTests):
111 def key_name(self, r):
112 return r[0]
113
114 def test_related_objects(self):
115 result_key = "get_all_related_objects_with_model"
116 for model, expected in TEST_RESULTS[result_key].items():
117 objects = [
118 (field, self._model(model, field))
119 for field in model._meta.get_fields()
120 if field.auto_created and not field.concrete
121 ]
122 self.assertEqual(
123 sorted(self._map_related_query_names(objects), key=self.key_name),
124 sorted(expected, key=self.key_name),
125 )
126
127 def test_related_objects_local(self):
128 result_key = "get_all_related_objects_with_model_local"
129 for model, expected in TEST_RESULTS[result_key].items():
130 objects = [
131 (field, self._model(model, field))
132 for field in model._meta.get_fields(include_parents=False)
133 if field.auto_created and not field.concrete
134 ]
135 self.assertEqual(
136 sorted(self._map_related_query_names(objects), key=self.key_name),
137 sorted(expected, key=self.key_name),
138 )
139
140 def test_related_objects_include_hidden(self):
141 result_key = "get_all_related_objects_with_model_hidden"
142 for model, expected in TEST_RESULTS[result_key].items():
143 objects = [
144 (field, self._model(model, field))
145 for field in model._meta.get_fields(include_hidden=True)
146 if field.auto_created and not field.concrete
147 ]
148 self.assertEqual(
149 sorted(self._map_names(objects), key=self.key_name),
150 sorted(expected, key=self.key_name),
151 )
152
153 def test_related_objects_include_hidden_local_only(self):
154 result_key = "get_all_related_objects_with_model_hidden_local"
155 for model, expected in TEST_RESULTS[result_key].items():
156 objects = [
157 (field, self._model(model, field))
158 for field in model._meta.get_fields(
159 include_hidden=True, include_parents=False
160 )
161 if field.auto_created and not field.concrete
162 ]
163 self.assertEqual(
164 sorted(self._map_names(objects), key=self.key_name),
165 sorted(expected, key=self.key_name),
166 )
167
168
169 class PrivateFieldsTests(OptionsBaseTests):
170 def test_private_fields(self):
171 for model, expected_names in TEST_RESULTS["private_fields"].items():
172 objects = model._meta.private_fields
173 self.assertEqual(sorted(f.name for f in objects), sorted(expected_names))
174
175
176 class GetFieldByNameTests(OptionsBaseTests):
177 def test_get_data_field(self):
178 field_info = self._details(Person, Person._meta.get_field("data_abstract"))
179 self.assertEqual(field_info[1:], (BasePerson, True, False))
180 self.assertIsInstance(field_info[0], CharField)
181
182 def test_get_m2m_field(self):
183 field_info = self._details(Person, Person._meta.get_field("m2m_base"))
184 self.assertEqual(field_info[1:], (BasePerson, True, True))
185 self.assertIsInstance(field_info[0], ManyToManyField)
186
187 def test_get_related_object(self):
188 field_info = self._details(
189 Person, Person._meta.get_field("relating_baseperson")
190 )
191 self.assertEqual(field_info[1:], (BasePerson, False, False))
192 self.assertIsInstance(field_info[0], ForeignObjectRel)
193
194 def test_get_related_m2m(self):
195 field_info = self._details(Person, Person._meta.get_field("relating_people"))
196 self.assertEqual(field_info[1:], (None, False, True))
197 self.assertIsInstance(field_info[0], ForeignObjectRel)
198
199 def test_get_generic_relation(self):
200 field_info = self._details(
201 Person, Person._meta.get_field("generic_relation_base")
202 )
203 self.assertEqual(field_info[1:], (None, True, False))
204 self.assertIsInstance(field_info[0], GenericRelation)
205
206 def test_get_fields_only_searches_forward_on_apps_not_ready(self):
207 opts = Person._meta
208 # If apps registry is not ready, get_field() searches over only
209 # forward fields.
210 opts.apps.models_ready = False
211 try:
212 # 'data_abstract' is a forward field, and therefore will be found
213 self.assertTrue(opts.get_field("data_abstract"))
214 msg = (
215 "Person has no field named 'relating_baseperson'. The app "
216 "cache isn't ready yet, so if this is an auto-created related "
217 "field, it won't be available yet."
218 )
219 # 'data_abstract' is a reverse field, and will raise an exception
220 with self.assertRaisesMessage(FieldDoesNotExist, msg):
221 opts.get_field("relating_baseperson")
222 finally:
223 opts.apps.models_ready = True
224
225
226 class VerboseNameRawTests(SimpleTestCase):
227 def test_string(self):
228 # Clear cached property.
229 Relation._meta.__dict__.pop("verbose_name_raw", None)
230 self.assertEqual(Relation._meta.verbose_name_raw, "relation")
231
232 def test_gettext(self):
233 Person._meta.__dict__.pop("verbose_name_raw", None)
234 self.assertEqual(Person._meta.verbose_name_raw, "Person")
235
236
237 class SwappedTests(SimpleTestCase):
238 def test_plain_model_none(self):
239 self.assertIsNone(Relation._meta.swapped)
240
241 def test_unset(self):
242 self.assertIsNone(Swappable._meta.swapped)
243
244 def test_set_and_unset(self):
245 with override_settings(MODEL_META_TESTS_SWAPPED="model_meta.Relation"):
246 self.assertEqual(Swappable._meta.swapped, "model_meta.Relation")
247 self.assertIsNone(Swappable._meta.swapped)
248
249 def test_setting_none(self):
250 with override_settings(MODEL_META_TESTS_SWAPPED=None):
251 self.assertIsNone(Swappable._meta.swapped)
252
253 def test_setting_non_label(self):
254 with override_settings(MODEL_META_TESTS_SWAPPED="not-a-label"):
255 self.assertEqual(Swappable._meta.swapped, "not-a-label")
256
257 def test_setting_self(self):
258 with override_settings(MODEL_META_TESTS_SWAPPED="model_meta.swappable"):
259 self.assertIsNone(Swappable._meta.swapped)
260
261
262 class RelationTreeTests(SimpleTestCase):
263 all_models = (Relation, AbstractPerson, BasePerson, Person, ProxyPerson, Relating)
264
265 def setUp(self):
266 apps.clear_cache()
267
268 def test_clear_cache_clears_relation_tree(self):
269 # The apps.clear_cache is setUp() should have deleted all trees.
270 # Exclude abstract models that are not included in the Apps registry
271 # and have no cache.
272 all_models_with_cache = (m for m in self.all_models if not m._meta.abstract)
273 for m in all_models_with_cache:
274 self.assertNotIn("_relation_tree", m._meta.__dict__)
275
276 def test_first_relation_tree_access_populates_all(self):
277 # On first access, relation tree should have populated cache.
278 self.assertTrue(self.all_models[0]._meta._relation_tree)
279
280 # AbstractPerson does not have any relations, so relation_tree
281 # should just return an EMPTY_RELATION_TREE.
282 self.assertEqual(AbstractPerson._meta._relation_tree, EMPTY_RELATION_TREE)
283
284 # All the other models should already have their relation tree
285 # in the internal __dict__ .
286 all_models_but_abstractperson = (
287 m for m in self.all_models if m is not AbstractPerson
288 )
289 for m in all_models_but_abstractperson:
290 self.assertIn("_relation_tree", m._meta.__dict__)
291
292 def test_relations_related_objects(self):
293 # Testing non hidden related objects
294 self.assertEqual(
295 sorted(
296 field.related_query_name()
297 for field in Relation._meta._relation_tree
298 if not field.remote_field.field.remote_field.hidden
299 ),
300 sorted(
301 [
302 "fk_abstract_rel",
303 "fk_base_rel",
304 "fk_concrete_rel",
305 "fo_abstract_rel",
306 "fo_base_rel",
307 "fo_concrete_rel",
308 "m2m_abstract_rel",
309 "m2m_base_rel",
310 "m2m_concrete_rel",
311 ]
312 ),
313 )
314 # Testing hidden related objects
315 self.assertEqual(
316 sorted(
317 field.related_query_name() for field in BasePerson._meta._relation_tree
318 ),
319 sorted(
320 [
321 "+",
322 "_model_meta_relating_basepeople_hidden_+",
323 "BasePerson_following_abstract+",
324 "BasePerson_following_abstract+",
325 "BasePerson_following_base+",
326 "BasePerson_following_base+",
327 "BasePerson_friends_abstract+",
328 "BasePerson_friends_abstract+",
329 "BasePerson_friends_base+",
330 "BasePerson_friends_base+",
331 "BasePerson_m2m_abstract+",
332 "BasePerson_m2m_base+",
333 "Relating_basepeople+",
334 "Relating_basepeople_hidden+",
335 "followers_abstract",
336 "followers_base",
337 "friends_abstract_rel_+",
338 "friends_base_rel_+",
339 "person",
340 "relating_basepeople",
341 "relating_baseperson",
342 ]
343 ),
344 )
345 self.assertEqual(
346 [
347 field.related_query_name()
348 for field in AbstractPerson._meta._relation_tree
349 ],
350 [],
351 )
352
353
354 class AllParentsTests(SimpleTestCase):
355 def test_all_parents(self):
356 self.assertEqual(CommonAncestor._meta.all_parents, ())
357 self.assertEqual(FirstParent._meta.all_parents, (CommonAncestor,))
358 self.assertEqual(SecondParent._meta.all_parents, (CommonAncestor,))
359 self.assertEqual(
360 Child._meta.all_parents,
361 (FirstParent, SecondParent, CommonAncestor),
362 )
363
364 def test_get_parent_list(self):
365 self.assertEqual(Child._meta.get_parent_list(), list(Child._meta.all_parents))
366
367
368 class PropertyNamesTests(SimpleTestCase):
369 def test_person(self):
370 # Instance only descriptors don't appear in _property_names.
371 self.assertEqual(BasePerson().test_instance_only_descriptor, 1)
372 with self.assertRaisesMessage(AttributeError, "Instance only"):
373 AbstractPerson.test_instance_only_descriptor
374 self.assertEqual(
375 AbstractPerson._meta._property_names, frozenset(["pk", "test_property"])
376 )
377
378
379 class ReturningFieldsTests(SimpleTestCase):
380 def test_pk(self):
381 self.assertEqual(Relation._meta.db_returning_fields, [Relation._meta.pk])
382
383
384 class AbstractModelTests(SimpleTestCase):
385 def test_abstract_model_not_instantiated(self):
386 msg = "Abstract models cannot be instantiated."
387 with self.assertRaisesMessage(TypeError, msg):
388 AbstractPerson()