class TestReader(BaseTest): def setUp(self): super(TestReader, self).setUp() mongo = MongoStore.get_default() collection = mongo.get_collection("default_testpbehavior") pb_coll = MongoCollection(collection) self.logger = Logger.get('alertsreader', '/tmp/null') conf = Configuration.load(PBehaviorManager.CONF_PATH, Ini) self.pbehavior_manager = PBehaviorManager(config=conf, logger=self.logger, pb_collection=pb_coll) self.reader = AlertsReader(config=conf, logger=self.logger, storage=self.manager.alerts_storage, pbehavior_manager=self.pbehavior_manager) self.reader._alarm_fields = { 'properties': { 'connector': { 'stored_name': 'v.ctr' }, 'component': { 'stored_name': 'v.cpt' }, 'entity_id': { 'stored_name': 'd' } } } def tearDown(self): """Teardown""" super(TestReader, self).setUp() self.pbehavior_manager.delete(_filter={}) def test__translate_key(self): cases = [{ 'key': 'untranslated_key', 'tkey': 'untranslated_key' }, { 'key': 'connector', 'tkey': 'v.ctr' }, { 'key': 'entity_id', 'tkey': 'd' }] for case in cases: tkey = self.reader._translate_key(case['key']) self.assertEqual(tkey, case['tkey']) def test__translate_filter(self): cases = [{ 'filter': {}, 'tfilter': {} }, { 'filter': { 'connector': 'c' }, 'tfilter': { 'v.ctr': 'c' } }, { 'filter': { '$or': [{ 'connector': 'c1' }, { 'component': 'c2' }] }, 'tfilter': { '$or': [{ 'v.ctr': 'c1' }, { 'v.cpt': 'c2' }] } }, { 'filter': { '$or': [{ 'entity_id': { '$gte': 12 }, 'untranslated': 'val' }, { 'connector': 'c1' }, { '$or': [{ 'component': 'c2' }, { 'untranslated': 'val' }] }] }, 'tfilter': { '$or': [{ 'd': { '$gte': 12 }, 'untranslated': 'val' }, { 'v.ctr': 'c1' }, { '$or': [{ 'v.cpt': 'c2' }, { 'untranslated': 'val' }] }] } }] for case in cases: tfilter = self.reader._translate_filter(case['filter']) self.assertEqual(tfilter, case['tfilter']) def test__get_time_filter(self): # opened=False, resolved=False self.assertIs( self.reader._get_opened_resolved_time_filter(opened=False, resolved=False, tstart=0, tstop=0), None) # opened=True, resolved=False expected_opened = {'v.resolved': None, 't': {'$lte': 2, "$gte": 1}} self.assertEqual( self.reader._get_opened_resolved_time_filter(opened=True, resolved=False, tstart=1, tstop=2), expected_opened) # opened=False, resolved=True expected_resolved = { 'v.resolved': { '$ne': None }, 't': { '$gte': 1, '$lte': 2 } } self.assertEqual( self.reader._get_opened_resolved_time_filter(opened=False, resolved=True, tstart=1, tstop=2), expected_resolved) # opened=True, resolved=True expected_both = {'$or': [expected_opened, expected_resolved]} self.assertEqual( self.reader._get_opened_resolved_time_filter(opened=True, resolved=True, tstart=1, tstop=2), expected_both) # opened=True, resolved=True, tstart=tstop=None self.assertEqual( self.reader._get_opened_resolved_time_filter(opened=True, resolved=True, tstart=None, tstop=None), {}) def test__get_opened_time_filter(self): cases = [{ 'tstart': None, 'tstop': None, 'expected': { 'v.resolved': None } }, { 'tstart': None, 'tstop': 0, 'expected': { 'v.resolved': None, 't': { '$lte': 0 } } }, { 'tstart': None, 'tstop': 42, 'expected': { 'v.resolved': None, 't': { '$lte': 42 } } }, { 'tstart': 13, 'tstop': None, 'expected': { 'v.resolved': None, 't': { '$gte': 13 } } }, { 'tstart': 13, 'tstop': 42, 'expected': { 'v.resolved': None, 't': { '$lte': 42, "$gte": 13 } } }] for case in cases: time_filter = self.reader._get_opened_time_filter( case['tstart'], case['tstop']) self.assertEqual(time_filter, case['expected']) def test__get_resolved_time_filter(self): cases = [{ 'tstart': None, 'tstop': None, 'expected': { 'v.resolved': { '$ne': None } } }, { 'tstart': 13, 'tstop': None, 'expected': { 'v.resolved': { '$ne': None }, 't': { '$gte': 13 } } }, { 'tstart': None, 'tstop': 42, 'expected': { 'v.resolved': { '$ne': None }, 't': { '$lte': 42 } } }, { 'tstart': 0, 'tstop': 0, 'expected': { 'v.resolved': { '$ne': None }, 't': { '$gte': 0, '$lte': 0 } } }, { 'tstart': 1, 'tstop': 2, 'expected': { 'v.resolved': { '$ne': None }, 't': { '$gte': 1, '$lte': 2 } } }] for case in cases: time_filter = self.reader._get_resolved_time_filter( case['tstart'], case['tstop']) self.assertEqual(time_filter, case['expected']) def test__translate_sort(self): cases = [{ 'sort_key': 'untranslated', 'sort_dir': 'DESC', 'tkey': 'untranslated', 'tdir': -1 }, { 'sort_key': 'untranslated', 'sort_dir': 'ASC', 'tkey': 'untranslated', 'tdir': 1 }, { 'sort_key': 'component', 'sort_dir': 'DESC', 'tkey': 'v.cpt', 'tdir': -1 }] for case in cases: tkey, tdir = self.reader._translate_sort(case['sort_key'], case['sort_dir']) self.assertEqual(tkey, case['tkey']) self.assertEqual(tdir, case['tdir']) def test__get_final_filter_bnf(self): view_filter = {'$and': [{'resource': 'companion cube'}]} time_filter = {'glados': 'shell'} bnf_search = 'NOT resource="turret"' active_columns = ['resource', 'component'] filter_ = self.reader._get_final_filter(view_filter, time_filter, bnf_search, active_columns) ref_filter = { '$and': [{ "d": { "$not": re.compile("^meta-alarm-entity-.+") } }, view_filter, time_filter, { 'resource': { '$not': { '$eq': 'turret' } } }] } self.assertEqual(ref_filter, filter_) def test__get_final_filter_natural(self): view_filter = {'$and': [{'resource': 'companion cube'}]} time_filter = {'glados': 'shell'} search = 'turret' active_columns = ['resource', 'component'] filter_ = self.reader._get_final_filter(view_filter, time_filter, search, active_columns) self.maxDiff = None ref_filter = { '$and': [{ "d": { "$not": re.compile("^meta-alarm-entity-.+") } }, view_filter, time_filter, { '$or': [{ 'resource': { '$regex': u'.*turret.*', '$options': 'i' } }, { 'component': { '$regex': u'.*turret.*', '$options': 'i' } }, { 'd': { '$regex': u'.*turret.*', '$options': 'i' } }] }] } # compiled regex resluted diffrent objects, that makes mismatched ref_filter and filter_ # first assert equality of patterns of these values # then assert equality for rest of conditions without compiled pattern objects _get_regex_condition = lambda x: x["$and"][0]["d"]["$not"] _get_pattern = lambda x: _get_regex_condition(x).pattern def _del_pattern(x): del x["$and"][0]["d"]["$not"] return x ref_pattern, filter_pattern = _get_pattern(ref_filter), _get_pattern( filter_) self.assertEqual(ref_pattern, filter_pattern) print("representation of matched paterns: {} {}, compiled regex {} {}". format(ref_pattern, filter_pattern, _get_regex_condition(ref_filter), _get_regex_condition(filter_))) self.assertEqual(_del_pattern(ref_filter), _del_pattern(filter_)) def test__get_final_filter_natural_numonly(self): view_filter = {} time_filter = {} search = 11111 active_columns = ['resource'] filter_ = self.reader._get_final_filter(view_filter, time_filter, search, active_columns) self.maxDiff = None res_filter = { '$and': [{ "d": { "$not": re.compile("^meta-alarm-entity-.+") } }, { '$or': [{ 'resource': { '$options': 'i', '$regex': '.*11111.*' } }, { 'd': { '$options': 'i', '$regex': '.*11111.*' } }] }] } self.assertEqual(res_filter, filter_) def test_contains_wildcard_dynamic_filter(self): # not contains dynamic wildcard filter view_filter = {} time_filter = {} search = 11111 active_columns = ['resource'] filter_ = self.reader._get_final_filter(view_filter, time_filter, search, active_columns) self.maxDiff = None res_filter = { '$and': [{ "d": { "$not": re.compile("^meta-alarm-entity-.+") } }, { '$or': [{ 'resource': { '$options': 'i', '$regex': '.*11111.*' } }, { 'd': { '$options': 'i', '$regex': '.*11111.*' } }] }] } t = self.reader.contains_wildcard_dynamic_filter(filter_) self.assertFalse(t) self.assertEqual(res_filter, filter_) # contains dynamic wildcard filter view_filter = {} time_filter = {} search = 11111 active_columns = ['v.infos.*.type'] filter_ = self.reader._get_final_filter(view_filter, time_filter, search, active_columns) t = self.reader.contains_wildcard_dynamic_filter(filter_) self.maxDiff = None res_filter = { '$and': [{ "d": { "$not": re.compile("^meta-alarm-entity-.+") } }, { '$or': [{ 'infos_array.v.type': { '$options': 'i', '$regex': '.*11111.*' } }, { 'd': { '$options': 'i', '$regex': '.*11111.*' } }] }] } self.assertTrue(t) self.assertEqual(res_filter, filter_) # contains dynamic wildcard filter view_filter = {'$and': [{'v.infos.*.tt': 'companion cube'}]} time_filter = {'glados': 'shell'} bnf_search = 'NOT resource="turret"' active_columns = ['resource', 'component'] filter_ = self.reader._get_final_filter(view_filter, time_filter, bnf_search, active_columns) ref_filter = { '$and': [{ "d": { "$not": re.compile("^meta-alarm-entity-.+") } }, { '$and': [{ 'infos_array.v.tt': 'companion cube' }] }, time_filter, { 'resource': { '$not': { '$eq': 'turret' } } }] } t = self.reader.contains_wildcard_dynamic_filter(filter_) self.assertTrue(t) self.assertEqual(ref_filter, filter_) def test_count_alarms_by_period(self): day = 24 * 3600 alarm0_id = '/fake/alarm/id0' event0 = { 'connector': 'ut', 'connector_name': 'ut0', 'component': 'c', 'output': '...', 'timestamp': day / 2 } alarm0 = self.manager.make_alarm(alarm0_id, event0) alarm0 = self.manager.update_state(alarm0, 1, event0) new_value0 = alarm0[self.manager.alerts_storage.VALUE] self.manager.update_current_alarm(alarm0, new_value0) alarm1_id = '/fake/alarm/id1' event1 = { 'connector': 'ut', 'connector_name': 'ut0', 'component': 'c', 'output': '...', 'timestamp': 3 * day / 2 } alarm1 = self.manager.make_alarm(alarm1_id, event1) alarm1 = self.manager.update_state(alarm1, 1, event1) new_value1 = alarm1[self.manager.alerts_storage.VALUE] self.manager.update_current_alarm(alarm1, new_value1) # Are subperiods well cut ? count = self.reader.count_alarms_by_period(0, day) self.assertEqual(len(count), 1) count = self.reader.count_alarms_by_period(0, day * 3) self.assertEqual(len(count), 3) count = self.reader.count_alarms_by_period(day, day * 10) self.assertEqual(len(count), 9) count = self.reader.count_alarms_by_period( 0, day, subperiod={'hour': 1}, ) self.assertEqual(len(count), 24) # Are counts by period correct ? count = self.reader.count_alarms_by_period(0, day / 4) self.assertEqual(count[0]['count'], 0) count = self.reader.count_alarms_by_period(0, day) self.assertEqual(count[0]['count'], 1) count = self.reader.count_alarms_by_period(day / 2, 3 * day / 2) self.assertEqual(count[0]['count'], 2) # Does limit limits count ? count = self.reader.count_alarms_by_period(0, day, limit=100) self.assertEqual(count[0]['count'], 1) count = self.reader.count_alarms_by_period(day / 2, 3 * day / 2, limit=1) self.assertEqual(count[0]['count'], 1) def test__get_disable_entity(self): event = { 'connector': '03-K64_Firefly', 'connector_name': 'serenity', 'component': 'Malcolm_Reynolds', 'output': 'the big red recall button', 'timestamp': int(time.time()) - 100, "source_type": "component" } alarm_id = '/strawberry' alarm = self.manager.make_alarm(alarm_id, event) context_manager = ContextGraph(logger=LoggerMock()) ent_id = context_manager.get_id(event) entity = context_manager.create_entity_dict(ent_id, "inara", "component") entity["enabled"] = False context_manager._put_entities(entity) alarms = self.reader.get(opened=True) print(alarms) self.assertEqual(len(alarms["alarms"]), 0)
class TestReader(BaseTest): def setUp(self): super(TestReader, self).setUp() self.pb_storage = Middleware.get_middleware_by_uri( PBehaviorManager.PB_STORAGE_URI ) self.logger = Logger.get('alertsreader', '/tmp/null') conf = Configuration.load(PBehaviorManager.CONF_PATH, Ini) self.pbehavior_manager = PBehaviorManager(config=conf, logger=self.logger, pb_storage=self.pb_storage) self.reader = AlertsReader(config=conf, logger=self.logger, storage=self.manager.alerts_storage, pbehavior_manager=self.pbehavior_manager) self.reader._alarm_fields = { 'properties': { 'connector': {'stored_name': 'v.ctr'}, 'component': {'stored_name': 'v.cpt'}, 'entity_id': {'stored_name': 'd'} } } def tearDown(self): """Teardown""" super(TestReader, self).setUp() self.pb_storage.remove_elements() def test__translate_key(self): cases = [ { 'key': 'untranslated_key', 'tkey': 'untranslated_key' }, { 'key': 'connector', 'tkey': 'v.ctr' }, { 'key': 'entity_id', 'tkey': 'd' } ] for case in cases: tkey = self.reader._translate_key(case['key']) self.assertEqual(tkey, case['tkey']) def test__translate_filter(self): cases = [ { 'filter': {}, 'tfilter': {} }, { 'filter': {'connector': 'c'}, 'tfilter': {'v.ctr': 'c'} }, { 'filter': {'$or': [{'connector': 'c1'}, {'component': 'c2'}]}, 'tfilter': {'$or': [{'v.ctr': 'c1'}, {'v.cpt': 'c2'}]} }, { 'filter': { '$or': [ {'entity_id': {'$gte': 12}, 'untranslated': 'val'}, {'connector': 'c1'}, {'$or': [{'component': 'c2'}, {'untranslated': 'val'}]} ] }, 'tfilter': { '$or': [ {'d': {'$gte': 12}, 'untranslated': 'val'}, {'v.ctr': 'c1'}, {'$or': [{'v.cpt': 'c2'}, {'untranslated': 'val'}]} ] } } ] for case in cases: tfilter = self.reader._translate_filter(case['filter']) self.assertEqual(tfilter, case['tfilter']) def test__get_time_filter(self): # opened=False, resolved=False self.assertIs( self.reader._get_time_filter( opened=False, resolved=False, tstart=0, tstop=0), None ) # opened=True, resolved=False expected_opened = {'v.resolved': None, 't': {'$lte': 2, "$gte": 1}} self.assertEqual( self.reader._get_time_filter( opened=True, resolved=False, tstart=1, tstop=2), expected_opened ) # opened=False, resolved=True expected_resolved = { 'v.resolved': {'$ne': None}, 't': {'$gte': 1, '$lte': 2} } self.assertEqual( self.reader._get_time_filter( opened=False, resolved=True, tstart=1, tstop=2), expected_resolved ) # opened=True, resolved=True expected_both = {'$or': [expected_opened, expected_resolved]} self.assertEqual( self.reader._get_time_filter( opened=True, resolved=True, tstart=1, tstop=2), expected_both ) # opened=True, resolved=True, tstart=tstop=None self.assertEqual( self.reader._get_time_filter( opened=True, resolved=True, tstart=None, tstop=None ), {} ) def test__get_opened_time_filter(self): cases = [ { 'tstart': None, 'tstop': None, 'expected': {'v.resolved': None} }, { 'tstart': None, 'tstop': 0, 'expected': {'v.resolved': None, 't': {'$lte': 0}} }, { 'tstart': None, 'tstop': 42, 'expected': {'v.resolved': None, 't': {'$lte': 42}} }, { 'tstart': 13, 'tstop': None, 'expected': {'v.resolved': None, 't': {'$lte': 13}} }, { 'tstart': 13, 'tstop': 42, 'expected': {'v.resolved': None, 't': {'$lte': 42, "$gte": 13}} } ] for case in cases: time_filter = self.reader._get_opened_time_filter( case['tstart'], case['tstop'] ) self.assertEqual(time_filter, case['expected']) def test__get_resolved_time_filter(self): cases = [ { 'tstart': None, 'tstop': None, 'expected': {'v.resolved': {'$ne': None}} }, { 'tstart': 13, 'tstop': None, 'expected': { 'v.resolved': {'$ne': None, '$gte': 13} } }, { 'tstart': None, 'tstop': 42, 'expected': { 'v.resolved': {'$ne': None}, 't': {'$lte': 42} } }, { 'tstart': 0, 'tstop': 0, 'expected': { 'v.resolved': {'$ne': None}, 't': {'$gte': 0, '$lte': 0} } }, { 'tstart': 1, 'tstop': 2, 'expected': { 'v.resolved': {'$ne': None}, 't': {'$gte': 1, '$lte': 2} } } ] for case in cases: time_filter = self.reader._get_resolved_time_filter( case['tstart'], case['tstop'] ) self.assertEqual(time_filter, case['expected']) def test__translate_sort(self): cases = [ { 'sort_key': 'untranslated', 'sort_dir': 'DESC', 'tkey': 'untranslated', 'tdir': -1 }, { 'sort_key': 'untranslated', 'sort_dir': 'ASC', 'tkey': 'untranslated', 'tdir': 1 }, { 'sort_key': 'component', 'sort_dir': 'DESC', 'tkey': 'v.cpt', 'tdir': -1 } ] for case in cases: tkey, tdir = self.reader._translate_sort( case['sort_key'], case['sort_dir'] ) self.assertEqual(tkey, case['tkey']) self.assertEqual(tdir, case['tdir']) def test__get_final_filter_bnf(self): view_filter = {'$and': [{'resource': 'companion cube'}]} time_filter = {'glados': 'shell'} bnf_search = 'NOT resource="turret"' active_columns = ['resource', 'component'] filter_ = self.reader._get_final_filter( view_filter, time_filter, bnf_search, active_columns ) ref_filter = { '$and': [ view_filter, time_filter, {'resource': {'$not': {'$eq': 'turret'}}} ] } self.assertEqual(ref_filter, filter_) def test__get_final_filter_natural(self): view_filter = {'$and': [{'resource': 'companion cube'}]} time_filter = {'glados': 'shell'} search = 'turret' active_columns = ['resource', 'component'] filter_ = self.reader._get_final_filter( view_filter, time_filter, search, active_columns ) self.maxDiff = None ref_filter = { '$and': [ view_filter, time_filter, { '$or': [ {'resource': { '$regex': '.*turret.*', '$options': 'i'}}, {'component': { '$regex': '.*turret.*', '$options': 'i'}}, {'d': { '$regex': '.*turret.*', '$options': 'i'}} ] } ] } self.assertEqual(ref_filter, filter_) def test__get_final_filter_natural_numonly(self): view_filter = {} time_filter = {} search = 11111 active_columns = ['resource'] filter_ = self.reader._get_final_filter( view_filter, time_filter, search, active_columns ) self.maxDiff = None res_filter = { '$and': [ {'$or': [ {'resource': {'$options': 'i', '$regex': '.*11111.*'}}, {'d': {'$options': 'i', '$regex': '.*11111.*'}} ]} ] } self.assertEqual(res_filter, filter_) def test_count_alarms_by_period(self): day = 24 * 3600 alarm0_id = '/fake/alarm/id0' event0 = { 'connector': 'ut', 'connector_name': 'ut0', 'component': 'c', 'output': '...', 'timestamp': day / 2 } alarm0 = self.manager.make_alarm( alarm0_id, event0 ) alarm0 = self.manager.update_state(alarm0, 1, event0) new_value0 = alarm0[self.manager.alerts_storage.VALUE] self.manager.update_current_alarm(alarm0, new_value0) alarm1_id = '/fake/alarm/id1' event1 = { 'connector': 'ut', 'connector_name': 'ut0', 'component': 'c', 'output': '...', 'timestamp': 3 * day / 2 } alarm1 = self.manager.make_alarm( alarm1_id, event1 ) alarm1 = self.manager.update_state(alarm1, 1, event1) new_value1 = alarm1[self.manager.alerts_storage.VALUE] self.manager.update_current_alarm(alarm1, new_value1) # Are subperiods well cut ? count = self.reader.count_alarms_by_period(0, day) self.assertEqual(len(count), 1) count = self.reader.count_alarms_by_period(0, day * 3) self.assertEqual(len(count), 3) count = self.reader.count_alarms_by_period(day, day * 10) self.assertEqual(len(count), 9) count = self.reader.count_alarms_by_period( 0, day, subperiod={'hour': 1}, ) self.assertEqual(len(count), 24) # Are counts by period correct ? count = self.reader.count_alarms_by_period(0, day / 4) self.assertEqual(count[0]['count'], 0) count = self.reader.count_alarms_by_period(0, day) self.assertEqual(count[0]['count'], 1) count = self.reader.count_alarms_by_period(day / 2, 3 * day / 2) self.assertEqual(count[0]['count'], 2) # Does limit limits count ? count = self.reader.count_alarms_by_period(0, day, limit=100) self.assertEqual(count[0]['count'], 1) count = self.reader.count_alarms_by_period(day / 2, 3 * day / 2, limit=1) self.assertEqual(count[0]['count'], 1) def test__get_disable_entity(self): event = { 'connector': '03-K64_Firefly', 'connector_name': 'serenity', 'component': 'Malcolm_Reynolds', 'output': 'the big red recall button', 'timestamp': int(time.time()) - 100, "source_type": "component" } alarm_id = '/strawberry' alarm = self.manager.make_alarm( alarm_id, event ) context_manager = ContextGraph(logger=LoggerMock()) ent_id = context_manager.get_id(event) entity = context_manager.create_entity_dict(ent_id, "inara", "component") entity["enabled"] = False context_manager._put_entities(entity) alarms = self.reader.get(opened=True) print(alarms) self.assertEqual(len(alarms["alarms"]), 0)