Fixed #33379 -- Added minimum database version checks.

Thanks Tim Graham for the review.

5 files changed, 94 insertions, 24 deletions

diff --git a/tests/backends/base/test_base.py b/tests/backends/base/test_base.py
index 00ef766d5d..57d22ce269 100644
--- a/tests/backends/base/test_base.py
+++ b/tests/backends/base/test_base.py
@@ -41,6 +41,19 @@ class DatabaseWrapperTests(SimpleTestCase):
         self.assertEqual(BaseDatabaseWrapper.display_name, "unknown")
         self.assertNotEqual(connection.display_name, "unknown")
 
+    def test_get_database_version(self):
+        with patch.object(BaseDatabaseWrapper, "__init__", return_value=None):
+            msg = (
+                "subclasses of BaseDatabaseWrapper may require a "
+                "get_database_version() method."
+            )
+            with self.assertRaisesMessage(NotImplementedError, msg):
+                BaseDatabaseWrapper().get_database_version()
+
+    def test_check_database_version_supported_with_none_as_database_version(self):
+        with patch.object(connection.features, "minimum_database_version", None):
+            connection.check_database_version_supported()
+
 
 class ExecuteWrapperTests(TestCase):
     @staticmethod
@@ -297,3 +310,25 @@ class ConnectionHealthChecksTests(SimpleTestCase):
         connection.commit()
         connection.set_autocommit(True)
         self.assertIs(new_connection, connection.connection)
+
+
+class MultiDatabaseTests(TestCase):
+    databases = {"default", "other"}
+
+    def test_multi_database_init_connection_state_called_once(self):
+        for db in self.databases:
+            with self.subTest(database=db):
+                with patch.object(connections[db], "commit", return_value=None):
+                    with patch.object(
+                        connections[db],
+                        "check_database_version_supported",
+                    ) as mocked_check_database_version_supported:
+                        connections[db].init_connection_state()
+                        after_first_calls = len(
+                            mocked_check_database_version_supported.mock_calls
+                        )
+                        connections[db].init_connection_state()
+                        self.assertEqual(
+                            len(mocked_check_database_version_supported.mock_calls),
+                            after_first_calls,
+                        )
diff --git a/tests/backends/mysql/tests.py b/tests/backends/mysql/tests.py
index 139b363bf4..e84762584a 100644
--- a/tests/backends/mysql/tests.py
+++ b/tests/backends/mysql/tests.py
@@ -1,8 +1,9 @@
 import unittest
 from contextlib import contextmanager
+from unittest import mock
 
 from django.core.exceptions import ImproperlyConfigured
-from django.db import connection
+from django.db import NotSupportedError, connection
 from django.test import TestCase, override_settings
 
 
@@ -99,3 +100,19 @@ class IsolationLevelTests(TestCase):
         )
         with self.assertRaisesMessage(ImproperlyConfigured, msg):
             new_connection.cursor()
+
+
+@unittest.skipUnless(connection.vendor == "mysql", "MySQL tests")
+class Tests(TestCase):
+    @mock.patch.object(connection, "get_database_version")
+    def test_check_database_version_supported(self, mocked_get_database_version):
+        if connection.mysql_is_mariadb:
+            mocked_get_database_version.return_value = (10, 1)
+            msg = "MariaDB 10.2 or later is required (found 10.1)."
+        else:
+            mocked_get_database_version.return_value = (5, 6)
+            msg = "MySQL 5.7 or later is required (found 5.6)."
+
+        with self.assertRaisesMessage(NotSupportedError, msg):
+            connection.check_database_version_supported()
+        self.assertTrue(mocked_get_database_version.called)
diff --git a/tests/backends/oracle/tests.py b/tests/backends/oracle/tests.py
index 3f51d57de8..9a4e8ad435 100644
--- a/tests/backends/oracle/tests.py
+++ b/tests/backends/oracle/tests.py
@@ -1,14 +1,15 @@
 import unittest
+from unittest import mock
 
-from django.db import DatabaseError, connection
+from django.db import DatabaseError, NotSupportedError, connection
 from django.db.models import BooleanField
-from django.test import TransactionTestCase
+from django.test import TestCase, TransactionTestCase
 
 from ..models import Square, VeryLongModelNameZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZ
 
 
 @unittest.skipUnless(connection.vendor == "oracle", "Oracle tests")
-class Tests(unittest.TestCase):
+class Tests(TestCase):
     def test_quote_name(self):
         """'%' chars are escaped for query execution."""
         name = '"SOME%NAME"'
@@ -56,6 +57,17 @@ class Tests(unittest.TestCase):
                 field.set_attributes_from_name("is_nice")
                 self.assertIn('"IS_NICE" IN (0,1)', field.db_check(connection))
 
