mirrors/django
1
0
Fork 0
mirror of https://github.com/django/django.git synced 2025-10-31 09:41:08 +00:00
Code Issues 32 Releases Wiki Activity

Refs #33476 -- Reformatted code with Black.

Browse Source
This commit is contained in:
django-bot
2022-02-03 20:24:19 +01:00
committed by Mariusz Felisiak
parent f68fa8b45d
commit 9c19aff7c7
1992 changed files with 139577 additions and 96284 deletions
Download Patch File Download Diff File Expand all files Collapse all files

112
tests/model_meta/models.py
View File

@@ -1,6 +1,4 @@
from django.contrib.contenttypes.fields import (
GenericForeignKey, GenericRelation,
)
from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation
from django.contrib.contenttypes.models import ContentType
from django.db import models
@@ -12,33 +10,41 @@ class Relation(models.Model):
class InstanceOnlyDescriptor:
def __get__(self, instance, cls=None):
if instance is None:
raise AttributeError('Instance only')
raise AttributeError("Instance only")
return 1
class AbstractPerson(models.Model):
# DATA fields
data_abstract = models.CharField(max_length=10)
fk_abstract = models.ForeignKey(Relation, models.CASCADE, related_name='fk_abstract_rel')
fk_abstract = models.ForeignKey(
Relation, models.CASCADE, related_name="fk_abstract_rel"
)
# M2M fields
m2m_abstract = models.ManyToManyField(Relation, related_name='m2m_abstract_rel')
friends_abstract = models.ManyToManyField('self', symmetrical=True)
following_abstract = models.ManyToManyField('self', related_name='followers_abstract', symmetrical=False)
m2m_abstract = models.ManyToManyField(Relation, related_name="m2m_abstract_rel")
friends_abstract = models.ManyToManyField("self", symmetrical=True)
following_abstract = models.ManyToManyField(
"self", related_name="followers_abstract", symmetrical=False
)
# VIRTUAL fields
data_not_concrete_abstract = models.ForeignObject(
Relation,
on_delete=models.CASCADE,
from_fields=['abstract_non_concrete_id'],
to_fields=['id'],
related_name='fo_abstract_rel',
from_fields=["abstract_non_concrete_id"],
to_fields=["id"],
related_name="fo_abstract_rel",
)
# GFK fields
content_type_abstract = models.ForeignKey(ContentType, models.CASCADE, related_name='+')
content_type_abstract = models.ForeignKey(
ContentType, models.CASCADE, related_name="+"
)
object_id_abstract = models.PositiveIntegerField()
content_object_abstract = GenericForeignKey('content_type_abstract', 'object_id_abstract')
content_object_abstract = GenericForeignKey(
"content_type_abstract", "object_id_abstract"
)
# GR fields
generic_relation_abstract = GenericRelation(Relation)
@@ -56,26 +62,28 @@ class AbstractPerson(models.Model):
class BasePerson(AbstractPerson):
# DATA fields
data_base = models.CharField(max_length=10)
fk_base = models.ForeignKey(Relation, models.CASCADE, related_name='fk_base_rel')
fk_base = models.ForeignKey(Relation, models.CASCADE, related_name="fk_base_rel")
# M2M fields
m2m_base = models.ManyToManyField(Relation, related_name='m2m_base_rel')
friends_base = models.ManyToManyField('self', symmetrical=True)
following_base = models.ManyToManyField('self', related_name='followers_base', symmetrical=False)
m2m_base = models.ManyToManyField(Relation, related_name="m2m_base_rel")
friends_base = models.ManyToManyField("self", symmetrical=True)
following_base = models.ManyToManyField(
"self", related_name="followers_base", symmetrical=False
)
# VIRTUAL fields
data_not_concrete_base = models.ForeignObject(
Relation,
on_delete=models.CASCADE,
from_fields=['base_non_concrete_id'],
to_fields=['id'],
related_name='fo_base_rel',
from_fields=["base_non_concrete_id"],
to_fields=["id"],
related_name="fo_base_rel",
)
# GFK fields
content_type_base = models.ForeignKey(ContentType, models.CASCADE, related_name='+')
content_type_base = models.ForeignKey(ContentType, models.CASCADE, related_name="+")
object_id_base = models.PositiveIntegerField()
content_object_base = GenericForeignKey('content_type_base', 'object_id_base')
content_object_base = GenericForeignKey("content_type_base", "object_id_base")
# GR fields
generic_relation_base = GenericRelation(Relation)
@@ -84,26 +92,34 @@ class BasePerson(AbstractPerson):
class Person(BasePerson):
# DATA fields
data_inherited = models.CharField(max_length=10)
fk_inherited = models.ForeignKey(Relation, models.CASCADE, related_name='fk_concrete_rel')
fk_inherited = models.ForeignKey(
Relation, models.CASCADE, related_name="fk_concrete_rel"
)
# M2M Fields
m2m_inherited = models.ManyToManyField(Relation, related_name='m2m_concrete_rel')
friends_inherited = models.ManyToManyField('self', symmetrical=True)
following_inherited = models.ManyToManyField('self', related_name='followers_concrete', symmetrical=False)
m2m_inherited = models.ManyToManyField(Relation, related_name="m2m_concrete_rel")
friends_inherited = models.ManyToManyField("self", symmetrical=True)
following_inherited = models.ManyToManyField(
"self", related_name="followers_concrete", symmetrical=False
)
# VIRTUAL fields
data_not_concrete_inherited = models.ForeignObject(
Relation,
on_delete=models.CASCADE,
from_fields=['model_non_concrete_id'],
to_fields=['id'],
related_name='fo_concrete_rel',
from_fields=["model_non_concrete_id"],
to_fields=["id"],
related_name="fo_concrete_rel",
)
# GFK fields
content_type_concrete = models.ForeignKey(ContentType, models.CASCADE, related_name='+')
content_type_concrete = models.ForeignKey(
ContentType, models.CASCADE, related_name="+"
)
object_id_concrete = models.PositiveIntegerField()
content_object_concrete = GenericForeignKey('content_type_concrete', 'object_id_concrete')
content_object_concrete = GenericForeignKey(
"content_type_concrete", "object_id_concrete"
)
# GR fields
generic_relation_concrete = GenericRelation(Relation)
@@ -121,24 +137,30 @@ class PersonThroughProxySubclass(ProxyPerson):
class Relating(models.Model):
# ForeignKey to BasePerson
baseperson = models.ForeignKey(BasePerson, models.CASCADE, related_name='relating_baseperson')
baseperson_hidden = models.ForeignKey(BasePerson, models.CASCADE, related_name='+')
baseperson = models.ForeignKey(
BasePerson, models.CASCADE, related_name="relating_baseperson"
)
baseperson_hidden = models.ForeignKey(BasePerson, models.CASCADE, related_name="+")
# ForeignKey to Person
person = models.ForeignKey(Person, models.CASCADE, related_name='relating_person')
person_hidden = models.ForeignKey(Person, models.CASCADE, related_name='+')
person = models.ForeignKey(Person, models.CASCADE, related_name="relating_person")
person_hidden = models.ForeignKey(Person, models.CASCADE, related_name="+")
# ForeignKey to ProxyPerson
proxyperson = models.ForeignKey(ProxyPerson, models.CASCADE, related_name='relating_proxyperson')
proxyperson_hidden = models.ForeignKey(ProxyPerson, models.CASCADE, related_name='relating_proxyperson_hidden+')
proxyperson = models.ForeignKey(
ProxyPerson, models.CASCADE, related_name="relating_proxyperson"
)
proxyperson_hidden = models.ForeignKey(
ProxyPerson, models.CASCADE, related_name="relating_proxyperson_hidden+"
)
# ManyToManyField to BasePerson
basepeople = models.ManyToManyField(BasePerson, related_name='relating_basepeople')
basepeople_hidden = models.ManyToManyField(BasePerson, related_name='+')
basepeople = models.ManyToManyField(BasePerson, related_name="relating_basepeople")
basepeople_hidden = models.ManyToManyField(BasePerson, related_name="+")
# ManyToManyField to Person
people = models.ManyToManyField(Person, related_name='relating_people')
people_hidden = models.ManyToManyField(Person, related_name='+')
people = models.ManyToManyField(Person, related_name="relating_people")
people_hidden = models.ManyToManyField(Person, related_name="+")
# ParentListTests models
@@ -147,11 +169,15 @@ class CommonAncestor(models.Model):
class FirstParent(CommonAncestor):
first_ancestor = models.OneToOneField(CommonAncestor, models.CASCADE, primary_key=True, parent_link=True)
first_ancestor = models.OneToOneField(
CommonAncestor, models.CASCADE, primary_key=True, parent_link=True
)
class SecondParent(CommonAncestor):
second_ancestor = models.OneToOneField(CommonAncestor, models.CASCADE, primary_key=True, parent_link=True)
second_ancestor = models.OneToOneField(
CommonAncestor, models.CASCADE, primary_key=True, parent_link=True
)
class Child(FirstParent, SecondParent):

