diff options
Diffstat (limited to 'parts/django/tests/modeltests/unmanaged_models')
3 files changed, 185 insertions, 0 deletions
diff --git a/parts/django/tests/modeltests/unmanaged_models/__init__.py b/parts/django/tests/modeltests/unmanaged_models/__init__.py new file mode 100644 index 0000000..139597f --- /dev/null +++ b/parts/django/tests/modeltests/unmanaged_models/__init__.py @@ -0,0 +1,2 @@ + + diff --git a/parts/django/tests/modeltests/unmanaged_models/models.py b/parts/django/tests/modeltests/unmanaged_models/models.py new file mode 100644 index 0000000..0c2cf50 --- /dev/null +++ b/parts/django/tests/modeltests/unmanaged_models/models.py @@ -0,0 +1,125 @@ +""" +Models can have a ``managed`` attribute, which specifies whether the SQL code +is generated for the table on various manage.py operations. +""" + +from django.db import models + +# All of these models are creatd in the database by Django. + +class A01(models.Model): + f_a = models.CharField(max_length=10, db_index=True) + f_b = models.IntegerField() + + class Meta: + db_table = 'A01' + + def __unicode__(self): + return self.f_a + +class B01(models.Model): + fk_a = models.ForeignKey(A01) + f_a = models.CharField(max_length=10, db_index=True) + f_b = models.IntegerField() + + class Meta: + db_table = 'B01' + # 'managed' is True by default. This tests we can set it explicitly. + managed = True + + def __unicode__(self): + return self.f_a + +class C01(models.Model): + mm_a = models.ManyToManyField(A01, db_table='D01') + f_a = models.CharField(max_length=10, db_index=True) + f_b = models.IntegerField() + + class Meta: + db_table = 'C01' + + def __unicode__(self): + return self.f_a + +# All of these models use the same tables as the previous set (they are shadows +# of possibly a subset of the columns). There should be no creation errors, +# since we have told Django they aren't managed by Django. + +class A02(models.Model): + f_a = models.CharField(max_length=10, db_index=True) + + class Meta: + db_table = 'A01' + managed = False + + def __unicode__(self): + return self.f_a + +class B02(models.Model): + class Meta: + db_table = 'B01' + managed = False + + fk_a = models.ForeignKey(A02) + f_a = models.CharField(max_length=10, db_index=True) + f_b = models.IntegerField() + + def __unicode__(self): + return self.f_a + +# To re-use the many-to-many intermediate table, we need to manually set up +# things up. +class C02(models.Model): + mm_a = models.ManyToManyField(A02, through="Intermediate") + f_a = models.CharField(max_length=10, db_index=True) + f_b = models.IntegerField() + + class Meta: + db_table = 'C01' + managed = False + + def __unicode__(self): + return self.f_a + +class Intermediate(models.Model): + a02 = models.ForeignKey(A02, db_column="a01_id") + c02 = models.ForeignKey(C02, db_column="c01_id") + + class Meta: + db_table = 'D01' + managed = False + +# +# These next models test the creation (or not) of many to many join tables +# between managed and unmanaged models. A join table between two unmanaged +# models shouldn't be automatically created (see #10647). +# + +# Firstly, we need some models that will create the tables, purely so that the +# tables are created. This is a test setup, not a requirement for unmanaged +# models. +class Proxy1(models.Model): + class Meta: + db_table = "unmanaged_models_proxy1" + +class Proxy2(models.Model): + class Meta: + db_table = "unmanaged_models_proxy2" + +class Unmanaged1(models.Model): + class Meta: + managed = False + db_table = "unmanaged_models_proxy1" + +# Unmanged with an m2m to unmanaged: the intermediary table won't be created. +class Unmanaged2(models.Model): + mm = models.ManyToManyField(Unmanaged1) + + class Meta: + managed = False + db_table = "unmanaged_models_proxy2" + +# Here's an unmanaged model with an m2m to a managed one; the intermediary +# table *will* be created (unless given a custom `through` as for C02 above). +class Managed1(models.Model): + mm = models.ManyToManyField(Unmanaged1) diff --git a/parts/django/tests/modeltests/unmanaged_models/tests.py b/parts/django/tests/modeltests/unmanaged_models/tests.py new file mode 100644 index 0000000..dbbe848 --- /dev/null +++ b/parts/django/tests/modeltests/unmanaged_models/tests.py @@ -0,0 +1,58 @@ +from django.test import TestCase +from django.db import connection +from models import Unmanaged1, Unmanaged2, Managed1 +from models import A01, A02, B01, B02, C01, C02 + +class SimpleTests(TestCase): + + def test_simple(self): + """ + The main test here is that the all the models can be created without + any database errors. We can also do some more simple insertion and + lookup tests whilst we're here to show that the second of models do + refer to the tables from the first set. + """ + # Insert some data into one set of models. + a = A01.objects.create(f_a="foo", f_b=42) + B01.objects.create(fk_a=a, f_a="fred", f_b=1729) + c = C01.objects.create(f_a="barney", f_b=1) + c.mm_a = [a] + + # ... and pull it out via the other set. + a2 = A02.objects.all()[0] + self.assertTrue(isinstance(a2, A02)) + self.assertEqual(a2.f_a, "foo") + + b2 = B02.objects.all()[0] + self.assertTrue(isinstance(b2, B02)) + self.assertEqual(b2.f_a, "fred") + + self.assertTrue(isinstance(b2.fk_a, A02)) + self.assertEqual(b2.fk_a.f_a, "foo") + + self.assertEqual(list(C02.objects.filter(f_a=None)), []) + + resp = list(C02.objects.filter(mm_a=a.id)) + self.assertEqual(len(resp), 1) + + self.assertTrue(isinstance(resp[0], C02)) + self.assertEqual(resp[0].f_a, 'barney') + + +class ManyToManyUnmanagedTests(TestCase): + + def test_many_to_many_between_unmanaged(self): + """ + The intermediary table between two unmanaged models should not be created. + """ + table = Unmanaged2._meta.get_field('mm').m2m_db_table() + tables = connection.introspection.table_names() + self.assert_(table not in tables, "Table '%s' should not exist, but it does." % table) + + def test_many_to_many_between_unmanaged_and_managed(self): + """ + An intermediary table between a managed and an unmanaged model should be created. + """ + table = Managed1._meta.get_field('mm').m2m_db_table() + tables = connection.introspection.table_names() + self.assert_(table in tables, "Table '%s' does not exist." % table) |