Ticket #18088: 18088.diff

django/db/backends/__init__.py

@@ -405 +405 @@
     supports_transactions = None
     supports_stddev = None
     can_introspect_foreign_keys = None
+    supports_foreign_keys = None
 
     # Support for the DISTINCT ON clause
     can_distinct_on_fields = False
@@ -418 +419 @@
         self.supports_transactions = self._supports_transactions()
         self.supports_stddev = self._supports_stddev()
         self.can_introspect_foreign_keys = self._can_introspect_foreign_keys()
+        self.supports_foreign_keys = self._supports_foreign_keys()
 
     def _supports_transactions(self):
         "Confirm support for transactions"
@@ -448 +450 @@
         # which can't do it for MyISAM tables
         return True
 
+    def _supports_foreign_keys(self):
+        """
+        Check support for foreign keys.
+        """
+        return True
+
 
 class BaseDatabaseOperations(object):
     """

django/db/backends/mysql/base.py

@@ -187 +187 @@
         "Confirm support for introspected foreign keys"
         return self._mysql_storage_engine() != 'MyISAM'
 
+    def _supports_foreign_keys(self):
+        "MyISAM does not support foreign keys."
+        return self._mysql_storage_engine() != 'MyISAM'
+
+
 class DatabaseOperations(BaseDatabaseOperations):
     compiler_module = "django.db.backends.mysql.compiler"
 

django/db/backends/sqlite3/base.py

@@ -103 +103 @@
         cursor.execute('DROP TABLE STDDEV_TEST')
         return has_support
 
+    def _supports_foreign_keys(self):
+        """
+        Standard SQLite does not support foreign key constraints. However,
+        one can compile an edition which does. Currently we just return false,
+        but we could check if a foreign key constraint is enforced by sqlite
+        here.
+        """
+        return False
+
 class DatabaseOperations(BaseDatabaseOperations):
     def date_extract_sql(self, lookup_type, field_name):
         # sqlite doesn't support extract, so we fake it with the user-defined

tests/regressiontests/backends/tests.py

@@ -379 +379 @@
         with self.assertRaises(DatabaseError):
             cursor.execute(query)
 
-# We don't make these tests conditional because that means we would need to
-# check and differentiate between:
-# * MySQL+InnoDB, MySQL+MYISAM (something we currently can't do).
-# * if sqlite3 (if/once we get #14204 fixed) has referential integrity turned
-#   on or not, something that would be controlled by runtime support and user
-#   preference.
-# verify if its type is django.database.db.IntegrityError.
 
 class FkConstraintsTests(TransactionTestCase):
 
@@ -393 +386 @@
         # Create a Reporter.
         self.r = models.Reporter.objects.create(first_name='John', last_name='Smith')
 
+    @skipUnlessDBFeature('supports_foreign_keys')
     def test_integrity_checks_on_creation(self):
         """
         Try to create a model instance that violates a FK constraint. If it
         fails it should fail with IntegrityError.
         """
         a = models.Article(headline="This is a test", pub_date=datetime.datetime(2005, 7, 27), reporter_id=30)
-        try:
+        with self.assertRaises(IntegrityError):
             a.save()
-        except IntegrityError:
-            return
-        self.skipTest("This backend does not support integrity checks.")
 
+    @skipUnlessDBFeature('supports_foreign_keys')
     def test_integrity_checks_on_update(self):
         """
         Try to update a model instance introducing a FK constraint violation.
@@ -415 +407 @@
         # Retrive it from the DB
         a = models.Article.objects.get(headline="Test article")
         a.reporter_id = 30
-        try:
+        with self.assertRaises(IntegrityError):
             a.save()
-        except IntegrityError:
-            return
-        self.skipTest("This backend does not support integrity checks.")
 
     def test_disable_constraint_checks_manually(self):
         """