class TestAlertIncreasing(_BaseTestCase):

    def setUp(self):
        self.alert = Alert(ALERT_INC)

    def test_name_matches(self):
        self.assertEqual(self.alert.get('name'), ALERT_INC['name'])

    def test_target_matches(self):
        self.assertEqual(self.alert.get('target'), ALERT_INC['target'])

    def test_warning_matches(self):
        self.assertEqual(self.alert.get('warning'), ALERT_INC['warning'])

    def test_critical_matches(self):
        self.assertEqual(self.alert.get('critical'), ALERT_INC['critical'])

    def test_should_return_none_for_low_value(self):
        self.assert_check_value_returns_item_for_value(0, Level.NOMINAL)

    def test_should_return_warning_for_warning_value(self):
        self.assert_check_value_returns_item_for_value(
            self.alert.get('warning'), Level.WARNING)

    def test_should_return_warning_for_mid_value(self):
        self.assert_check_value_returns_item_for_value(1.5, Level.WARNING)

    def test_should_return_critical_for_critical_value(self):
        self.assert_check_value_returns_item_for_value(2, Level.CRITICAL)

    def test_should_return_critical_for_high_value(self):
        self.assert_check_value_returns_item_for_value(3, Level.CRITICAL)
 def test_url_with_base_and_target(self):
     base = 'http://example.com'
     alert = Alert(ALERT_INC, doc_url=base)
     url = '{0}/{1}#{2}'.format(
         base,
         ALERT_INC['name'],
         ALERT_INC['target'])
     self.assertEqual(alert.documentation_url(ALERT_INC['target']), url)
class TestAlertWithFrom(_BaseTestCase):

    def setUp(self):
        self.alert = Alert(ALERT_FROM)

    def test_should_have_default_from_time_of_1_min(self):
        self.assertEqual(self.alert.get('from'), ALERT_FROM['from'])
class TestValueForLevel(_BaseTestCase):

    def setUp(self):
        self.alert = Alert(ALERT_INC)

    def test_nominal_returns_warning_value(self):
        self.assertEqual(self.alert.value_for_level(Level.NOMINAL), self.alert.warning)

    def test_warning_returns_warning_value(self):
        self.assertEqual(self.alert.value_for_level(Level.WARNING), self.alert.warning)

    def test_critical_returns_critical_value(self):
        self.assertEqual(self.alert.value_for_level(Level.CRITICAL), self.alert.critical)

    def test_unknown_level_returns_none(self):
        self.assertEqual(self.alert.value_for_level('unkown level'), None)
class TestValueForLevel(_BaseTestCase):
    def setUp(self):
        self.alert = Alert(ALERT_INC)

    def test_nominal_returns_warning_value(self):
        self.assertEqual(self.alert.value_for_level(Level.NOMINAL),
                         self.alert.warning)

    def test_warning_returns_warning_value(self):
        self.assertEqual(self.alert.value_for_level(Level.WARNING),
                         self.alert.warning)

    def test_critical_returns_critical_value(self):
        self.assertEqual(self.alert.value_for_level(Level.CRITICAL),
                         self.alert.critical)

    def test_unknown_level_returns_none(self):
        self.assertEqual(self.alert.value_for_level('unkown level'), None)
class TestAlertHasNoData(_BaseTestCase):

    def setUp(self):
        self.alert = Alert(ALERT_DEC)

    def test_should_return_no_data_for_no_data(self):
        class Record(object):
            target = 'name'
            def get_last_value(self):
                raise NoDataError()

        level, value = self.alert.check_record(Record())
        self.assertEqual(level, 'NO DATA')
class TestAlertHasNoData(_BaseTestCase):
    def setUp(self):
        self.alert = Alert(ALERT_DEC)

    def test_should_return_no_data_for_no_data(self):
        class Record(object):
            target = 'name'

            def get_last_value(self):
                raise NoDataError()

        level, value = self.alert.check_record(Record())
        self.assertEqual(level, 'NO DATA')
