1. import unittest
    
  2. from unittest import mock
    
  3. 
    
  4. from django.core.checks.database import check_database_backends
    
  5. from django.db import connection, connections
    
  6. from django.test import TestCase
    
  7. 
    
  8. 
    
  9. class DatabaseCheckTests(TestCase):
    
  10.     databases = {"default", "other"}
    
  11. 
    
  12.     @mock.patch("django.db.backends.base.validation.BaseDatabaseValidation.check")
    
  13.     def test_database_checks_called(self, mocked_check):
    
  14.         check_database_backends()
    
  15.         self.assertFalse(mocked_check.called)
    
  16.         check_database_backends(databases=self.databases)
    
  17.         self.assertTrue(mocked_check.called)
    
  18. 
    
  19.     @unittest.skipUnless(connection.vendor == "mysql", "Test only for MySQL")
    
  20.     def test_mysql_strict_mode(self):
    
  21.         def _clean_sql_mode():
    
  22.             for alias in self.databases:
    
  23.                 if hasattr(connections[alias], "sql_mode"):
    
  24.                     del connections[alias].sql_mode
    
  25. 
    
  26.         _clean_sql_mode()
    
  27.         good_sql_modes = [
    
  28.             "STRICT_TRANS_TABLES,STRICT_ALL_TABLES",
    
  29.             "STRICT_TRANS_TABLES",
    
  30.             "STRICT_ALL_TABLES",
    
  31.         ]
    
  32.         for sql_mode in good_sql_modes:
    
  33.             with mock.patch.object(
    
  34.                 connection,
    
  35.                 "mysql_server_data",
    
  36.                 {"sql_mode": sql_mode},
    
  37.             ):
    
  38.                 self.assertEqual(check_database_backends(databases=self.databases), [])
    
  39.             _clean_sql_mode()
    
  40. 
    
  41.         bad_sql_modes = ["", "WHATEVER"]
    
  42.         for sql_mode in bad_sql_modes:
    
  43.             mocker_default = mock.patch.object(
    
  44.                 connection,
    
  45.                 "mysql_server_data",
    
  46.                 {"sql_mode": sql_mode},
    
  47.             )
    
  48.             mocker_other = mock.patch.object(
    
  49.                 connections["other"],
    
  50.                 "mysql_server_data",
    
  51.                 {"sql_mode": sql_mode},
    
  52.             )
    
  53.             with mocker_default, mocker_other:
    
  54.                 # One warning for each database alias
    
  55.                 result = check_database_backends(databases=self.databases)
    
  56.                 self.assertEqual(len(result), 2)
    
  57.                 self.assertEqual([r.id for r in result], ["mysql.W002", "mysql.W002"])
    
  58.             _clean_sql_mode()