+    @mock.patch.object(
+        connection,
+        "get_database_version",
+        return_value=(18, 1),
+    )
+    def test_check_database_version_supported(self, mocked_get_database_version):
+        msg = "Oracle 19 or later is required (found 18.1)."
+        with self.assertRaisesMessage(NotSupportedError, msg):
+            connection.check_database_version_supported()
+        self.assertTrue(mocked_get_database_version.called)
+
 
 @unittest.skipUnless(connection.vendor == "oracle", "Oracle tests")
 class TransactionalTests(TransactionTestCase):
diff --git a/tests/backends/postgresql/tests.py b/tests/backends/postgresql/tests.py
index af08f6f286..ce8ed7b4d5 100644
--- a/tests/backends/postgresql/tests.py
+++ b/tests/backends/postgresql/tests.py
@@ -4,7 +4,13 @@ from io import StringIO
 from unittest import mock
 
 from django.core.exceptions import ImproperlyConfigured
-from django.db import DEFAULT_DB_ALIAS, DatabaseError, connection, connections
+from django.db import (
+    DEFAULT_DB_ALIAS,
+    DatabaseError,
+    NotSupportedError,
+    connection,
+    connections,
+)
 from django.db.backends.base.base import BaseDatabaseWrapper
 from django.test import TestCase, override_settings
 
@@ -303,3 +309,15 @@ class Tests(TestCase):
             [q["sql"] for q in connection.queries],
             [copy_expert_sql, "COPY django_session TO STDOUT"],
         )
+
+    def test_get_database_version(self):
+        new_connection = connection.copy()
+        new_connection.pg_version = 110009
+        self.assertEqual(new_connection.get_database_version(), (11, 9))
+
+    @mock.patch.object(connection, "get_database_version", return_value=(9, 6))
+    def test_check_database_version_supported(self, mocked_get_database_version):
+        msg = "PostgreSQL 10 or later is required (found 9.6)."
+        with self.assertRaisesMessage(NotSupportedError, msg):
+            connection.check_database_version_supported()
+        self.assertTrue(mocked_get_database_version.called)
diff --git a/tests/backends/sqlite/tests.py b/tests/backends/sqlite/tests.py
index e167e09dcf..97505eaa36 100644
--- a/tests/backends/sqlite/tests.py
+++ b/tests/backends/sqlite/tests.py
@@ -4,10 +4,8 @@ import tempfile
 import threading
 import unittest
 from pathlib import Path
-from sqlite3 import dbapi2
 from unittest import mock
 
-from django.core.exceptions import ImproperlyConfigured
 from django.db import NotSupportedError, connection, transaction
 from django.db.models import Aggregate, Avg, CharField, StdDev, Sum, Variance
 from django.db.utils import ConnectionHandler
@@ -21,28 +19,11 @@ from django.test.utils import isolate_apps
 
 from ..models import Author, Item, Object, Square
 
-try:
-    from django.db.backends.sqlite3.base import check_sqlite_version
-except ImproperlyConfigured:
-    # Ignore "SQLite is too old" when running tests on another database.
-    pass
-
 
 @unittest.skipUnless(connection.vendor == "sqlite", "SQLite tests")
 class Tests(TestCase):
     longMessage = True
 
-    def test_check_sqlite_version(self):
-        msg = "SQLite 3.9.0 or later is required (found 3.8.11.1)."
-        with mock.patch.object(
-            dbapi2, "sqlite_version_info", (3, 8, 11, 1)
-        ), mock.patch.object(
-            dbapi2, "sqlite_version", "3.8.11.1"
-        ), self.assertRaisesMessage(
-            ImproperlyConfigured, msg
-        ):
-            check_sqlite_version()
-
     def test_aggregation(self):
         """Raise NotSupportedError when aggregating on date/time fields."""
         for aggregate in (Sum, Avg, Variance, StdDev):
@@ -125,6 +106,13 @@ class Tests(TestCase):
             connections["default"].close()
             self.assertTrue(os.path.isfile(os.path.join(tmp, "test.db")))
 
+    @mock.patch.object(connection, "get_database_version", return_value=(3, 8))
+    def test_check_database_version_supported(self, mocked_get_database_version):
+        msg = "SQLite 3.9 or later is required (found 3.8)."
+        with self.assertRaisesMessage(NotSupportedError, msg):
+            connection.check_database_version_supported()
+        self.assertTrue(mocked_get_database_version.called)
+
 
 @unittest.skipUnless(connection.vendor == "sqlite", "SQLite tests")
 @isolate_apps("backends")