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)
Beispiel #2
0
    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, [])
Beispiel #3
0
    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_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_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)
Beispiel #6
0
    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_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, [])
Beispiel #8
0
    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)
Beispiel #9
0
    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)
Beispiel #10
0
    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_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)
Beispiel #12
0
    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_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_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_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 __init__(self, config):
     self.statsd = monascastatsd.Client(name='monasca',
                                        dimensions=BaseProcessor.dimensions)
     notifiers.init(self.statsd)
     notifiers.load_plugins(config['notification_types'])
     notifiers.config(config['notification_types'])
     self._db_repo = get_db_repo(config)
     self.insert_configured_plugins()
    def test_enabled_notifications(self, mock_log, mock_smtp):
        notifiers.init(self.statsd)
        notifiers.config()

        notifications = notifiers.enabled_notifications()

        self.assertEqual(len(notifications), 3)
        self.assertEqual(sorted(notifications),
                         ["EMAIL", "PAGERDUTY", "WEBHOOK"])
    def __init__(self):
        self.statsd = get_statsd_client()
        notifiers.init(self.statsd)

        notifiers.load_plugins()
        notifiers.config()

        self._db_repo = get_db_repo()
        self.insert_configured_plugins()
 def __init__(self, config):
     self.statsd = get_statsd_client(config)
     notifiers.init(self.statsd)
     notifiers.load_plugins(config['notification_types'])
     notifiers.config(config['notification_types'])
     self._db_repo = get_db_repo(config)
     self.insert_configured_plugins()
     self._invalid_type_count = self.statsd.get_counter(name='invalid_type_count')
     self._sent_failed_count = self.statsd.get_counter(name='sent_failed_count')
Beispiel #20
0
    def __init__(self):
        self.statsd = get_statsd_client()
        notifiers.init(self.statsd)

        notifiers.load_plugins()
        notifiers.config()

        self._db_repo = get_db_repo()
        self.insert_configured_plugins()
Beispiel #21
0
    def test_enabled_notifications_none(self):
        self.conf_override(group='notification_types', enabled=[])

        notifiers.init(self.statsd)
        notifiers.load_plugins()
        notifiers.config()

        notifications = notifiers.enabled_notifications()

        self.assertEqual(len(notifications), 0)
    def test_config_missing_data(self, mock_log, mock_smtp):
        mock_log.warn = self.trap.append
        mock_log.error = self.trap.append
        mock_log.info = self.trap.append

        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)
    def test_enabled_notifications(self, mock_log, mock_smtp):
        config_dict = {'email': self.email_config,
                       'webhook': {'address': 'xyz.com'},
                       'pagerduty': {'address': 'xyz.com'}}

        notifiers.init(self.statsd)
        notifiers.config(config_dict)
        notifications = notifiers.enabled_notifications()

        self.assertEqual(len(notifications), 3)
        self.assertEqual(sorted(notifications),
                         ["EMAIL", "PAGERDUTY", "WEBHOOK"])
    def test_enabled_notifications_none(self):
        self.conf_override(
            group='notification_types',
            enabled=[]
        )

        notifiers.init(self.statsd)
        notifiers.load_plugins()
        notifiers.config()

        notifications = notifiers.enabled_notifications()

        self.assertEqual(len(notifications), 0)
    def test_config_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._configExceptionStub

        config_dict = {'email': self.email_config,
                       'webhook': {'address': 'xyz.com'},
                       'pagerduty': {'address': 'abc'}}

        notifiers.init(self.statsd)
        notifiers.config(config_dict)

        self.assertIn("config exception for email", self.trap)
    def test_config_correct(self, mock_log, mock_smtp):
        mock_log.warn = self.trap.append
        mock_log.error = self.trap.append
        mock_log.info = self.trap.append

        config_dict = {'email': self.email_config,
                       'webhook': {'address': 'xyz.com'},
                       'pagerduty': {'address': 'abc'}}

        notifiers.init(self.statsd)
        notifiers.config(config_dict)

        self.assertIn("email notification ready", self.trap)
        self.assertIn("webhook notification ready", self.trap)
        self.assertIn("pagerduty notification ready", self.trap)
Beispiel #27
0
    def test_plugin_load(self):
        self.conf_override(
            group='notification_types',
            enabled=[
                'monasca_notification.plugins.hipchat_notifier:HipChatNotifier',
                'monasca_notification.plugins.slack_notifier:SlackNotifier'
            ])

        notifiers.init(self.statsd)
        notifiers.load_plugins()
        notifiers.config()

        self.assertEqual(len(notifiers.possible_notifiers), 2)
        self.assertItemsEqual(['hipchat', 'slack'],
                              notifiers.configured_notifiers)
    def test_plugin_load(self):
        self.conf_override(
            group='notification_types',
            enabled=[
                'monasca_notification.plugins.hipchat_notifier:HipChatNotifier',
                'monasca_notification.plugins.slack_notifier:SlackNotifier'
            ]
        )

        notifiers.init(self.statsd)
        notifiers.load_plugins()
        notifiers.config()

        self.assertEqual(len(notifiers.possible_notifiers), 2)
        self.assertItemsEqual(['hipchat', 'slack'],
                              notifiers.configured_notifiers)
