mirror of
https://github.com/django/django.git
synced 2025-10-29 08:36:09 +00:00
2227 lines
78 KiB
Python
2227 lines
78 KiB
Python
from django.apps.registry import Apps
|
|
from django.contrib.contenttypes.fields import GenericForeignKey
|
|
from django.db import models
|
|
from django.db.migrations.exceptions import InvalidBasesError
|
|
from django.db.migrations.operations import (
|
|
AddField,
|
|
AlterField,
|
|
DeleteModel,
|
|
RemoveField,
|
|
)
|
|
from django.db.migrations.state import (
|
|
ModelState,
|
|
ProjectState,
|
|
get_related_models_recursive,
|
|
)
|
|
from django.test import SimpleTestCase, override_settings
|
|
from django.test.utils import isolate_apps
|
|
|
|
from .models import (
|
|
FoodManager,
|
|
FoodQuerySet,
|
|
ModelWithCustomBase,
|
|
NoMigrationFoodManager,
|
|
UnicodeModel,
|
|
)
|
|
|
|
|
|
class StateTests(SimpleTestCase):
|
|
"""
|
|
Tests state construction, rendering and modification by operations.
|
|
"""
|
|
|
|
def test_create(self):
|
|
"""
|
|
Tests making a ProjectState from an Apps
|
|
"""
|
|
|
|
new_apps = Apps(["migrations"])
|
|
|
|
class Author(models.Model):
|
|
name = models.CharField(max_length=255)
|
|
bio = models.TextField()
|
|
age = models.IntegerField(blank=True, null=True)
|
|
|
|
class Meta:
|
|
app_label = "migrations"
|
|
apps = new_apps
|
|
unique_together = ["name", "bio"]
|
|
|
|
class AuthorProxy(Author):
|
|
class Meta:
|
|
app_label = "migrations"
|
|
apps = new_apps
|
|
proxy = True
|
|
ordering = ["name"]
|
|
|
|
class SubAuthor(Author):
|
|
width = models.FloatField(null=True)
|
|
|
|
class Meta:
|
|
app_label = "migrations"
|
|
apps = new_apps
|
|
|
|
class Book(models.Model):
|
|
title = models.CharField(max_length=1000)
|
|
author = models.ForeignKey(Author, models.CASCADE)
|
|
contributors = models.ManyToManyField(Author)
|
|
|
|
class Meta:
|
|
app_label = "migrations"
|
|
apps = new_apps
|
|
verbose_name = "tome"
|
|
db_table = "test_tome"
|
|
indexes = [models.Index(fields=["title"])]
|
|
|
|
class Food(models.Model):
|
|
food_mgr = FoodManager("a", "b")
|
|
food_qs = FoodQuerySet.as_manager()
|
|
food_no_mgr = NoMigrationFoodManager("x", "y")
|
|
|
|
class Meta:
|
|
app_label = "migrations"
|
|
apps = new_apps
|
|
|
|
class FoodNoManagers(models.Model):
|
|
class Meta:
|
|
app_label = "migrations"
|
|
apps = new_apps
|
|
|
|
class FoodNoDefaultManager(models.Model):
|
|
food_no_mgr = NoMigrationFoodManager("x", "y")
|
|
food_mgr = FoodManager("a", "b")
|
|
food_qs = FoodQuerySet.as_manager()
|
|
|
|
class Meta:
|
|
app_label = "migrations"
|
|
apps = new_apps
|
|
|
|
mgr1 = FoodManager("a", "b")
|
|
mgr2 = FoodManager("x", "y", c=3, d=4)
|
|
|
|
class FoodOrderedManagers(models.Model):
|
|
# The managers on this model should be ordered by their creation
|
|
# counter and not by the order in model body
|
|
|
|
food_no_mgr = NoMigrationFoodManager("x", "y")
|
|
food_mgr2 = mgr2
|
|
food_mgr1 = mgr1
|
|
|
|
class Meta:
|
|
app_label = "migrations"
|
|
apps = new_apps
|
|
|
|
project_state = ProjectState.from_apps(new_apps)
|
|
author_state = project_state.models["migrations", "author"]
|
|
author_proxy_state = project_state.models["migrations", "authorproxy"]
|
|
sub_author_state = project_state.models["migrations", "subauthor"]
|
|
book_state = project_state.models["migrations", "book"]
|
|
food_state = project_state.models["migrations", "food"]
|
|
food_no_managers_state = project_state.models["migrations", "foodnomanagers"]
|
|
food_no_default_manager_state = project_state.models[
|
|
"migrations", "foodnodefaultmanager"
|
|
]
|
|
food_order_manager_state = project_state.models[
|
|
"migrations", "foodorderedmanagers"
|
|
]
|
|
book_index = models.Index(fields=["title"])
|
|
book_index.set_name_with_model(Book)
|
|
|
|
self.assertEqual(author_state.app_label, "migrations")
|
|
self.assertEqual(author_state.name, "Author")
|
|
self.assertEqual(list(author_state.fields), ["id", "name", "bio", "age"])
|
|
self.assertEqual(author_state.fields["name"].max_length, 255)
|
|
self.assertIs(author_state.fields["bio"].null, False)
|
|
self.assertIs(author_state.fields["age"].null, True)
|
|
self.assertEqual(
|
|
author_state.options,
|
|
{
|
|
"unique_together": {("name", "bio")},
|
|
"indexes": [],
|
|
"constraints": [],
|
|
},
|
|
)
|
|
self.assertEqual(author_state.bases, (models.Model,))
|
|
|
|
self.assertEqual(book_state.app_label, "migrations")
|
|
self.assertEqual(book_state.name, "Book")
|
|
self.assertEqual(
|
|
list(book_state.fields), ["id", "title", "author", "contributors"]
|
|
)
|
|
self.assertEqual(book_state.fields["title"].max_length, 1000)
|
|
self.assertIs(book_state.fields["author"].null, False)
|
|
self.assertEqual(
|
|
book_state.fields["contributors"].__class__.__name__, "ManyToManyField"
|
|
)
|
|
self.assertEqual(
|
|
book_state.options,
|
|
{
|
|
"verbose_name": "tome",
|
|
"db_table": "test_tome",
|
|
"indexes": [book_index],
|
|
"constraints": [],
|
|
},
|
|
)
|
|
self.assertEqual(book_state.bases, (models.Model,))
|
|
|
|
self.assertEqual(author_proxy_state.app_label, "migrations")
|
|
self.assertEqual(author_proxy_state.name, "AuthorProxy")
|
|
self.assertEqual(author_proxy_state.fields, {})
|
|
self.assertEqual(
|
|
author_proxy_state.options,
|
|
{"proxy": True, "ordering": ["name"], "indexes": [], "constraints": []},
|
|
)
|
|
self.assertEqual(author_proxy_state.bases, ("migrations.author",))
|
|
|
|
self.assertEqual(sub_author_state.app_label, "migrations")
|
|
self.assertEqual(sub_author_state.name, "SubAuthor")
|
|
self.assertEqual(len(sub_author_state.fields), 2)
|
|
self.assertEqual(sub_author_state.bases, ("migrations.author",))
|
|
|
|
# The default manager is used in migrations
|
|
self.assertEqual([name for name, mgr in food_state.managers], ["food_mgr"])
|
|
self.assertTrue(all(isinstance(name, str) for name, mgr in food_state.managers))
|
|
self.assertEqual(food_state.managers[0][1].args, ("a", "b", 1, 2))
|
|
|
|
# No explicit managers defined. Migrations will fall back to the default
|
|
self.assertEqual(food_no_managers_state.managers, [])
|
|
|
|
# food_mgr is used in migration but isn't the default mgr, hence add the
|
|
# default
|
|
self.assertEqual(
|
|
[name for name, mgr in food_no_default_manager_state.managers],
|
|
["food_no_mgr", "food_mgr"],
|
|
)
|
|
self.assertTrue(
|
|
all(
|
|
isinstance(name, str)
|
|
for name, mgr in food_no_default_manager_state.managers
|
|
)
|
|
)
|
|
self.assertEqual(
|
|
food_no_default_manager_state.managers[0][1].__class__, models.Manager
|
|
)
|
|
self.assertIsInstance(food_no_default_manager_state.managers[1][1], FoodManager)
|
|
|
|
self.assertEqual(
|
|
[name for name, mgr in food_order_manager_state.managers],
|
|
["food_mgr1", "food_mgr2"],
|
|
)
|
|
self.assertTrue(
|
|
all(
|
|
isinstance(name, str) for name, mgr in food_order_manager_state.managers
|
|
)
|
|
)
|
|
self.assertEqual(
|
|
[mgr.args for name, mgr in food_order_manager_state.managers],
|
|
[("a", "b", 1, 2), ("x", "y", 3, 4)],
|
|
)
|
|
|
|
def test_custom_default_manager_added_to_the_model_state(self):
|
|
"""
|
|
When the default manager of the model is a custom manager,
|
|
it needs to be added to the model state.
|
|
"""
|
|
new_apps = Apps(["migrations"])
|
|
custom_manager = models.Manager()
|
|
|
|
class Author(models.Model):
|
|
objects = models.TextField()
|
|
authors = custom_manager
|
|
|
|
class Meta:
|
|
app_label = "migrations"
|
|
apps = new_apps
|
|
|
|
project_state = ProjectState.from_apps(new_apps)
|
|
author_state = project_state.models["migrations", "author"]
|
|
self.assertEqual(author_state.managers, [("authors", custom_manager)])
|
|
|
|
def test_custom_default_manager_named_objects_with_false_migration_flag(self):
|
|
"""
|
|
When a manager is added with a name of 'objects' but it does not
|
|
have `use_in_migrations = True`, no migration should be added to the
|
|
model state (#26643).
|
|
"""
|
|
new_apps = Apps(["migrations"])
|
|
|
|
class Author(models.Model):
|
|
objects = models.Manager()
|
|
|
|
class Meta:
|
|
app_label = "migrations"
|
|
apps = new_apps
|
|
|
|
project_state = ProjectState.from_apps(new_apps)
|
|
author_state = project_state.models["migrations", "author"]
|
|
self.assertEqual(author_state.managers, [])
|
|
|
|
def test_no_duplicate_managers(self):
|
|
"""
|
|
When a manager is added with `use_in_migrations = True` and a parent
|
|
model had a manager with the same name and `use_in_migrations = True`,
|
|
the parent's manager shouldn't appear in the model state (#26881).
|
|
"""
|
|
new_apps = Apps(["migrations"])
|
|
|
|
class PersonManager(models.Manager):
|
|
use_in_migrations = True
|
|
|
|
class Person(models.Model):
|
|
objects = PersonManager()
|
|
|
|
class Meta:
|
|
abstract = True
|
|
|
|
class BossManager(PersonManager):
|
|
use_in_migrations = True
|
|
|
|
class Boss(Person):
|
|
objects = BossManager()
|
|
|
|
class Meta:
|
|
app_label = "migrations"
|
|
apps = new_apps
|
|
|
|
project_state = ProjectState.from_apps(new_apps)
|
|
boss_state = project_state.models["migrations", "boss"]
|
|
self.assertEqual(boss_state.managers, [("objects", Boss.objects)])
|
|
|
|
def test_custom_default_manager(self):
|
|
new_apps = Apps(["migrations"])
|
|
|
|
class Author(models.Model):
|
|
manager1 = models.Manager()
|
|
manager2 = models.Manager()
|
|
|
|
class Meta:
|
|
app_label = "migrations"
|
|
apps = new_apps
|
|
default_manager_name = "manager2"
|
|
|
|
project_state = ProjectState.from_apps(new_apps)
|
|
author_state = project_state.models["migrations", "author"]
|
|
self.assertEqual(author_state.options["default_manager_name"], "manager2")
|
|
self.assertEqual(author_state.managers, [("manager2", Author.manager1)])
|
|
|
|
def test_custom_base_manager(self):
|
|
new_apps = Apps(["migrations"])
|
|
|
|
class Author(models.Model):
|
|
manager1 = models.Manager()
|
|
manager2 = models.Manager()
|
|
|
|
class Meta:
|
|
app_label = "migrations"
|
|
apps = new_apps
|
|
base_manager_name = "manager2"
|
|
|
|
class Author2(models.Model):
|
|
manager1 = models.Manager()
|
|
manager2 = models.Manager()
|
|
|
|
class Meta:
|
|
app_label = "migrations"
|
|
apps = new_apps
|
|
base_manager_name = "manager1"
|
|
|
|
project_state = ProjectState.from_apps(new_apps)
|
|
|
|
author_state = project_state.models["migrations", "author"]
|
|
self.assertEqual(author_state.options["base_manager_name"], "manager2")
|
|
self.assertEqual(
|
|
author_state.managers,
|
|
[
|
|
("manager1", Author.manager1),
|
|
("manager2", Author.manager2),
|
|
],
|
|
)
|
|
|
|
author2_state = project_state.models["migrations", "author2"]
|
|
self.assertEqual(author2_state.options["base_manager_name"], "manager1")
|
|
self.assertEqual(
|
|
author2_state.managers,
|
|
[
|
|
("manager1", Author2.manager1),
|
|
],
|
|
)
|
|
|
|
def test_apps_bulk_update(self):
|
|
"""
|
|
StateApps.bulk_update() should update apps.ready to False and reset
|
|
the value afterward.
|
|
"""
|
|
project_state = ProjectState()
|
|
apps = project_state.apps
|
|
with apps.bulk_update():
|
|
self.assertFalse(apps.ready)
|
|
self.assertTrue(apps.ready)
|
|
with self.assertRaises(ValueError):
|
|
with apps.bulk_update():
|
|
self.assertFalse(apps.ready)
|
|
raise ValueError()
|
|
self.assertTrue(apps.ready)
|
|
|
|
def test_render(self):
|
|
"""
|
|
Tests rendering a ProjectState into an Apps.
|
|
"""
|
|
project_state = ProjectState()
|
|
project_state.add_model(
|
|
ModelState(
|
|
app_label="migrations",
|
|
name="Tag",
|
|
fields=[
|
|
("id", models.AutoField(primary_key=True)),
|
|
("name", models.CharField(max_length=100)),
|
|
("hidden", models.BooleanField()),
|
|
],
|
|
)
|
|
)
|
|
project_state.add_model(
|
|
ModelState(
|
|
app_label="migrations",
|
|
name="SubTag",
|
|
fields=[
|
|
(
|
|
"tag_ptr",
|
|
models.OneToOneField(
|
|
"migrations.Tag",
|
|
models.CASCADE,
|
|
auto_created=True,
|
|
parent_link=True,
|
|
primary_key=True,
|
|
to_field="id",
|
|
serialize=False,
|
|
),
|
|
),
|
|
("awesome", models.BooleanField()),
|
|
],
|
|
bases=("migrations.Tag",),
|
|
)
|
|
)
|
|
|
|
base_mgr = models.Manager()
|
|
mgr1 = FoodManager("a", "b")
|
|
mgr2 = FoodManager("x", "y", c=3, d=4)
|
|
project_state.add_model(
|
|
ModelState(
|
|
app_label="migrations",
|
|
name="Food",
|
|
fields=[
|
|
("id", models.AutoField(primary_key=True)),
|
|
],
|
|
managers=[
|
|
# The ordering we really want is objects, mgr1, mgr2
|
|
("default", base_mgr),
|
|
("food_mgr2", mgr2),
|
|
("food_mgr1", mgr1),
|
|
],
|
|
)
|
|
)
|
|
|
|
new_apps = project_state.apps
|
|
self.assertEqual(
|
|
new_apps.get_model("migrations", "Tag")._meta.get_field("name").max_length,
|
|
100,
|
|
)
|
|
self.assertIs(
|
|
new_apps.get_model("migrations", "Tag")._meta.get_field("hidden").null,
|
|
False,
|
|
)
|
|
|
|
self.assertEqual(
|
|
len(new_apps.get_model("migrations", "SubTag")._meta.local_fields), 2
|
|
)
|
|
|
|
Food = new_apps.get_model("migrations", "Food")
|
|
self.assertEqual(
|
|
[mgr.name for mgr in Food._meta.managers],
|
|
["default", "food_mgr1", "food_mgr2"],
|
|
)
|
|
self.assertTrue(all(isinstance(mgr.name, str) for mgr in Food._meta.managers))
|
|
self.assertEqual(
|
|
[mgr.__class__ for mgr in Food._meta.managers],
|
|
[models.Manager, FoodManager, FoodManager],
|
|
)
|
|
|
|
def test_render_model_inheritance(self):
|
|
class Book(models.Model):
|
|
title = models.CharField(max_length=1000)
|
|
|
|
class Meta:
|
|
app_label = "migrations"
|
|
apps = Apps()
|
|
|
|
class Novel(Book):
|
|
class Meta:
|
|
app_label = "migrations"
|
|
apps = Apps()
|
|
|
|
# First, test rendering individually
|
|
apps = Apps(["migrations"])
|
|
|
|
# We shouldn't be able to render yet
|
|
ms = ModelState.from_model(Novel)
|
|
with self.assertRaises(InvalidBasesError):
|
|
ms.render(apps)
|
|
|
|
# Once the parent model is in the app registry, it should be fine
|
|
ModelState.from_model(Book).render(apps)
|
|
ModelState.from_model(Novel).render(apps)
|
|
|
|
def test_render_model_with_multiple_inheritance(self):
|
|
class Foo(models.Model):
|
|
class Meta:
|
|
app_label = "migrations"
|
|
apps = Apps()
|
|
|
|
class Bar(models.Model):
|
|
class Meta:
|
|
app_label = "migrations"
|
|
apps = Apps()
|
|
|
|
class FooBar(Foo, Bar):
|
|
class Meta:
|
|
app_label = "migrations"
|
|
apps = Apps()
|
|
|
|
class AbstractSubFooBar(FooBar):
|
|
class Meta:
|
|
abstract = True
|
|
apps = Apps()
|
|
|
|
class SubFooBar(AbstractSubFooBar):
|
|
class Meta:
|
|
app_label = "migrations"
|
|
apps = Apps()
|
|
|
|
apps = Apps(["migrations"])
|
|
|
|
# We shouldn't be able to render yet
|
|
ms = ModelState.from_model(FooBar)
|
|
with self.assertRaises(InvalidBasesError):
|
|
ms.render(apps)
|
|
|
|
# Once the parent models are in the app registry, it should be fine
|
|
ModelState.from_model(Foo).render(apps)
|
|
self.assertSequenceEqual(ModelState.from_model(Foo).bases, [models.Model])
|
|
ModelState.from_model(Bar).render(apps)
|
|
self.assertSequenceEqual(ModelState.from_model(Bar).bases, [models.Model])
|
|
ModelState.from_model(FooBar).render(apps)
|
|
self.assertSequenceEqual(
|
|
ModelState.from_model(FooBar).bases, ["migrations.foo", "migrations.bar"]
|
|
)
|
|
ModelState.from_model(SubFooBar).render(apps)
|
|
self.assertSequenceEqual(
|
|
ModelState.from_model(SubFooBar).bases, ["migrations.foobar"]
|
|
)
|
|
|
|
def test_render_project_dependencies(self):
|
|
"""
|
|
The ProjectState render method correctly renders models
|
|
to account for inter-model base dependencies.
|
|
"""
|
|
new_apps = Apps()
|
|
|
|
class A(models.Model):
|
|
class Meta:
|
|
app_label = "migrations"
|
|
apps = new_apps
|
|
|
|
class B(A):
|
|
class Meta:
|
|
app_label = "migrations"
|
|
apps = new_apps
|
|
|
|
class C(B):
|
|
class Meta:
|
|
app_label = "migrations"
|
|
apps = new_apps
|
|
|
|
class D(A):
|
|
class Meta:
|
|
app_label = "migrations"
|
|
apps = new_apps
|
|
|
|
class E(B):
|
|
class Meta:
|
|
app_label = "migrations"
|
|
apps = new_apps
|
|
proxy = True
|
|
|
|
class F(D):
|
|
class Meta:
|
|
app_label = "migrations"
|
|
apps = new_apps
|
|
proxy = True
|
|
|
|
# Make a ProjectState and render it
|
|
project_state = ProjectState()
|
|
project_state.add_model(ModelState.from_model(A))
|
|
project_state.add_model(ModelState.from_model(B))
|
|
project_state.add_model(ModelState.from_model(C))
|
|
project_state.add_model(ModelState.from_model(D))
|
|
project_state.add_model(ModelState.from_model(E))
|
|
project_state.add_model(ModelState.from_model(F))
|
|
final_apps = project_state.apps
|
|
self.assertEqual(len(final_apps.get_models()), 6)
|
|
|
|
# Now make an invalid ProjectState and make sure it fails
|
|
project_state = ProjectState()
|
|
project_state.add_model(ModelState.from_model(A))
|
|
project_state.add_model(ModelState.from_model(B))
|
|
project_state.add_model(ModelState.from_model(C))
|
|
project_state.add_model(ModelState.from_model(F))
|
|
with self.assertRaises(InvalidBasesError):
|
|
project_state.apps
|
|
|
|
def test_render_unique_app_labels(self):
|
|
"""
|
|
The ProjectState render method doesn't raise an
|
|
ImproperlyConfigured exception about unique labels if two dotted app
|
|
names have the same last part.
|
|
"""
|
|
|
|
class A(models.Model):
|
|
class Meta:
|
|
app_label = "django.contrib.auth"
|
|
|
|
class B(models.Model):
|
|
class Meta:
|
|
app_label = "vendor.auth"
|
|
|
|
# Make a ProjectState and render it
|
|
project_state = ProjectState()
|
|
project_state.add_model(ModelState.from_model(A))
|
|
project_state.add_model(ModelState.from_model(B))
|
|
self.assertEqual(len(project_state.apps.get_models()), 2)
|
|
|
|
def test_reload_related_model_on_non_relational_fields(self):
|
|
"""
|
|
The model is reloaded even on changes that are not involved in
|
|
relations. Other models pointing to or from it are also reloaded.
|
|
"""
|
|
project_state = ProjectState()
|
|
project_state.apps # Render project state.
|
|
project_state.add_model(ModelState("migrations", "A", []))
|
|
project_state.add_model(
|
|
ModelState(
|
|
"migrations",
|
|
"B",
|
|
[
|
|
("a", models.ForeignKey("A", models.CASCADE)),
|
|
],
|
|
)
|
|
)
|
|
project_state.add_model(
|
|
ModelState(
|
|
"migrations",
|
|
"C",
|
|
[
|
|
("b", models.ForeignKey("B", models.CASCADE)),
|
|
("name", models.TextField()),
|
|
],
|
|
)
|
|
)
|
|
project_state.add_model(
|
|
ModelState(
|
|
"migrations",
|
|
"D",
|
|
[
|
|
("a", models.ForeignKey("A", models.CASCADE)),
|
|
],
|
|
)
|
|
)
|
|
operation = AlterField(
|
|
model_name="C",
|
|
name="name",
|
|
field=models.TextField(blank=True),
|
|
)
|
|
operation.state_forwards("migrations", project_state)
|
|
project_state.reload_model("migrations", "a", delay=True)
|
|
A = project_state.apps.get_model("migrations.A")
|
|
B = project_state.apps.get_model("migrations.B")
|
|
D = project_state.apps.get_model("migrations.D")
|
|
self.assertIs(B._meta.get_field("a").related_model, A)
|
|
self.assertIs(D._meta.get_field("a").related_model, A)
|
|
|
|
def test_reload_model_relationship_consistency(self):
|
|
project_state = ProjectState()
|
|
project_state.add_model(ModelState("migrations", "A", []))
|
|
project_state.add_model(
|
|
ModelState(
|
|
"migrations",
|
|
"B",
|
|
[
|
|
("a", models.ForeignKey("A", models.CASCADE)),
|
|
],
|
|
)
|
|
)
|
|
project_state.add_model(
|
|
ModelState(
|
|
"migrations",
|
|
"C",
|
|
[
|
|
("b", models.ForeignKey("B", models.CASCADE)),
|
|
],
|
|
)
|
|
)
|
|
A = project_state.apps.get_model("migrations.A")
|
|
B = project_state.apps.get_model("migrations.B")
|
|
C = project_state.apps.get_model("migrations.C")
|
|
self.assertEqual([r.related_model for r in A._meta.related_objects], [B])
|
|
self.assertEqual([r.related_model for r in B._meta.related_objects], [C])
|
|
self.assertEqual([r.related_model for r in C._meta.related_objects], [])
|
|
|
|
project_state.reload_model("migrations", "a", delay=True)
|
|
A = project_state.apps.get_model("migrations.A")
|
|
B = project_state.apps.get_model("migrations.B")
|
|
C = project_state.apps.get_model("migrations.C")
|
|
self.assertEqual([r.related_model for r in A._meta.related_objects], [B])
|
|
self.assertEqual([r.related_model for r in B._meta.related_objects], [C])
|
|
self.assertEqual([r.related_model for r in C._meta.related_objects], [])
|
|
|
|
def test_add_relations(self):
|
|
"""
|
|
#24573 - Adding relations to existing models should reload the
|
|
referenced models too.
|
|
"""
|
|
new_apps = Apps()
|
|
|
|
class A(models.Model):
|
|
class Meta:
|
|
app_label = "something"
|
|
apps = new_apps
|
|
|
|
class B(A):
|
|
class Meta:
|
|
app_label = "something"
|
|
apps = new_apps
|
|
|
|
class C(models.Model):
|
|
class Meta:
|
|
app_label = "something"
|
|
apps = new_apps
|
|
|
|
project_state = ProjectState()
|
|
project_state.add_model(ModelState.from_model(A))
|
|
project_state.add_model(ModelState.from_model(B))
|
|
project_state.add_model(ModelState.from_model(C))
|
|
|
|
project_state.apps # We need to work with rendered models
|
|
|
|
old_state = project_state.clone()
|
|
model_a_old = old_state.apps.get_model("something", "A")
|
|
model_b_old = old_state.apps.get_model("something", "B")
|
|
model_c_old = old_state.apps.get_model("something", "C")
|
|
# The relations between the old models are correct
|
|
self.assertIs(model_a_old._meta.get_field("b").related_model, model_b_old)
|
|
self.assertIs(model_b_old._meta.get_field("a_ptr").related_model, model_a_old)
|
|
|
|
operation = AddField(
|
|
"c",
|
|
"to_a",
|
|
models.OneToOneField(
|
|
"something.A",
|
|
models.CASCADE,
|
|
related_name="from_c",
|
|
),
|
|
)
|
|
operation.state_forwards("something", project_state)
|
|
model_a_new = project_state.apps.get_model("something", "A")
|
|
model_b_new = project_state.apps.get_model("something", "B")
|
|
model_c_new = project_state.apps.get_model("something", "C")
|
|
|
|
# All models have changed
|
|
self.assertIsNot(model_a_old, model_a_new)
|
|
self.assertIsNot(model_b_old, model_b_new)
|
|
self.assertIsNot(model_c_old, model_c_new)
|
|
# The relations between the old models still hold
|
|
self.assertIs(model_a_old._meta.get_field("b").related_model, model_b_old)
|
|
self.assertIs(model_b_old._meta.get_field("a_ptr").related_model, model_a_old)
|
|
# The relations between the new models correct
|
|
self.assertIs(model_a_new._meta.get_field("b").related_model, model_b_new)
|
|
self.assertIs(model_b_new._meta.get_field("a_ptr").related_model, model_a_new)
|
|
self.assertIs(model_a_new._meta.get_field("from_c").related_model, model_c_new)
|
|
self.assertIs(model_c_new._meta.get_field("to_a").related_model, model_a_new)
|
|
|
|
def test_remove_relations(self):
|
|
"""
|
|
#24225 - Relations between models are updated while
|
|
remaining the relations and references for models of an old state.
|
|
"""
|
|
new_apps = Apps()
|
|
|
|
class A(models.Model):
|
|
class Meta:
|
|
app_label = "something"
|
|
apps = new_apps
|
|
|
|
class B(models.Model):
|
|
to_a = models.ForeignKey(A, models.CASCADE)
|
|
|
|
class Meta:
|
|
app_label = "something"
|
|
apps = new_apps
|
|
|
|
def get_model_a(state):
|
|
return [
|
|
mod for mod in state.apps.get_models() if mod._meta.model_name == "a"
|
|
][0]
|
|
|
|
project_state = ProjectState()
|
|
project_state.add_model(ModelState.from_model(A))
|
|
project_state.add_model(ModelState.from_model(B))
|
|
self.assertEqual(len(get_model_a(project_state)._meta.related_objects), 1)
|
|
old_state = project_state.clone()
|
|
|
|
operation = RemoveField("b", "to_a")
|
|
operation.state_forwards("something", project_state)
|
|
# Model from old_state still has the relation
|
|
model_a_old = get_model_a(old_state)
|
|
model_a_new = get_model_a(project_state)
|
|
self.assertIsNot(model_a_old, model_a_new)
|
|
self.assertEqual(len(model_a_old._meta.related_objects), 1)
|
|
self.assertEqual(len(model_a_new._meta.related_objects), 0)
|
|
|
|
# Same test for deleted model
|
|
project_state = ProjectState()
|
|
project_state.add_model(ModelState.from_model(A))
|
|
project_state.add_model(ModelState.from_model(B))
|
|
old_state = project_state.clone()
|
|
|
|
operation = DeleteModel("b")
|
|
operation.state_forwards("something", project_state)
|
|
model_a_old = get_model_a(old_state)
|
|
model_a_new = get_model_a(project_state)
|
|
self.assertIsNot(model_a_old, model_a_new)
|
|
self.assertEqual(len(model_a_old._meta.related_objects), 1)
|
|
self.assertEqual(len(model_a_new._meta.related_objects), 0)
|
|
|
|
def test_self_relation(self):
|
|
"""
|
|
#24513 - Modifying an object pointing to itself would cause it to be
|
|
rendered twice and thus breaking its related M2M through objects.
|
|
"""
|
|
|
|
class A(models.Model):
|
|
to_a = models.ManyToManyField("something.A", symmetrical=False)
|
|
|
|
class Meta:
|
|
app_label = "something"
|
|
|
|
def get_model_a(state):
|
|
return [
|
|
mod for mod in state.apps.get_models() if mod._meta.model_name == "a"
|
|
][0]
|
|
|
|
project_state = ProjectState()
|
|
project_state.add_model(ModelState.from_model(A))
|
|
self.assertEqual(len(get_model_a(project_state)._meta.related_objects), 1)
|
|
old_state = project_state.clone()
|
|
|
|
operation = AlterField(
|
|
model_name="a",
|
|
name="to_a",
|
|
field=models.ManyToManyField("something.A", symmetrical=False, blank=True),
|
|
)
|
|
# At this point the model would be rendered twice causing its related
|
|
# M2M through objects to point to an old copy and thus breaking their
|
|
# attribute lookup.
|
|
operation.state_forwards("something", project_state)
|
|
|
|
model_a_old = get_model_a(old_state)
|
|
model_a_new = get_model_a(project_state)
|
|
self.assertIsNot(model_a_old, model_a_new)
|
|
|
|
# The old model's _meta is still consistent
|
|
field_to_a_old = model_a_old._meta.get_field("to_a")
|
|
self.assertEqual(field_to_a_old.m2m_field_name(), "from_a")
|
|
self.assertEqual(field_to_a_old.m2m_reverse_field_name(), "to_a")
|
|
self.assertIs(field_to_a_old.related_model, model_a_old)
|
|
self.assertIs(
|
|
field_to_a_old.remote_field.through._meta.get_field("to_a").related_model,
|
|
model_a_old,
|
|
)
|
|
self.assertIs(
|
|
field_to_a_old.remote_field.through._meta.get_field("from_a").related_model,
|
|
model_a_old,
|
|
)
|
|
|
|
# The new model's _meta is still consistent
|
|
field_to_a_new = model_a_new._meta.get_field("to_a")
|
|
self.assertEqual(field_to_a_new.m2m_field_name(), "from_a")
|
|
self.assertEqual(field_to_a_new.m2m_reverse_field_name(), "to_a")
|
|
self.assertIs(field_to_a_new.related_model, model_a_new)
|
|
self.assertIs(
|
|
field_to_a_new.remote_field.through._meta.get_field("to_a").related_model,
|
|
model_a_new,
|
|
)
|
|
self.assertIs(
|
|
field_to_a_new.remote_field.through._meta.get_field("from_a").related_model,
|
|
model_a_new,
|
|
)
|
|
|
|
def test_equality(self):
|
|
"""
|
|
== and != are implemented correctly.
|
|
"""
|
|
# Test two things that should be equal
|
|
project_state = ProjectState()
|
|
project_state.add_model(
|
|
ModelState(
|
|
"migrations",
|
|
"Tag",
|
|
[
|
|
("id", models.AutoField(primary_key=True)),
|
|
("name", models.CharField(max_length=100)),
|
|
("hidden", models.BooleanField()),
|
|
],
|
|
{},
|
|
None,
|
|
)
|
|
)
|
|
project_state.apps # Fill the apps cached property
|
|
other_state = project_state.clone()
|
|
self.assertEqual(project_state, project_state)
|
|
self.assertEqual(project_state, other_state)
|
|
self.assertIs(project_state != project_state, False)
|
|
self.assertIs(project_state != other_state, False)
|
|
self.assertNotEqual(project_state.apps, other_state.apps)
|
|
|
|
# Make a very small change (max_len 99) and see if that affects it
|
|
project_state = ProjectState()
|
|
project_state.add_model(
|
|
ModelState(
|
|
"migrations",
|
|
"Tag",
|
|
[
|
|
("id", models.AutoField(primary_key=True)),
|
|
("name", models.CharField(max_length=99)),
|
|
("hidden", models.BooleanField()),
|
|
],
|
|
{},
|
|
None,
|
|
)
|
|
)
|
|
self.assertNotEqual(project_state, other_state)
|
|
self.assertIs(project_state == other_state, False)
|
|
|
|
def test_dangling_references_throw_error(self):
|
|
new_apps = Apps()
|
|
|
|
class Author(models.Model):
|
|
name = models.TextField()
|
|
|
|
class Meta:
|
|
app_label = "migrations"
|
|
apps = new_apps
|
|
|
|
class Publisher(models.Model):
|
|
name = models.TextField()
|
|
|
|
class Meta:
|
|
app_label = "migrations"
|
|
apps = new_apps
|
|
|
|
class Book(models.Model):
|
|
author = models.ForeignKey(Author, models.CASCADE)
|
|
publisher = models.ForeignKey(Publisher, models.CASCADE)
|
|
|
|
class Meta:
|
|
app_label = "migrations"
|
|
apps = new_apps
|
|
|
|
class Magazine(models.Model):
|
|
authors = models.ManyToManyField(Author)
|
|
|
|
class Meta:
|
|
app_label = "migrations"
|
|
apps = new_apps
|
|
|
|
# Make a valid ProjectState and render it
|
|
project_state = ProjectState()
|
|
project_state.add_model(ModelState.from_model(Author))
|
|
project_state.add_model(ModelState.from_model(Publisher))
|
|
project_state.add_model(ModelState.from_model(Book))
|
|
project_state.add_model(ModelState.from_model(Magazine))
|
|
self.assertEqual(len(project_state.apps.get_models()), 4)
|
|
|
|
# now make an invalid one with a ForeignKey
|
|
project_state = ProjectState()
|
|
project_state.add_model(ModelState.from_model(Book))
|
|
msg = (
|
|
"The field migrations.Book.author was declared with a lazy reference "
|
|
"to 'migrations.author', but app 'migrations' doesn't provide model "
|
|
"'author'.\n"
|
|
"The field migrations.Book.publisher was declared with a lazy reference "
|
|
"to 'migrations.publisher', but app 'migrations' doesn't provide model "
|
|
"'publisher'."
|
|
)
|
|
with self.assertRaisesMessage(ValueError, msg):
|
|
project_state.apps
|
|
|
|
# And another with ManyToManyField.
|
|
project_state = ProjectState()
|
|
project_state.add_model(ModelState.from_model(Magazine))
|
|
msg = (
|
|
"The field migrations.Magazine.authors was declared with a lazy reference "
|
|
"to 'migrations.author', but app 'migrations' doesn't provide model "
|
|
"'author'.\n"
|
|
"The field migrations.Magazine_authors.author was declared with a lazy "
|
|
"reference to 'migrations.author', but app 'migrations' doesn't provide "
|
|
"model 'author'."
|
|
)
|
|
with self.assertRaisesMessage(ValueError, msg):
|
|
project_state.apps
|
|
|
|
# And now with multiple models and multiple fields.
|
|
project_state.add_model(ModelState.from_model(Book))
|
|
msg = (
|
|
"The field migrations.Book.author was declared with a lazy reference "
|
|
"to 'migrations.author', but app 'migrations' doesn't provide model "
|
|
"'author'.\n"
|
|
"The field migrations.Book.publisher was declared with a lazy reference "
|
|
"to 'migrations.publisher', but app 'migrations' doesn't provide model "
|
|
"'publisher'.\n"
|
|
"The field migrations.Magazine.authors was declared with a lazy reference "
|
|
"to 'migrations.author', but app 'migrations' doesn't provide model "
|
|
"'author'.\n"
|
|
"The field migrations.Magazine_authors.author was declared with a lazy "
|
|
"reference to 'migrations.author', but app 'migrations' doesn't provide "
|
|
"model 'author'."
|
|
)
|
|
with self.assertRaisesMessage(ValueError, msg):
|
|
project_state.apps
|
|
|
|
def test_reference_mixed_case_app_label(self):
|
|
new_apps = Apps()
|
|
|
|
class Author(models.Model):
|
|
class Meta:
|
|
app_label = "MiXedCase_migrations"
|
|
apps = new_apps
|
|
|
|
class Book(models.Model):
|
|
author = models.ForeignKey(Author, models.CASCADE)
|
|
|
|
class Meta:
|
|
app_label = "MiXedCase_migrations"
|
|
apps = new_apps
|
|
|
|
class Magazine(models.Model):
|
|
authors = models.ManyToManyField(Author)
|
|
|
|
class Meta:
|
|
app_label = "MiXedCase_migrations"
|
|
apps = new_apps
|
|
|
|
project_state = ProjectState()
|
|
project_state.add_model(ModelState.from_model(Author))
|
|
project_state.add_model(ModelState.from_model(Book))
|
|
project_state.add_model(ModelState.from_model(Magazine))
|
|
self.assertEqual(len(project_state.apps.get_models()), 3)
|
|
|
|
def test_real_apps(self):
|
|
"""
|
|
Including real apps can resolve dangling FK errors.
|
|
This test relies on the fact that contenttypes is always loaded.
|
|
"""
|
|
new_apps = Apps()
|
|
|
|
class TestModel(models.Model):
|
|
ct = models.ForeignKey("contenttypes.ContentType", models.CASCADE)
|
|
|
|
class Meta:
|
|
app_label = "migrations"
|
|
apps = new_apps
|
|
|
|
# If we just stick it into an empty state it should fail
|
|
project_state = ProjectState()
|
|
project_state.add_model(ModelState.from_model(TestModel))
|
|
with self.assertRaises(ValueError):
|
|
project_state.apps
|
|
|
|
# If we include the real app it should succeed
|
|
project_state = ProjectState(real_apps={"contenttypes"})
|
|
project_state.add_model(ModelState.from_model(TestModel))
|
|
rendered_state = project_state.apps
|
|
self.assertEqual(
|
|
len(
|
|
[
|
|
x
|
|
for x in rendered_state.get_models()
|
|
if x._meta.app_label == "migrations"
|
|
]
|
|
),
|
|
1,
|
|
)
|
|
|
|
def test_real_apps_non_set(self):
|
|
with self.assertRaises(AssertionError):
|
|
ProjectState(real_apps=["contenttypes"])
|
|
|
|
def test_ignore_order_wrt(self):
|
|
"""
|
|
Makes sure ProjectState doesn't include OrderWrt fields when
|
|
making from existing models.
|
|
"""
|
|
new_apps = Apps()
|
|
|
|
class Author(models.Model):
|
|
name = models.TextField()
|
|
|
|
class Meta:
|
|
app_label = "migrations"
|
|
apps = new_apps
|
|
|
|
class Book(models.Model):
|
|
author = models.ForeignKey(Author, models.CASCADE)
|
|
|
|
class Meta:
|
|
app_label = "migrations"
|
|
apps = new_apps
|
|
order_with_respect_to = "author"
|
|
|
|
# Make a valid ProjectState and render it
|
|
project_state = ProjectState()
|
|
project_state.add_model(ModelState.from_model(Author))
|
|
project_state.add_model(ModelState.from_model(Book))
|
|
self.assertEqual(
|
|
list(project_state.models["migrations", "book"].fields),
|
|
["id", "author"],
|
|
)
|
|
|
|
def test_modelstate_get_field_order_wrt(self):
|
|
new_apps = Apps()
|
|
|
|
class Author(models.Model):
|
|
name = models.TextField()
|
|
|
|
class Meta:
|
|
app_label = "migrations"
|
|
apps = new_apps
|
|
|
|
class Book(models.Model):
|
|
author = models.ForeignKey(Author, models.CASCADE)
|
|
|
|
class Meta:
|
|
app_label = "migrations"
|
|
apps = new_apps
|
|
order_with_respect_to = "author"
|
|
|
|
model_state = ModelState.from_model(Book)
|
|
order_wrt_field = model_state.get_field("_order")
|
|
self.assertIsInstance(order_wrt_field, models.ForeignKey)
|
|
self.assertEqual(order_wrt_field.related_model, "migrations.author")
|
|
|
|
def test_modelstate_get_field_no_order_wrt_order_field(self):
|
|
new_apps = Apps()
|
|
|
|
class HistoricalRecord(models.Model):
|
|
_order = models.PositiveSmallIntegerField()
|
|
|
|
class Meta:
|
|
app_label = "migrations"
|
|
apps = new_apps
|
|
|
|
model_state = ModelState.from_model(HistoricalRecord)
|
|
order_field = model_state.get_field("_order")
|
|
self.assertIsNone(order_field.related_model)
|
|
self.assertIsInstance(order_field, models.PositiveSmallIntegerField)
|
|
|
|
def test_manager_refer_correct_model_version(self):
|
|
"""
|
|
#24147 - Managers refer to the correct version of a
|
|
historical model
|
|
"""
|
|
project_state = ProjectState()
|
|
project_state.add_model(
|
|
ModelState(
|
|
app_label="migrations",
|
|
name="Tag",
|
|
fields=[
|
|
("id", models.AutoField(primary_key=True)),
|
|
("hidden", models.BooleanField()),
|
|
],
|
|
managers=[
|
|
("food_mgr", FoodManager("a", "b")),
|
|
("food_qs", FoodQuerySet.as_manager()),
|
|
],
|
|
)
|
|
)
|
|
|
|
old_model = project_state.apps.get_model("migrations", "tag")
|
|
|
|
new_state = project_state.clone()
|
|
operation = RemoveField("tag", "hidden")
|
|
operation.state_forwards("migrations", new_state)
|
|
|
|
new_model = new_state.apps.get_model("migrations", "tag")
|
|
|
|
self.assertIsNot(old_model, new_model)
|
|
self.assertIs(old_model, old_model.food_mgr.model)
|
|
self.assertIs(old_model, old_model.food_qs.model)
|
|
self.assertIs(new_model, new_model.food_mgr.model)
|
|
self.assertIs(new_model, new_model.food_qs.model)
|
|
self.assertIsNot(old_model.food_mgr, new_model.food_mgr)
|
|
self.assertIsNot(old_model.food_qs, new_model.food_qs)
|
|
self.assertIsNot(old_model.food_mgr.model, new_model.food_mgr.model)
|
|
self.assertIsNot(old_model.food_qs.model, new_model.food_qs.model)
|
|
|
|
def test_choices_iterator(self):
|
|
"""
|
|
#24483 - ProjectState.from_apps should not destructively consume
|
|
Field.choices iterators.
|
|
"""
|
|
new_apps = Apps(["migrations"])
|
|
choices = [("a", "A"), ("b", "B")]
|
|
|
|
class Author(models.Model):
|
|
name = models.CharField(max_length=255)
|
|
choice = models.CharField(max_length=255, choices=iter(choices))
|
|
|
|
class Meta:
|
|
app_label = "migrations"
|
|
apps = new_apps
|
|
|
|
ProjectState.from_apps(new_apps)
|
|
choices_field = Author._meta.get_field("choice")
|
|
self.assertEqual(list(choices_field.choices), choices)
|
|
|
|
|
|
class StateRelationsTests(SimpleTestCase):
|
|
def get_base_project_state(self):
|
|
new_apps = Apps()
|
|
|
|
class User(models.Model):
|
|
class Meta:
|
|
app_label = "tests"
|
|
apps = new_apps
|
|
|
|
class Comment(models.Model):
|
|
text = models.TextField()
|
|
user = models.ForeignKey(User, models.CASCADE)
|
|
comments = models.ManyToManyField("self")
|
|
|
|
class Meta:
|
|
app_label = "tests"
|
|
apps = new_apps
|
|
|
|
class Post(models.Model):
|
|
text = models.TextField()
|
|
authors = models.ManyToManyField(User)
|
|
|
|
class Meta:
|
|
app_label = "tests"
|
|
apps = new_apps
|
|
|
|
project_state = ProjectState()
|
|
project_state.add_model(ModelState.from_model(User))
|
|
project_state.add_model(ModelState.from_model(Comment))
|
|
project_state.add_model(ModelState.from_model(Post))
|
|
return project_state
|
|
|
|
def test_relations_population(self):
|
|
tests = [
|
|
(
|
|
"add_model",
|
|
[
|
|
ModelState(
|
|
app_label="migrations",
|
|
name="Tag",
|
|
fields=[("id", models.AutoField(primary_key=True))],
|
|
),
|
|
],
|
|
),
|
|
("remove_model", ["tests", "comment"]),
|
|
("rename_model", ["tests", "comment", "opinion"]),
|
|
(
|
|
"add_field",
|
|
[
|
|
"tests",
|
|
"post",
|
|
"next_post",
|
|
models.ForeignKey("self", models.CASCADE),
|
|
True,
|
|
],
|
|
),
|
|
("remove_field", ["tests", "post", "text"]),
|
|
("rename_field", ["tests", "comment", "user", "author"]),
|
|
(
|
|
"alter_field",
|
|
[
|
|
"tests",
|
|
"comment",
|
|
"user",
|
|
models.IntegerField(),
|
|
True,
|
|
],
|
|
),
|
|
]
|
|
for method, args in tests:
|
|
with self.subTest(method=method):
|
|
project_state = self.get_base_project_state()
|
|
getattr(project_state, method)(*args)
|
|
# ProjectState's `_relations` are populated on `relations` access.
|
|
self.assertIsNone(project_state._relations)
|
|
self.assertEqual(project_state.relations, project_state._relations)
|
|
self.assertIsNotNone(project_state._relations)
|
|
|
|
def test_add_model(self):
|
|
project_state = self.get_base_project_state()
|
|
self.assertEqual(
|
|
list(project_state.relations["tests", "user"]),
|
|
[("tests", "comment"), ("tests", "post")],
|
|
)
|
|
self.assertEqual(
|
|
list(project_state.relations["tests", "comment"]),
|
|
[("tests", "comment")],
|
|
)
|
|
self.assertNotIn(("tests", "post"), project_state.relations)
|
|
|
|
def test_add_model_no_relations(self):
|
|
project_state = ProjectState()
|
|
project_state.add_model(
|
|
ModelState(
|
|
app_label="migrations",
|
|
name="Tag",
|
|
fields=[("id", models.AutoField(primary_key=True))],
|
|
)
|
|
)
|
|
self.assertEqual(project_state.relations, {})
|
|
|
|
def test_add_model_other_app(self):
|
|
project_state = self.get_base_project_state()
|
|
self.assertEqual(
|
|
list(project_state.relations["tests", "user"]),
|
|
[("tests", "comment"), ("tests", "post")],
|
|
)
|
|
project_state.add_model(
|
|
ModelState(
|
|
app_label="tests_other",
|
|
name="comment",
|
|
fields=[
|
|
("id", models.AutoField(primary_key=True)),
|
|
("user", models.ForeignKey("tests.user", models.CASCADE)),
|
|
],
|
|
)
|
|
)
|
|
self.assertEqual(
|
|
list(project_state.relations["tests", "user"]),
|
|
[("tests", "comment"), ("tests", "post"), ("tests_other", "comment")],
|
|
)
|
|
|
|
def test_remove_model(self):
|
|
project_state = self.get_base_project_state()
|
|
self.assertEqual(
|
|
list(project_state.relations["tests", "user"]),
|
|
[("tests", "comment"), ("tests", "post")],
|
|
)
|
|
self.assertEqual(
|
|
list(project_state.relations["tests", "comment"]),
|
|
[("tests", "comment")],
|
|
)
|
|
|
|
project_state.remove_model("tests", "comment")
|
|
self.assertEqual(
|
|
list(project_state.relations["tests", "user"]),
|
|
[("tests", "post")],
|
|
)
|
|
self.assertNotIn(("tests", "comment"), project_state.relations)
|
|
project_state.remove_model("tests", "post")
|
|
self.assertEqual(project_state.relations, {})
|
|
project_state.remove_model("tests", "user")
|
|
self.assertEqual(project_state.relations, {})
|
|
|
|
def test_rename_model(self):
|
|
project_state = self.get_base_project_state()
|
|
self.assertEqual(
|
|
list(project_state.relations["tests", "user"]),
|
|
[("tests", "comment"), ("tests", "post")],
|
|
)
|
|
self.assertEqual(
|
|
list(project_state.relations["tests", "comment"]),
|
|
[("tests", "comment")],
|
|
)
|
|
|
|
related_field = project_state.relations["tests", "user"]["tests", "comment"]
|
|
project_state.rename_model("tests", "comment", "opinion")
|
|
self.assertEqual(
|
|
list(project_state.relations["tests", "user"]),
|
|
[("tests", "post"), ("tests", "opinion")],
|
|
)
|
|
self.assertEqual(
|
|
list(project_state.relations["tests", "opinion"]),
|
|
[("tests", "opinion")],
|
|
)
|
|
self.assertNotIn(("tests", "comment"), project_state.relations)
|
|
self.assertEqual(
|
|
project_state.relations["tests", "user"]["tests", "opinion"],
|
|
related_field,
|
|
)
|
|
|
|
project_state.rename_model("tests", "user", "author")
|
|
self.assertEqual(
|
|
list(project_state.relations["tests", "author"]),
|
|
[("tests", "post"), ("tests", "opinion")],
|
|
)
|
|
self.assertNotIn(("tests", "user"), project_state.relations)
|
|
|
|
def test_rename_model_no_relations(self):
|
|
project_state = self.get_base_project_state()
|
|
self.assertEqual(
|
|
list(project_state.relations["tests", "user"]),
|
|
[("tests", "comment"), ("tests", "post")],
|
|
)
|
|
related_field = project_state.relations["tests", "user"]["tests", "post"]
|
|
self.assertNotIn(("tests", "post"), project_state.relations)
|
|
# Rename a model without relations.
|
|
project_state.rename_model("tests", "post", "blog")
|
|
self.assertEqual(
|
|
list(project_state.relations["tests", "user"]),
|
|
[("tests", "comment"), ("tests", "blog")],
|
|
)
|
|
self.assertNotIn(("tests", "blog"), project_state.relations)
|
|
self.assertEqual(
|
|
related_field,
|
|
project_state.relations["tests", "user"]["tests", "blog"],
|
|
)
|
|
|
|
def test_add_field(self):
|
|
project_state = self.get_base_project_state()
|
|
self.assertNotIn(("tests", "post"), project_state.relations)
|
|
# Add a self-referential foreign key.
|
|
new_field = models.ForeignKey("self", models.CASCADE)
|
|
project_state.add_field(
|
|
"tests",
|
|
"post",
|
|
"next_post",
|
|
new_field,
|
|
preserve_default=True,
|
|
)
|
|
self.assertEqual(
|
|
list(project_state.relations["tests", "post"]),
|
|
[("tests", "post")],
|
|
)
|
|
self.assertEqual(
|
|
project_state.relations["tests", "post"]["tests", "post"],
|
|
{"next_post": new_field},
|
|
)
|
|
# Add a foreign key.
|
|
new_field = models.ForeignKey("tests.post", models.CASCADE)
|
|
project_state.add_field(
|
|
"tests",
|
|
"comment",
|
|
"post",
|
|
new_field,
|
|
preserve_default=True,
|
|
)
|
|
self.assertEqual(
|
|
list(project_state.relations["tests", "post"]),
|
|
[("tests", "post"), ("tests", "comment")],
|
|
)
|
|
self.assertEqual(
|
|
project_state.relations["tests", "post"]["tests", "comment"],
|
|
{"post": new_field},
|
|
)
|
|
|
|
def test_add_field_m2m_with_through(self):
|
|
project_state = self.get_base_project_state()
|
|
project_state.add_model(
|
|
ModelState(
|
|
app_label="tests",
|
|
name="Tag",
|
|
fields=[("id", models.AutoField(primary_key=True))],
|
|
)
|
|
)
|
|
project_state.add_model(
|
|
ModelState(
|
|
app_label="tests",
|
|
name="PostTag",
|
|
fields=[
|
|
("id", models.AutoField(primary_key=True)),
|
|
("post", models.ForeignKey("tests.post", models.CASCADE)),
|
|
("tag", models.ForeignKey("tests.tag", models.CASCADE)),
|
|
],
|
|
)
|
|
)
|
|
self.assertEqual(
|
|
list(project_state.relations["tests", "post"]),
|
|
[("tests", "posttag")],
|
|
)
|
|
self.assertEqual(
|
|
list(project_state.relations["tests", "tag"]),
|
|
[("tests", "posttag")],
|
|
)
|
|
# Add a many-to-many field with the through model.
|
|
new_field = models.ManyToManyField("tests.tag", through="tests.posttag")
|
|
project_state.add_field(
|
|
"tests",
|
|
"post",
|
|
"tags",
|
|
new_field,
|
|
preserve_default=True,
|
|
)
|
|
self.assertEqual(
|
|
list(project_state.relations["tests", "post"]),
|
|
[("tests", "posttag")],
|
|
)
|
|
self.assertEqual(
|
|
list(project_state.relations["tests", "tag"]),
|
|
[("tests", "posttag"), ("tests", "post")],
|
|
)
|
|
self.assertEqual(
|
|
project_state.relations["tests", "tag"]["tests", "post"],
|
|
{"tags": new_field},
|
|
)
|
|
|
|
def test_remove_field(self):
|
|
project_state = self.get_base_project_state()
|
|
self.assertEqual(
|
|
list(project_state.relations["tests", "user"]),
|
|
[("tests", "comment"), ("tests", "post")],
|
|
)
|
|
# Remove a many-to-many field.
|
|
project_state.remove_field("tests", "post", "authors")
|
|
self.assertEqual(
|
|
list(project_state.relations["tests", "user"]),
|
|
[("tests", "comment")],
|
|
)
|
|
# Remove a foreign key.
|
|
project_state.remove_field("tests", "comment", "user")
|
|
self.assertEqual(project_state.relations["tests", "user"], {})
|
|
|
|
def test_remove_field_no_relations(self):
|
|
project_state = self.get_base_project_state()
|
|
self.assertEqual(
|
|
list(project_state.relations["tests", "user"]),
|
|
[("tests", "comment"), ("tests", "post")],
|
|
)
|
|
# Remove a non-relation field.
|
|
project_state.remove_field("tests", "post", "text")
|
|
self.assertEqual(
|
|
list(project_state.relations["tests", "user"]),
|
|
[("tests", "comment"), ("tests", "post")],
|
|
)
|
|
|
|
def test_rename_field(self):
|
|
project_state = self.get_base_project_state()
|
|
field = project_state.models["tests", "comment"].fields["user"]
|
|
self.assertEqual(
|
|
project_state.relations["tests", "user"]["tests", "comment"],
|
|
{"user": field},
|
|
)
|
|
|
|
project_state.rename_field("tests", "comment", "user", "author")
|
|
renamed_field = project_state.models["tests", "comment"].fields["author"]
|
|
self.assertEqual(
|
|
project_state.relations["tests", "user"]["tests", "comment"],
|
|
{"author": renamed_field},
|
|
)
|
|
self.assertEqual(field, renamed_field)
|
|
|
|
def test_rename_field_no_relations(self):
|
|
project_state = self.get_base_project_state()
|
|
self.assertEqual(
|
|
list(project_state.relations["tests", "user"]),
|
|
[("tests", "comment"), ("tests", "post")],
|
|
)
|
|
# Rename a non-relation field.
|
|
project_state.rename_field("tests", "post", "text", "description")
|
|
self.assertEqual(
|
|
list(project_state.relations["tests", "user"]),
|
|
[("tests", "comment"), ("tests", "post")],
|
|
)
|
|
|
|
def test_alter_field(self):
|
|
project_state = self.get_base_project_state()
|
|
self.assertEqual(
|
|
list(project_state.relations["tests", "user"]),
|
|
[("tests", "comment"), ("tests", "post")],
|
|
)
|
|
# Alter a foreign key to a non-relation field.
|
|
project_state.alter_field(
|
|
"tests",
|
|
"comment",
|
|
"user",
|
|
models.IntegerField(),
|
|
preserve_default=True,
|
|
)
|
|
self.assertEqual(
|
|
list(project_state.relations["tests", "user"]),
|
|
[("tests", "post")],
|
|
)
|
|
# Alter a non-relation field to a many-to-many field.
|
|
m2m_field = models.ManyToManyField("tests.user")
|
|
project_state.alter_field(
|
|
"tests",
|
|
"comment",
|
|
"user",
|
|
m2m_field,
|
|
preserve_default=True,
|
|
)
|
|
self.assertEqual(
|
|
list(project_state.relations["tests", "user"]),
|
|
[("tests", "post"), ("tests", "comment")],
|
|
)
|
|
self.assertEqual(
|
|
project_state.relations["tests", "user"]["tests", "comment"],
|
|
{"user": m2m_field},
|
|
)
|
|
|
|
def test_alter_field_m2m_to_fk(self):
|
|
project_state = self.get_base_project_state()
|
|
project_state.add_model(
|
|
ModelState(
|
|
app_label="tests_other",
|
|
name="user_other",
|
|
fields=[("id", models.AutoField(primary_key=True))],
|
|
)
|
|
)
|
|
self.assertEqual(
|
|
list(project_state.relations["tests", "user"]),
|
|
[("tests", "comment"), ("tests", "post")],
|
|
)
|
|
self.assertNotIn(("tests_other", "user_other"), project_state.relations)
|
|
# Alter a many-to-many field to a foreign key.
|
|
foreign_key = models.ForeignKey("tests_other.user_other", models.CASCADE)
|
|
project_state.alter_field(
|
|
"tests",
|
|
"post",
|
|
"authors",
|
|
foreign_key,
|
|
preserve_default=True,
|
|
)
|
|
self.assertEqual(
|
|
list(project_state.relations["tests", "user"]),
|
|
[("tests", "comment")],
|
|
)
|
|
self.assertEqual(
|
|
list(project_state.relations["tests_other", "user_other"]),
|
|
[("tests", "post")],
|
|
)
|
|
self.assertEqual(
|
|
project_state.relations["tests_other", "user_other"]["tests", "post"],
|
|
{"authors": foreign_key},
|
|
)
|
|
|
|
def test_many_relations_to_same_model(self):
|
|
project_state = self.get_base_project_state()
|
|
new_field = models.ForeignKey("tests.user", models.CASCADE)
|
|
project_state.add_field(
|
|
"tests",
|
|
"comment",
|
|
"reviewer",
|
|
new_field,
|
|
preserve_default=True,
|
|
)
|
|
self.assertEqual(
|
|
list(project_state.relations["tests", "user"]),
|
|
[("tests", "comment"), ("tests", "post")],
|
|
)
|
|
comment_rels = project_state.relations["tests", "user"]["tests", "comment"]
|
|
# Two foreign keys to the same model.
|
|
self.assertEqual(len(comment_rels), 2)
|
|
self.assertEqual(comment_rels["reviewer"], new_field)
|
|
# Rename the second foreign key.
|
|
project_state.rename_field("tests", "comment", "reviewer", "supervisor")
|
|
self.assertEqual(len(comment_rels), 2)
|
|
self.assertEqual(comment_rels["supervisor"], new_field)
|
|
# Remove the first foreign key.
|
|
project_state.remove_field("tests", "comment", "user")
|
|
self.assertEqual(comment_rels, {"supervisor": new_field})
|
|
|
|
|
|
class ModelStateTests(SimpleTestCase):
|
|
def test_custom_model_base(self):
|
|
state = ModelState.from_model(ModelWithCustomBase)
|
|
self.assertEqual(state.bases, (models.Model,))
|
|
|
|
def test_bound_field_sanity_check(self):
|
|
field = models.CharField(max_length=1)
|
|
field.model = models.Model
|
|
with self.assertRaisesMessage(
|
|
ValueError, 'ModelState.fields cannot be bound to a model - "field" is.'
|
|
):
|
|
ModelState("app", "Model", [("field", field)])
|
|
|
|
def test_sanity_check_to(self):
|
|
field = models.ForeignKey(UnicodeModel, models.CASCADE)
|
|
with self.assertRaisesMessage(
|
|
ValueError,
|
|
'Model fields in "ModelState.fields" cannot refer to a model class - '
|
|
'"app.Model.field.to" does. Use a string reference instead.',
|
|
):
|
|
ModelState("app", "Model", [("field", field)])
|
|
|
|
def test_sanity_check_through(self):
|
|
field = models.ManyToManyField("UnicodeModel")
|
|
field.remote_field.through = UnicodeModel
|
|
with self.assertRaisesMessage(
|
|
ValueError,
|
|
'Model fields in "ModelState.fields" cannot refer to a model class - '
|
|
'"app.Model.field.through" does. Use a string reference instead.',
|
|
):
|
|
ModelState("app", "Model", [("field", field)])
|
|
|
|
def test_sanity_index_name(self):
|
|
field = models.IntegerField()
|
|
options = {"indexes": [models.Index(fields=["field"])]}
|
|
msg = (
|
|
"Indexes passed to ModelState require a name attribute. <Index: "
|
|
"fields=['field']> doesn't have one."
|
|
)
|
|
with self.assertRaisesMessage(ValueError, msg):
|
|
ModelState("app", "Model", [("field", field)], options=options)
|
|
|
|
def test_fields_immutability(self):
|
|
"""
|
|
Rendering a model state doesn't alter its internal fields.
|
|
"""
|
|
apps = Apps()
|
|
field = models.CharField(max_length=1)
|
|
state = ModelState("app", "Model", [("name", field)])
|
|
Model = state.render(apps)
|
|
self.assertNotEqual(Model._meta.get_field("name"), field)
|
|
|
|
def test_repr(self):
|
|
field = models.CharField(max_length=1)
|
|
state = ModelState(
|
|
"app", "Model", [("name", field)], bases=["app.A", "app.B", "app.C"]
|
|
)
|
|
self.assertEqual(repr(state), "<ModelState: 'app.Model'>")
|
|
|
|
project_state = ProjectState()
|
|
project_state.add_model(state)
|
|
with self.assertRaisesMessage(
|
|
InvalidBasesError, "Cannot resolve bases for [<ModelState: 'app.Model'>]"
|
|
):
|
|
project_state.apps
|
|
|
|
def test_fields_ordering_equality(self):
|
|
state = ModelState(
|
|
"migrations",
|
|
"Tag",
|
|
[
|
|
("id", models.AutoField(primary_key=True)),
|
|
("name", models.CharField(max_length=100)),
|
|
("hidden", models.BooleanField()),
|
|
],
|
|
)
|
|
reordered_state = ModelState(
|
|
"migrations",
|
|
"Tag",
|
|
[
|
|
("id", models.AutoField(primary_key=True)),
|
|
# Purposely re-ordered.
|
|
("hidden", models.BooleanField()),
|
|
("name", models.CharField(max_length=100)),
|
|
],
|
|
)
|
|
self.assertEqual(state, reordered_state)
|
|
|
|
@override_settings(TEST_SWAPPABLE_MODEL="migrations.SomeFakeModel")
|
|
def test_create_swappable(self):
|
|
"""
|
|
Tests making a ProjectState from an Apps with a swappable model
|
|
"""
|
|
new_apps = Apps(["migrations"])
|
|
|
|
class Author(models.Model):
|
|
name = models.CharField(max_length=255)
|
|
bio = models.TextField()
|
|
age = models.IntegerField(blank=True, null=True)
|
|
|
|
class Meta:
|
|
app_label = "migrations"
|
|
apps = new_apps
|
|
swappable = "TEST_SWAPPABLE_MODEL"
|
|
|
|
author_state = ModelState.from_model(Author)
|
|
self.assertEqual(author_state.app_label, "migrations")
|
|
self.assertEqual(author_state.name, "Author")
|
|
self.assertEqual(list(author_state.fields), ["id", "name", "bio", "age"])
|
|
self.assertEqual(author_state.fields["name"].max_length, 255)
|
|
self.assertIs(author_state.fields["bio"].null, False)
|
|
self.assertIs(author_state.fields["age"].null, True)
|
|
self.assertEqual(
|
|
author_state.options,
|
|
{"swappable": "TEST_SWAPPABLE_MODEL", "indexes": [], "constraints": []},
|
|
)
|
|
self.assertEqual(author_state.bases, (models.Model,))
|
|
self.assertEqual(author_state.managers, [])
|
|
|
|
@override_settings(TEST_SWAPPABLE_MODEL="migrations.SomeFakeModel")
|
|
def test_create_swappable_from_abstract(self):
|
|
"""
|
|
A swappable model inheriting from a hierarchy:
|
|
concrete -> abstract -> concrete.
|
|
"""
|
|
new_apps = Apps(["migrations"])
|
|
|
|
class SearchableLocation(models.Model):
|
|
keywords = models.CharField(max_length=256)
|
|
|
|
class Meta:
|
|
app_label = "migrations"
|
|
apps = new_apps
|
|
|
|
class Station(SearchableLocation):
|
|
name = models.CharField(max_length=128)
|
|
|
|
class Meta:
|
|
abstract = True
|
|
|
|
class BusStation(Station):
|
|
bus_routes = models.CharField(max_length=128)
|
|
inbound = models.BooleanField(default=False)
|
|
|
|
class Meta(Station.Meta):
|
|
app_label = "migrations"
|
|
apps = new_apps
|
|
swappable = "TEST_SWAPPABLE_MODEL"
|
|
|
|
station_state = ModelState.from_model(BusStation)
|
|
self.assertEqual(station_state.app_label, "migrations")
|
|
self.assertEqual(station_state.name, "BusStation")
|
|
self.assertEqual(
|
|
list(station_state.fields),
|
|
["searchablelocation_ptr", "name", "bus_routes", "inbound"],
|
|
)
|
|
self.assertEqual(station_state.fields["name"].max_length, 128)
|
|
self.assertIs(station_state.fields["bus_routes"].null, False)
|
|
self.assertEqual(
|
|
station_state.options,
|
|
{
|
|
"abstract": False,
|
|
"swappable": "TEST_SWAPPABLE_MODEL",
|
|
"indexes": [],
|
|
"constraints": [],
|
|
},
|
|
)
|
|
self.assertEqual(station_state.bases, ("migrations.searchablelocation",))
|
|
self.assertEqual(station_state.managers, [])
|
|
|
|
@override_settings(TEST_SWAPPABLE_MODEL="migrations.SomeFakeModel")
|
|
def test_custom_manager_swappable(self):
|
|
"""
|
|
Tests making a ProjectState from unused models with custom managers
|
|
"""
|
|
new_apps = Apps(["migrations"])
|
|
|
|
class Food(models.Model):
|
|
food_mgr = FoodManager("a", "b")
|
|
food_qs = FoodQuerySet.as_manager()
|
|
food_no_mgr = NoMigrationFoodManager("x", "y")
|
|
|
|
class Meta:
|
|
app_label = "migrations"
|
|
apps = new_apps
|
|
swappable = "TEST_SWAPPABLE_MODEL"
|
|
|
|
food_state = ModelState.from_model(Food)
|
|
|
|
# The default manager is used in migrations
|
|
self.assertEqual([name for name, mgr in food_state.managers], ["food_mgr"])
|
|
self.assertEqual(food_state.managers[0][1].args, ("a", "b", 1, 2))
|
|
|
|
@isolate_apps("migrations", "django.contrib.contenttypes")
|
|
def test_order_with_respect_to_private_field(self):
|
|
class PrivateFieldModel(models.Model):
|
|
content_type = models.ForeignKey("contenttypes.ContentType", models.CASCADE)
|
|
object_id = models.PositiveIntegerField()
|
|
private = GenericForeignKey()
|
|
|
|
class Meta:
|
|
order_with_respect_to = "private"
|
|
|
|
state = ModelState.from_model(PrivateFieldModel)
|
|
self.assertNotIn("order_with_respect_to", state.options)
|
|
|
|
@isolate_apps("migrations")
|
|
def test_abstract_model_children_inherit_indexes(self):
|
|
class Abstract(models.Model):
|
|
name = models.CharField(max_length=50)
|
|
|
|
class Meta:
|
|
app_label = "migrations"
|
|
abstract = True
|
|
indexes = [models.Index(fields=["name"])]
|
|
|
|
class Child1(Abstract):
|
|
pass
|
|
|
|
class Child2(Abstract):
|
|
pass
|
|
|
|
abstract_state = ModelState.from_model(Abstract)
|
|
child1_state = ModelState.from_model(Child1)
|
|
child2_state = ModelState.from_model(Child2)
|
|
index_names = [index.name for index in abstract_state.options["indexes"]]
|
|
self.assertEqual(index_names, ["migrations__name_ae16a4_idx"])
|
|
index_names = [index.name for index in child1_state.options["indexes"]]
|
|
self.assertEqual(index_names, ["migrations__name_b0afd7_idx"])
|
|
index_names = [index.name for index in child2_state.options["indexes"]]
|
|
self.assertEqual(index_names, ["migrations__name_016466_idx"])
|
|
|
|
# Modifying the state doesn't modify the index on the model.
|
|
child1_state.options["indexes"][0].name = "bar"
|
|
self.assertEqual(Child1._meta.indexes[0].name, "migrations__name_b0afd7_idx")
|
|
|
|
@isolate_apps("migrations")
|
|
def test_explicit_index_name(self):
|
|
class TestModel(models.Model):
|
|
name = models.CharField(max_length=50)
|
|
|
|
class Meta:
|
|
app_label = "migrations"
|
|
indexes = [models.Index(fields=["name"], name="foo_idx")]
|
|
|
|
model_state = ModelState.from_model(TestModel)
|
|
index_names = [index.name for index in model_state.options["indexes"]]
|
|
self.assertEqual(index_names, ["foo_idx"])
|
|
|
|
@isolate_apps("migrations")
|
|
def test_from_model_constraints(self):
|
|
class ModelWithConstraints(models.Model):
|
|
size = models.IntegerField()
|
|
|
|
class Meta:
|
|
constraints = [
|
|
models.CheckConstraint(
|
|
condition=models.Q(size__gt=1), name="size_gt_1"
|
|
)
|
|
]
|
|
|
|
state = ModelState.from_model(ModelWithConstraints)
|
|
model_constraints = ModelWithConstraints._meta.constraints
|
|
state_constraints = state.options["constraints"]
|
|
self.assertEqual(model_constraints, state_constraints)
|
|
self.assertIsNot(model_constraints, state_constraints)
|
|
self.assertIsNot(model_constraints[0], state_constraints[0])
|
|
|
|
|
|
class RelatedModelsTests(SimpleTestCase):
|
|
def setUp(self):
|
|
self.apps = Apps(["migrations.related_models_app"])
|
|
|
|
def create_model(
|
|
self, name, foreign_keys=[], bases=(), abstract=False, proxy=False
|
|
):
|
|
test_name = "related_models_app"
|
|
assert not (abstract and proxy)
|
|
meta_contents = {
|
|
"abstract": abstract,
|
|
"app_label": test_name,
|
|
"apps": self.apps,
|
|
"proxy": proxy,
|
|
}
|
|
meta = type("Meta", (), meta_contents)
|
|
if not bases:
|
|
bases = (models.Model,)
|
|
body = {
|
|
"Meta": meta,
|
|
"__module__": "__fake__",
|
|
}
|
|
fname_base = fname = "%s_%%d" % name.lower()
|
|
for i, fk in enumerate(foreign_keys, 1):
|
|
fname = fname_base % i
|
|
body[fname] = fk
|
|
return type(name, bases, body)
|
|
|
|
def assertRelated(self, model, needle):
|
|
self.assertEqual(
|
|
get_related_models_recursive(model),
|
|
{(n._meta.app_label, n._meta.model_name) for n in needle},
|
|
)
|
|
|
|
def test_unrelated(self):
|
|
A = self.create_model("A")
|
|
B = self.create_model("B")
|
|
self.assertRelated(A, [])
|
|
self.assertRelated(B, [])
|
|
|
|
def test_direct_fk(self):
|
|
A = self.create_model(
|
|
"A", foreign_keys=[models.ForeignKey("B", models.CASCADE)]
|
|
)
|
|
B = self.create_model("B")
|
|
self.assertRelated(A, [B])
|
|
self.assertRelated(B, [A])
|
|
|
|
def test_direct_hidden_fk(self):
|
|
A = self.create_model(
|
|
"A", foreign_keys=[models.ForeignKey("B", models.CASCADE, related_name="+")]
|
|
)
|
|
B = self.create_model("B")
|
|
self.assertRelated(A, [B])
|
|
self.assertRelated(B, [A])
|
|
|
|
def test_fk_through_proxy(self):
|
|
A = self.create_model("A")
|
|
B = self.create_model("B", bases=(A,), proxy=True)
|
|
C = self.create_model("C", bases=(B,), proxy=True)
|
|
D = self.create_model(
|
|
"D", foreign_keys=[models.ForeignKey("C", models.CASCADE)]
|
|
)
|
|
self.assertRelated(A, [B, C, D])
|
|
self.assertRelated(B, [A, C, D])
|
|
self.assertRelated(C, [A, B, D])
|
|
self.assertRelated(D, [A, B, C])
|
|
|
|
def test_nested_fk(self):
|
|
A = self.create_model(
|
|
"A", foreign_keys=[models.ForeignKey("B", models.CASCADE)]
|
|
)
|
|
B = self.create_model(
|
|
"B", foreign_keys=[models.ForeignKey("C", models.CASCADE)]
|
|
)
|
|
C = self.create_model("C")
|
|
self.assertRelated(A, [B, C])
|
|
self.assertRelated(B, [A, C])
|
|
self.assertRelated(C, [A, B])
|
|
|
|
def test_two_sided(self):
|
|
A = self.create_model(
|
|
"A", foreign_keys=[models.ForeignKey("B", models.CASCADE)]
|
|
)
|
|
B = self.create_model(
|
|
"B", foreign_keys=[models.ForeignKey("A", models.CASCADE)]
|
|
)
|
|
self.assertRelated(A, [B])
|
|
self.assertRelated(B, [A])
|
|
|
|
def test_circle(self):
|
|
A = self.create_model(
|
|
"A", foreign_keys=[models.ForeignKey("B", models.CASCADE)]
|
|
)
|
|
B = self.create_model(
|
|
"B", foreign_keys=[models.ForeignKey("C", models.CASCADE)]
|
|
)
|
|
C = self.create_model(
|
|
"C", foreign_keys=[models.ForeignKey("A", models.CASCADE)]
|
|
)
|
|
self.assertRelated(A, [B, C])
|
|
self.assertRelated(B, [A, C])
|
|
self.assertRelated(C, [A, B])
|
|
|
|
def test_base(self):
|
|
A = self.create_model("A")
|
|
B = self.create_model("B", bases=(A,))
|
|
self.assertRelated(A, [B])
|
|
self.assertRelated(B, [A])
|
|
|
|
def test_nested_base(self):
|
|
A = self.create_model("A")
|
|
B = self.create_model("B", bases=(A,))
|
|
C = self.create_model("C", bases=(B,))
|
|
self.assertRelated(A, [B, C])
|
|
self.assertRelated(B, [A, C])
|
|
self.assertRelated(C, [A, B])
|
|
|
|
def test_multiple_bases(self):
|
|
A = self.create_model("A")
|
|
B = self.create_model("B")
|
|
C = self.create_model(
|
|
"C",
|
|
bases=(
|
|
A,
|
|
B,
|
|
),
|
|
)
|
|
self.assertRelated(A, [B, C])
|
|
self.assertRelated(B, [A, C])
|
|
self.assertRelated(C, [A, B])
|
|
|
|
def test_multiple_nested_bases(self):
|
|
A = self.create_model("A")
|
|
B = self.create_model("B")
|
|
C = self.create_model(
|
|
"C",
|
|
bases=(
|
|
A,
|
|
B,
|
|
),
|
|
)
|
|
D = self.create_model("D")
|
|
E = self.create_model("E", bases=(D,))
|
|
F = self.create_model(
|
|
"F",
|
|
bases=(
|
|
C,
|
|
E,
|
|
),
|
|
)
|
|
Y = self.create_model("Y")
|
|
Z = self.create_model("Z", bases=(Y,))
|
|
self.assertRelated(A, [B, C, D, E, F])
|
|
self.assertRelated(B, [A, C, D, E, F])
|
|
self.assertRelated(C, [A, B, D, E, F])
|
|
self.assertRelated(D, [A, B, C, E, F])
|
|
self.assertRelated(E, [A, B, C, D, F])
|
|
self.assertRelated(F, [A, B, C, D, E])
|
|
self.assertRelated(Y, [Z])
|
|
self.assertRelated(Z, [Y])
|
|
|
|
def test_base_to_base_fk(self):
|
|
A = self.create_model(
|
|
"A", foreign_keys=[models.ForeignKey("Y", models.CASCADE)]
|
|
)
|
|
B = self.create_model("B", bases=(A,))
|
|
Y = self.create_model("Y")
|
|
Z = self.create_model("Z", bases=(Y,))
|
|
self.assertRelated(A, [B, Y, Z])
|
|
self.assertRelated(B, [A, Y, Z])
|
|
self.assertRelated(Y, [A, B, Z])
|
|
self.assertRelated(Z, [A, B, Y])
|
|
|
|
def test_base_to_subclass_fk(self):
|
|
A = self.create_model(
|
|
"A", foreign_keys=[models.ForeignKey("Z", models.CASCADE)]
|
|
)
|
|
B = self.create_model("B", bases=(A,))
|
|
Y = self.create_model("Y")
|
|
Z = self.create_model("Z", bases=(Y,))
|
|
self.assertRelated(A, [B, Y, Z])
|
|
self.assertRelated(B, [A, Y, Z])
|
|
self.assertRelated(Y, [A, B, Z])
|
|
self.assertRelated(Z, [A, B, Y])
|
|
|
|
def test_direct_m2m(self):
|
|
A = self.create_model("A", foreign_keys=[models.ManyToManyField("B")])
|
|
B = self.create_model("B")
|
|
self.assertRelated(A, [A.a_1.rel.through, B])
|
|
self.assertRelated(B, [A, A.a_1.rel.through])
|
|
|
|
def test_direct_m2m_self(self):
|
|
A = self.create_model("A", foreign_keys=[models.ManyToManyField("A")])
|
|
self.assertRelated(A, [A.a_1.rel.through])
|
|
|
|
def test_intermediate_m2m_self(self):
|
|
A = self.create_model(
|
|
"A", foreign_keys=[models.ManyToManyField("A", through="T")]
|
|
)
|
|
T = self.create_model(
|
|
"T",
|
|
foreign_keys=[
|
|
models.ForeignKey("A", models.CASCADE),
|
|
models.ForeignKey("A", models.CASCADE),
|
|
],
|
|
)
|
|
self.assertRelated(A, [T])
|
|
self.assertRelated(T, [A])
|
|
|
|
def test_intermediate_m2m(self):
|
|
A = self.create_model(
|
|
"A", foreign_keys=[models.ManyToManyField("B", through="T")]
|
|
)
|
|
B = self.create_model("B")
|
|
T = self.create_model(
|
|
"T",
|
|
foreign_keys=[
|
|
models.ForeignKey("A", models.CASCADE),
|
|
models.ForeignKey("B", models.CASCADE),
|
|
],
|
|
)
|
|
self.assertRelated(A, [B, T])
|
|
self.assertRelated(B, [A, T])
|
|
self.assertRelated(T, [A, B])
|
|
|
|
def test_intermediate_m2m_extern_fk(self):
|
|
A = self.create_model(
|
|
"A", foreign_keys=[models.ManyToManyField("B", through="T")]
|
|
)
|
|
B = self.create_model("B")
|
|
Z = self.create_model("Z")
|
|
T = self.create_model(
|
|
"T",
|
|
foreign_keys=[
|
|
models.ForeignKey("A", models.CASCADE),
|
|
models.ForeignKey("B", models.CASCADE),
|
|
models.ForeignKey("Z", models.CASCADE),
|
|
],
|
|
)
|
|
self.assertRelated(A, [B, T, Z])
|
|
self.assertRelated(B, [A, T, Z])
|
|
self.assertRelated(T, [A, B, Z])
|
|
self.assertRelated(Z, [A, B, T])
|
|
|
|
def test_intermediate_m2m_base(self):
|
|
A = self.create_model(
|
|
"A", foreign_keys=[models.ManyToManyField("B", through="T")]
|
|
)
|
|
B = self.create_model("B")
|
|
S = self.create_model("S")
|
|
T = self.create_model(
|
|
"T",
|
|
foreign_keys=[
|
|
models.ForeignKey("A", models.CASCADE),
|
|
models.ForeignKey("B", models.CASCADE),
|
|
],
|
|
bases=(S,),
|
|
)
|
|
self.assertRelated(A, [B, S, T])
|
|
self.assertRelated(B, [A, S, T])
|
|
self.assertRelated(S, [A, B, T])
|
|
self.assertRelated(T, [A, B, S])
|
|
|
|
def test_generic_fk(self):
|
|
A = self.create_model(
|
|
"A",
|
|
foreign_keys=[
|
|
models.ForeignKey("B", models.CASCADE),
|
|
GenericForeignKey(),
|
|
],
|
|
)
|
|
B = self.create_model(
|
|
"B",
|
|
foreign_keys=[
|
|
models.ForeignKey("C", models.CASCADE),
|
|
],
|
|
)
|
|
self.assertRelated(A, [B])
|
|
self.assertRelated(B, [A])
|
|
|
|
def test_abstract_base(self):
|
|
A = self.create_model("A", abstract=True)
|
|
B = self.create_model("B", bases=(A,))
|
|
self.assertRelated(A, [B])
|
|
self.assertRelated(B, [])
|
|
|
|
def test_nested_abstract_base(self):
|
|
A = self.create_model("A", abstract=True)
|
|
B = self.create_model("B", bases=(A,), abstract=True)
|
|
C = self.create_model("C", bases=(B,))
|
|
self.assertRelated(A, [B, C])
|
|
self.assertRelated(B, [C])
|
|
self.assertRelated(C, [])
|
|
|
|
def test_proxy_base(self):
|
|
A = self.create_model("A")
|
|
B = self.create_model("B", bases=(A,), proxy=True)
|
|
self.assertRelated(A, [B])
|
|
self.assertRelated(B, [])
|
|
|
|
def test_nested_proxy_base(self):
|
|
A = self.create_model("A")
|
|
B = self.create_model("B", bases=(A,), proxy=True)
|
|
C = self.create_model("C", bases=(B,), proxy=True)
|
|
self.assertRelated(A, [B, C])
|
|
self.assertRelated(B, [C])
|
|
self.assertRelated(C, [])
|
|
|
|
def test_multiple_mixed_bases(self):
|
|
A = self.create_model("A", abstract=True)
|
|
M = self.create_model("M")
|
|
P = self.create_model("P")
|
|
Q = self.create_model("Q", bases=(P,), proxy=True)
|
|
Z = self.create_model("Z", bases=(A, M, Q))
|
|
# M has a pointer O2O field p_ptr to P
|
|
self.assertRelated(A, [M, P, Q, Z])
|
|
self.assertRelated(M, [P, Q, Z])
|
|
self.assertRelated(P, [M, Q, Z])
|
|
self.assertRelated(Q, [M, P, Z])
|
|
self.assertRelated(Z, [M, P, Q])
|