diff --git a/tests/unit/common/test_logging.py b/tests/unit/common/test_logging.py index 1f6c3c13..3714876b 100644 --- a/tests/unit/common/test_logging.py +++ b/tests/unit/common/test_logging.py @@ -13,13 +13,201 @@ # License for the specific language governing permissions and limitations # under the License. +import logging # noqa + import mock from rally.common.i18n import _ -from rally.common import logging +from rally.common import logging as rally_logging from tests.unit import test +class SetUpLogTestCase(test.TestCase): + + @mock.patch("rally.common.logging.CONF") + @mock.patch("rally.common.logging.handlers") + @mock.patch("rally.common.logging.oslogging") + def test_setup(self, mock_oslogging, mock_handlers, mock_conf): + + proj = "fakep" + version = "fakev" + mock_handlers.ColorHandler.LEVEL_COLORS = { + logging.DEBUG: "debug_color"} + mock_conf.rally_debug = True + + rally_logging.setup(proj, version) + + self.assertIn(logging.RDEBUG, mock_handlers.ColorHandler.LEVEL_COLORS) + self.assertEqual( + mock_handlers.ColorHandler.LEVEL_COLORS[logging.DEBUG], + mock_handlers.ColorHandler.LEVEL_COLORS[logging.RDEBUG]) + + mock_oslogging.setup.assert_called_once_with(mock_conf, proj, version) + mock_oslogging.getLogger(None).logger.setLevel.assert_called_once_with( + logging.RDEBUG) + + @mock.patch("rally.common.logging.log") + @mock.patch("rally.common.logging.RallyContextAdapter") + @mock.patch("rally.common.logging.oslogging") + def test_getLogger(self, mock_oslogging, mock_rally_context_adapter, + mock_log): + + name = "fake" + vers = "fake" + mock_oslogging._loggers = {} + + returned_logger = rally_logging.getLogger(name, vers) + + self.assertIn(name, mock_oslogging._loggers) + mock_rally_context_adapter.assert_called_once_with( + mock_log.getLogger(name), + {"project": "rally", "version": vers}) + self.assertEqual(mock_oslogging._loggers[name], returned_logger) + + +class LogRallyContaxtAdapterTestCase(test.TestCase): + + @mock.patch("rally.common.logging.log") + @mock.patch("rally.common.logging.oslogging.KeywordArgumentAdapter") + def test_debug(self, mock_keyword_argument_adapter, mock_log): + + mock_log.RDEBUG = 123 + fake_msg = "fake message" + radapter = rally_logging.RallyContextAdapter(mock.MagicMock(), "fakep") + radapter.log = mock.MagicMock() + + radapter.debug(fake_msg) + + radapter.log.assert_called_once_with(mock_log.RDEBUG, + fake_msg) + + +class ExceptionLoggerTestCase(test.TestCase): + + @mock.patch("rally.common.logging.is_debug") + def test_context(self, mock_is_debug): + # Prepare + mock_is_debug.return_value = True + + logger = mock.MagicMock() + exception = Exception() + + # Run + with rally_logging.ExceptionLogger(logger, "foo") as e: + raise exception + + # Assertions + logger.warning.assert_called_once_with("foo") + + logger.exception.assert_called_once_with(exception) + + logger.debug.assert_called_once_with(exception) + + self.assertEqual(e.exception, exception) + + +class LogCatcherTestCase(test.TestCase): + # FIXME(pboldin): These are really functional tests and should be moved + # there when the infrastructure is ready + def test_logcatcher(self): + LOG = rally_logging.getLogger("testlogger") + LOG.logger.setLevel(rally_logging.INFO) + + with rally_logging.LogCatcher(LOG) as catcher: + LOG.warning("Warning") + LOG.info("Info") + LOG.debug("Debug") + + catcher.assertInLogs("Warning") + self.assertRaises(AssertionError, catcher.assertInLogs, "Error") + + self.assertEqual(["Warning", "Info"], catcher.fetchLogs()) + self.assertEqual(2, len(catcher.fetchLogRecords())) + + +class CatcherHandlerTestCase(test.TestCase): + @mock.patch("logging.handlers.BufferingHandler.__init__") + def test_init(self, mock_buffering_handler___init__): + catcher_handler = rally_logging.CatcherHandler() + mock_buffering_handler___init__.assert_called_once_with( + catcher_handler, 0) + + def test_shouldFlush(self): + catcher_handler = rally_logging.CatcherHandler() + self.assertFalse(catcher_handler.shouldFlush()) + + def test_emit(self): + catcher_handler = rally_logging.CatcherHandler() + catcher_handler.buffer = mock.Mock() + + catcher_handler.emit("foobar") + + catcher_handler.buffer.append.assert_called_once_with("foobar") + + +class LogCatcherUnitTestCase(test.TestCase): + def setUp(self): + super(LogCatcherUnitTestCase, self).setUp() + patcher = mock.patch("rally.common.logging.CatcherHandler") + self.catcher_handler = patcher.start() + self.catcher_handler.return_value.buffer = [ + mock.Mock(msg="foo"), mock.Mock(msg="bar")] + self.addCleanup(patcher.stop) + + self.logger = mock.Mock() + + def test_init(self): + catcher = rally_logging.LogCatcher(self.logger) + + self.assertEqual(self.logger.logger, catcher.logger) + self.assertEqual(self.catcher_handler.return_value, catcher.handler) + self.catcher_handler.assert_called_once_with() + + def test_enter(self): + catcher = rally_logging.LogCatcher(self.logger) + + self.assertEqual(catcher, catcher.__enter__()) + self.logger.logger.addHandler.assert_called_once_with( + self.catcher_handler.return_value) + + def test_exit(self): + catcher = rally_logging.LogCatcher(self.logger) + + catcher.__exit__(None, None, None) + self.logger.logger.removeHandler.assert_called_once_with( + self.catcher_handler.return_value) + + def test_assertInLogs(self): + catcher = rally_logging.LogCatcher(self.logger) + + self.assertEqual(["foo"], catcher.assertInLogs("foo")) + self.assertEqual(["bar"], catcher.assertInLogs("bar")) + self.assertRaises(AssertionError, catcher.assertInLogs, "foobar") + + def test_assertInLogs_contains(self): + catcher = rally_logging.LogCatcher(self.logger) + + record_mock = mock.MagicMock() + self.catcher_handler.return_value.buffer = [record_mock] + record_mock.msg.__contains__.return_value = True + self.assertEqual([record_mock.msg], catcher.assertInLogs("foo")) + + record_mock.msg.__contains__.assert_called_once_with("foo") + + def test_fetchLogRecords(self): + catcher = rally_logging.LogCatcher(self.logger) + + self.assertEqual(self.catcher_handler.return_value.buffer, + catcher.fetchLogRecords()) + + def test_fetchLogs(self): + catcher = rally_logging.LogCatcher(self.logger) + + self.assertEqual( + [r.msg for r in self.catcher_handler.return_value.buffer], + catcher.fetchLogs()) + + class LogTestCase(test.TestCase): def test_log_task_wrapper(self): @@ -31,7 +219,7 @@ class LogTestCase(test.TestCase): def __init__(self): self.task = {"uuid": "some_uuid"} - @logging.log_task_wrapper(mock_log, msg, a=10, b=20) + @rally_logging.log_task_wrapper(mock_log, msg, a=10, b=20) def some_method(self, x, y): return x + y @@ -48,7 +236,7 @@ class LogTestCase(test.TestCase): def test_log_deprecated(self): mock_log = mock.MagicMock() - @logging.log_deprecated("depr42", "1.1.1", mock_log) + @rally_logging.log_deprecated("depr42", "1.1.1", mock_log) def some_method(x, y): return x + y @@ -60,8 +248,8 @@ class LogTestCase(test.TestCase): def test_log_deprecated_args(self): mock_log = mock.MagicMock() - @logging.log_deprecated_args("ABC42", "0.0.1", ("z",), - mock_log, once=True) + @rally_logging.log_deprecated_args("ABC42", "0.0.1", ("z",), + mock_log, once=True) def some_method(x, y, z): return x + y + z @@ -74,8 +262,8 @@ class LogTestCase(test.TestCase): self.assertEqual(some_method(2, 2, z=3), 7) self.assertFalse(mock_log.called) - @logging.log_deprecated_args("CBA42", "0.0.1", ("z",), - mock_log, once=False) + @rally_logging.log_deprecated_args("CBA42", "0.0.1", ("z",), + mock_log, once=False) def some_method(x, y, z): return x + y + z diff --git a/tests/unit/test_logging.py b/tests/unit/test_logging.py deleted file mode 100644 index 35cc0873..00000000 --- a/tests/unit/test_logging.py +++ /dev/null @@ -1,207 +0,0 @@ -# Copyright 2014: Mirantis Inc. -# All Rights Reserved. -# -# Licensed under the Apache License, Version 2.0 (the "License"); you may -# not use this file except in compliance with the License. You may obtain -# a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations -# under the License. - -import logging - -import mock - -from rally.common import logging as log -from tests.unit import test - - -class LogTestCase(test.TestCase): - - @mock.patch("rally.common.logging.CONF") - @mock.patch("rally.common.logging.handlers") - @mock.patch("rally.common.logging.oslogging") - def test_setup(self, mock_oslogging, mock_handlers, mock_conf): - - proj = "fakep" - version = "fakev" - mock_handlers.ColorHandler.LEVEL_COLORS = { - logging.DEBUG: "debug_color"} - mock_conf.rally_debug = True - - log.setup(proj, version) - - self.assertIn(logging.RDEBUG, mock_handlers.ColorHandler.LEVEL_COLORS) - self.assertEqual( - mock_handlers.ColorHandler.LEVEL_COLORS[logging.DEBUG], - mock_handlers.ColorHandler.LEVEL_COLORS[logging.RDEBUG]) - - mock_oslogging.setup.assert_called_once_with(mock_conf, proj, version) - mock_oslogging.getLogger(None).logger.setLevel.assert_called_once_with( - logging.RDEBUG) - - @mock.patch("rally.common.logging.log") - @mock.patch("rally.common.logging.RallyContextAdapter") - @mock.patch("rally.common.logging.oslogging") - def test_getLogger(self, mock_oslogging, mock_rally_context_adapter, - mock_log): - - name = "fake" - vers = "fake" - mock_oslogging._loggers = {} - - returned_logger = log.getLogger(name, vers) - - self.assertIn(name, mock_oslogging._loggers) - mock_rally_context_adapter.assert_called_once_with( - mock_log.getLogger(name), - {"project": "rally", "version": vers}) - self.assertEqual(mock_oslogging._loggers[name], returned_logger) - - -class LogRallyContaxtAdapter(test.TestCase): - - @mock.patch("rally.common.logging.log") - @mock.patch("rally.common.logging.oslogging.KeywordArgumentAdapter") - def test_debug(self, mock_keyword_argument_adapter, mock_log): - - mock_log.RDEBUG = 123 - fake_msg = "fake message" - radapter = log.RallyContextAdapter(mock.MagicMock(), "fakep") - radapter.log = mock.MagicMock() - - radapter.debug(fake_msg) - - radapter.log.assert_called_once_with(mock_log.RDEBUG, - fake_msg) - - -class ExceptionLoggerTestCase(test.TestCase): - - @mock.patch("rally.common.logging.is_debug") - def test_context(self, mock_is_debug): - # Prepare - mock_is_debug.return_value = True - - logger = mock.MagicMock() - exception = Exception() - - # Run - with log.ExceptionLogger(logger, "foo") as e: - raise exception - - # Assertions - logger.warning.assert_called_once_with("foo") - - logger.exception.assert_called_once_with(exception) - - logger.debug.assert_called_once_with(exception) - - self.assertEqual(e.exception, exception) - - -class LogCatcherTestCase(test.TestCase): - # FIXME(pboldin): These are really functional tests and should be moved - # there when the infrastructure is ready - def test_logcatcher(self): - LOG = log.getLogger("testlogger") - LOG.logger.setLevel(log.INFO) - - with log.LogCatcher(LOG) as catcher: - LOG.warning("Warning") - LOG.info("Info") - LOG.debug("Debug") - - catcher.assertInLogs("Warning") - self.assertRaises(AssertionError, catcher.assertInLogs, "Error") - - self.assertEqual(["Warning", "Info"], catcher.fetchLogs()) - self.assertEqual(2, len(catcher.fetchLogRecords())) - - -class CatcherHandlerTestCase(test.TestCase): - @mock.patch("logging.handlers.BufferingHandler.__init__") - def test_init(self, mock_buffering_handler___init__): - catcher_handler = log.CatcherHandler() - mock_buffering_handler___init__.assert_called_once_with( - catcher_handler, 0) - - def test_shouldFlush(self): - catcher_handler = log.CatcherHandler() - self.assertFalse(catcher_handler.shouldFlush()) - - def test_emit(self): - catcher_handler = log.CatcherHandler() - catcher_handler.buffer = mock.Mock() - - catcher_handler.emit("foobar") - - catcher_handler.buffer.append.assert_called_once_with("foobar") - - -class LogCatcherUnitTestCase(test.TestCase): - def setUp(self): - super(LogCatcherUnitTestCase, self).setUp() - patcher = mock.patch("rally.common.logging.CatcherHandler") - self.catcher_handler = patcher.start() - self.catcher_handler.return_value.buffer = [ - mock.Mock(msg="foo"), mock.Mock(msg="bar")] - self.addCleanup(patcher.stop) - - self.logger = mock.Mock() - - def test_init(self): - catcher = log.LogCatcher(self.logger) - - self.assertEqual(self.logger.logger, catcher.logger) - self.assertEqual(self.catcher_handler.return_value, catcher.handler) - self.catcher_handler.assert_called_once_with() - - def test_enter(self): - catcher = log.LogCatcher(self.logger) - - self.assertEqual(catcher, catcher.__enter__()) - self.logger.logger.addHandler.assert_called_once_with( - self.catcher_handler.return_value) - - def test_exit(self): - catcher = log.LogCatcher(self.logger) - - catcher.__exit__(None, None, None) - self.logger.logger.removeHandler.assert_called_once_with( - self.catcher_handler.return_value) - - def test_assertInLogs(self): - catcher = log.LogCatcher(self.logger) - - self.assertEqual(["foo"], catcher.assertInLogs("foo")) - self.assertEqual(["bar"], catcher.assertInLogs("bar")) - self.assertRaises(AssertionError, catcher.assertInLogs, "foobar") - - def test_assertInLogs_contains(self): - catcher = log.LogCatcher(self.logger) - - record_mock = mock.MagicMock() - self.catcher_handler.return_value.buffer = [record_mock] - record_mock.msg.__contains__.return_value = True - self.assertEqual([record_mock.msg], catcher.assertInLogs("foo")) - - record_mock.msg.__contains__.assert_called_once_with("foo") - - def test_fetchLogRecords(self): - catcher = log.LogCatcher(self.logger) - - self.assertEqual(self.catcher_handler.return_value.buffer, - catcher.fetchLogRecords()) - - def test_fetchLogs(self): - catcher = log.LogCatcher(self.logger) - - self.assertEqual( - [r.msg for r in self.catcher_handler.return_value.buffer], - catcher.fetchLogs())