Debian Codegraph @

tests/check_framework/tests.py

raw
1 import multiprocessing
2 import sys
3 from io import StringIO
4 from unittest import skipIf
5
6 from django.apps import apps
7 from django.core import checks
8 from django.core.checks import Error, Warning
9 from django.core.checks.messages import CheckMessage
10 from django.core.checks.registry import CheckRegistry
11 from django.core.management import call_command
12 from django.core.management.base import CommandError
13 from django.db import models
14 from django.test import SimpleTestCase
15 from django.test.utils import isolate_apps, override_settings, override_system_checks
16
17 from .models import SimpleModel, my_check
18
19
20 class DummyObj:
21 def __repr__(self):
22 return "obj"
23
24
25 class SystemCheckFrameworkTests(SimpleTestCase):
26 def test_register_and_run_checks(self):
27 def f(**kwargs):
28 calls[0] += 1
29 return [1, 2, 3]
30
31 def f2(**kwargs):
32 return [4]
33
34 def f3(**kwargs):
35 return [5]
36
37 calls = [0]
38
39 # test register as decorator
40 registry = CheckRegistry()
41 registry.register()(f)
42 registry.register("tag1", "tag2")(f2)
43 registry.register("tag2", deploy=True)(f3)
44
45 # test register as function
46 registry2 = CheckRegistry()
47 registry2.register(f)
48 registry2.register(f2, "tag1", "tag2")
49 registry2.register(f3, "tag2", deploy=True)
50
51 # check results
52 errors = registry.run_checks()
53 errors2 = registry2.run_checks()
54 self.assertEqual(errors, errors2)
55 self.assertEqual(sorted(errors), [1, 2, 3, 4])
56 self.assertEqual(calls[0], 2)
57
58 errors = registry.run_checks(tags=["tag1"])
59 errors2 = registry2.run_checks(tags=["tag1"])
60 self.assertEqual(errors, errors2)
61 self.assertEqual(sorted(errors), [4])
62
63 errors = registry.run_checks(
64 tags=["tag1", "tag2"], include_deployment_checks=True
65 )
66 errors2 = registry2.run_checks(
67 tags=["tag1", "tag2"], include_deployment_checks=True
68 )
69 self.assertEqual(errors, errors2)
70 self.assertEqual(sorted(errors), [4, 5])
71
72 def test_register_no_kwargs_error(self):
73 registry = CheckRegistry()
74 msg = "Check functions must accept keyword arguments (**kwargs)."
75 with self.assertRaisesMessage(TypeError, msg):
76
77 @registry.register
78 def no_kwargs(app_configs, databases):
79 pass
80
81 def test_register_run_checks_non_iterable(self):
82 registry = CheckRegistry()
83
84 @registry.register
85 def return_non_iterable(**kwargs):
86 return Error("Message")
87
88 msg = (
89 "The function %r did not return a list. All functions registered "
90 "with the checks registry must return a list." % return_non_iterable
91 )
92 with self.assertRaisesMessage(TypeError, msg):
93 registry.run_checks()
94
95
96 class MessageTests(SimpleTestCase):
97 def test_printing(self):
98 e = Error("Message", hint="Hint", obj=DummyObj())
99 expected = "obj: Message\n\tHINT: Hint"
100 self.assertEqual(str(e), expected)
101
102 def test_printing_no_hint(self):
103 e = Error("Message", obj=DummyObj())
104 expected = "obj: Message"
105 self.assertEqual(str(e), expected)
106
107 def test_printing_no_object(self):
108 e = Error("Message", hint="Hint")
109 expected = "?: Message\n\tHINT: Hint"
110 self.assertEqual(str(e), expected)
111
112 def test_printing_with_given_id(self):
113 e = Error("Message", hint="Hint", obj=DummyObj(), id="ID")
114 expected = "obj: (ID) Message\n\tHINT: Hint"
115 self.assertEqual(str(e), expected)
116
117 def test_printing_field_error(self):
118 field = SimpleModel._meta.get_field("field")
119 e = Error("Error", obj=field)
120 expected = "check_framework.SimpleModel.field: Error"
121 self.assertEqual(str(e), expected)
122
123 def test_printing_model_error(self):
124 e = Error("Error", obj=SimpleModel)
125 expected = "check_framework.SimpleModel: Error"
126 self.assertEqual(str(e), expected)
127
128 def test_printing_manager_error(self):
129 manager = SimpleModel.manager
130 e = Error("Error", obj=manager)
131 expected = "check_framework.SimpleModel.manager: Error"
132 self.assertEqual(str(e), expected)
133
134 def test_equal_to_self(self):
135 e = Error("Error", obj=SimpleModel)
136 self.assertEqual(e, e)
137
138 def test_equal_to_same_constructed_check(self):
139 e1 = Error("Error", obj=SimpleModel)
140 e2 = Error("Error", obj=SimpleModel)
141 self.assertEqual(e1, e2)
142
143 def test_not_equal_to_different_constructed_check(self):
144 e1 = Error("Error", obj=SimpleModel)
145 e2 = Error("Error2", obj=SimpleModel)
146 self.assertNotEqual(e1, e2)
147
148 def test_not_equal_to_non_check(self):
149 e = Error("Error", obj=DummyObj())
150 self.assertNotEqual(e, "a string")
151
152 def test_invalid_level(self):
153 msg = "The first argument should be level."
154 with self.assertRaisesMessage(TypeError, msg):
155 CheckMessage("ERROR", "Message")
156
157
158 def simple_system_check(**kwargs):
159 simple_system_check.kwargs = kwargs
160 return []
161
162
163 def tagged_system_check(**kwargs):
164 tagged_system_check.kwargs = kwargs
165 return [checks.Warning("System Check")]
166
167
168 tagged_system_check.tags = ["simpletag"]
169
170
171 def deployment_system_check(**kwargs):
172 deployment_system_check.kwargs = kwargs
173 return [checks.Warning("Deployment Check")]
174
175
176 deployment_system_check.tags = ["deploymenttag"]
177
178
179 class CheckCommandTests(SimpleTestCase):
180 def setUp(self):
181 simple_system_check.kwargs = None
182 tagged_system_check.kwargs = None
183 self.old_stdout, self.old_stderr = sys.stdout, sys.stderr
184 sys.stdout, sys.stderr = StringIO(), StringIO()
185
186 def tearDown(self):
187 sys.stdout, sys.stderr = self.old_stdout, self.old_stderr
188
189 @override_system_checks([simple_system_check, tagged_system_check])
190 def test_simple_call(self):
191 call_command("check")
192 self.assertEqual(
193 simple_system_check.kwargs, {"app_configs": None, "databases": None}
194 )
195 self.assertEqual(
196 tagged_system_check.kwargs, {"app_configs": None, "databases": None}
197 )
198
199 @override_system_checks([simple_system_check, tagged_system_check])
200 def test_given_app(self):
201 call_command("check", "auth", "admin")
202 auth_config = apps.get_app_config("auth")
203 admin_config = apps.get_app_config("admin")
204 self.assertEqual(
205 simple_system_check.kwargs,
206 {"app_configs": [auth_config, admin_config], "databases": None},
207 )
208 self.assertEqual(
209 tagged_system_check.kwargs,
210 {"app_configs": [auth_config, admin_config], "databases": None},
211 )
212
213 @override_system_checks([simple_system_check, tagged_system_check])
214 def test_given_tag(self):
215 call_command("check", tags=["simpletag"])
216 self.assertIsNone(simple_system_check.kwargs)
217 self.assertEqual(
218 tagged_system_check.kwargs, {"app_configs": None, "databases": None}
219 )
220
221 @override_system_checks([simple_system_check, tagged_system_check])
222 def test_invalid_tag(self):
223 msg = 'There is no system check with the "missingtag" tag.'
224 with self.assertRaisesMessage(CommandError, msg):
225 call_command("check", tags=["missingtag"])
226
227 @override_system_checks([simple_system_check])
228 def test_list_tags_empty(self):
229 call_command("check", list_tags=True)
230 self.assertEqual("\n", sys.stdout.getvalue())
231
232 @override_system_checks([tagged_system_check])
233 def test_list_tags(self):
234 call_command("check", list_tags=True)
235 self.assertEqual("simpletag\n", sys.stdout.getvalue())
236
237 @override_system_checks(
238 [tagged_system_check], deployment_checks=[deployment_system_check]
239 )
240 def test_list_deployment_check_omitted(self):
241 call_command("check", list_tags=True)
242 self.assertEqual("simpletag\n", sys.stdout.getvalue())
243
244 @override_system_checks(
245 [tagged_system_check], deployment_checks=[deployment_system_check]
246 )
247 def test_list_deployment_check_included(self):
248 call_command("check", deploy=True, list_tags=True)
249 self.assertEqual("deploymenttag\nsimpletag\n", sys.stdout.getvalue())
250
251 @override_system_checks(
252 [tagged_system_check], deployment_checks=[deployment_system_check]
253 )
254 def test_tags_deployment_check_omitted(self):
255 msg = 'There is no system check with the "deploymenttag" tag.'
256 with self.assertRaisesMessage(CommandError, msg):
257 call_command("check", tags=["deploymenttag"])
258
259 @override_system_checks(
260 [tagged_system_check], deployment_checks=[deployment_system_check]
261 )
262 def test_tags_deployment_check_included(self):
263 call_command("check", deploy=True, tags=["deploymenttag"])
264 self.assertIn("Deployment Check", sys.stderr.getvalue())
265
266 @override_system_checks([tagged_system_check])
267 def test_fail_level(self):
268 with self.assertRaises(CommandError):
269 call_command("check", fail_level="WARNING")
270
271
272 def custom_error_system_check(app_configs, **kwargs):
273 return [Error("Error", id="myerrorcheck.E001")]
274
275
276 def custom_warning_system_check(app_configs, **kwargs):
277 return [Warning("Warning", id="mywarningcheck.E001")]
278
279
280 class SilencingCheckTests(SimpleTestCase):
281 def setUp(self):
282 self.old_stdout, self.old_stderr = sys.stdout, sys.stderr
283 self.stdout, self.stderr = StringIO(), StringIO()
284 sys.stdout, sys.stderr = self.stdout, self.stderr
285
286 def tearDown(self):
287 sys.stdout, sys.stderr = self.old_stdout, self.old_stderr
288
289 @override_settings(SILENCED_SYSTEM_CHECKS=["myerrorcheck.E001"])
290 @override_system_checks([custom_error_system_check])
291 def test_silenced_error(self):
292 out = StringIO()
293 err = StringIO()
294 call_command("check", stdout=out, stderr=err)
295 self.assertEqual(
296 out.getvalue(), "System check identified no issues (1 silenced).\n"
297 )
298 self.assertEqual(err.getvalue(), "")
299
300 @override_settings(SILENCED_SYSTEM_CHECKS=["mywarningcheck.E001"])
301 @override_system_checks([custom_warning_system_check])
302 def test_silenced_warning(self):
303 out = StringIO()
304 err = StringIO()
305 call_command("check", stdout=out, stderr=err)
306 self.assertEqual(
307 out.getvalue(), "System check identified no issues (1 silenced).\n"
308 )
309 self.assertEqual(err.getvalue(), "")
310
311
312 class CheckFrameworkReservedNamesTests(SimpleTestCase):
313 @isolate_apps("check_framework", kwarg_name="apps")
314 @override_system_checks([checks.model_checks.check_all_models])
315 def test_model_check_method_not_shadowed(self, apps):
316 class ModelWithAttributeCalledCheck(models.Model):
317 check = 42
318
319 class ModelWithFieldCalledCheck(models.Model):
320 check = models.IntegerField()
321
322 class ModelWithRelatedManagerCalledCheck(models.Model):
323 pass
324
325 class ModelWithDescriptorCalledCheck(models.Model):
326 check = models.ForeignKey(
327 ModelWithRelatedManagerCalledCheck, models.CASCADE
328 )
329 article = models.ForeignKey(
330 ModelWithRelatedManagerCalledCheck,
331 models.CASCADE,
332 related_name="check",
333 )
334
335 errors = checks.run_checks(app_configs=apps.get_app_configs())
336 expected = [
337 Error(
338 "The 'ModelWithAttributeCalledCheck.check()' class method is "
339 "currently overridden by 42.",
340 obj=ModelWithAttributeCalledCheck,
341 id="models.E020",
342 ),
343 Error(
344 "The 'ModelWithFieldCalledCheck.check()' class method is "
345 "currently overridden by %r." % ModelWithFieldCalledCheck.check,
346 obj=ModelWithFieldCalledCheck,
347 id="models.E020",
348 ),
349 Error(
350 "The 'ModelWithRelatedManagerCalledCheck.check()' class method is "
351 "currently overridden by %r."
352 % ModelWithRelatedManagerCalledCheck.check,
353 obj=ModelWithRelatedManagerCalledCheck,
354 id="models.E020",
355 ),
356 Error(
357 "The 'ModelWithDescriptorCalledCheck.check()' class method is "
358 "currently overridden by %r." % ModelWithDescriptorCalledCheck.check,
359 obj=ModelWithDescriptorCalledCheck,
360 id="models.E020",
361 ),
362 ]
363 self.assertEqual(errors, expected)
364
365
366 @skipIf(
367 multiprocessing.get_start_method() == "spawn",
368 "Spawning reimports modules, overwriting my_check.did_run to False, making this "
369 "test useless.",
370 )
371 class ChecksRunDuringTests(SimpleTestCase):
372 databases = "__all__"
373
374 def test_registered_check_did_run(self):
375 self.assertTrue(my_check.did_run)