From b181aba7dd24c73ec9923c39e35393b0487a5f47 Mon Sep 17 00:00:00 2001
From: Simon Charette <charette.s@gmail.com>
Date: Sat, 12 Jan 2019 16:14:54 -0500
Subject: Refs #28478 -- Prevented database feature based skipping on tests
 disallowing queries.

Database features may require a connection to be established to determine
whether or not they are enabled.
---
 tests/test_utils/tests.py | 72 +++++++++++++++++++++++++++++++++++++++--------
 1 file changed, 60 insertions(+), 12 deletions(-)

(limited to 'tests/test_utils')

diff --git a/tests/test_utils/tests.py b/tests/test_utils/tests.py
index 680924b838..3a315e7c10 100644
--- a/tests/test_utils/tests.py
+++ b/tests/test_utils/tests.py
@@ -29,15 +29,14 @@ from .views import empty_response
 
 
 class SkippingTestCase(SimpleTestCase):
-    def _assert_skipping(self, func, expected_exc):
-        # We cannot simply use assertRaises because a SkipTest exception will go unnoticed
+    def _assert_skipping(self, func, expected_exc, msg=None):
         try:
-            func()
-        except expected_exc:
-            pass
-        except Exception as e:
-            self.fail("No %s exception should have been raised for %s." % (
-                e.__class__.__name__, func.__name__))
+            if msg is not None:
+                self.assertRaisesMessage(expected_exc, msg, func)
+            else:
+                self.assertRaises(expected_exc, func)
+        except unittest.SkipTest:
+            self.fail('%s should not result in a skipped test.' % func.__name__)
 
     def test_skip_unless_db_feature(self):
         """
@@ -65,6 +64,20 @@ class SkippingTestCase(SimpleTestCase):
         self._assert_skipping(test_func3, ValueError)
         self._assert_skipping(test_func4, unittest.SkipTest)
 
+        class SkipTestCase(SimpleTestCase):
+            @skipUnlessDBFeature('missing')
+            def test_foo(self):
+                pass
+
+        self._assert_skipping(
+            SkipTestCase('test_foo').test_foo,
+            ValueError,
+            "skipUnlessDBFeature cannot be used on test_foo (test_utils.tests."
+            "SkippingTestCase.test_skip_unless_db_feature.<locals>.SkipTestCase) "
+            "as SkippingTestCase.test_skip_unless_db_feature.<locals>.SkipTestCase "
+            "doesn't allow queries against the 'default' database."
+        )
+
     def test_skip_if_db_feature(self):
         """
         Testing the django.test.skipIfDBFeature decorator.
@@ -95,17 +108,31 @@ class SkippingTestCase(SimpleTestCase):
         self._assert_skipping(test_func4, unittest.SkipTest)
         self._assert_skipping(test_func5, ValueError)
 
+        class SkipTestCase(SimpleTestCase):
+            @skipIfDBFeature('missing')
+            def test_foo(self):
+                pass
+
+        self._assert_skipping(
+            SkipTestCase('test_foo').test_foo,
+            ValueError,
+            "skipIfDBFeature cannot be used on test_foo (test_utils.tests."
+            "SkippingTestCase.test_skip_if_db_feature.<locals>.SkipTestCase) "
+            "as SkippingTestCase.test_skip_if_db_feature.<locals>.SkipTestCase "
+            "doesn't allow queries against the 'default' database."
+        )
+
 
-class SkippingClassTestCase(SimpleTestCase):
+class SkippingClassTestCase(TestCase):
     def test_skip_class_unless_db_feature(self):
         @skipUnlessDBFeature("__class__")
-        class NotSkippedTests(unittest.TestCase):
+        class NotSkippedTests(TestCase):
             def test_dummy(self):
                 return
 
         @skipUnlessDBFeature("missing")
         @skipIfDBFeature("__class__")
-        class SkippedTests(unittest.TestCase):
+        class SkippedTests(TestCase):
             def test_will_be_skipped(self):
                 self.fail("We should never arrive here.")
 
@@ -119,13 +146,34 @@ class SkippingClassTestCase(SimpleTestCase):
             test_suite.addTest(SkippedTests('test_will_be_skipped'))
             test_suite.addTest(SkippedTestsSubclass('test_will_be_skipped'))
         except unittest.SkipTest:
-            self.fail("SkipTest should not be raised at this stage")
+            self.fail('SkipTest should not be raised here.')
         result = unittest.TextTestRunner(stream=StringIO()).run(test_suite)
         self.assertEqual(result.testsRun, 3)
         self.assertEqual(len(result.skipped), 2)
         self.assertEqual(result.skipped[0][1], 'Database has feature(s) __class__')
         self.assertEqual(result.skipped[1][1], 'Database has feature(s) __class__')
 
+    def test_missing_default_databases(self):
+        @skipIfDBFeature('missing')
+        class MissingDatabases(SimpleTestCase):
+            def test_assertion_error(self):
+                pass
+
+        suite = unittest.TestSuite()
+        try:
+            suite.addTest(MissingDatabases('test_assertion_error'))
+        except unittest.SkipTest:
+            self.fail("SkipTest should not be raised at this stage")
+        runner = unittest.TextTestRunner(stream=StringIO())
+        msg = (
+            "skipIfDBFeature cannot be used on <class 'test_utils.tests."
+            "SkippingClassTestCase.test_missing_default_databases.<locals>."
+            "MissingDatabases'> as it doesn't allow queries against the "
+            "'default' database."
+        )
+        with self.assertRaisesMessage(ValueError, msg):
+            runner.run(suite)
+
 
 @override_settings(ROOT_URLCONF='test_utils.urls')
 class AssertNumQueriesTests(TestCase):
-- 
cgit v1.3