def test_update_correct_alarm(self):
"""
This test ensures the AlarmFilter updates the right alarm and not old
ones that are already resolved.
For that we create two alarms with the same data, but the first one
will get resolved at a given timestamp.
The alarmfilter will gather every single alarm, not matter the state
or the resolved field, then apply the condition on them.
"""
alarm, value = self.gen_fake_alarm(moment=42)
self.manager.update_current_alarm(alarm, value)
coll_alerts = self.manager.alerts_storage._backend
alarm_doc = list(coll_alerts.find({}))[0]
alarm['_id'] = alarm_doc['_id']
# set arbitrary resolution time
coll_alerts.update(
{'_id': alarm['_id']},
{'$set': {'v.resolved': 42, 'v.state.val': 0}}
)
alarm2, value2 = self.gen_fake_alarm(moment=4242)
self.manager.update_current_alarm(alarm2, value2)
all_alarms = list(coll_alerts.find({}))
self.assertEqual(all_alarms[0]['v']['resolved'], 42)
self.assertEqual(all_alarms[1]['v']['resolved'], None)
self.assertEqual(all_alarms[0]['v']['state']['val'], 0)
self.assertEqual(all_alarms[1]['v']['state']['val'], 1)
filter_ = AlarmFilter(
{
AlarmFilter.FILTER: {},
AlarmFilter.FORMAT: "{old} -- 2424",
AlarmFilter.LIMIT: 100,
AlarmFilter.REPEAT: 100,
AlarmFilter.CONDITION: {'v.state.val': 1},
AlarmFilter.TASKS: [
'alerts.systemaction.state_increase',
'alerts.useraction.keepstate'
]
},
storage=self.filter_storage,
alarm_storage=self.alerts_storage,
logger=self.logger
)
filter_.save()
self.manager.check_alarm_filters()
all_alarms = list(coll_alerts.find({}))
self.assertEqual(all_alarms[0]['v']['resolved'], 42)
self.assertEqual(all_alarms[1]['v']['resolved'], None)
self.assertEqual(all_alarms[0]['v']['state']['val'], 0)
self.assertEqual(all_alarms[1]['v']['state']['val'], 2)
def test_next_run(self):
delta = 100
alarm, value = self.gen_fake_alarm(moment=0)
self.manager.update_current_alarm(alarm, value)
doc_id = list(self.manager.alerts_storage._backend.find({}))[0]['_id']
alarm['_id'] = doc_id
# Check no repeat
lifter = AlarmFilter({AlarmFilter.REPEAT: 0},
storage=self.filter_storage,
alarm_storage=self.alerts_storage,
logger=self.logger)
self.assertIsNone(lifter.next_run(alarm))
# Check simple next run
lifter = AlarmFilter({AlarmFilter.LIMIT: delta},
storage=self.filter_storage,
alarm_storage=self.alerts_storage,
logger=self.logger)
self.assertTrue(lifter.next_run(alarm) >= delta)
# Check next next run date
value[AlarmField.alarmfilter.value] = {}
value[AlarmField.alarmfilter.value][AlarmFilterField.runs.value] = {
alarm['_id']: [666]
}
self.manager.update_current_alarm(alarm, value)
lifter = AlarmFilter({
AlarmFilter.LIMIT: delta,
AlarmFilter.REPEAT: 2
},
storage=self.filter_storage,
alarm_storage=self.alerts_storage,
logger=self.logger)
self.assertEqual(lifter.next_run(alarm), 666 + delta)
def test_check_alarm(self):
alarm, value = self.gen_fake_alarm()
self.manager.update_current_alarm(alarm, value)
# get back the alert's MongoDB ID for AlarmFilter
doc = self.manager.alerts_storage._backend.find({})
alarm['_id'] = list(doc)[0]['_id']
lifter = AlarmFilter(element={},
storage=self.filter_storage,
alarm_storage=self.alerts_storage,
logger=self.logger)
self.assertTrue(lifter.check_alarm(alarm))
lifter = AlarmFilter(
element={
AlarmFilter.CONDITION: {"cacao": {"$eq": 'maigre'}},
},
storage=self.filter_storage,
alarm_storage=self.alerts_storage,
logger=self.logger)
self.assertFalse(lifter.check_alarm(alarm))
lifter = AlarmFilter(
element={
AlarmFilter.CONDITION: {"v.component": {"$eq": 'bb'}},
},
storage=self.filter_storage,
alarm_storage=self.alerts_storage,
logger=self.logger)
self.assertFalse(lifter.check_alarm(alarm))
lifter = AlarmFilter(
element={
AlarmFilter.CONDITION: {"v.component": {"$eq": 'c'}},
},
storage=self.filter_storage,
alarm_storage=self.alerts_storage,
logger=self.logger)
self.assertTrue(lifter.check_alarm(alarm))
lifter = AlarmFilter(
element={
AlarmFilter.CONDITION: {"v.state.val": {"$gte": 1}},
},
storage=self.filter_storage,
alarm_storage=self.alerts_storage,
logger=self.logger)
self.assertTrue(lifter.check_alarm(alarm))
def test_output(self):
alarm, value = self.gen_fake_alarm()
self.manager.update_current_alarm(alarm, value)
lifter = AlarmFilter({AlarmFilter.FORMAT: ""},
storage=self.filter_storage,
alarm_storage=self.alerts_storage,
logger=self.logger)
self.assertEqual(lifter.output(''), "")
lifter = AlarmFilter({AlarmFilter.FORMAT: "{old} -- foo"},
storage=self.filter_storage,
alarm_storage=self.alerts_storage,
logger=self.logger)
self.assertEqual(lifter.output('toto'), "toto -- foo")
def gen_alarm_filter(self, update={}, storage=None):
"""
Generate a standard alarm filter.
"""
base = {
AlarmFilter.LIMIT: 180.0,
AlarmFilter.FILTER: '',
AlarmFilter.CONDITION: {},
AlarmFilter.TASKS: ['alerts.systemaction.state_increase'],
}
dictio = merge_two_dicts(base, update)
return AlarmFilter(dictio, logger=self.logger, storage=storage)
def test_output(self):
alarm, value = self.gen_fake_alarm()
self.manager.update_current_alarm(alarm, value)
lifter = AlarmFilter({AlarmFilter.FORMAT: ""},
storage=self.filter_storage,
alarm_storage=self.alerts_storage,
logger=self.logger)
self.assertEqual(lifter.output(''), "")
lifter = AlarmFilter({AlarmFilter.FORMAT: "{old} -- foo"},
storage=self.filter_storage,
alarm_storage=self.alerts_storage,
logger=self.logger)
self.assertEqual(lifter.output('toto'), "toto -- foo")
def test_next_run(self):
delta = 100
alarm, value = self.gen_fake_alarm(moment=0)
self.manager.update_current_alarm(alarm, value)
doc_id = list(self.manager.alerts_storage._backend.find({}))[0]['_id']
alarm['_id'] = doc_id
# Check no repeat
lifter = AlarmFilter({AlarmFilter.REPEAT: 0},
storage=self.filter_storage,
alarm_storage=self.alerts_storage,
logger=self.logger)
self.assertIsNone(lifter.next_run(alarm))
# Check simple next run
lifter = AlarmFilter({AlarmFilter.LIMIT: delta},
storage=self.filter_storage,
alarm_storage=self.alerts_storage,
logger=self.logger)
self.assertTrue(lifter.next_run(alarm) >= delta)
# Check next next run date
value[AlarmField.alarmfilter.value] = {}
value[AlarmField.alarmfilter.value][AlarmFilterField.runs.value] = {
alarm['_id']: [666]
}
self.manager.update_current_alarm(alarm, value)
lifter = AlarmFilter(
{
AlarmFilter.LIMIT: delta,
AlarmFilter.REPEAT: 2
},
storage=self.filter_storage,
alarm_storage=self.alerts_storage,
logger=self.logger
)
self.assertEqual(lifter.next_run(alarm), 666 + delta)
def test_update_correct_alarm(self):
"""
This test ensures the AlarmFilter updates the right alarm and not old
ones that are already resolved.
For that we create two alarms with the same data, but the first one
will get resolved at a given timestamp.
The alarmfilter will gather every single alarm, not matter the state
or the resolved field, then apply the condition on them.
"""
alarm, value = self.gen_fake_alarm(moment=42)
self.manager.update_current_alarm(alarm, value)
coll_alerts = self.manager.alerts_storage._backend
alarm_doc = list(coll_alerts.find({}))[0]
alarm['_id'] = alarm_doc['_id']
# set arbitrary resolution time
coll_alerts.update({'_id': alarm['_id']},
{'$set': {
'v.resolved': 42,
'v.state.val': 0
}})
alarm2, value2 = self.gen_fake_alarm(moment=4242)
self.manager.update_current_alarm(alarm2, value2)
all_alarms = list(coll_alerts.find({}))
self.assertEqual(all_alarms[0]['v']['resolved'], 42)
self.assertEqual(all_alarms[1]['v']['resolved'], None)
self.assertEqual(all_alarms[0]['v']['state']['val'], 0)
self.assertEqual(all_alarms[1]['v']['state']['val'], 1)
filter_ = AlarmFilter(
{
AlarmFilter.FILTER: {},
AlarmFilter.FORMAT:
"{old} -- 2424",
AlarmFilter.LIMIT:
100,
AlarmFilter.REPEAT:
100,
AlarmFilter.CONDITION: {
'v.state.val': 1
},
AlarmFilter.TASKS: [
'alerts.systemaction.state_increase',
'alerts.useraction.keepstate'
]
},
storage=self.filter_storage,
alarm_storage=self.alerts_storage,
logger=self.logger)
filter_.save()
self.manager.check_alarm_filters()
all_alarms = list(coll_alerts.find({}))
self.assertEqual(all_alarms[0]['v']['resolved'], 42)
self.assertEqual(all_alarms[1]['v']['resolved'], None)
self.assertEqual(all_alarms[0]['v']['state']['val'], 0)
self.assertEqual(all_alarms[1]['v']['state']['val'], 2)
def test_check_alarm(self):
alarm, value = self.gen_fake_alarm()
self.manager.update_current_alarm(alarm, value)
# get back the alert's MongoDB ID for AlarmFilter
doc = self.manager.alerts_storage._backend.find({})
alarm['_id'] = list(doc)[0]['_id']
lifter = AlarmFilter(element={},
storage=self.filter_storage,
alarm_storage=self.alerts_storage,
logger=self.logger)
self.assertTrue(lifter.check_alarm(alarm))
lifter = AlarmFilter(element={
AlarmFilter.CONDITION: {
"cacao": {
"$eq": 'maigre'
}
},
},
storage=self.filter_storage,
alarm_storage=self.alerts_storage,
logger=self.logger)
self.assertFalse(lifter.check_alarm(alarm))
lifter = AlarmFilter(element={
AlarmFilter.CONDITION: {
"v.component": {
"$eq": 'bb'
}
},
},
storage=self.filter_storage,
alarm_storage=self.alerts_storage,
logger=self.logger)
self.assertFalse(lifter.check_alarm(alarm))
lifter = AlarmFilter(element={
AlarmFilter.CONDITION: {
"v.component": {
"$eq": 'c'
}
},
},
storage=self.filter_storage,
alarm_storage=self.alerts_storage,
logger=self.logger)
self.assertTrue(lifter.check_alarm(alarm))
lifter = AlarmFilter(element={
AlarmFilter.CONDITION: {
"v.state.val": {
"$gte": 1
}
},
},
storage=self.filter_storage,
alarm_storage=self.alerts_storage,
logger=self.logger)
self.assertTrue(lifter.check_alarm(alarm))