Beispiel #29
0
    def test_config_missing_data(self, mock_log, mock_smtp):
        mock_log.warn = self.trap.append
        mock_log.error = self.trap.append
        mock_log.info = self.trap.append

        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)
Beispiel #30
0
    def test_enabled_notifications(self, mock_log, mock_smtp):
        config_dict = {
            'email': self.email_config,
            'webhook': {
                'address': 'xyz.com'
            },
            'pagerduty': {
                'address': 'xyz.com'
            }
        }

        notifiers.init(self.statsd)
        notifiers.config(config_dict)
        notifications = notifiers.enabled_notifications()

        self.assertEqual(len(notifications), 3)
        self.assertEqual(sorted(notifications),
                         ["EMAIL", "PAGERDUTY", "WEBHOOK"])
    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)
Beispiel #32
0
    def test_enabled_notifications(self):
        self.conf_override(
            group='notification_types',
            enabled=[
                'monasca_notification.plugins.email_notifier:EmailNotifier',
                'monasca_notification.plugins.pagerduty_notifier:PagerdutyNotifier',
                'monasca_notification.plugins.webhook_notifier:WebhookNotifier',
                'monasca_notification.plugins.hipchat_notifier:HipChatNotifier',
                'monasca_notification.plugins.slack_notifier:SlackNotifier',
                'monasca_notification.plugins.jira_notifier:JiraNotifier'
            ])
        notifiers.init(self.statsd)
        notifiers.load_plugins()
        notifiers.config()

        notifications = notifiers.enabled_notifications()
        self.assertEqual(len(notifications), 6)
        self.assertItemsEqual(
            notifications,
            ['EMAIL', 'PAGERDUTY', 'WEBHOOK', 'HIPCHAT', 'SLACK', 'JIRA'])
    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, [])
Beispiel #34
0
    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_enabled_notifications(self):
        self.conf_override(
            group='notification_types',
            enabled=[
                'monasca_notification.plugins.email_notifier:EmailNotifier',
                'monasca_notification.plugins.pagerduty_notifier:PagerdutyNotifier',
                'monasca_notification.plugins.webhook_notifier:WebhookNotifier',
                'monasca_notification.plugins.hipchat_notifier:HipChatNotifier',
                'monasca_notification.plugins.slack_notifier:SlackNotifier',
                'monasca_notification.plugins.jira_notifier:JiraNotifier'
            ]
        )
        notifiers.init(self.statsd)
        notifiers.load_plugins()
        notifiers.config()

        notifications = notifiers.enabled_notifications()
        self.assertEqual(len(notifications), 6)
        self.assertItemsEqual(notifications,
                              ['EMAIL', 'PAGERDUTY', 'WEBHOOK',
                               'HIPCHAT', 'SLACK', 'JIRA'])
Beispiel #36
0
    def test_config_correct(self, mock_log, mock_smtp):
        mock_log.warn = self.trap.append
        mock_log.error = self.trap.append
        mock_log.info = self.trap.append

        config_dict = {
            'email': self.email_config,
            'webhook': {
                'address': 'xyz.com'
            },
            'pagerduty': {
                'address': 'abc'
            }
        }

        notifiers.init(self.statsd)
        notifiers.config(config_dict)

        self.assertIn("email notification ready", self.trap)
        self.assertIn("webhook notification ready", self.trap)
        self.assertIn("pagerduty notification ready", 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)
Beispiel #38
0
    def test_config_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._configExceptionStub

        config_dict = {
            'email': self.email_config,
            'webhook': {
                'address': 'xyz.com'
            },
            'pagerduty': {
                'address': 'abc'
            }
        }

        notifiers.init(self.statsd)
        notifiers.config(config_dict)

        self.assertIn("config exception for email", 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(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)
Beispiel #41
0
    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)
Beispiel #42
0
 def __init__(self, config):
     self.statsd = monascastatsd.Client(name='monasca',
                                        dimensions=BaseProcessor.dimensions)
     notifiers.init(self.statsd)
     notifiers.config(config)
 def __init__(self, config):
     self.statsd = monascastatsd.Client(name='monasca', dimensions=BaseProcessor.dimensions)
     notifiers.init(self.statsd)
     notifiers.config(config)