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
config_dict = {'email': self.email_config,
'webhook': {'address': 'xyz.com'},
'pagerduty': {'address': 'abc'}}
notifiers.init(self.statsd)
notifiers.config(config_dict)
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_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
config_dict = {
'email': self.email_config,
'webhook': {
'address': 'xyz.com'
},
'pagerduty': {
'address': 'abc'
}
}
notifiers.init(self.statsd)
notifiers.config(config_dict)
notifications = []
notifications.append(
Notification(0, 'email', 'email notification', '*****@*****.**', 0, 0,
alarm({})))
notifications.append(
Notification(1, 'email', 'email notification', '*****@*****.**', 0,
0, alarm({})))
notifications.append(
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_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 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
config_dict = {
'email': self.email_config,
'webhook': {
'address': 'xyz.com'
},
'pagerduty': {
'address': 'abc'
}
}
notifiers.init(self.statsd)
notifiers.config(config_dict)
notifications = []
notifications.append(
Notification(0, 'email', 'email notification', '*****@*****.**', 0, 0,
alarm({})))
notifiers.send_notifications(notifications)
self.assertIn("send_notification exception for email", self.trap)
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 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_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_send_notification_unconfigured(self, mock_log, mock_smtp,
mock_email):
mock_log.warn = self.trap.append
mock_log.error = self.trap.append
mock_log.info = self.trap.append
mock_email.EmailNotifier = self._sendExceptionStub
config_dict = {
'email': self.email_config,
'webhook': {
'address': 'xyz.com'
}
}
notifiers.init(self.statsd)
notifiers.config(config_dict)
self.assertIn("No config data for type: pagerduty", self.trap)
notifications = []
notifications.append(
Notification(0, 'pagerduty', 'pagerduty notification',
'*****@*****.**', 0, 0, alarm({})))
sent, failed, invalid = notifiers.send_notifications(notifications)
self.assertEqual(sent, [])
self.assertEqual(failed, [])
self.assertEqual(len(invalid), 1)
self.assertIn(
"attempting to send unconfigured notification: pagerduty",
self.trap)
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
config_dict = {
'email': self.email_config,
'webhook': {
'address': 'xyz.com'
},
'pagerduty': {
'address': 'abc'
}
}
notifiers.init(self.statsd)
notifiers.config(config_dict)
notifications = []
notifications.append(
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_send_notification_unconfigured(self, mock_log, mock_smtp, mock_email):
mock_log.warn = self.trap.append
mock_log.error = self.trap.append
mock_log.info = self.trap.append
mock_email.EmailNotifier = self._sendExceptionStub
config_dict = {'email': self.email_config,
'webhook': {'address': 'xyz.com'}}
notifiers.init(self.statsd)
notifiers.config(config_dict)
self.assertIn("No config data for type: pagerduty", self.trap)
notifications = []
notifications.append(m_notification.Notification(0, 'pagerduty', 'pagerduty notification',
'*****@*****.**', 0, 0, alarm({})))
sent, failed, invalid = notifiers.send_notifications(notifications)
self.assertEqual(sent, [])
self.assertEqual(failed, [])
self.assertEqual(len(invalid), 1)
self.assertIn("attempting to send unconfigured notification: pagerduty", self.trap)
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_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_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
config_dict = {'email': self.email_config,
'webhook': {'address': 'xyz.com'},
'pagerduty': {'address': 'abc'}}
notifiers.init(self.statsd)
notifiers.config(config_dict)
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_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 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
config_dict = {'email': self.email_config,
'webhook': {'address': 'xyz.com'},
'pagerduty': {'address': 'abc'}}
notifiers.init(self.statsd)
notifiers.config(config_dict)
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 send(self, notifications):
"""Send the notifications
For each notification in a message it is sent according to its type.
If all notifications fail the alarm partition/offset are added to the finished queue
"""
sent, failed, invalid = notifiers.send_notifications(notifications)
for notif in failed:
self._sent_failed_count.increment(1, dimensions={'notification_type': notif.type})
for notif in invalid:
self._invalid_type_count.increment(1, dimensions={'notification_type': notif.type})
return sent, failed
def send(self, notifications):
"""Send the notifications
For each notification in a message it is sent according to its type.
If all notifications fail the alarm partition/offset are added to the the finished queue
"""
invalid_type_count = self.statsd.get_counter(name='invalid_type_count')
sent_failed_count = self.statsd.get_counter(name='sent_failed_count')
sent, failed, invalid = notifiers.send_notifications(notifications)
if failed:
sent_failed_count.increment(len(failed))
if invalid:
invalid_type_count.increment(len(invalid))
return sent, failed
def send(self, notifications):
"""Send the notifications
For each notification in a message it is sent according to its type.
If all notifications fail the alarm partition/offset are added to the finished queue
"""
invalid_type_count = self.statsd.get_counter(name='invalid_type_count')
sent_failed_count = self.statsd.get_counter(name='sent_failed_count')
sent, failed, invalid = notifiers.send_notifications(notifications)
if failed:
sent_failed_count.increment(len(failed))
if invalid:
invalid_type_count.increment(len(invalid))
return sent, failed
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 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
config_dict = {
'email': self.email_config,
'webhook': {
'address': 'xyz.com'
},
'pagerduty': {
'address': 'abc'
}
}
notifiers.init(self.statsd)
notifiers.config(config_dict)
notifications = []
notifications.append(
Notification(0, 'email', 'email notification', '*****@*****.**', 0, 0,
alarm({})))
notifications.append(
Notification(1, 'email', 'email notification', '*****@*****.**', 0,
0, alarm({})))
notifications.append(
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_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
config_dict = {'email': self.email_config,
'webhook': {'address': 'xyz.com'},
'pagerduty': {'address': 'abc'}}
notifiers.init(self.statsd)
notifiers.config(config_dict)
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 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 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)
