apps/south/tests/db.py

   1 import unittest
   2
   3 from south.db import db
   4 from django.db import connection, models
   5
   6 # Create a list of error classes from the various database libraries
   7 errors = []
   8 try:
   9     from psycopg2 import ProgrammingError
  10     errors.append(ProgrammingError)
  11 except ImportError:
  12     pass
  13 errors = tuple(errors)
  14
  15 class TestOperations(unittest.TestCase):
  16
  17     """
  18     Tests if the various DB abstraction calls work.
  19     Can only test a limited amount due to DB differences.
  20     """
  21
  22     def setUp(self):
  23         db.debug = False
  24         db.clear_deferred_sql()
  25
  26     def test_create(self):
  27         """
  28         Test creation and deletion of tables.
  29         """
  30         cursor = connection.cursor()
  31         # It needs to take at least 2 args
  32         self.assertRaises(TypeError, db.create_table)
  33         self.assertRaises(TypeError, db.create_table, "test1")
  34         # Empty tables (i.e. no columns) are not fine, so make at least 1
  35         db.create_table("test1", [('email_confirmed', models.BooleanField(default=False))])
  36         db.start_transaction()
  37         # And should exist
  38         cursor.execute("SELECT * FROM test1")
  39         # Make sure we can't do the same query on an empty table
  40         try:
  41             cursor.execute("SELECT * FROM nottheretest1")
  42             self.fail("Non-existent table could be selected!")
  43         except:
  44             pass
  45         # Clear the dirty transaction
  46         db.rollback_transaction()
  47         db.start_transaction()
  48         # Remove the table
  49         db.drop_table("test1")
  50         # Make sure it went
  51         try:
  52             cursor.execute("SELECT * FROM test1")
  53             self.fail("Just-deleted table could be selected!")
  54         except:
  55             pass
  56         # Clear the dirty transaction
  57         db.rollback_transaction()
  58         db.start_transaction()
  59         # Try deleting a nonexistent one
  60         try:
  61             db.delete_table("nottheretest1")
  62             self.fail("Non-existent table could be deleted!")
  63         except:
  64             pass
  65         db.rollback_transaction()
  66
  67     def test_foreign_keys(self):
  68         """
  69         Tests foreign key creation, especially uppercase (see #61)
  70         """
  71         Test = db.mock_model(model_name='Test', db_table='test5a',
  72                              db_tablespace='', pk_field_name='ID',
  73                              pk_field_type=models.AutoField, pk_field_args=[])
  74         cursor = connection.cursor()
  75         db.start_transaction()
  76         db.create_table("test5a", [('ID', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True))])
  77         db.create_table("test5b", [
  78             ('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
  79             ('UNIQUE', models.ForeignKey(Test)),
  80         ])
  81         db.execute_deferred_sql()
  82         db.rollback_transaction()
  83
  84     def test_rename(self):
  85         """
  86         Test column renaming
  87         """
  88         cursor = connection.cursor()
  89         db.create_table("test2", [('spam', models.BooleanField(default=False))])
  90         db.start_transaction()
  91         # Make sure we can select the column
  92         cursor.execute("SELECT spam FROM test2")
  93         # Rename it
  94         db.rename_column("test2", "spam", "eggs")
  95         cursor.execute("SELECT eggs FROM test2")
  96         try:
  97             cursor.execute("SELECT spam FROM test2")
  98             self.fail("Just-renamed column could be selected!")
  99         except:
 100             pass
 101         db.rollback_transaction()
 102         db.delete_table("test2")
 103
 104     def test_dry_rename(self):
 105         """
 106         Test column renaming while --dry-run is turned on (should do nothing)
 107         See ticket #65
 108         """
 109         cursor = connection.cursor()
 110         db.create_table("test2", [('spam', models.BooleanField(default=False))])
 111         db.start_transaction()
 112         # Make sure we can select the column
 113         cursor.execute("SELECT spam FROM test2")
 114         # Rename it
 115         db.dry_run = True
 116         db.rename_column("test2", "spam", "eggs")
 117         db.dry_run = False
 118         cursor.execute("SELECT spam FROM test2")
 119         try:
 120             cursor.execute("SELECT eggs FROM test2")
 121             self.fail("Dry-renamed new column could be selected!")
 122         except:
 123             pass
 124         db.rollback_transaction()
 125         db.delete_table("test2")
 126
 127     def test_table_rename(self):
 128         """
 129         Test column renaming
 130         """
 131         cursor = connection.cursor()
 132         db.create_table("testtr", [('spam', models.BooleanField(default=False))])
 133         db.start_transaction()
 134         # Make sure we can select the column
 135         cursor.execute("SELECT spam FROM testtr")
 136         # Rename it
 137         db.rename_table("testtr", "testtr2")
 138         cursor.execute("SELECT spam FROM testtr2")
 139         try:
 140             cursor.execute("SELECT spam FROM testtr")
 141             self.fail("Just-renamed column could be selected!")
 142         except:
 143             pass
 144         db.rollback_transaction()
 145         db.delete_table("testtr2")
 146
 147     def test_index(self):
 148         """
 149         Test the index operations
 150         """
 151         db.create_table("test3", [
 152             ('SELECT', models.BooleanField(default=False)),
 153             ('eggs', models.IntegerField(unique=True)),
 154         ])
 155         db.execute_deferred_sql()
 156         db.start_transaction()
 157         # Add an index on that column
 158         db.create_index("test3", ["SELECT"])
 159         # Add another index on two columns
 160         db.create_index("test3", ["SELECT", "eggs"])
 161         # Delete them both
 162         db.delete_index("test3", ["SELECT"])
 163         db.delete_index("test3", ["SELECT", "eggs"])
 164         # Delete the unique index
 165         db.delete_index("test3", ["eggs"])
 166         db.rollback_transaction()
 167         db.delete_table("test3")
 168
 169     def test_alter(self):
 170         """
 171         Test altering columns/tables
 172         """
 173         db.create_table("test4", [
 174             ('spam', models.BooleanField(default=False)),
 175             ('eggs', models.IntegerField()),
 176         ])
 177         db.start_transaction()
 178         # Add a column
 179         db.add_column("test4", "add1", models.IntegerField(default=3), keep_default=False)
 180         # Add a FK with keep_default=False (#69)
 181         User = db.mock_model(model_name='User', db_table='auth_user', db_tablespace='', pk_field_name='id', pk_field_type=models.AutoField, pk_field_args=[], pk_field_kwargs={})
 182         db.add_column("test4", "user", models.ForeignKey(User), keep_default=False)
 183
 184         db.rollback_transaction()
 185         db.delete_table("test4")