1 files changed, 94 insertions, 39 deletions
diff --git a/tests/regressiontests/backends/tests.py b/tests/regressiontests/backends/tests.py
index 6a26a608eb..01764135fa 100644
--- a/tests/regressiontests/backends/tests.py
+++ b/tests/regressiontests/backends/tests.py
@@ -1,13 +1,18 @@
 # -*- coding: utf-8 -*-
 # Unit and doctests for specific database backends.
 import datetime
-import models
 import unittest
-from django.db import backend, connection, DEFAULT_DB_ALIAS
-from django.db.backends.signals import connection_created
+
 from django.conf import settings
+from django.core import management
+from django.core.management.color import no_style
+from django.db import backend, connection, connections, DEFAULT_DB_ALIAS
+from django.db.backends.signals import connection_created
+from django.db.backends.postgresql import version as pg_version
 from django.test import TestCase
 
+from regressiontests.backends import models
+
 class Callproc(unittest.TestCase):
 
     def test_dbms_session(self):
@@ -76,6 +81,7 @@ class DateQuotingTest(TestCase):
         classes = models.SchoolClass.objects.filter(last_updated__day=20)
         self.assertEqual(len(classes), 1)
 
+
 class ParameterHandlingTest(TestCase):
     def test_bad_parameter_count(self):
         "An executemany call with too many/not enough parameters will raise an exception (Refs #12612)"
@@ -88,46 +94,95 @@ class ParameterHandlingTest(TestCase):
         self.assertRaises(Exception, cursor.executemany, query, [(1,2,3),])
         self.assertRaises(Exception, cursor.executemany, query, [(1,),])
 
+# Unfortunately, the following tests would be a good test to run on all
+# backends, but it breaks MySQL hard. Until #13711 is fixed, it can't be run
+# everywhere (although it would be an effective test of #13711).
+if settings.DATABASES[DEFAULT_DB_ALIAS]['ENGINE'] != 'django.db.backends.mysql':
+    class LongNameTest(TestCase):
+        """Long primary keys and model names can result in a sequence name
+        that exceeds the database limits, which will result in truncation
+        on certain databases (e.g., Postgres). The backend needs to use
+        the correct sequence name in last_insert_id and other places, so
+        check it is. Refs #8901.
+        """
 
-def connection_created_test(sender, **kwargs):
-    print 'connection_created signal'
-
-__test__ = {'API_TESTS': """
-# Check Postgres version parsing
->>> from django.db.backends.postgresql import version as pg_version
-
->>> pg_version._parse_version("PostgreSQL 8.3.1 on i386-apple-darwin9.2.2, compiled by GCC i686-apple-darwin9-gcc-4.0.1 (GCC) 4.0.1 (Apple Inc. build 5478)")
-(8, 3, 1)
-
->>> pg_version._parse_version("PostgreSQL 8.3.6")
-(8, 3, 6)
-
->>> pg_version._parse_version("PostgreSQL 8.3")
-(8, 3, None)
-
->>> pg_version._parse_version("EnterpriseDB 8.3")
-(8, 3, None)
-
->>> pg_version._parse_version("PostgreSQL 8.3 beta4")
-(8, 3, None)
+        def test_sequence_name_length_limits_create(self):
+            """Test creation of model with long name and long pk name doesn't error. Ref #8901"""
+            models.VeryLongModelNameZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ.objects.create()
+
+        def test_sequence_name_length_limits_m2m(self):
+            """Test an m2m save of a model with a long name and a long m2m field name doesn't error as on Django >=1.2 this now uses object saves. Ref #8901"""
+            obj = models.VeryLongModelNameZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ.objects.create()
+            rel_obj = models.Person.objects.create(first_name='Django', last_name='Reinhardt')
+            obj.m2m_also_quite_long_zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz.add(rel_obj)
+
+        def test_sequence_name_length_limits_flush(self):
+            """Test that sequence resetting as part of a flush with model with long name and long pk name doesn't error. Ref #8901"""
+            # A full flush is expensive to the full test, so we dig into the
+            # internals to generate the likely offending SQL and run it manually
+
+            # Some convenience aliases
+            VLM = models.VeryLongModelNameZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ
+            VLM_m2m = VLM.m2m_also_quite_long_zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz.through
+            tables = [
+                VLM._meta.db_table,
+                VLM_m2m._meta.db_table,
+            ]
+            sequences = [
+                {
+                    'column': VLM._meta.pk.column,
+                    'table': VLM._meta.db_table
+                },
+            ]
+            cursor = connection.cursor()
+            for statement in connection.ops.sql_flush(no_style(), tables, sequences):
+                cursor.execute(statement)
 
->>> pg_version._parse_version("PostgreSQL 8.4beta1")
-(8, 4, None)
+class SequenceResetTest(TestCase):
+    def test_generic_relation(self):
+        "Sequence names are correct when resetting generic relations (Ref #13941)"
+        # Create an object with a manually specified PK
+        models.Post.objects.create(id=10, name='1st post', text='hello world')
 
-"""}
+        # Reset the sequences for the database
+        cursor = connection.cursor()
+        commands = connections[DEFAULT_DB_ALIAS].ops.sequence_reset_sql(no_style(), [models.Post])
+        for sql in commands:
+            cursor.execute(sql)
+
+        # If we create a new object now, it should have a PK greater
+        # than the PK we specified manually.
+        obj = models.Post.objects.create(name='New post', text='goodbye world')
+        self.assertTrue(obj.pk > 10)
+
+class PostgresVersionTest(TestCase):
+    def assert_parses(self, version_string, version):
+        self.assertEqual(pg_version._parse_version(version_string), version)
+
+    def test_parsing(self):
+        self.assert_parses("PostgreSQL 8.3 beta4", (8, 3, None))
+        self.assert_parses("PostgreSQL 8.3", (8, 3, None))
+        self.assert_parses("EnterpriseDB 8.3", (8, 3, None))
+        self.assert_parses("PostgreSQL 8.3.6", (8, 3, 6))
+        self.assert_parses("PostgreSQL 8.4beta1", (8, 4, None))
+        self.assert_parses("PostgreSQL 8.3.1 on i386-apple-darwin9.2.2, compiled by GCC i686-apple-darwin9-gcc-4.0.1 (GCC) 4.0.1 (Apple Inc. build 5478)", (8, 3, 1))
 
 # Unfortunately with sqlite3 the in-memory test database cannot be
 # closed, and so it cannot be re-opened during testing, and so we
 # sadly disable this test for now.
-if settings.DATABASES[DEFAULT_DB_ALIAS]['ENGINE'] != 'django.db.backends.sqlite3':
-    __test__['API_TESTS'] += """
->>> connection_created.connect(connection_created_test)
->>> connection.close() # Ensure the connection is closed
->>> cursor = connection.cursor()
-connection_created signal
->>> connection_created.disconnect(connection_created_test)
->>> cursor = connection.cursor()
-"""
-
-if __name__ == '__main__':
-    unittest.main()
+if settings.DATABASES[DEFAULT_DB_ALIAS]["ENGINE"] != "django.db.backends.sqlite3":
+    class ConnectionCreatedSignalTest(TestCase):
+        def test_signal(self):
+            data = {}
+            def receiver(sender, connection, **kwargs):
+                data["connection"] = connection
+
+            connection_created.connect(receiver)
+            connection.close()
+            cursor = connection.cursor()
+            self.assertTrue(data["connection"] is connection)
+
+            connection_created.disconnect(receiver)
+            data.clear()
+            cursor = connection.cursor()
+            self.assertTrue(data == {})