| import multiprocessing |
| import sys |
| from io import StringIO |
| from unittest import skipIf |
|
|
| from django.apps import apps |
| from django.core import checks |
| from django.core.checks import Error, Warning |
| from django.core.checks.messages import CheckMessage |
| from django.core.checks.registry import CheckRegistry |
| from django.core.management import call_command |
| from django.core.management.base import CommandError |
| from django.db import models |
| from django.test import SimpleTestCase |
| from django.test.utils import isolate_apps, override_settings, override_system_checks |
|
|
| from .models import SimpleModel, my_check |
|
|
|
|
| class DummyObj: |
| def __repr__(self): |
| return "obj" |
|
|
|
|
| class SystemCheckFrameworkTests(SimpleTestCase): |
| def test_register_and_run_checks(self): |
| def f(**kwargs): |
| calls[0] += 1 |
| return [1, 2, 3] |
|
|
| def f2(**kwargs): |
| return [4] |
|
|
| def f3(**kwargs): |
| return [5] |
|
|
| calls = [0] |
|
|
| |
| registry = CheckRegistry() |
| registry.register()(f) |
| registry.register("tag1", "tag2")(f2) |
| registry.register("tag2", deploy=True)(f3) |
|
|
| |
| registry2 = CheckRegistry() |
| registry2.register(f) |
| registry2.register(f2, "tag1", "tag2") |
| registry2.register(f3, "tag2", deploy=True) |
|
|
| |
| errors = registry.run_checks() |
| errors2 = registry2.run_checks() |
| self.assertEqual(errors, errors2) |
| self.assertEqual(sorted(errors), [1, 2, 3, 4]) |
| self.assertEqual(calls[0], 2) |
|
|
| errors = registry.run_checks(tags=["tag1"]) |
| errors2 = registry2.run_checks(tags=["tag1"]) |
| self.assertEqual(errors, errors2) |
| self.assertEqual(sorted(errors), [4]) |
|
|
| errors = registry.run_checks( |
| tags=["tag1", "tag2"], include_deployment_checks=True |
| ) |
| errors2 = registry2.run_checks( |
| tags=["tag1", "tag2"], include_deployment_checks=True |
| ) |
| self.assertEqual(errors, errors2) |
| self.assertEqual(sorted(errors), [4, 5]) |
|
|
| def test_register_no_kwargs_error(self): |
| registry = CheckRegistry() |
| msg = "Check functions must accept keyword arguments (**kwargs)." |
| with self.assertRaisesMessage(TypeError, msg): |
|
|
| @registry.register |
| def no_kwargs(app_configs, databases): |
| pass |
|
|
| def test_register_run_checks_non_iterable(self): |
| registry = CheckRegistry() |
|
|
| @registry.register |
| def return_non_iterable(**kwargs): |
| return Error("Message") |
|
|
| msg = ( |
| "The function %r did not return a list. All functions registered " |
| "with the checks registry must return a list." % return_non_iterable |
| ) |
| with self.assertRaisesMessage(TypeError, msg): |
| registry.run_checks() |
|
|
|
|
| class MessageTests(SimpleTestCase): |
| def test_printing(self): |
| e = Error("Message", hint="Hint", obj=DummyObj()) |
| expected = "obj: Message\n\tHINT: Hint" |
| self.assertEqual(str(e), expected) |
|
|
| def test_printing_no_hint(self): |
| e = Error("Message", obj=DummyObj()) |
| expected = "obj: Message" |
| self.assertEqual(str(e), expected) |
|
|
| def test_printing_no_object(self): |
| e = Error("Message", hint="Hint") |
| expected = "?: Message\n\tHINT: Hint" |
| self.assertEqual(str(e), expected) |
|
|
| def test_printing_with_given_id(self): |
| e = Error("Message", hint="Hint", obj=DummyObj(), id="ID") |
| expected = "obj: (ID) Message\n\tHINT: Hint" |
| self.assertEqual(str(e), expected) |
|
|
| def test_printing_field_error(self): |
| field = SimpleModel._meta.get_field("field") |
| e = Error("Error", obj=field) |
| expected = "check_framework.SimpleModel.field: Error" |
| self.assertEqual(str(e), expected) |
|
|
| def test_printing_model_error(self): |
| e = Error("Error", obj=SimpleModel) |
| expected = "check_framework.SimpleModel: Error" |
| self.assertEqual(str(e), expected) |
|
|
| def test_printing_manager_error(self): |
| manager = SimpleModel.manager |
| e = Error("Error", obj=manager) |
| expected = "check_framework.SimpleModel.manager: Error" |
| self.assertEqual(str(e), expected) |
|
|
| def test_equal_to_self(self): |
| e = Error("Error", obj=SimpleModel) |
| self.assertEqual(e, e) |
|
|
| def test_equal_to_same_constructed_check(self): |
| e1 = Error("Error", obj=SimpleModel) |
| e2 = Error("Error", obj=SimpleModel) |
| self.assertEqual(e1, e2) |
|
|
| def test_not_equal_to_different_constructed_check(self): |
| e1 = Error("Error", obj=SimpleModel) |
| e2 = Error("Error2", obj=SimpleModel) |
| self.assertNotEqual(e1, e2) |
|
|
| def test_not_equal_to_non_check(self): |
| e = Error("Error", obj=DummyObj()) |
| self.assertNotEqual(e, "a string") |
|
|
| def test_invalid_level(self): |
| msg = "The first argument should be level." |
| with self.assertRaisesMessage(TypeError, msg): |
| CheckMessage("ERROR", "Message") |
|
|
|
|
| def simple_system_check(**kwargs): |
| simple_system_check.kwargs = kwargs |
| return [] |
|
|
|
|
| def tagged_system_check(**kwargs): |
| tagged_system_check.kwargs = kwargs |
| return [checks.Warning("System Check")] |
|
|
|
|
| tagged_system_check.tags = ["simpletag"] |
|
|
|
|
| def deployment_system_check(**kwargs): |
| deployment_system_check.kwargs = kwargs |
| return [checks.Warning("Deployment Check")] |
|
|
|
|
| deployment_system_check.tags = ["deploymenttag"] |
|
|
|
|
| class CheckCommandTests(SimpleTestCase): |
| def setUp(self): |
| simple_system_check.kwargs = None |
| tagged_system_check.kwargs = None |
| self.old_stdout, self.old_stderr = sys.stdout, sys.stderr |
| sys.stdout, sys.stderr = StringIO(), StringIO() |
|
|
| def tearDown(self): |
| sys.stdout, sys.stderr = self.old_stdout, self.old_stderr |
|
|
| @override_system_checks([simple_system_check, tagged_system_check]) |
| def test_simple_call(self): |
| call_command("check") |
| self.assertEqual( |
| simple_system_check.kwargs, {"app_configs": None, "databases": None} |
| ) |
| self.assertEqual( |
| tagged_system_check.kwargs, {"app_configs": None, "databases": None} |
| ) |
|
|
| @override_system_checks([simple_system_check, tagged_system_check]) |
| def test_given_app(self): |
| call_command("check", "auth", "admin") |
| auth_config = apps.get_app_config("auth") |
| admin_config = apps.get_app_config("admin") |
| self.assertEqual( |
| simple_system_check.kwargs, |
| {"app_configs": [auth_config, admin_config], "databases": None}, |
| ) |
| self.assertEqual( |
| tagged_system_check.kwargs, |
| {"app_configs": [auth_config, admin_config], "databases": None}, |
| ) |
|
|
| @override_system_checks([simple_system_check, tagged_system_check]) |
| def test_given_tag(self): |
| call_command("check", tags=["simpletag"]) |
| self.assertIsNone(simple_system_check.kwargs) |
| self.assertEqual( |
| tagged_system_check.kwargs, {"app_configs": None, "databases": None} |
| ) |
|
|
| @override_system_checks([simple_system_check, tagged_system_check]) |
| def test_invalid_tag(self): |
| msg = 'There is no system check with the "missingtag" tag.' |
| with self.assertRaisesMessage(CommandError, msg): |
| call_command("check", tags=["missingtag"]) |
|
|
| @override_system_checks([simple_system_check]) |
| def test_list_tags_empty(self): |
| call_command("check", list_tags=True) |
| self.assertEqual("\n", sys.stdout.getvalue()) |
|
|
| @override_system_checks([tagged_system_check]) |
| def test_list_tags(self): |
| call_command("check", list_tags=True) |
| self.assertEqual("simpletag\n", sys.stdout.getvalue()) |
|
|
| @override_system_checks( |
| [tagged_system_check], deployment_checks=[deployment_system_check] |
| ) |
| def test_list_deployment_check_omitted(self): |
| call_command("check", list_tags=True) |
| self.assertEqual("simpletag\n", sys.stdout.getvalue()) |
|
|
| @override_system_checks( |
| [tagged_system_check], deployment_checks=[deployment_system_check] |
| ) |
| def test_list_deployment_check_included(self): |
| call_command("check", deploy=True, list_tags=True) |
| self.assertEqual("deploymenttag\nsimpletag\n", sys.stdout.getvalue()) |
|
|
| @override_system_checks( |
| [tagged_system_check], deployment_checks=[deployment_system_check] |
| ) |
| def test_tags_deployment_check_omitted(self): |
| msg = 'There is no system check with the "deploymenttag" tag.' |
| with self.assertRaisesMessage(CommandError, msg): |
| call_command("check", tags=["deploymenttag"]) |
|
|
| @override_system_checks( |
| [tagged_system_check], deployment_checks=[deployment_system_check] |
| ) |
| def test_tags_deployment_check_included(self): |
| call_command("check", deploy=True, tags=["deploymenttag"]) |
| self.assertIn("Deployment Check", sys.stderr.getvalue()) |
|
|
| @override_system_checks([tagged_system_check]) |
| def test_fail_level(self): |
| with self.assertRaises(CommandError): |
| call_command("check", fail_level="WARNING") |
|
|
|
|
| def custom_error_system_check(app_configs, **kwargs): |
| return [Error("Error", id="myerrorcheck.E001")] |
|
|
|
|
| def custom_warning_system_check(app_configs, **kwargs): |
| return [Warning("Warning", id="mywarningcheck.E001")] |
|
|
|
|
| class SilencingCheckTests(SimpleTestCase): |
| def setUp(self): |
| self.old_stdout, self.old_stderr = sys.stdout, sys.stderr |
| self.stdout, self.stderr = StringIO(), StringIO() |
| sys.stdout, sys.stderr = self.stdout, self.stderr |
|
|
| def tearDown(self): |
| sys.stdout, sys.stderr = self.old_stdout, self.old_stderr |
|
|
| @override_settings(SILENCED_SYSTEM_CHECKS=["myerrorcheck.E001"]) |
| @override_system_checks([custom_error_system_check]) |
| def test_silenced_error(self): |
| out = StringIO() |
| err = StringIO() |
| call_command("check", stdout=out, stderr=err) |
| self.assertEqual( |
| out.getvalue(), "System check identified no issues (1 silenced).\n" |
| ) |
| self.assertEqual(err.getvalue(), "") |
|
|
| @override_settings(SILENCED_SYSTEM_CHECKS=["mywarningcheck.E001"]) |
| @override_system_checks([custom_warning_system_check]) |
| def test_silenced_warning(self): |
| out = StringIO() |
| err = StringIO() |
| call_command("check", stdout=out, stderr=err) |
| self.assertEqual( |
| out.getvalue(), "System check identified no issues (1 silenced).\n" |
| ) |
| self.assertEqual(err.getvalue(), "") |
|
|
|
|
| class CheckFrameworkReservedNamesTests(SimpleTestCase): |
| @isolate_apps("check_framework", kwarg_name="apps") |
| @override_system_checks([checks.model_checks.check_all_models]) |
| def test_model_check_method_not_shadowed(self, apps): |
| class ModelWithAttributeCalledCheck(models.Model): |
| check = 42 |
|
|
| class ModelWithFieldCalledCheck(models.Model): |
| check = models.IntegerField() |
|
|
| class ModelWithRelatedManagerCalledCheck(models.Model): |
| pass |
|
|
| class ModelWithDescriptorCalledCheck(models.Model): |
| check = models.ForeignKey( |
| ModelWithRelatedManagerCalledCheck, models.CASCADE |
| ) |
| article = models.ForeignKey( |
| ModelWithRelatedManagerCalledCheck, |
| models.CASCADE, |
| related_name="check", |
| ) |
|
|
| errors = checks.run_checks(app_configs=apps.get_app_configs()) |
| expected = [ |
| Error( |
| "The 'ModelWithAttributeCalledCheck.check()' class method is " |
| "currently overridden by 42.", |
| obj=ModelWithAttributeCalledCheck, |
| id="models.E020", |
| ), |
| Error( |
| "The 'ModelWithFieldCalledCheck.check()' class method is " |
| "currently overridden by %r." % ModelWithFieldCalledCheck.check, |
| obj=ModelWithFieldCalledCheck, |
| id="models.E020", |
| ), |
| Error( |
| "The 'ModelWithRelatedManagerCalledCheck.check()' class method is " |
| "currently overridden by %r." |
| % ModelWithRelatedManagerCalledCheck.check, |
| obj=ModelWithRelatedManagerCalledCheck, |
| id="models.E020", |
| ), |
| Error( |
| "The 'ModelWithDescriptorCalledCheck.check()' class method is " |
| "currently overridden by %r." % ModelWithDescriptorCalledCheck.check, |
| obj=ModelWithDescriptorCalledCheck, |
| id="models.E020", |
| ), |
| ] |
| self.assertEqual(errors, expected) |
|
|
|
|
| @skipIf( |
| multiprocessing.get_start_method() == "spawn", |
| "Spawning reimports modules, overwriting my_check.did_run to False, making this " |
| "test useless.", |
| ) |
| class ChecksRunDuringTests(SimpleTestCase): |
| databases = "__all__" |
|
|
| def test_registered_check_did_run(self): |
| self.assertTrue(my_check.did_run) |
|
|