class TestAlertHasExcludeNone(_BaseTestCase):

    def setUp(self):
        self.alert = Alert(ALERT_WITH_EXCLUDE_NONE)

    def test_should_not_exclude(self):
        class Record(object):
            target = 'name'
            def get_last_value(self):
                raise NoDataError()

        level, value = self.alert.check_record(Record())
        self.assertEqual(level, 'NO DATA')
class TestAlertisExcluded(_BaseTestCase):

    def setUp(self):
        self.alert = Alert(ALERT_WITH_EXCLUDE)

    def test_should_return_no_data_for_no_data(self):
        class Record(object):
            target = 'exclude_1'
            def get_last_value(self):
                raise NoDataError()

        level, value = self.alert.check_record(Record())
        self.assertEqual(level, Level.NOMINAL)
        self.assertEqual(value, 'Excluded')
class TestAlertisExcludedByWildcard(_BaseTestCase):

    def setUp(self):
        self.alert = Alert(ALERT_WITH_EXCLUDE_WILDCARD)

    def test_is_excluded(self):
        class Record(object):
            target = 'exclude_1'
            def get_last_value(self):
                raise NoDataError()

        level, value = self.alert.check_record(Record())
        self.assertEqual(level, Level.NOMINAL)
        self.assertEqual(value, 'Excluded')

    def test_is_not_excluded(self):
        class Record(object):
            target = 'hello_1'
            def get_last_value(self):
                raise NoDataError()

        level, value = self.alert.check_record(Record())
        self.assertEqual(level, 'NO DATA')
class TestAlertisExcludedByHealthcheck(_BaseTestCase):

    def setUp(self):
        self.alert = Alert(ALERT_WITH_EXCLUDE_HEALTHCHECK)

    def test_is_excluded(self):
        class Record(object):
            target = 'healthcheck.tusapi3-dead.pulse_emis.healthy'
            def get_last_value(self):
                raise NoDataError()

        level, value = self.alert.check_record(Record())
        self.assertEqual(level, Level.NOMINAL)
        self.assertEqual(value, 'Excluded')

    def test_is_not_excluded(self):
        class Record(object):
            target = 'healthcheck.tusapi3.pulse_emis.healthy'
            def get_last_value(self):
                raise NoDataError()

        level, value = self.alert.check_record(Record())
        self.assertEqual(level, 'NO DATA')
class TestAlertisExcluded(_BaseTestCase):
    def setUp(self):
        self.alert = Alert(ALERT_WITH_EXCLUDE)

    def test_should_return_no_data_for_no_data(self):
        class Record(object):
            target = 'exclude_1'

            def get_last_value(self):
                raise NoDataError()

        level, value = self.alert.check_record(Record())
        self.assertEqual(level, Level.NOMINAL)
        self.assertEqual(value, 'Excluded')
 def setUp(self):
     self.alert = Alert(ALERT_INC)
 def test_url_with_base_includes_name(self):
     base = 'http://example.com'
     alert = Alert(ALERT_INC, doc_url=base)
     url = '{0}/{1}'.format(base, ALERT_INC['name'])
     self.assertEqual(alert.documentation_url(), url)
 def test_url_with_no_base_url_is_none(self):
     alert = Alert(ALERT_INC)
     self.assertEqual(alert.documentation_url(), None)
 def setUp(self):
     self.alert = Alert(ALERT_FROM)
 def setUp(self):
     self.alert = Alert(ALERT_WITH_EXCLUDE_HEALTHCHECK)
 def setUp(self):
     self.alert = Alert(ALERT_WITH_EXCLUDE)
Beispiel #19
0
 def setUp(self):
     self.alert = Alert(ALERT_FROM)
 def test_url_with_base_includes_name(self):
     base = 'http://example.com'
     alert = Alert(ALERT_INC, doc_url=base)
     url = '{0}/{1}'.format(base, ALERT_INC['name'])
     self.assertEqual(alert.documentation_url(), url)
 def test_url_with_no_base_url_is_none(self):
     alert = Alert(ALERT_INC)
     self.assertEqual(alert.documentation_url(), None)
 def setUp(self):
     self.alert = Alert(ALERT_INC)
 def setUp(self):
     self.alert = Alert(ALERT_WITH_EXCLUDE)