1441
tests/model_meta/results.py
View File

File diff suppressed because it is too large Load Diff

174
tests/model_meta/tests.py
View File

@@ -1,23 +1,26 @@
from django.apps import apps
from django.contrib.contenttypes.fields import (
GenericForeignKey, GenericRelation,
)
from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation
from django.core.exceptions import FieldDoesNotExist
from django.db.models import (
CharField, Field, ForeignObjectRel, ManyToManyField,
)
from django.db.models import CharField, Field, ForeignObjectRel, ManyToManyField
from django.db.models.options import EMPTY_RELATION_TREE, IMMUTABLE_WARNING
from django.test import SimpleTestCase
from .models import (
AbstractPerson, BasePerson, Child, CommonAncestor, FirstParent, Person,
ProxyPerson, Relating, Relation, SecondParent,
AbstractPerson,
BasePerson,
Child,
CommonAncestor,
FirstParent,
Person,
ProxyPerson,
Relating,
Relation,
SecondParent,
)
from .results import TEST_RESULTS
class OptionsBaseTests(SimpleTestCase):
def _map_related_query_names(self, res):
return tuple((o.name, m) for o, m in res)
@@ -35,11 +38,15 @@ class OptionsBaseTests(SimpleTestCase):
model = None
field = relation if direct else relation.field
return relation, model, direct, bool(field.many_to_many) # many_to_many can be None
return (
relation,
model,
direct,
bool(field.many_to_many),
) # many_to_many can be None
class GetFieldsTests(OptionsBaseTests):
def test_get_fields_is_immutable(self):
msg = IMMUTABLE_WARNING % "get_fields()"
for _ in range(2):
@@ -51,20 +58,18 @@ class GetFieldsTests(OptionsBaseTests):
class LabelTests(OptionsBaseTests):
def test_label(self):
for model, expected_result in TEST_RESULTS['labels'].items():
for model, expected_result in TEST_RESULTS["labels"].items():
self.assertEqual(model._meta.label, expected_result)
def test_label_lower(self):
for model, expected_result in TEST_RESULTS['lower_labels'].items():
for model, expected_result in TEST_RESULTS["lower_labels"].items():
self.assertEqual(model._meta.label_lower, expected_result)
class DataTests(OptionsBaseTests):
def test_fields(self):
for model, expected_result in TEST_RESULTS['fields'].items():
for model, expected_result in TEST_RESULTS["fields"].items():
fields = model._meta.fields
self.assertEqual([f.attname for f in fields], expected_result)
@@ -72,7 +77,7 @@ class DataTests(OptionsBaseTests):
def is_data_field(f):
return isinstance(f, Field) and not f.many_to_many
for model, expected_result in TEST_RESULTS['local_fields'].items():
for model, expected_result in TEST_RESULTS["local_fields"].items():
fields = model._meta.local_fields
self.assertEqual([f.attname for f in fields], expected_result)
for f in fields:
@@ -80,7 +85,7 @@ class DataTests(OptionsBaseTests):
self.assertTrue(is_data_field(f))
def test_local_concrete_fields(self):
for model, expected_result in TEST_RESULTS['local_concrete_fields'].items():
for model, expected_result in TEST_RESULTS["local_concrete_fields"].items():
fields = model._meta.local_concrete_fields
self.assertEqual([f.attname for f in fields], expected_result)
for f in fields:
@@ -88,16 +93,15 @@ class DataTests(OptionsBaseTests):
class M2MTests(OptionsBaseTests):
def test_many_to_many(self):
for model, expected_result in TEST_RESULTS['many_to_many'].items():
for model, expected_result in TEST_RESULTS["many_to_many"].items():
fields = model._meta.many_to_many
self.assertEqual([f.attname for f in fields], expected_result)
for f in fields:
self.assertTrue(f.many_to_many and f.is_relation)
def test_many_to_many_with_model(self):
for model, expected_result in TEST_RESULTS['many_to_many_with_model'].items():
for model, expected_result in TEST_RESULTS["many_to_many_with_model"].items():
models = [self._model(model, field) for field in model._meta.many_to_many]
self.assertEqual(models, expected_result)
@@ -107,7 +111,7 @@ class RelatedObjectsTests(OptionsBaseTests):
return r[0]
def test_related_objects(self):
result_key = 'get_all_related_objects_with_model'
result_key = "get_all_related_objects_with_model"
for model, expected in TEST_RESULTS[result_key].items():
objects = [
(field, self._model(model, field))
@@ -120,7 +124,7 @@ class RelatedObjectsTests(OptionsBaseTests):
)
def test_related_objects_local(self):
result_key = 'get_all_related_objects_with_model_local'
result_key = "get_all_related_objects_with_model_local"
for model, expected in TEST_RESULTS[result_key].items():
objects = [
(field, self._model(model, field))
@@ -133,7 +137,7 @@ class RelatedObjectsTests(OptionsBaseTests):
)
def test_related_objects_include_hidden(self):
result_key = 'get_all_related_objects_with_model_hidden'
result_key = "get_all_related_objects_with_model_hidden"
for model, expected in TEST_RESULTS[result_key].items():
objects = [
(field, self._model(model, field))
@@ -142,55 +146,59 @@ class RelatedObjectsTests(OptionsBaseTests):
]
self.assertEqual(
sorted(self._map_names(objects), key=self.key_name),
sorted(expected, key=self.key_name)
sorted(expected, key=self.key_name),
)
def test_related_objects_include_hidden_local_only(self):
result_key = 'get_all_related_objects_with_model_hidden_local'
result_key = "get_all_related_objects_with_model_hidden_local"
for model, expected in TEST_RESULTS[result_key].items():
objects = [
(field, self._model(model, field))
for field in model._meta.get_fields(include_hidden=True, include_parents=False)
for field in model._meta.get_fields(
include_hidden=True, include_parents=False
)
if field.auto_created and not field.concrete
]
self.assertEqual(
sorted(self._map_names(objects), key=self.key_name),
sorted(expected, key=self.key_name)
sorted(expected, key=self.key_name),
)
class PrivateFieldsTests(OptionsBaseTests):
def test_private_fields(self):
for model, expected_names in TEST_RESULTS['private_fields'].items():
for model, expected_names in TEST_RESULTS["private_fields"].items():
objects = model._meta.private_fields
self.assertEqual(sorted(f.name for f in objects), sorted(expected_names))
class GetFieldByNameTests(OptionsBaseTests):
def test_get_data_field(self):
field_info = self._details(Person, Person._meta.get_field('data_abstract'))
field_info = self._details(Person, Person._meta.get_field("data_abstract"))
self.assertEqual(field_info[1:], (BasePerson, True, False))
self.assertIsInstance(field_info[0], CharField)
def test_get_m2m_field(self):
field_info = self._details(Person, Person._meta.get_field('m2m_base'))
field_info = self._details(Person, Person._meta.get_field("m2m_base"))
self.assertEqual(field_info[1:], (BasePerson, True, True))
self.assertIsInstance(field_info[0], ManyToManyField)
def test_get_related_object(self):
field_info = self._details(Person, Person._meta.get_field('relating_baseperson'))
field_info = self._details(
Person, Person._meta.get_field("relating_baseperson")
)
self.assertEqual(field_info[1:], (BasePerson, False, False))
self.assertIsInstance(field_info[0], ForeignObjectRel)
def test_get_related_m2m(self):
field_info = self._details(Person, Person._meta.get_field('relating_people'))
field_info = self._details(Person, Person._meta.get_field("relating_people"))
self.assertEqual(field_info[1:], (None, False, True))
self.assertIsInstance(field_info[0], ForeignObjectRel)
def test_get_generic_relation(self):
field_info = self._details(Person, Person._meta.get_field('generic_relation_base'))
field_info = self._details(
Person, Person._meta.get_field("generic_relation_base")
)
self.assertEqual(field_info[1:], (None, True, False))
self.assertIsInstance(field_info[0], GenericRelation)
@@ -201,7 +209,7 @@ class GetFieldByNameTests(OptionsBaseTests):
opts.apps.models_ready = False
try:
# 'data_abstract' is a forward field, and therefore will be found
self.assertTrue(opts.get_field('data_abstract'))
self.assertTrue(opts.get_field("data_abstract"))
msg = (
"Person has no field named 'relating_baseperson'. The app "
"cache isn't ready yet, so if this is an auto-created related "
@@ -209,7 +217,7 @@ class GetFieldByNameTests(OptionsBaseTests):
)
# 'data_abstract' is a reverse field, and will raise an exception
with self.assertRaisesMessage(FieldDoesNotExist, msg):
opts.get_field('relating_baseperson')
opts.get_field("relating_baseperson")
finally:
opts.apps.models_ready = True
@@ -226,7 +234,7 @@ class RelationTreeTests(SimpleTestCase):
# and have no cache.
all_models_with_cache = (m for m in self.all_models if not m._meta.abstract)
for m in all_models_with_cache:
self.assertNotIn('_relation_tree', m._meta.__dict__)
self.assertNotIn("_relation_tree", m._meta.__dict__)
def test_first_relation_tree_access_populates_all(self):
# On first access, relation tree should have populated cache.
@@ -238,34 +246,72 @@ class RelationTreeTests(SimpleTestCase):
# All the other models should already have their relation tree
# in the internal __dict__ .
all_models_but_abstractperson = (m for m in self.all_models if m is not AbstractPerson)
all_models_but_abstractperson = (
m for m in self.all_models if m is not AbstractPerson
)
for m in all_models_but_abstractperson:
self.assertIn('_relation_tree', m._meta.__dict__)
self.assertIn("_relation_tree", m._meta.__dict__)
def test_relations_related_objects(self):
# Testing non hidden related objects
self.assertEqual(
sorted(field.related_query_name() for field in Relation._meta._relation_tree
if not field.remote_field.field.remote_field.is_hidden()),
sorted([
'fk_abstract_rel', 'fk_base_rel', 'fk_concrete_rel', 'fo_abstract_rel',
'fo_base_rel', 'fo_concrete_rel', 'm2m_abstract_rel',
'm2m_base_rel', 'm2m_concrete_rel'
])
sorted(
field.related_query_name()
for field in Relation._meta._relation_tree
if not field.remote_field.field.remote_field.is_hidden()
),
sorted(
[
"fk_abstract_rel",
"fk_base_rel",
"fk_concrete_rel",
"fo_abstract_rel",
"fo_base_rel",
"fo_concrete_rel",
"m2m_abstract_rel",
"m2m_base_rel",
"m2m_concrete_rel",
]
),
)
# Testing hidden related objects
self.assertEqual(
sorted(field.related_query_name() for field in BasePerson._meta._relation_tree),
sorted([
'+', '_model_meta_relating_basepeople_hidden_+', 'BasePerson_following_abstract+',
'BasePerson_following_abstract+', 'BasePerson_following_base+', 'BasePerson_following_base+',
'BasePerson_friends_abstract+', 'BasePerson_friends_abstract+', 'BasePerson_friends_base+',
'BasePerson_friends_base+', 'BasePerson_m2m_abstract+', 'BasePerson_m2m_base+', 'Relating_basepeople+',
'Relating_basepeople_hidden+', 'followers_abstract', 'followers_base', 'friends_abstract_rel_+',
'friends_base_rel_+', 'person', 'relating_basepeople', 'relating_baseperson',
])
sorted(
field.related_query_name() for field in BasePerson._meta._relation_tree
),
sorted(
[
"+",
"_model_meta_relating_basepeople_hidden_+",
"BasePerson_following_abstract+",
"BasePerson_following_abstract+",
"BasePerson_following_base+",
"BasePerson_following_base+",
"BasePerson_friends_abstract+",
"BasePerson_friends_abstract+",
"BasePerson_friends_base+",
"BasePerson_friends_base+",
"BasePerson_m2m_abstract+",
"BasePerson_m2m_base+",
"Relating_basepeople+",
"Relating_basepeople_hidden+",
"followers_abstract",
"followers_base",
"friends_abstract_rel_+",
"friends_base_rel_+",
"person",
"relating_basepeople",
"relating_baseperson",
]
),
)
self.assertEqual(
[
field.related_query_name()
for field in AbstractPerson._meta._relation_tree
],
[],
)
self.assertEqual([field.related_query_name() for field in AbstractPerson._meta._relation_tree], [])
class ParentListTests(SimpleTestCase):
@@ -273,16 +319,20 @@ class ParentListTests(SimpleTestCase):
self.assertEqual(CommonAncestor._meta.get_parent_list(), [])
self.assertEqual(FirstParent._meta.get_parent_list(), [CommonAncestor])
self.assertEqual(SecondParent._meta.get_parent_list(), [CommonAncestor])
self.assertEqual(Child._meta.get_parent_list(), [FirstParent, SecondParent, CommonAncestor])
self.assertEqual(
Child._meta.get_parent_list(), [FirstParent, SecondParent, CommonAncestor]
)
class PropertyNamesTests(SimpleTestCase):
def test_person(self):
# Instance only descriptors don't appear in _property_names.
self.assertEqual(BasePerson().test_instance_only_descriptor, 1)
with self.assertRaisesMessage(AttributeError, 'Instance only'):
with self.assertRaisesMessage(AttributeError, "Instance only"):
AbstractPerson.test_instance_only_descriptor
self.assertEqual(AbstractPerson._meta._property_names, frozenset(['pk', 'test_property']))
self.assertEqual(
AbstractPerson._meta._property_names, frozenset(["pk", "test_property"])
)
class ReturningFieldsTests(SimpleTestCase):
@@ -292,6 +342,6 @@ class ReturningFieldsTests(SimpleTestCase):
class AbstractModelTests(SimpleTestCase):
def test_abstract_model_not_instantiated(self):
msg = 'Abstract models cannot be instantiated.'
msg = "Abstract models cannot be instantiated."
with self.assertRaisesMessage(TypeError, msg):
AbstractPerson()