async def test_init_with_default_handlers_initializes_handlers_with_proper_log_levels( self): handlers = [Mock(), Mock()] with asynctest.patch("aiologger.logger.AsyncStreamHandler", side_effect=handlers) as init_from_pipe: logger = Logger.with_default_handlers() self.assertCountEqual(logger.handlers, handlers)
async def test_it_only_keeps_a_reference_to_the_loop_after_the_first_log_call( self): logger = Logger.with_default_handlers() self.assertIs(logger._loop, get_running_loop()) await logger.info("Xablau") self.assertIs(logger._loop, get_running_loop())
async def test_logger_handlers_are_not_initialized_twice(self): handler = Mock(spec=AsyncStreamHandler, level=logging.DEBUG) with patch("aiologger.logger.AsyncStreamHandler", return_value=handler) as Handler: formatter = Mock() logger = Logger.with_default_handlers(formatter=formatter) await asyncio.gather( logger.info("sardinha"), logger.info("tilápia"), logger.info("xerelete"), logger.error("fraldinha"), ) Handler.allert_has_calls([ call( stream=self.write_pipe, level=logging.DEBUG, formatter=formatter, filter=StdoutFilter(), ), call( stream=self.write_pipe, level=logging.WARNING, formatter=formatter, ), ]) await logger.shutdown()
async def test_it_only_keeps_a_reference_to_the_loop_after_the_first_log_call( self): logger = Logger.with_default_handlers() self.assertIsNone(logger._loop) await logger.info("Xablau") self.assertIsInstance(logger._loop, asyncio.AbstractEventLoop)
async def test_it_doesnt_calls_handlers_if_logger_is_disabled(self): logger = Logger.with_default_handlers() with asynctest.patch.object(logger, "callHandlers") as callHandlers: record = Mock() logger.disabled = True await logger.handle(record) callHandlers.assert_not_awaited()
async def test_it_doesnt_calls_handlers_if_record_isnt_loggable(self): logger = Logger.with_default_handlers() with patch.object(logger, 'filter', return_value=False) as filter, \ asynctest.patch.object(logger, 'callHandlers') as callHandlers: record = Mock() await logger.handle(record) filter.assert_called_once_with(record) callHandlers.assert_not_awaited()
async def test_make_log_record_returns_a_log_record(self): logger = Logger.with_default_handlers() await logger._initialize() record = logger.make_log_record(level=10, msg='Xablau', args=None) self.assertIsInstance(record, LogRecord) self.assertEqual(record.msg, 'Xablau') self.assertEqual(record.levelno, 10) self.assertEqual(record.levelname, 'DEBUG')
async def test_it_returns_a_dummy_task_if_logging_isnt_enabled_for_level( self): logger = Logger.with_default_handlers() self.assertIsNone(logger._dummy_task) with patch.object(logger, "isEnabledFor", return_value=False) as isEnabledFor, patch.object( logger, "_dummy_task") as _dummy_task: log_task = logger.info("im disabled") isEnabledFor.assert_called_once_with(logging.INFO) self.assertEqual(log_task, _dummy_task)
async def test_it_calls_handlers_if_logger_is_enabled_and_record_is_loggable( self): logger = Logger.with_default_handlers() with patch.object(logger, "filter", return_value=True) as filter, asynctest.patch.object( logger, "callHandlers") as callHandlers: record = Mock() await logger.handle(record) filter.assert_called_once_with(record) callHandlers.assert_awaited_once_with(record)
async def test_init_with_default_handlers_initializes_handlers_for_stdout_and_stderr( self): handlers = [Mock(), Mock()] with asynctest.patch("aiologger.logger.AsyncStreamHandler", side_effect=handlers) as handler_init: logger = Logger.with_default_handlers(loop=self.loop) self.assertCountEqual(logger.handlers, handlers) self.assertCountEqual( [logging.DEBUG, logging.WARNING], [call[1]["level"] for call in handler_init.call_args_list], )
async def test_it_returns_a_log_task_if_logging_is_enabled_for_level(self): logger = Logger.with_default_handlers() log_task = logger.info("Xablau") self.assertIsInstance(log_task, asyncio.Task) self.assertFalse(log_task.done()) await log_task self.assertTrue(log_task.done()) logged_content = await self.stream_reader.readline() self.assertEqual(logged_content, b"Xablau\n")
async def test_init_with_default_handlers_initializes_handlers_for_stdout_and_stderr( self): handlers = [Mock(), Mock()] with asynctest.patch( 'aiologger.logger.AsyncStreamHandler.init_from_pipe', CoroutineMock(side_effect=handlers)) as init_from_pipe: logger = Logger.with_default_handlers(loop=self.loop) await logger._initialize() self.assertCountEqual(logger.handlers, handlers) self.assertCountEqual( [logging.DEBUG, logging.WARNING], [call[1]['level'] for call in init_from_pipe.await_args_list])
async def test_log_makes_a_record_with_build_exc_info_from_sys_stack(self): logger = Logger.with_default_handlers() try: raise ValueError("41 isn't the answer") except Exception as e: with patch.object(logger, "handle", CoroutineMock()) as handle: await logger.exception("Xablau") call = handle.await_args_list.pop() record: LogRecord = call[0][0] exc_class, exc, exc_traceback = record.exc_info self.assertEqual(exc_class, ValueError) self.assertEqual(exc, e)
async def test_it_raises_an_error_if_no_handlers_are_found_for_record( self): logger = Logger.with_default_handlers() await logger._initialize() logger.handlers = [] record = LogRecord(level=10, name='aiologger', pathname="/aiologger/tests/test_logger.py", lineno=17, msg="Xablau!", exc_info=None, args=None) with self.assertRaises(Exception): await logger.callHandlers(record)
async def test_it_logs_exception_messages(self): logger = Logger.with_default_handlers() try: raise Exception("Xablau") except Exception: await logger.exception("Batemos tambores, eles panela.") logged_content = await self.stream_reader.readline() self.assertEqual(logged_content, b"Batemos tambores, eles panela.\n") while self.stream_reader._buffer: logged_content += await self.stream_reader.readline() current_func_name = inspect.currentframe().f_code.co_name self.assertIn(current_func_name.encode(), logged_content) self.assertIn(b'raise Exception("Xablau")', logged_content)
async def test_callhandlers_calls_handlers_for_loglevel(self): level10_handler = Mock(level=10, handle=CoroutineMock()) level30_handler = Mock(level=30, handle=CoroutineMock()) logger = Logger.with_default_handlers() await logger._initialize() logger.handlers = [level10_handler, level30_handler] record = LogRecord(level=20, name='aiologger', pathname="/aiologger/tests/test_logger.py", lineno=17, msg="Xablau!", exc_info=None, args=None) await logger.callHandlers(record) level10_handler.handle.assert_awaited_once_with(record) level30_handler.handle.assert_not_awaited()
async def test_it_calls_multiple_handlers_if_multiple_handle_matches_are_found_for_record( self): level10_handler = Mock(level=10, handle=CoroutineMock()) level20_handler = Mock(level=20, handle=CoroutineMock()) logger = Logger.with_default_handlers() logger.handlers = [level10_handler, level20_handler] record = LogRecord( level=30, name="aiologger", pathname="/aiologger/tests/test_logger.py", lineno=17, msg="Xablau!", exc_info=None, args=None, ) await logger.callHandlers(record) level10_handler.handle.assert_awaited_once_with(record) level20_handler.handle.assert_awaited_once_with(record)
async def test_it_logs_critical_messages(self): logger = Logger.with_default_handlers() await logger.critical("Xablau") logged_content = await self.stream_reader.readline() self.assertEqual(logged_content, b"Xablau\n")
async def test_it_blocks_logs_with_level_lower_than_Logger_level(self): logger = Logger.with_default_handlers(level=LogLevel.CRITICAL) await logger.info("Xablau") self.assertEqual(len(self.stream_reader._buffer), 0)