Debian Codegraph @

tests/logging_tests/tests.py

raw
1 import logging
2 from contextlib import contextmanager
3 from io import StringIO
4 from unittest import TestCase, mock
5
6 from admin_scripts.tests import AdminScriptTestCase
7
8 from django.conf import settings
9 from django.core import mail
10 from django.core.exceptions import DisallowedHost, PermissionDenied, SuspiciousOperation
11 from django.core.files.temp import NamedTemporaryFile
12 from django.core.management import color
13 from django.http import HttpResponse
14 from django.http.multipartparser import MultiPartParserError
15 from django.test import RequestFactory, SimpleTestCase, override_settings
16 from django.test.utils import LoggingCaptureMixin
17 from django.utils.log import (
18 DEFAULT_LOGGING,
19 AdminEmailHandler,
20 CallbackFilter,
21 RequireDebugFalse,
22 RequireDebugTrue,
23 ServerFormatter,
24 log_response,
25 )
26 from django.views.debug import ExceptionReporter
27
28 from . import views
29 from .logconfig import MyEmailBackend
30
31
32 class LoggingFiltersTest(SimpleTestCase):
33 def test_require_debug_false_filter(self):
34 """
35 Test the RequireDebugFalse filter class.
36 """
37 filter_ = RequireDebugFalse()
38
39 with self.settings(DEBUG=True):
40 self.assertIs(filter_.filter("record is not used"), False)
41
42 with self.settings(DEBUG=False):
43 self.assertIs(filter_.filter("record is not used"), True)
44
45 def test_require_debug_true_filter(self):
46 """
47 Test the RequireDebugTrue filter class.
48 """
49 filter_ = RequireDebugTrue()
50
51 with self.settings(DEBUG=True):
52 self.assertIs(filter_.filter("record is not used"), True)
53
54 with self.settings(DEBUG=False):
55 self.assertIs(filter_.filter("record is not used"), False)
56
57
58 class SetupDefaultLoggingMixin:
59 @classmethod
60 def setUpClass(cls):
61 super().setUpClass()
62 logging.config.dictConfig(DEFAULT_LOGGING)
63 cls.addClassCleanup(logging.config.dictConfig, settings.LOGGING)
64
65
66 class DefaultLoggingTests(
67 SetupDefaultLoggingMixin, LoggingCaptureMixin, SimpleTestCase
68 ):
69 def test_django_logger(self):
70 """
71 The 'django' base logger only output anything when DEBUG=True.
72 """
73 self.logger.error("Hey, this is an error.")
74 self.assertEqual(self.logger_output.getvalue(), "")
75
76 with self.settings(DEBUG=True):
77 self.logger.error("Hey, this is an error.")
78 self.assertEqual(self.logger_output.getvalue(), "Hey, this is an error.\n")
79
80 @override_settings(DEBUG=True)
81 def test_django_logger_warning(self):
82 self.logger.warning("warning")
83 self.assertEqual(self.logger_output.getvalue(), "warning\n")
84
85 @override_settings(DEBUG=True)
86 def test_django_logger_info(self):
87 self.logger.info("info")
88 self.assertEqual(self.logger_output.getvalue(), "info\n")
89
90 @override_settings(DEBUG=True)
91 def test_django_logger_debug(self):
92 self.logger.debug("debug")
93 self.assertEqual(self.logger_output.getvalue(), "")
94
95
96 class LoggingAssertionMixin:
97
98 def assertLogRecord(
99 self,
100 logger_cm,
101 msg,
102 levelno,
103 status_code,
104 request=None,
105 exc_class=None,
106 ):
107 self.assertEqual(
108 records_len := len(logger_cm.records),
109 1,
110 f"Wrong number of calls for {logger_cm=} in {levelno=} (expected 1, got "
111 f"{records_len}).",
112 )
113 record = logger_cm.records[0]
114 self.assertEqual(record.getMessage(), msg)
115 self.assertEqual(record.levelno, levelno)
116 self.assertEqual(record.status_code, status_code)
117 if request is not None:
118 self.assertEqual(record.request, request)
119 if exc_class:
120 self.assertIsNotNone(record.exc_info)
121 self.assertEqual(record.exc_info[0], exc_class)
122 return record
123
124 def assertLogsRequest(
125 self, url, level, msg, status_code, logger="django.request", exc_class=None
126 ):
127 with self.assertLogs(logger, level) as cm:
128 try:
129 self.client.get(url)
130 except views.UncaughtException:
131 pass
132 self.assertLogRecord(
133 cm, msg, getattr(logging, level), status_code, exc_class=exc_class
134 )
135
136
137 @override_settings(DEBUG=True, ROOT_URLCONF="logging_tests.urls")
138 class HandlerLoggingTests(
139 SetupDefaultLoggingMixin, LoggingAssertionMixin, LoggingCaptureMixin, SimpleTestCase
140 ):
141 def test_page_found_no_warning(self):
142 self.client.get("/innocent/")
143 self.assertEqual(self.logger_output.getvalue(), "")
144
145 def test_redirect_no_warning(self):
146 self.client.get("/redirect/")
147 self.assertEqual(self.logger_output.getvalue(), "")
148
149 def test_page_not_found_warning(self):
150 self.assertLogsRequest(
151 url="/does_not_exist/",
152 level="WARNING",
153 status_code=404,
154 msg="Not Found: /does_not_exist/",
155 )
156
157 def test_control_chars_escaped(self):
158 self.assertLogsRequest(
159 url="/%1B[1;31mNOW IN RED!!!1B[0m/",
160 level="WARNING",
161 status_code=404,
162 msg=r"Not Found: /\x1b[1;31mNOW IN RED!!!1B[0m/",
163 )
164
165 async def test_async_page_not_found_warning(self):
166 with self.assertLogs("django.request", "WARNING") as cm:
167 await self.async_client.get("/does_not_exist/")
168
169 self.assertLogRecord(cm, "Not Found: /does_not_exist/", logging.WARNING, 404)
170
171 async def test_async_control_chars_escaped(self):
172 with self.assertLogs("django.request", "WARNING") as cm:
173 await self.async_client.get(r"/%1B[1;31mNOW IN RED!!!1B[0m/")
174
175 self.assertLogRecord(
176 cm, r"Not Found: /\x1b[1;31mNOW IN RED!!!1B[0m/", logging.WARNING, 404
177 )
178
179 def test_page_not_found_raised(self):
180 self.assertLogsRequest(
181 url="/does_not_exist_raised/",
182 level="WARNING",
183 status_code=404,
184 msg="Not Found: /does_not_exist_raised/",
185 )
186
187 def test_uncaught_exception(self):
188 self.assertLogsRequest(
189 url="/uncaught_exception/",
190 level="ERROR",
191 status_code=500,
192 msg="Internal Server Error: /uncaught_exception/",
193 exc_class=views.UncaughtException,
194 )
195
196 def test_internal_server_error(self):
197 self.assertLogsRequest(
198 url="/internal_server_error/",
199 level="ERROR",
200 status_code=500,
201 msg="Internal Server Error: /internal_server_error/",
202 )
203
204 def test_internal_server_error_599(self):
205 self.assertLogsRequest(
206 url="/internal_server_error/?status=599",
207 level="ERROR",
208 status_code=599,
209 msg="Unknown Status Code: /internal_server_error/",
210 )
211
212 def test_permission_denied(self):
213 self.assertLogsRequest(
214 url="/permission_denied/",
215 level="WARNING",
216 status_code=403,
217 msg="Forbidden (Permission denied): /permission_denied/",
218 exc_class=PermissionDenied,
219 )
220
221 def test_multi_part_parser_error(self):
222 self.assertLogsRequest(
223 url="/multi_part_parser_error/",
224 level="WARNING",
225 status_code=400,
226 msg="Bad request (Unable to parse request body): /multi_part_parser_error/",
227 exc_class=MultiPartParserError,
228 )
229
230
231 @override_settings(
232 DEBUG=True,
233 USE_I18N=True,
234 LANGUAGES=[("en", "English")],
235 MIDDLEWARE=[
236 "django.middleware.locale.LocaleMiddleware",
237 "django.middleware.common.CommonMiddleware",
238 ],
239 ROOT_URLCONF="logging_tests.urls_i18n",
240 )
241 class I18nLoggingTests(SetupDefaultLoggingMixin, LoggingCaptureMixin, SimpleTestCase):
242 def test_i18n_page_found_no_warning(self):
243 self.client.get("/exists/")
244 self.client.get("/en/exists/")
245 self.assertEqual(self.logger_output.getvalue(), "")
246
247 def test_i18n_page_not_found_warning(self):
248 self.client.get("/this_does_not/")
249 self.client.get("/en/nor_this/")
250 self.assertEqual(
251 self.logger_output.getvalue(),
252 "Not Found: /this_does_not/\nNot Found: /en/nor_this/\n",
253 )
254
255
256 class CallbackFilterTest(SimpleTestCase):
257 def test_sense(self):
258 f_false = CallbackFilter(lambda r: False)
259 f_true = CallbackFilter(lambda r: True)
260
261 self.assertFalse(f_false.filter("record"))
262 self.assertTrue(f_true.filter("record"))
263
264 def test_passes_on_record(self):
265 collector = []
266
267 def _callback(record):
268 collector.append(record)
269 return True
270
271 f = CallbackFilter(_callback)
272
273 f.filter("a record")
274
275 self.assertEqual(collector, ["a record"])
276
277
278 class AdminEmailHandlerTest(SimpleTestCase):
279 logger = logging.getLogger("django")
280 request_factory = RequestFactory()
281
282 def get_admin_email_handler(self, logger):
283 # AdminEmailHandler does not get filtered out
284 # even with DEBUG=True.
285 return [
286 h for h in logger.handlers if h.__class__.__name__ == "AdminEmailHandler"
287 ][0]
288
289 def test_fail_silently(self):
290 admin_email_handler = self.get_admin_email_handler(self.logger)
291 self.assertTrue(admin_email_handler.connection().fail_silently)
292
293 @override_settings(
294 ADMINS=[("whatever admin", "[email protected]")],
295 EMAIL_SUBJECT_PREFIX="-SuperAwesomeSubject-",
296 )
297 def test_accepts_args(self):
298 """
299 User-supplied arguments and the EMAIL_SUBJECT_PREFIX setting are used
300 to compose the email subject (#16736).
301 """
302 message = "Custom message that says '%s' and '%s'"
303 token1 = "ping"
304 token2 = "pong"
305
306 admin_email_handler = self.get_admin_email_handler(self.logger)
307 # Backup then override original filters
308 orig_filters = admin_email_handler.filters
309 try:
310 admin_email_handler.filters = []
311
312 self.logger.error(message, token1, token2)
313
314 self.assertEqual(len(mail.outbox), 1)
315 self.assertEqual(mail.outbox[0].to, ["[email protected]"])
316 self.assertEqual(
317 mail.outbox[0].subject,
318 "-SuperAwesomeSubject-ERROR: "
319 "Custom message that says 'ping' and 'pong'",
320 )
321 finally:
322 # Restore original filters
323 admin_email_handler.filters = orig_filters
324
325 @override_settings(
326 ADMINS=[("whatever admin", "[email protected]")],
327 EMAIL_SUBJECT_PREFIX="-SuperAwesomeSubject-",
328 INTERNAL_IPS=["127.0.0.1"],
329 )
330 def test_accepts_args_and_request(self):
331 """
332 The subject is also handled if being passed a request object.
333 """
334 message = "Custom message that says '%s' and '%s'"
335 token1 = "ping"
336 token2 = "pong"
337
338 admin_email_handler = self.get_admin_email_handler(self.logger)
339 # Backup then override original filters
340 orig_filters = admin_email_handler.filters
341 try:
342 admin_email_handler.filters = []
343 request = self.request_factory.get("/")
344 self.logger.error(
345 message,
346 token1,
347 token2,
348 extra={
349 "status_code": 403,
350 "request": request,
351 },
352 )
353 self.assertEqual(len(mail.outbox), 1)
354 self.assertEqual(mail.outbox[0].to, ["[email protected]"])
355 self.assertEqual(
356 mail.outbox[0].subject,
357 "-SuperAwesomeSubject-ERROR (internal IP): "
358 "Custom message that says 'ping' and 'pong'",
359 )
360 finally:
361 # Restore original filters
362 admin_email_handler.filters = orig_filters
363
364 @override_settings(
365 ADMINS=[("admin", "[email protected]")],
366 EMAIL_SUBJECT_PREFIX="",
367 DEBUG=False,
368 )
369 def test_subject_accepts_newlines(self):
370 """
371 Newlines in email reports' subjects are escaped to prevent
372 AdminErrorHandler from failing (#17281).
373 """
374 message = "Message \r\n with newlines"
375 expected_subject = "ERROR: Message \\r\\n with newlines"
376
377 self.assertEqual(len(mail.outbox), 0)
378
379 self.logger.error(message)
380
381 self.assertEqual(len(mail.outbox), 1)
382 self.assertNotIn("\n", mail.outbox[0].subject)
383 self.assertNotIn("\r", mail.outbox[0].subject)
384 self.assertEqual(mail.outbox[0].subject, expected_subject)
385
386 @override_settings(
387 ADMINS=[("admin", "[email protected]")],
388 DEBUG=False,
389 )
390 def test_uses_custom_email_backend(self):
391 """
392 Refs #19325
393 """
394 message = "All work and no play makes Jack a dull boy"
395 admin_email_handler = self.get_admin_email_handler(self.logger)
396 mail_admins_called = {"called": False}
397
398 def my_mail_admins(*args, **kwargs):
399 connection = kwargs["connection"]
400 self.assertIsInstance(connection, MyEmailBackend)
401 mail_admins_called["called"] = True
402
403 # Monkeypatches
404 orig_mail_admins = mail.mail_admins
405 orig_email_backend = admin_email_handler.email_backend
406 mail.mail_admins = my_mail_admins
407 admin_email_handler.email_backend = "logging_tests.logconfig.MyEmailBackend"
408
409 try:
410 self.logger.error(message)
411 self.assertTrue(mail_admins_called["called"])
412 finally:
413 # Revert Monkeypatches
414 mail.mail_admins = orig_mail_admins
415 admin_email_handler.email_backend = orig_email_backend
416
417 @override_settings(
418 ADMINS=[("whatever admin", "[email protected]")],
419 )
420 def test_emit_non_ascii(self):
421 """
422 #23593 - AdminEmailHandler should allow Unicode characters in the
423 request.
424 """
425 handler = self.get_admin_email_handler(self.logger)
426 record = self.logger.makeRecord(
427 "name", logging.ERROR, "function", "lno", "message", None, None
428 )
429 url_path = "/º"
430 record.request = self.request_factory.get(url_path)
431 handler.emit(record)
432 self.assertEqual(len(mail.outbox), 1)
433 msg = mail.outbox[0]
434 self.assertEqual(msg.to, ["[email protected]"])
435 self.assertEqual(msg.subject, "[Django] ERROR (EXTERNAL IP): message")
436 self.assertIn("Report at %s" % url_path, msg.body)
437
438 @override_settings(
439 MANAGERS=[("manager", "[email protected]")],
440 DEBUG=False,
441 )
442 def test_customize_send_mail_method(self):
443 class ManagerEmailHandler(AdminEmailHandler):
444 def send_mail(self, subject, message, *args, **kwargs):
445 mail.mail_managers(
446 subject, message, *args, connection=self.connection(), **kwargs
447 )
448
449 handler = ManagerEmailHandler()
450 record = self.logger.makeRecord(
451 "name", logging.ERROR, "function", "lno", "message", None, None
452 )
453 self.assertEqual(len(mail.outbox), 0)
454 handler.emit(record)
455 self.assertEqual(len(mail.outbox), 1)
456 self.assertEqual(mail.outbox[0].to, ["[email protected]"])
457
458 @override_settings(ALLOWED_HOSTS="example.com")
459 def test_disallowed_host_doesnt_crash(self):
460 admin_email_handler = self.get_admin_email_handler(self.logger)
461 old_include_html = admin_email_handler.include_html
462
463 # Text email
464 admin_email_handler.include_html = False
465 try:
466 self.client.get("/", headers={"host": "evil.com"})
467 finally:
468 admin_email_handler.include_html = old_include_html
469
470 # HTML email
471 admin_email_handler.include_html = True
472 try:
473 self.client.get("/", headers={"host": "evil.com"})
474 finally:
475 admin_email_handler.include_html = old_include_html
476
477 def test_default_exception_reporter_class(self):
478 admin_email_handler = self.get_admin_email_handler(self.logger)
479 self.assertEqual(admin_email_handler.reporter_class, ExceptionReporter)
480
481 @override_settings(ADMINS=[("A.N.Admin", "[email protected]")])
482 def test_custom_exception_reporter_is_used(self):
483 record = self.logger.makeRecord(
484 "name", logging.ERROR, "function", "lno", "message", None, None
485 )
486 record.request = self.request_factory.get("/")
487 handler = AdminEmailHandler(
488 reporter_class="logging_tests.logconfig.CustomExceptionReporter"
489 )
490 handler.emit(record)
491 self.assertEqual(len(mail.outbox), 1)
492 msg = mail.outbox[0]
493 self.assertEqual(msg.body, "message\n\ncustom traceback text")
494
495 @override_settings(ADMINS=[("admin", "[email protected]")])
496 def test_emit_no_form_tag(self):
497 """HTML email doesn't contain forms."""
498 handler = AdminEmailHandler(include_html=True)
499 record = self.logger.makeRecord(
500 "name",
501 logging.ERROR,
502 "function",
503 "lno",
504 "message",
505 None,
506 None,
507 )
508 handler.emit(record)
509 self.assertEqual(len(mail.outbox), 1)
510 msg = mail.outbox[0]
511 self.assertEqual(msg.subject, "[Django] ERROR: message")
512 self.assertEqual(len(msg.alternatives), 1)
513 body_html = str(msg.alternatives[0].content)
514 self.assertIn('<div id="traceback">', body_html)
515 self.assertNotIn("<form", body_html)
516
517 @override_settings(ADMINS=[])
518 def test_emit_no_admins(self):
519 handler = AdminEmailHandler()
520 record = self.logger.makeRecord(
521 "name",
522 logging.ERROR,
523 "function",
524 "lno",
525 "message",
526 None,
527 None,
528 )
529 with mock.patch.object(
530 handler,
531 "format_subject",
532 side_effect=AssertionError("Should not be called"),
533 ):
534 handler.emit(record)
535 self.assertEqual(len(mail.outbox), 0)
536
537
538 class SettingsConfigTest(AdminScriptTestCase):
539 """
540 Accessing settings in a custom logging handler does not trigger
541 a circular import error.
542 """
543
544 def setUp(self):
545 super().setUp()
546 log_config = """{
547 'version': 1,
548 'handlers': {
549 'custom_handler': {
550 'level': 'INFO',
551 'class': 'logging_tests.logconfig.MyHandler',
552 }
553 }
554 }"""
555 self.write_settings("settings.py", sdict={"LOGGING": log_config})
556
557 def test_circular_dependency(self):
558 # validate is just an example command to trigger settings configuration
559 out, err = self.run_manage(["check"])
560 self.assertNoOutput(err)
561 self.assertOutput(out, "System check identified no issues (0 silenced).")
562
563
564 def dictConfig(config):
565 dictConfig.called = True
566
567
568 dictConfig.called = False
569
570
571 class SetupConfigureLogging(SimpleTestCase):
572 """
573 Calling django.setup() initializes the logging configuration.
574 """
575
576 def test_configure_initializes_logging(self):
577 from django import setup
578
579 try:
580 with override_settings(
581 LOGGING_CONFIG="logging_tests.tests.dictConfig",
582 ):
583 setup()
584 finally:
585 # Restore logging from settings.
586 setup()
587 self.assertTrue(dictConfig.called)
588
589
590 @override_settings(DEBUG=True, ROOT_URLCONF="logging_tests.urls")
591 class SecurityLoggerTest(LoggingAssertionMixin, SimpleTestCase):
592 def test_suspicious_operation_creates_log_message(self):
593 self.assertLogsRequest(
594 url="/suspicious/",
595 level="ERROR",
596 msg="dubious",
597 status_code=400,
598 logger="django.security.SuspiciousOperation",
599 exc_class=SuspiciousOperation,
600 )
601
602 def test_suspicious_operation_uses_sublogger(self):
603 self.assertLogsRequest(
604 url="/suspicious_spec/",
605 level="ERROR",
606 msg="dubious",
607 status_code=400,
608 logger="django.security.DisallowedHost",
609 exc_class=DisallowedHost,
610 )
611
612 @override_settings(
613 ADMINS=[("admin", "[email protected]")],
614 DEBUG=False,
615 )
616 def test_suspicious_email_admins(self):
617 self.client.get("/suspicious/")
618 self.assertEqual(len(mail.outbox), 1)
619 self.assertIn("SuspiciousOperation at /suspicious/", mail.outbox[0].body)
620
621 def test_response_logged(self):
622 with self.assertLogs("django.security.SuspiciousOperation", "ERROR") as handler:
623 response = self.client.get("/suspicious/")
624
625 self.assertLogRecord(
626 handler, "dubious", logging.ERROR, 400, request=response.wsgi_request
627 )
628 self.assertEqual(response.status_code, 400)
629
630
631 class SettingsCustomLoggingTest(AdminScriptTestCase):
632 """
633 Using a logging defaults are still applied when using a custom
634 callable in LOGGING_CONFIG (i.e., logging.config.fileConfig).
635 """
636
637 def setUp(self):
638 super().setUp()
639 logging_conf = """
640 [loggers]
641 keys=root
642 [handlers]
643 keys=stream
644 [formatters]
645 keys=simple
646 [logger_root]
647 handlers=stream
648 [handler_stream]
649 class=StreamHandler
650 formatter=simple
651 args=(sys.stdout,)
652 [formatter_simple]
653 format=%(message)s
654 """
655 temp_file = NamedTemporaryFile()
656 temp_file.write(logging_conf.encode())
657 temp_file.flush()
658 self.addCleanup(temp_file.close)
659 self.write_settings(
660 "settings.py",
661 sdict={
662 "LOGGING_CONFIG": '"logging.config.fileConfig"',
663 "LOGGING": 'r"%s"' % temp_file.name,
664 },
665 )
666
667 def test_custom_logging(self):
668 out, err = self.run_manage(["check"])
669 self.assertNoOutput(err)
670 self.assertOutput(out, "System check identified no issues (0 silenced).")
671
672
673 class LogFormattersTests(SimpleTestCase):
674 def test_server_formatter_styles(self):
675 color_style = color.make_style("")
676 formatter = ServerFormatter()
677 formatter.style = color_style
678 log_msg = "log message"
679 status_code_styles = [
680 (200, "HTTP_SUCCESS"),
681 (100, "HTTP_INFO"),
682 (304, "HTTP_NOT_MODIFIED"),
683 (300, "HTTP_REDIRECT"),
684 (404, "HTTP_NOT_FOUND"),
685 (400, "HTTP_BAD_REQUEST"),
686 (500, "HTTP_SERVER_ERROR"),
687 ]
688 for status_code, style in status_code_styles:
689 record = logging.makeLogRecord({"msg": log_msg, "status_code": status_code})
690 self.assertEqual(
691 formatter.format(record), getattr(color_style, style)(log_msg)
692 )
693 record = logging.makeLogRecord({"msg": log_msg})
694 self.assertEqual(formatter.format(record), log_msg)
695
696 def test_server_formatter_default_format(self):
697 server_time = "2016-09-25 10:20:30"
698 log_msg = "log message"
699 logger = logging.getLogger("django.server")
700
701 @contextmanager
702 def patch_django_server_logger():
703 old_stream = logger.handlers[0].stream
704 new_stream = StringIO()
705 logger.handlers[0].stream = new_stream
706 yield new_stream
707 logger.handlers[0].stream = old_stream
708
709 with patch_django_server_logger() as logger_output:
710 logger.info(log_msg, extra={"server_time": server_time})
711 self.assertEqual(
712 "[%s] %s\n" % (server_time, log_msg), logger_output.getvalue()
713 )
714
715 with patch_django_server_logger() as logger_output:
716 logger.info(log_msg)
717 self.assertRegex(
718 logger_output.getvalue(), r"^\[[/:,\w\s\d]+\] %s\n" % log_msg
719 )
720
721
722 class LogResponseRealLoggerTests(LoggingAssertionMixin, TestCase):
723
724 request = RequestFactory().get("/test-path/")
725
726 def test_missing_response_raises_attribute_error(self):
727 with self.assertRaises(AttributeError):
728 log_response("No response provided", response=None, request=self.request)
729
730 def test_missing_request_logs_with_none(self):
731 response = HttpResponse(status=403)
732 with self.assertLogs("django.request", level="INFO") as cm:
733 log_response(msg := "Missing request", response=response, request=None)
734 self.assertLogRecord(cm, msg, logging.WARNING, 403, request=None)
735
736 def test_logs_5xx_as_error(self):
737 response = HttpResponse(status=508)
738 with self.assertLogs("django.request", level="ERROR") as cm:
739 log_response(
740 msg := "Server error occurred", response=response, request=self.request
741 )
742 self.assertLogRecord(cm, msg, logging.ERROR, 508, self.request)
743
744 def test_logs_4xx_as_warning(self):
745 response = HttpResponse(status=418)
746 with self.assertLogs("django.request", level="WARNING") as cm:
747 log_response(
748 msg := "This is a teapot!", response=response, request=self.request
749 )
750 self.assertLogRecord(cm, msg, logging.WARNING, 418, self.request)
751
752 def test_logs_2xx_as_info(self):
753 response = HttpResponse(status=201)
754 with self.assertLogs("django.request", level="INFO") as cm:
755 log_response(msg := "OK response", response=response, request=self.request)
756 self.assertLogRecord(cm, msg, logging.INFO, 201, self.request)
757
758 def test_custom_log_level(self):
759 response = HttpResponse(status=403)
760 with self.assertLogs("django.request", level="DEBUG") as cm:
761 log_response(
762 msg := "Debug level log",
763 response=response,
764 request=self.request,
765 level="debug",
766 )
767 self.assertLogRecord(cm, msg, logging.DEBUG, 403, self.request)
768
769 def test_logs_only_once_per_response(self):
770 response = HttpResponse(status=500)
771 with self.assertLogs("django.request", level="ERROR") as cm:
772 log_response("First log", response=response, request=self.request)
773 log_response("Second log", response=response, request=self.request)
774 self.assertLogRecord(cm, "First log", logging.ERROR, 500, self.request)
775
776 def test_exc_info_output(self):
777 response = HttpResponse(status=500)
778 try:
779 raise ValueError("Simulated failure")
780 except ValueError as exc:
781 with self.assertLogs("django.request", level="ERROR") as cm:
782 log_response(
783 "With exception",
784 response=response,
785 request=self.request,
786 exception=exc,
787 )
788 self.assertLogRecord(cm, "With exception", logging.ERROR, 500, self.request)
789 self.assertIn("ValueError", "\n".join(cm.output)) # Stack trace included
790
791 def test_format_args_are_applied(self):
792 response = HttpResponse(status=500)
793 with self.assertLogs("django.request", level="ERROR") as cm:
794 log_response(
795 "Something went wrong: %s (%d)",
796 "DB error",
797 42,
798 response=response,
799 request=self.request,
800 )
801 msg = "Something went wrong: DB error (42)"
802 self.assertLogRecord(cm, msg, logging.ERROR, 500, self.request)
803
804 def test_logs_with_custom_logger(self):
805 handler = logging.StreamHandler(log_stream := StringIO())
806 handler.setFormatter(logging.Formatter("%(levelname)s:%(name)s:%(message)s"))
807
808 custom_logger = logging.getLogger("my.custom.logger")
809 custom_logger.setLevel(logging.DEBUG)
810 custom_logger.addHandler(handler)
811 self.addCleanup(custom_logger.removeHandler, handler)
812
813 response = HttpResponse(status=404)
814 log_response(
815 msg := "Handled by custom logger",
816 response=response,
817 request=self.request,
818 logger=custom_logger,
819 )
820
821 self.assertEqual(
822 f"WARNING:my.custom.logger:{msg}", log_stream.getvalue().strip()
823 )
824
825 def test_unicode_escape_escaping(self):
826 test_cases = [
827 # Control characters.
828 ("line\nbreak", "line\\nbreak"),
829 ("carriage\rreturn", "carriage\\rreturn"),
830 ("tab\tseparated", "tab\\tseparated"),
831 ("formfeed\f", "formfeed\\x0c"),
832 ("bell\a", "bell\\x07"),
833 ("multi\nline\ntext", "multi\\nline\\ntext"),
834 # Slashes.
835 ("slash\\test", "slash\\\\test"),
836 ("back\\slash", "back\\\\slash"),
837 # Quotes.
838 ('quote"test"', 'quote"test"'),
839 ("quote'test'", "quote'test'"),
840 # Accented, composed characters, emojis and symbols.
841 ("café", "caf\\xe9"),
842 ("e\u0301", "e\\u0301"), # e + combining acute
843 ("smile🙂", "smile\\U0001f642"),
844 ("weird ☃️", "weird \\u2603\\ufe0f"),
845 # Non-Latin alphabets.
846 ("Привет", "\\u041f\\u0440\\u0438\\u0432\\u0435\\u0442"),
847 ("你好", "\\u4f60\\u597d"),
848 # ANSI escape sequences.
849 ("escape\x1b[31mred\x1b[0m", "escape\\x1b[31mred\\x1b[0m"),
850 (
851 "/\x1b[1;31mCAUTION!!YOU ARE PWNED\x1b[0m/",
852 "/\\x1b[1;31mCAUTION!!YOU ARE PWNED\\x1b[0m/",
853 ),
854 (
855 "/\r\n\r\n1984-04-22 INFO Listening on 0.0.0.0:8080\r\n\r\n",
856 "/\\r\\n\\r\\n1984-04-22 INFO Listening on 0.0.0.0:8080\\r\\n\\r\\n",
857 ),
858 # Plain safe input.
859 ("normal-path", "normal-path"),
860 ("slash/colon:", "slash/colon:"),
861 # Non strings.
862 (0, "0"),
863 ([1, 2, 3], "[1, 2, 3]"),
864 ({"test": "🙂"}, "{'test': '🙂'}"),
865 ]
866
867 msg = "Test message: %s"
868 for case, expected in test_cases:
869 with (
870 self.assertLogs("django.request", level="ERROR") as cm,
871 self.subTest(case=case),
872 ):
873 response = HttpResponse(status=318)
874 log_response(msg, case, response=response, level="error")
875
876 record = self.assertLogRecord(
877 cm,
878 msg % expected,
879 levelno=logging.ERROR,
880 status_code=318,
881 request=None,
882 )
883 # Log record is always a single line.
884 self.assertEqual(len(record.getMessage().splitlines()), 1)