def test_send_notification_correct(self, mock_log, mock_smtp, mock_email,
mock_time):
mock_log.warn = self.trap.append
mock_log.error = self.trap.append
mock_email.EmailNotifier = self._goodSendStub
mock_time.time.return_value = 42
notifiers.init(self.statsd)
notifiers.config()
notifications = []
notifications.append(
m_notification.Notification(0, 'email', 'email notification',
'*****@*****.**', 0, 0, alarm({})))
notifications.append(
m_notification.Notification(1, 'email', 'email notification',
'*****@*****.**', 0, 0, alarm({})))
notifications.append(
m_notification.Notification(2, 'email', 'email notification',
'*****@*****.**', 0, 0, alarm({})))
sent, failed, invalid = notifiers.send_notifications(notifications)
self.assertEqual(len(sent), 3)
self.assertEqual(failed, [])
self.assertEqual(invalid, [])
for n in sent:
self.assertEqual(n.notification_timestamp, 42)
def test_statsd(self, mock_im, mock_log, mock_smtp, mock_email):
self.conf_override(
group='notification_types',
enabled=[
'monasca_notification.plugins.email_notifier:EmailNotifier'
])
mock_log.warn = self.trap.append
mock_log.error = self.trap.append
mock_email.EmailNotifier = self._goodSendStub
mock_im.import_class.return_value = mock_email.EmailNotifier
notifiers.init(self.statsd)
notifiers.load_plugins()
notifiers.config()
notifications = [
m_notification.Notification(0, 'email', 'email notification',
'*****@*****.**', 0, 0, alarm({})),
m_notification.Notification(1, 'email', 'email notification',
'*****@*****.**', 0, 0, alarm({})),
m_notification.Notification(2, 'email', 'email notification',
'*****@*****.**', 0, 0, alarm({}))
]
notifiers.send_notifications(notifications)
self.assertEqual(self.statsd.timer.timer_calls['email_time_start'], 3)
self.assertEqual(self.statsd.timer.timer_calls['email_time_stop'], 3)
self.assertEqual(self.statsd.counter.counter, 3)
def test_statsd(self, mock_log, mock_smtp, mock_email):
mock_log.warn = self.trap.append
mock_log.error = self.trap.append
mock_email.EmailNotifier = self._goodSendStub
notifiers.init(self.statsd)
notifiers.config()
notifications = []
notifications.append(
m_notification.Notification(0, 'email', 'email notification',
'*****@*****.**', 0, 0, alarm({})))
notifications.append(
m_notification.Notification(1, 'email', 'email notification',
'*****@*****.**', 0, 0, alarm({})))
notifications.append(
m_notification.Notification(2, 'email', 'email notification',
'*****@*****.**', 0, 0, alarm({})))
notifiers.send_notifications(notifications)
self.assertEqual(self.statsd.timer.timer_calls['email_time_start'], 3)
self.assertEqual(self.statsd.timer.timer_calls['email_time_stop'], 3)
self.assertEqual(self.statsd.counter.counter, 3)
def test_two_valid_notifications(self):
alarm_dict = {
"tenantId": "0",
"alarmDefinitionId": "0",
"alarmId": "1",
"alarmName": "test Alarm",
"oldState": "OK",
"newState": "ALARM",
"stateChangeReason": "I am alarming!",
"timestamp": time.time() * 1000,
"actionsEnabled": 1,
"metrics": "cpu_util",
"severity": "LOW",
"link": "http://some-place.com",
"lifecycleState": "OPEN"
}
alarm = self._create_raw_alarm(0, 5, alarm_dict)
sql_response = [[1, 'EMAIL', 'test notification', '*****@*****.**', 0],
[2, 'EMAIL', 'test notification2', '*****@*****.**', 0]]
notifications, partition, offset = self._run_alarm_processor(
alarm, sql_response)
test_notification = m_notification.Notification(
1, 'email', 'test notification', '*****@*****.**', 0, 0, alarm_dict)
test_notification2 = m_notification.Notification(
2, 'email', 'test notification2', '*****@*****.**', 0, 0, alarm_dict)
self.assertEqual(notifications,
[test_notification, test_notification2])
self.assertEqual(partition, 0)
self.assertEqual(offset, 5)
def test_send_notification_exception(self, mock_im, mock_log, mock_smtp,
mock_email):
self.conf_override(
group='notification_types',
enabled=[
'monasca_notification.plugins.email_notifier:EmailNotifier'
])
mock_log.warn = self.trap.append
mock_log.error = self.trap.append
mock_log.exception = self.trap.append
mock_email.EmailNotifier = self._sendExceptionStub
mock_im.import_class.return_value = mock_email.EmailNotifier
notifiers.init(self.statsd)
notifiers.load_plugins()
notifiers.config()
notifications = [
m_notification.Notification(0, 'email', 'email notification',
'*****@*****.**', 0, 0, alarm({}))
]
notifiers.send_notifications(notifications)
self.assertIn("send_notification exception for email", self.trap)
def notify(self, http_func, mock_requests):
mock_log = mock.MagicMock()
mock_log.warn = self.trap.put
mock_log.error = self.trap.put
mock_log.exception = self.trap.put
mock_requests.post = http_func
pagerduty = pagerduty_notifier.PagerdutyNotifier(mock_log)
metric = []
metric_data = {'dimensions': {'hostname': 'foo1', 'service': 'bar1'}}
metric.append(metric_data)
alarm_dict = alarm(metric)
notification = m_notification.Notification(0,
'pagerduty',
'pagerduty notification',
'ABCDEF',
0,
0,
alarm_dict)
self.trap.put(pagerduty.send_notification(notification))
def test_send_notification_failure(self, mock_im, mock_log, mock_smtp,
mock_email):
self.conf_override(
group='notification_types',
enabled=[
'monasca_notification.plugins.email_notifier:EmailNotifier'
])
mock_log.warn = self.trap.append
mock_log.error = self.trap.append
mock_log.exception = self.trap.append
mock_email.EmailNotifier = self._sendFailureStub
mock_im.import_class.return_value = mock_email.EmailNotifier
notifiers.init(self.statsd)
notifiers.load_plugins()
notifiers.config()
notifications = [
m_notification.Notification(0, 'email', 'email notification',
'*****@*****.**', 0, 0, alarm({}))
]
sent, failed, invalid = notifiers.send_notifications(notifications)
self.assertEqual(sent, [])
self.assertEqual(len(failed), 1)
self.assertEqual(invalid, [])
def test_equal():
alarm = {
'alarmId': 'alarmId',
'alarmName': 'alarmName',
'timestamp': 1429029121239,
'stateChangeReason': 'stateChangeReason',
'newState': 'newState',
'tenantId': 'tenantId',
'metrics': 'cpu_util'
}
test_notification = notification.Notification('ntype', 'src_partition',
'src_offset', 'name',
'address', 0, alarm)
test_notification2 = notification.Notification('ntype', 'src_partition',
'src_offset', 'name',
'address', 0, alarm)
assert (test_notification == test_notification2)
def test_equal():
alarm = {
'alarmId': 'alarmId',
'alarmName': 'alarmName',
'timestamp': 1429029121239,
'stateChangeReason': 'stateChangeReason',
'newState': 'newState',
'severity': 'LOW',
"link": "some-link",
"lifecycleState": "OPEN",
'tenantId': 'tenantId',
'metrics': 'cpu_util'
}
test_notification = notification.Notification(0, 'ntype', 'name',
'address', 0, 0, alarm)
test_notification2 = notification.Notification(0, 'ntype', 'name',
'address', 0, 0, alarm)
assert (test_notification == test_notification2)
def _build_notification(self, alarm):
db_time = self._statsd.get_timer()
with db_time.time('config_db_time'):
alarms_actions = self._db_repo.fetch_notifications(alarm)
return [
notification.Notification(alarms_action[0], alarms_action[1],
alarms_action[2], alarms_action[3],
alarms_action[4], 0, alarm)
for alarms_action in alarms_actions
]
def test_json_non_zero_period():
"""Test the to_json method to verify it behaves as expected.
"""
ts = 1429029121239
alarm = {
'alarmId': 'alarmId',
'alarmName': 'alarmName',
'timestamp': ts,
'stateChangeReason': 'stateChangeReason',
'newState': 'newState',
'severity': 'LOW',
"link": "some-link",
"lifecycleState": "OPEN",
'tenantId': 'tenantId',
'metrics': 'cpu_util'
}
test_notification = notification.Notification('ntype', 'src_partition',
'src_offset', 'name',
'address', 60, 0, alarm)
expected_dict = {
u'name': u'name',
u'type': u'ntype',
u'notification_timestamp': None,
u'tenant_id': u'tenantId',
u'alarm_name': u'alarmName',
u'alarm_id': u'alarmId',
u'state': u'newState',
u'severity': u'LOW',
u'link': u'some-link',
u'lifecycle_state': u'OPEN',
u'alarm_timestamp': ts / 1000,
u'address': u'address',
u'message': u'stateChangeReason',
u'period': 60,
u'periodic_topic': 60,
u'retry_count': 0,
u'raw_alarm': {
u'alarmId': u'alarmId',
u'alarmName': u'alarmName',
u'timestamp': ts,
u'stateChangeReason': u'stateChangeReason',
u'newState': u'newState',
u'severity': u'LOW',
u'link': u'some-link',
u'lifecycleState': u'OPEN',
u'tenantId': u'tenantId',
u'metrics': u'cpu_util'
}
}
# Compare as dicts so ordering is not an issue
assert json.loads(test_notification.to_json()) == expected_dict
def test_send_notification_correct(self, mock_im, mock_log, mock_smtp,
mock_email, mock_time):
self.conf_override(
group='notification_types',
enabled=[
'monasca_notification.plugins.email_notifier:EmailNotifier'
])
mock_log.warn = self.trap.append
mock_log.error = self.trap.append
mock_email.EmailNotifier = self._goodSendStub
mock_time.time.return_value = 42
mock_im.import_class.return_value = mock_email.EmailNotifier
notifiers.init(self.statsd)
notifiers.load_plugins()
notifiers.config()
notifications = [
m_notification.Notification(0, 'email', 'email notification',
'*****@*****.**', 0, 0, alarm({})),
m_notification.Notification(1, 'email', 'email notification',
'*****@*****.**', 0, 0, alarm({})),
m_notification.Notification(2, 'email', 'email notification',
'*****@*****.**', 0, 0, alarm({}))
]
sent, failed, invalid = notifiers.send_notifications(notifications)
self.assertEqual(len(sent), 3)
self.assertEqual(failed, [])
self.assertEqual(invalid, [])
for n in sent:
self.assertEqual(n.notification_timestamp, 42)
def _notify(self, response_list, mock_requests):
mock_requests.post = mock.Mock(side_effect=response_list)
metric = []
metric_data = {'dimensions': {'hostname': 'foo1', 'service': 'bar1'}}
metric.append(metric_data)
alarm_dict = alarm(metric)
notification = m_notification.Notification(0, 'slack',
'slack notification',
'http://test.slack:3333', 0,
0, alarm_dict)
return mock_requests.post, self._slk.send_notification(notification)
def test_send_notification_exception(self, mock_log, mock_smtp,
mock_email):
mock_log.warn = self.trap.append
mock_log.error = self.trap.append
mock_log.exception = self.trap.append
mock_email.EmailNotifier = self._sendExceptionStub
notifiers.init(self.statsd)
notifiers.config()
notifications = []
notifications.append(
m_notification.Notification(0, 'email', 'email notification',
'*****@*****.**', 0, 0, alarm({})))
notifiers.send_notifications(notifications)
self.assertIn("send_notification exception for email", self.trap)
def _notify(self, transitions_value, issue_status, address, mock_jira):
alarm_dict = alarm()
mock_jira_obj = mock.Mock()
mock_jira.JIRA.return_value = mock_jira_obj
mock_jira_issue = mock.Mock()
if issue_status:
mock_jira_obj.search_issues.return_value = [mock_jira_issue]
mock_jira_issue.fields.status.name = issue_status
else:
mock_jira_obj.search_issues.return_value = []
mock_jira_obj.transitions.side_effect = transitions_value
notification = m_notification.Notification(0, 'jira',
'jira notification',
address, 0, 0, alarm_dict)
return mock_jira, mock_jira_obj, self._jr.send_notification(
notification)
def test_json():
"""Test the to_json method to verify it behaves as expected.
"""
ts = 1429029121239
alarm = {
'alarmId': 'alarmId',
'alarmName': 'alarmName',
'timestamp': ts,
'stateChangeReason': 'stateChangeReason',
'newState': 'newState',
'tenantId': 'tenantId',
'metrics': 'cpu_util'
}
test_notification = notification.Notification('ntype', 'src_partition',
'src_offset', 'name',
'address', 0, alarm)
expected_dict = {
u'name': u'name',
u'type': u'ntype',
u'notification_timestamp': None,
u'tenant_id': u'tenantId',
u'alarm_name': u'alarmName',
u'alarm_id': u'alarmId',
u'state': u'newState',
u'alarm_timestamp': ts / 1000,
u'address': u'address',
u'message': u'stateChangeReason',
u'retry_count': 0,
u'raw_alarm': {
u'alarmId': u'alarmId',
u'alarmName': u'alarmName',
u'timestamp': ts,
u'stateChangeReason': u'stateChangeReason',
u'newState': u'newState',
u'tenantId': u'tenantId',
u'metrics': u'cpu_util'
}
}
# Compare as dicts so ordering is not an issue
assert json.loads(test_notification.to_json()) == expected_dict
def test_send_notification_failure(self, mock_log, mock_smtp, mock_email):
mock_log.warn = self.trap.append
mock_log.error = self.trap.append
mock_log.exception = self.trap.append
mock_email.EmailNotifier = self._sendFailureStub
notifiers.init(self.statsd)
notifiers.config()
notifications = []
notifications.append(
m_notification.Notification(0, 'email', 'email notification',
'*****@*****.**', 0, 0, alarm({})))
sent, failed, invalid = notifiers.send_notifications(notifications)
self.assertEqual(sent, [])
self.assertEqual(len(failed), 1)
self.assertEqual(invalid, [])
def email_setup(self, metric):
alarm_dict = {
"tenantId": "0",
"alarmId": "0",
"alarmName": "test Alarm",
"oldState": "OK",
"newState": "ALARM",
"severity": "LOW",
"link": "some-link",
"lifecycleState": "OPEN",
"stateChangeReason": "I am alarming!",
"timestamp": time.time(),
"metrics": metric
}
notification = m_notification.Notification(0, 'email',
'email notification',
'*****@*****.**', 0, 0,
alarm_dict)
self._start_processor([notification])
def notify(self, http_func, mock_requests):
mock_log = mock.MagicMock()
mock_log.warn = self.trap.put
mock_log.error = self.trap.put
mock_log.exception = self.trap.put
mock_requests.post = http_func
webhook = webhook_notifier.WebhookNotifier(mock_log)
metric = []
metric_data = {'dimensions': {'hostname': 'foo1', 'service': 'bar1'}}
metric.append(metric_data)
alarm_dict = alarm(metric)
notification = m_notification.Notification(0, 'webhook',
'webhook notification',
'http://mock:3333/', 0, 0,
alarm_dict)
self.trap.put(webhook.send_notification(notification))
def test_invalid_notification(self):
"""Verify invalid notification type is rejected.
"""
alarm_dict = {
"tenantId": "0",
"alarmId": "0",
"alarmName": "test Alarm",
"oldState": "OK",
"newState": "ALARM",
"stateChangeReason": "I am alarming!",
"timestamp": time.time(),
"metrics": "cpu_util",
"severity": "LOW",
"link": "http://some-place.com",
"lifecycleState": "OPEN"
}
invalid_notification = m_notification.Notification(
0, 'invalid', 'test notification', '*****@*****.**', 0, 0, alarm_dict)
self._start_processor([invalid_notification])
self.assertIn('attempting to send unconfigured notification: invalid',
self.trap)
def notify(self, http_func, mock_requests):
mock_log = mock.MagicMock()
mock_log.warn = self.trap.put
mock_log.error = self.trap.put
mock_log.exception = self.trap.put
mock_requests.post = http_func
hipchat = hipchat_notifier.HipChatNotifier(mock_log)
hipchat.config()
metric = []
metric_data = {'dimensions': {'hostname': 'foo1', 'service': 'bar1'}}
metric.append(metric_data)
alarm_dict = alarm(metric)
notification = m_notification.Notification(0, 'hipchat',
'hipchat notification',
'http://mock:3333/', 0, 0,
alarm_dict)
self.trap.put(hipchat.send_notification(notification))
