async def test_logger_handlers_are_not_initialized_twice(self):
condition = asyncio.Condition()
initialize_meta = {'count': 0}
async def create_handlers():
async with condition:
await condition.wait_for(
predicate=lambda: initialize_meta['count'] == 4)
return await Logger._create_default_handlers()
handlers_factory = CoroutineMock(side_effect=create_handlers)
logger = Logger(handler_factory=handlers_factory)
original_initialize = logger._initialize
async def initialize():
async with condition:
initialize_meta['count'] += 1
condition.notify_all()
await original_initialize()
patch.object(logger, '_initialize', initialize).start()
await asyncio.gather(
logger.info('sardinha'),
logger.info('tilápia'),
logger.info('xerelete'),
logger.error('fraldinha'),
)
handlers_factory.assert_called_once()
await logger.shutdown()
def test_property_loop_always_return_a_running_loop(self):
logger = Logger(name="mylogger")
# it's not safe to install the loop implictly, callers should use
# asynio.run
with self.assertRaises(RuntimeError):
logger.loop
# it's not safe to run the loop implictly, callers should use
# asynio.run
with contextlib.closing(asyncio.get_event_loop()) as loop:
with self.assertRaises(RuntimeError):
logger.loop
results = []
async def get_logger_loop():
results.append(logger.loop)
loop.run_until_complete(get_logger_loop())
logger_loop, = results
# now that the loop was explicitly set and started, we can use it
self.assertIs(logger_loop, loop)
del logger_loop
self.assertFalse(loop.is_closed())
# now that the loop was explicitly stopped, it's useless to return
loop = asyncio.get_event_loop()
with self.assertRaises(RuntimeError):
logger.loop
def test_removehandler_removes_handler_if_handler_in_handlers(self):
logger = Logger()
handler = Mock()
logger.handlers = [handler]
logger.remove_handler(handler)
self.assertEqual(logger.handlers, [])
def test_property_loop_always_return_a_running_loop(self):
logger = Logger(name="mylogger")
self.assertIsNotNone(logger.loop)
self.assertFalse(logger.loop.is_closed())
logger.loop.close()
asyncio.set_event_loop(asyncio.new_event_loop())
self.assertIsNotNone(logger.loop)
self.assertFalse(logger.loop.is_closed())
async def test_shutdown_doest_not_closes_handlers_if_not_initialized(self):
handler_factory = CoroutineMock(return_value=[
Mock(flush=CoroutineMock()),
Mock(flush=CoroutineMock())
])
logger = Logger(handler_factory=handler_factory)
await logger.shutdown()
handler_factory.assert_not_awaited()
self.assertCountEqual([], logger.handlers)
async def test_shutdown_ignores_erros(self):
logger = Logger()
logger.handlers = [
Mock(flush=CoroutineMock(side_effect=ValueError)),
Mock(flush=CoroutineMock()),
]
await logger.shutdown()
logger.handlers[0].close.assert_not_called()
logger.handlers[1].close.assert_called_once()
async def test_shutdown_closes_all_handlers(self):
logger = Logger()
logger.handlers = [
Mock(flush=CoroutineMock()),
Mock(flush=CoroutineMock())
]
await logger.shutdown()
for handler in logger.handlers:
handler.flush.assert_awaited_once()
handler.close.assert_called_once()
async def test_shutdown_closes_all_handlers_if_initialized(self):
handlers = [Mock(flush=CoroutineMock()), Mock(flush=CoroutineMock())]
logger = Logger(handler_factory=CoroutineMock(return_value=handlers))
await logger._initialize()
await logger.shutdown()
self.assertCountEqual(handlers, logger.handlers)
for handler in logger.handlers:
handler.flush.assert_awaited_once()
handler.close.assert_called_once()
def make_logger(config: Mapping[str, Any]) -> Logger:
""" Create Logger instance for using async logging """
handler = AsyncFileHandler(
filename=str(LOGS_PATH.joinpath(f'{config["filename"]}.log')),
encoding='utf-8'
)
logger = Logger(
name=config['name'],
level=config['level'],
)
logger.add_handler(handler)
return logger
async def test_shutdown_doest_not_closes_handlers_twice(self):
handlers = [Mock(flush=CoroutineMock()), Mock(flush=CoroutineMock())]
logger = Logger()
logger.handlers = handlers
await asyncio.gather(logger.shutdown(), logger.shutdown(),
logger.shutdown())
self.assertCountEqual(handlers, logger.handlers)
for handler in logger.handlers:
handler.flush.assert_awaited_once()
handler.close.assert_called_once()
def test_find_caller_without_current_frame_code(self):
logger = Logger()
with patch(
"aiologger.logger.get_current_frame",
return_value=Mock(f_back=object()),
):
caller = logger.find_caller()
self.assertEqual(caller.filename, "(unknown file)")
self.assertEqual(caller.line_number, 0)
self.assertEqual(caller.function_name, "(unknown function)")
self.assertIsNone(caller.stack)
def test_find_caller_without_stack_info(self):
logger = Logger()
def caller_function():
def log_function():
def make_log_task():
return logger.find_caller()
return make_log_task()
return log_function()
caller = caller_function()
self.assertEqual(caller, (__file__, ANY, "caller_function", None))
async def test_shutdown_closes_all_handlers_if_initialized(self):
handlers = [
Mock(spec=AsyncStreamHandler),
Mock(spec=AsyncStreamHandler),
]
logger = Logger()
logger.handlers = handlers
await logger.shutdown()
self.assertCountEqual(handlers, logger.handlers)
for handler in logger.handlers:
handler.flush.assert_awaited_once()
handler.close.assert_awaited_once()
async def test_shutdown_doest_not_closes_handlers_if_not_initialized(self):
initialized_handler = Mock(spec=AsyncStreamHandler)
not_initialized_handler = Mock(spec=AsyncStreamHandler,
initialized=False)
logger = Logger()
logger.handlers = [initialized_handler, not_initialized_handler]
await logger.shutdown()
initialized_handler.flush.assert_awaited_once()
initialized_handler.close.assert_awaited_once()
not_initialized_handler.flush.assert_not_awaited()
not_initialized_handler.close.assert_not_awaited()
def test_find_caller_with_stack_info(self):
logger = Logger()
def caller_function():
def log_function():
def make_log_task():
try:
raise ValueError("Xablau!")
except Exception:
return logger.find_caller(True)
return make_log_task()
return log_function()
caller = caller_function()
self.assertEqual(caller.filename, __file__)
self.assertEqual(caller.function_name, "caller_function")
self.assertIn("return log_function()", caller.stack)