def test_load_json(self):
logger = Mock()
self.assertEqual(self.reddalert.load_json('asd', logger), {})
self.assertEqual(self.reddalert.load_json(self.test_status_file, logger), self.test_json_data)
self.assertEqual(self.reddalert.load_json(self.test_invalid_json, logger), {})
self.assertEqual(logger.mock_calls, [
call.exception("Failed to read file '%s'", 'asd'),
call.exception("Invalid JSON file '%s'", self.test_invalid_json)
])
def test_load_json(self):
logger = Mock()
self.assertEqual(self.reddalert.load_json("asd", logger), {})
self.assertEqual(self.reddalert.load_json(self.test_status_file, logger), self.test_json_data)
self.assertEqual(self.reddalert.load_json(self.test_invalid_json, logger), {})
self.assertEqual(
logger.mock_calls,
[
call.exception("Failed to read file '%s'", "asd"),
call.exception("Invalid JSON file '%s'", self.test_invalid_json),
],
)
def test_read_and_send_exception(self):
def se_exc(*args, **kwargs):
raise Exception()
s1 = Mock(spec_set=BaseSensor)
s1.read.return_value = {
'sensor1': {'data': 's1data'},
'sensor2': {'data': 's2data'},
}
self.cls.sensors = [s1]
with patch('%s.logger' % pbm, autospec=True) as mock_logger:
with patch('%s.requests.post' % pbm, autospec=True) as mock_post:
mock_post.side_effect = se_exc
self.cls.read_and_send()
url = 'http://foo.bar.baz:1234/v1/sensors/update'
data = {
'host_id': 'myhostid',
'sensors': {
'sensor1': {'data': 's1data'},
'sensor2': {'data': 's2data'}
}
}
assert mock_post.mock_calls == [
call(url, json=data)
]
assert mock_logger.mock_calls == [
call.debug('Reading sensors'),
call.debug('POSTing sensor data to %s: %s', url, data),
call.exception('Exception caught when trying to POST data to '
'Engine; will try again at next interval.')
]
def test__get_version_info_py32(self):
with patch('awslimitchecker.version.logger') as mock_logger:
version._get_version_info()
assert mock_logger.mock_calls == [
call.exception(
'Error checking installed version; this installation'
' may not be in compliance with the AGPLv3 license:')
]
def test_read_and_send(self):
def se_exc():
raise Exception()
s1 = Mock(spec_set=BaseSensor)
s1.read.return_value = {
'sensor1': {
'data': 's1data'
},
'sensor2': {
'data': 's2data'
},
}
s2 = Mock(spec_set=BaseSensor)
s2.read.side_effect = se_exc
s3 = Mock(spec_set=BaseSensor)
s3.read.return_value = {
'sensor31': {
'data': 's31data'
},
'sensor32': {
'data': 's32data'
},
}
self.cls.sensors = [s1, s2, s3]
with patch('%s.logger' % pbm, autospec=True) as mock_logger:
with patch('%s.requests.post' % pbm, autospec=True) as mock_post:
mock_post.return_value = Mock(status_code=201)
self.cls.read_and_send()
url = 'http://foo.bar.baz:1234/v1/sensors/update'
data = {
'host_id': 'myhostid',
'sensors': {
'sensor1': {
'data': 's1data'
},
'sensor2': {
'data': 's2data'
},
'sensor31': {
'data': 's31data'
},
'sensor32': {
'data': 's32data'
},
}
}
assert mock_post.mock_calls == [call(url, json=data)]
assert mock_logger.mock_calls == [
call.debug('Reading sensors'),
call.exception('Exception reading sensor %s', 'BaseSensor'),
call.debug('POSTing sensor data to %s: %s', url, data),
call.info('POSTed sensor data to Engine')
]
def test_send_alerts_dynamo_exception(self, mock_logger, mock_dynamo):
"""AlertForwarder - Send Alerts with Dynamo Exception"""
mock_dynamo.side_effect = ClientError({}, 'batch_write')
self.forwarder.send_alerts(None)
mock_dynamo.assert_called_once_with(None)
mock_logger.assert_has_calls([
call.exception('Error saving alerts to Dynamo')
])
def test_save_json(self):
logger = Mock()
self.assertFalse(self.reddalert.save_json('/tmp', {}, logger))
self.assertFalse(self.reddalert.save_json('/tmp' * 100, {'foo': 'bar'}, logger))
self.assertTrue(self.reddalert.save_json('/tmp/reddalert_test.tmp', self.test_json_data, logger))
self.assertEqual(logger.mock_calls, [
call.warning('Got empty JSON content, not updating status file!'),
call.exception("Failed to write file '%s'", '/tmp' * 100)
])
def test_send_alert_exception(self, mock_logger):
"""Alert Processor - Send Alert - Exception"""
dispatcher = MagicMock()
dispatcher.dispatch.side_effect = AttributeError
alert = Alert('hello_world', {'abc': 123}, {'output'})
output = 'slack:unit_test_channel'
assert_false(AlertProcessor._send_alert(alert, output, dispatcher))
mock_logger.assert_has_calls([
call.info('Sending %s to %s', alert, output),
call.exception('Exception when sending %s to %s. Alert:\n%s', alert, output, ANY)
])
def test_handle_files(self):
flist = [
'foobar',
'pinevent_1420863332.123456_pin2_state1',
'pinevent_csds_pin3_state1',
'pinevent_1420863326.123456_pin3_state0',
'pinevent_1420863326.123456_pin2_state1',
'xsfjef_fhejfec_dfhe',
'pinevent_1420863326.456789_pin3_state2',
]
ex = Exception('foo')
def se_handle(fname, evt_datetime, pin, state):
if fname == 'pinevent_1420863332.123456_pin2_state1':
raise ex
type(self.config).QUEUE_PATH = '/foo/bar'
with patch('%s.logger' % pbm) as mock_logger:
with patch('%s.os.listdir' % pbm) as mock_listdir:
with patch('%s.handle_one_file' % pb) as mock_handle:
with patch('%s.os.unlink' % pbm) as mock_unlink:
mock_listdir.return_value = flist
mock_handle.side_effect = se_handle
self.cls.handle_files()
assert mock_logger.mock_calls == [
call.info("Found %d new events", 3),
call.debug('File handled; removing: %s',
'pinevent_1420863326.123456_pin2_state1'),
call.debug('File handled; removing: %s',
'pinevent_1420863326.123456_pin3_state0'),
call.exception('Execption while handling event file %s',
'pinevent_1420863332.123456_pin2_state1'),
]
assert mock_listdir.mock_calls == [call('/foo/bar')]
assert mock_handle.mock_calls == [
call('pinevent_1420863326.123456_pin2_state1',
datetime(2015, 1, 9, 23, 15, 26, 123456),
2, 1),
call('pinevent_1420863326.123456_pin3_state0',
datetime(2015, 1, 9, 23, 15, 26, 123456),
3, 0),
call('pinevent_1420863332.123456_pin2_state1',
datetime(2015, 1, 9, 23, 15, 32, 123456),
2, 1),
]
assert mock_unlink.mock_calls == [
call('/foo/bar/pinevent_1420863326.123456_pin2_state1'),
call('/foo/bar/pinevent_1420863326.123456_pin3_state0')
]
def test_save_json(self):
logger = Mock()
self.assertFalse(self.reddalert.save_json("/tmp", {}, logger))
self.assertFalse(self.reddalert.save_json("/tmp" * 100, {"foo": "bar"}, logger))
self.assertTrue(self.reddalert.save_json("/tmp/reddalert_test.tmp", self.test_json_data, logger))
self.assertEqual(
logger.mock_calls,
[
call.warning("Got empty JSON content, not updating status file!"),
call.exception("Failed to write file '%s'", "/tmp" * 100),
],
)
def test__get_version_info_fallback(self):
def se(foo):
raise Exception("foo")
with patch('awslimitchecker.version.find_version') as mock_ver:
mock_ver.side_effect = se
with patch('awslimitchecker.version.logger') as mock_logger:
v = version._get_version_info()
assert v.release == version._VERSION
assert v.url == version._PROJECT_URL
assert v.tag is None
assert v.commit is None
assert mock_ver.mock_calls == [call('awslimitchecker')]
assert mock_logger.mock_calls == [
call.exception('Error checking installed version; this installation'
' may not be in compliance with the AGPLv3 license:')
]
def test_read_and_send(self):
def se_exc():
raise Exception()
s1 = Mock(spec_set=BaseSensor)
s1.read.return_value = {
'sensor1': {'data': 's1data'},
'sensor2': {'data': 's2data'},
}
s2 = Mock(spec_set=BaseSensor)
s2.read.side_effect = se_exc
s3 = Mock(spec_set=BaseSensor)
s3.read.return_value = {
'sensor31': {'data': 's31data'},
'sensor32': {'data': 's32data'},
}
self.cls.sensors = [s1, s2, s3]
with patch('%s.logger' % pbm, autospec=True) as mock_logger:
with patch('%s.requests.post' % pbm, autospec=True) as mock_post:
mock_post.return_value = Mock(status_code=201)
self.cls.read_and_send()
url = 'http://foo.bar.baz:1234/v1/sensors/update'
data = {
'host_id': 'myhostid',
'sensors': {
'sensor1': {'data': 's1data'},
'sensor2': {'data': 's2data'},
'sensor31': {'data': 's31data'},
'sensor32': {'data': 's32data'},
}
}
assert mock_post.mock_calls == [
call(url, json=data)
]
assert mock_logger.mock_calls == [
call.debug('Reading sensors'),
call.exception('Exception reading sensor %s', 'BaseSensor'),
call.debug('POSTing sensor data to %s: %s', url, data),
call.info('POSTed sensor data to Engine')
]
def test_update_active_node_exception(self):
self.cls.last_poll_time = 'foo'
def se_exc():
raise RuntimeError('foo')
self.cls.active_node_ip_port = 'a:b'
with patch('%s.get_active_node' % pb) as mock_get:
mock_get.side_effect = se_exc
with patch('%s.logger' % pbm) as mock_logger:
self.cls.update_active_node()
assert self.cls.active_node_ip_port is None
assert mock_logger.mock_calls == [
call.exception('Exception encountered when polling active node'),
call.warning('Active vault node changed from %s to %s',
'a:b', None)
]
assert self.cls.last_poll_time == 'foo'
def test__get_version_info_fallback(self):
def se(foo):
raise Exception("foo")
with patch('awslimitchecker.version.find_version') as mock_ver:
mock_ver.side_effect = se
with patch('awslimitchecker.version.logger') as mock_logger:
v = version._get_version_info()
assert v.release == version._VERSION
assert v.url == version._PROJECT_URL
assert v.tag is None
assert v.commit is None
assert mock_ver.mock_calls == [call('awslimitchecker')]
assert mock_logger.mock_calls == [
call.exception(
'Error checking installed version; this installation'
' may not be in compliance with the AGPLv3 license:')
]
def test_repo_commit_in_last_day_exception(self):
def se_exc(foo):
raise GithubException("foo", "bar")
mock_repo = Mock(spec_set=Repository)
type(mock_repo).full_name = 'myuser/foo'
type(mock_repo).owner = Mock(login='******')
mock_repo.get_branch.side_effect = se_exc
with patch('%s.logger' % pbm) as mock_logger:
res = self.cls.repo_commit_in_last_day(mock_repo)
assert res is True
assert mock_repo.mock_calls == [call.get_branch('master')]
assert mock_logger.mock_calls == [
call.exception("Unable to get branch %s for repo %s",
'master', 'myuser/foo')
]
def test_update_active_node_exception(self):
self.cls.last_poll_time = 'foo'
def se_exc():
raise RuntimeError('foo')
self.cls.active_node_ip_port = 'a:b'
with patch('%s.get_active_node' % pb) as mock_get:
mock_get.side_effect = se_exc
with patch('%s.logger' % pbm) as mock_logger:
self.cls.update_active_node()
assert self.cls.active_node_ip_port is None
assert mock_logger.mock_calls == [
call.exception('Exception encountered when polling active node'),
call.warning('Active vault node changed from %s to %s', 'a:b',
None)
]
assert self.cls.last_poll_time == 'foo'
def test_parsing_error(self):
bad_bank_path = "banks/bad.bank"
self.sandbox.write(
bad_bank_path,
"\n".join([FEATURE_1, SCENARIO_1_1, ' """', " THIS IS AN UNFINISHED MULTILINE TEXT"]),
)
self._create_dealer([bad_bank_path])
with assert_raises(ParsingError):
self.dealer.load()
self.mocked_log.assert_has_calls(
[
call.debug("Loading banks"),
call.info("Loading features bank '%s'", bad_bank_path),
call.exception("Parsing error in %s:%d:%s", bad_bank_path, 3, ANY),
]
)
def test_send_alert_exception(self, mock_logger):
"""Alert Processor - Send Alert - Exception"""
dispatcher = MagicMock()
dispatcher.dispatch.side_effect = AttributeError
alert = {
'id': '123',
'rule_name': 'hello_world',
'record': {
'abc': 123
}
}
assert_false(
AlertProcessor._send_alert(alert, 'slack:unit_test_channel',
dispatcher))
mock_logger.assert_has_calls([
call.info('Sending alert %s to %s', '123',
'slack:unit_test_channel'),
call.exception('Exception when sending alert %s to %s. Alert:\n%s',
'123', 'slack:unit_test_channel', ANY)
])
def test_handle_one_file(self):
def se_exc(*argv):
raise Exception()
mock_cb1 = Mock()
mock_cb2 = Mock()
mock_cb2.side_effect = se_exc
cbs = [mock_cb1, mock_cb2]
pins = [
{'name': 'pin0', 'states': ['pin0state0', 'pin0state1']},
{'name': 'pin1', 'states': ['pin1state0', 'pin1state1']},
{'name': 'pin2', 'states': ['pin2state0', 'pin2state1']},
{'name': 'pin3', 'states': ['pin3state0', 'pin3state1']},
]
type(self.config).CALLBACKS = cbs
type(self.config).PINS = pins
with patch('%s.logger' % pbm) as mock_logger:
self.cls.handle_one_file(
'myfname', datetime(2015, 2, 13, 1, 2, 3, 123456), 2, 0)
assert mock_logger.mock_calls == [
call.debug("Handling event: pin=%d state=%d dt=%s (%s)",
2, 0, datetime(2015, 2, 13, 1, 2, 3, 123456), 'myfname'),
call.debug("Running callback: %s", mock_cb1),
call.debug("Callback finished"),
call.debug("Running callback: %s", mock_cb2),
call.exception("Callback raised an exception."),
call.debug("All callbacks finished.")
]
assert mock_cb1.mock_calls == [
call(datetime(2015, 2, 13, 1, 2, 3, 123456), 2, 0, 'pin2',
'pin2state0')
]
assert mock_cb2.mock_calls == [
call(datetime(2015, 2, 13, 1, 2, 3, 123456), 2, 0, 'pin2',
'pin2state0')
]
def test_read_and_send_exception(self):
def se_exc(*args, **kwargs):
raise Exception()
s1 = Mock(spec_set=BaseSensor)
s1.read.return_value = {
'sensor1': {
'data': 's1data'
},
'sensor2': {
'data': 's2data'
},
}
self.cls.sensors = [s1]
with patch('%s.logger' % pbm, autospec=True) as mock_logger:
with patch('%s.requests.post' % pbm, autospec=True) as mock_post:
mock_post.side_effect = se_exc
self.cls.read_and_send()
url = 'http://foo.bar.baz:1234/v1/sensors/update'
data = {
'host_id': 'myhostid',
'sensors': {
'sensor1': {
'data': 's1data'
},
'sensor2': {
'data': 's2data'
}
}
}
assert mock_post.mock_calls == [call(url, json=data)]
assert mock_logger.mock_calls == [
call.debug('Reading sensors'),
call.debug('POSTing sensor data to %s: %s', url, data),
call.exception('Exception caught when trying to POST data to '
'Engine; will try again at next interval.')
]
def test_middleware_extraction_failed(settings, request):
with patch('pylogctx.django.logger') as m:
ExtractRequestContextMiddleware().process_request(request)
assert call.exception() in m.method_calls
def test_middleware_extraction_failed(settings, request):
with patch('pylogctx.django.logger') as m:
ExtractRequestContextMiddleware().process_request(request)
assert call.exception() in m.method_calls
def test_extract_request_context_middleware_extraction_failed(request):
with patch('django_context_logging._log') as m:
ExtractRequestContextMiddleware().process_request(request)
assert m.method_calls == [call.exception()]
