x
/
collectd-openstack-plugins
Code Issues Proposed changes

Merge "[refactor] common/test_logger.py: move common code to setUp()"

This commit is contained in:
Jenkins 2017-09-26 09:41:40 +00:00 committed by Gerrit Code Review
parent 962eb9dd76 f6fd19b620
commit f004cdc6d2
1 changed files with 64 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

173
collectd_ceilometer/tests/common/test_logger.py
View File

@ -48,210 +48,165 @@ def make_record(
class TestCollectdLogHandler(unittest.TestCase): class TestCollectdLogHandler(unittest.TestCase):
def __init__(self, *args, **kwargs):
"""Declare additional class attributes"""
super(TestCollectdLogHandler, self).__init__(*args, **kwargs)
self.config = Config.instance()
@patch_class(MockedCollectd) @patch_class(MockedCollectd)
def test_registered_hooks_when_init(self, collectd): def setUp(self, collectd):
"""Set up some attributes which are common to all tests."""
super(TestCollectdLogHandler, self).setUp()
# When CollectdLogHandler is created self.collectd = collectd
handler = CollectdLogHandler(collectd=collectd, config=self.config) self.config = Config.instance()
self.handler = CollectdLogHandler(collectd=self.collectd,
config=self.config)
self.logger = logging.Logger('some_logger')
self.logger.addHandler(self.handler)
def test_registered_hooks_when_init(self):
# Then collectd logging hooks are registered # Then collectd logging hooks are registered
# pylint: disable=protected-access # pylint: disable=protected-access
self.assertEqual( self.assertEqual(
{logging.DEBUG: collectd.debug, {logging.DEBUG: self.collectd.debug,
logging.INFO: collectd.info, logging.INFO: self.collectd.info,
logging.WARNING: collectd.warning, logging.WARNING: self.collectd.warning,
logging.ERROR: collectd.error, logging.ERROR: self.collectd.error,
logging.FATAL: collectd.error}, logging.FATAL: self.collectd.error},
handler.priority_map) self.handler.priority_map)
@patch_class(MockedCollectd) def test_debug_when_emit(self):
def test_debug_when_emit(self, collectd):
# Given # Given
handler = CollectdLogHandler(collectd=collectd, config=self.config)
record = make_record(msg="message", level=logging.DEBUG) record = make_record(msg="message", level=logging.DEBUG)
# When a debug record is emitted # When a debug record is emitted
handler.emit(record=record) self.handler.emit(record=record)
# Then debug hook is called # Then debug hook is called
collectd.debug.assert_called_once_with("message") self.collectd.debug.assert_called_once_with("message")
@patch_class(MockedCollectd) def test_verbose_debug_when_emit(self):
def test_verbose_debug_when_emit(self, collectd):
# Given # Given
handler = CollectdLogHandler(collectd=collectd, config=self.config)
self.config.VERBOSE = True self.config.VERBOSE = True
record = make_record(msg="message", level=logging.DEBUG) record = make_record(msg="message", level=logging.DEBUG)
# When an info record is emitted # When an info record is emitted
handler.emit(record=record) self.handler.emit(record=record)
# Then info hook is called # Then info hook is called
collectd.info.assert_called_once_with("message") self.collectd.info.assert_called_once_with("message")
@patch_class(MockedCollectd) def test_info_when_emit(self):
def test_info_when_emit(self, collectd):
# Given # Given
handler = CollectdLogHandler(collectd=collectd, config=self.config)
record = make_record(msg="message", level=logging.INFO) record = make_record(msg="message", level=logging.INFO)
# When an info record is emitted # When an info record is emitted
handler.emit(record=record) self.handler.emit(record=record)
# Then info hook is called # Then info hook is called
collectd.info.assert_called_once_with("message") self.collectd.info.assert_called_once_with("message")
@patch_class(MockedCollectd) def test_warning_when_emit(self):
def test_warning_when_emit(self, collectd):
# Given # Given
handler = CollectdLogHandler(collectd=collectd, config=self.config)
record = make_record(msg="message", level=logging.WARNING) record = make_record(msg="message", level=logging.WARNING)
# When a warning record is emitted # When a warning record is emitted
handler.emit(record=record) self.handler.emit(record=record)
# Then info warning is called # Then info warning is called
collectd.warning.assert_called_once_with("message") self.collectd.warning.assert_called_once_with("message")
@patch_class(MockedCollectd) def test_error_when_emit(self):
def test_error_when_emit(self, collectd):
# Given # Given
handler = CollectdLogHandler(collectd=collectd, config=self.config)
record = make_record(msg="message", level=logging.ERROR) record = make_record(msg="message", level=logging.ERROR)
# When an error record is emitted # When an error record is emitted
handler.emit(record=record) self.handler.emit(record=record)
# Then error hook is called # Then error hook is called
collectd.error.assert_called_once_with("message") self.collectd.error.assert_called_once_with("message")
@patch_class(MockedCollectd) def test_fatal_when_emit(self):
def test_fatal_when_emit(self, collectd):
# Given # Given
handler = CollectdLogHandler(collectd=collectd, config=self.config)
record = make_record(msg="message", level=logging.FATAL) record = make_record(msg="message", level=logging.FATAL)
# When a fatal record is emitted # When a fatal record is emitted
handler.emit(record=record) self.handler.emit(record=record)
# Then error hook is called # Then error hook is called
collectd.error.assert_called_once_with("message") self.collectd.error.assert_called_once_with("message")
@patch_class(MockedCollectd) def test_long_message_when_emit(self):
def test_long_message_when_emit(self, collectd):
# Given # Given
long_message = "LONG " * 20 + "MESSAGE." long_message = "LONG " * 20 + "MESSAGE."
handler = CollectdLogHandler(collectd=collectd, config=self.config) self.handler.max_message_length = 10
handler.max_message_length = 10
record = make_record(msg=long_message) record = make_record(msg=long_message)
# When a long message is emitted # When a long message is emitted
handler.emit(record=record) self.handler.emit(record=record)
# Then info hook is called n times with split message # Then info hook is called n times with split message
collectd.info.assert_has_calls([ self.collectd.info.assert_has_calls([
mock.call(long_message[i:i + 10]) mock.call(long_message[i:i + 10])
for i in range(0, len(long_message), 10)]) for i in range(0, len(long_message), 10)])
@patch_class(MockedCollectd) def test_when_logger_debug(self):
def test_when_logger_debug(self, collectd):
# Given
handler = CollectdLogHandler(collectd=collectd, config=self.config)
logger = logging.Logger('some_logger')
logger.addHandler(handler)
# When debug is called # When debug is called
self.config.VERBOSE = False self.config.VERBOSE = False
logger.debug('Say cheese: %s %d', 'string', 10) self.logger.debug('Say cheese: %s %d', 'string', 10)
# Then debug hook is called # Then debug hook is called
collectd.debug.assert_called_once_with('Say cheese: string 10') self.collectd.debug.assert_called_once_with('Say cheese: string 10')
collectd.info.assert_not_called() self.collectd.info.assert_not_called()
@patch_class(MockedCollectd) def test_verbose_when_logger_info(self):
def test_verbose_when_logger_info(self, collectd):
# Given
handler = CollectdLogHandler(collectd=collectd, config=self.config)
logger = logging.Logger('some_logger')
logger.addHandler(handler)
# When debug is called # When debug is called
self.config.VERBOSE = True self.config.VERBOSE = True
logger.debug('Say cheese: %s %d', 'string', 10) self.logger.debug('Say cheese: %s %d', 'string', 10)
# Then info hook is called # Then info hook is called
collectd.info.assert_called_once_with('Say cheese: string 10') self.collectd.info.assert_called_once_with('Say cheese: string 10')
collectd.debug.assert_not_called() self.collectd.debug.assert_not_called()
@patch_class(MockedCollectd) def test_non_verbose_when_logger_info(self):
def test_non_verbose_when_logger_info(self, collectd):
# Given # Given
handler = CollectdLogHandler(collectd=collectd, config=self.config) self.handler.verbose = False
handler.verbose = False
logger = logging.Logger('some_logger')
logger.addHandler(handler)
# When debug is called # When debug is called
logger.debug('Say cheese: %s %d', 'string', 10) self.logger.debug('Say cheese: %s %d', 'string', 10)
# Then debug hook is called # Then debug hook is called
collectd.debug.assert_called_once_with('Say cheese: string 10') self.collectd.debug.assert_called_once_with('Say cheese: string 10')
collectd.info.assert_not_called() self.collectd.info.assert_not_called()
@patch_class(MockedCollectd) def test_info_from_logger(self):
def test_info_from_logger(self, collectd):
# Given
handler = CollectdLogHandler(collectd=collectd, config=self.config)
logger = logging.Logger('some_logger')
logger.addHandler(handler)
# When info is called # When info is called
logger.info('Say cheese: %s %d', 'string', 10) self.logger.info('Say cheese: %s %d', 'string', 10)
# Then info hook is called # Then info hook is called
collectd.info.assert_called_once_with('Say cheese: string 10') self.collectd.info.assert_called_once_with('Say cheese: string 10')
@patch_class(MockedCollectd) def test_warning_from_logger(self):
def test_warning_from_logger(self, collectd):
# Given
handler = CollectdLogHandler(collectd=collectd, config=self.config)
logger = logging.Logger('some_logger')
logger.addHandler(handler)
# When warning is called # When warning is called
logger.warning('Say cheese: %s %d', 'string', 10) self.logger.warning('Say cheese: %s %d', 'string', 10)
# Then warning hook is called # Then warning hook is called
collectd.warning.assert_called_once_with('Say cheese: string 10') self.collectd.warning.assert_called_once_with('Say cheese: string 10')
@patch_class(MockedCollectd) def test_error_from_logger(self):
def test_error_from_logger(self, collectd):
# Given
handler = CollectdLogHandler(collectd=collectd, config=self.config)
logger = logging.Logger('some_logger')
logger.addHandler(handler)
# When error is called # When error is called
logger.error('Say cheese: %s %d', 'string', 10) self.logger.error('Say cheese: %s %d', 'string', 10)
# Then error hook is called # Then error hook is called
collectd.error.assert_called_once_with('Say cheese: string 10') self.collectd.error.assert_called_once_with('Say cheese: string 10')
@patch_class(MockedCollectd) def test_fatal_from_logger(self):
def test_fatal_from_logger(self, collectd):
# Given
handler = CollectdLogHandler(collectd=collectd, config=self.config)
logger = logging.Logger('some_logger')
logger.addHandler(handler)
# When fatal is called # When fatal is called
logger.fatal('Say cheese: %s %d', 'string', 10) self.logger.fatal('Say cheese: %s %d', 'string', 10)
# Then error hook is called # Then error hook is called
collectd.error.assert_called_once_with('Say cheese: string 10') self.collectd.error.assert_called_once_with('Say cheese: string 10')