diff options
Diffstat (limited to 'parts/django/tests/modeltests/unmanaged_models')
3 files changed, 0 insertions, 185 deletions
diff --git a/parts/django/tests/modeltests/unmanaged_models/__init__.py b/parts/django/tests/modeltests/unmanaged_models/__init__.py deleted file mode 100644 index 139597f..0000000 --- a/parts/django/tests/modeltests/unmanaged_models/__init__.py +++ /dev/null @@ -1,2 +0,0 @@ - - diff --git a/parts/django/tests/modeltests/unmanaged_models/models.py b/parts/django/tests/modeltests/unmanaged_models/models.py deleted file mode 100644 index 0c2cf50..0000000 --- a/parts/django/tests/modeltests/unmanaged_models/models.py +++ /dev/null @@ -1,125 +0,0 @@ -""" -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 deleted file mode 100644 index dbbe848..0000000 --- a/parts/django/tests/modeltests/unmanaged_models/tests.py +++ /dev/null @@ -1,58 +0,0 @@ -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) |