def setUp(self):
config = configparser.RawConfigParser()
config.read(os.path.join(root_path, DEFAULT_CONF_FILE))
self.conf = {
MongoStore.CONF_CAT: {
"host": config["DATABASE"]["host"],
"port": config["DATABASE"]["port"],
'db': config["DATABASE"]["db"],
'user': config["DATABASE"]["user"],
'pwd': config["DATABASE"]["pwd"]
}
}
self.client = MongoStore(config=self.conf)
self.collection = self.client.get_collection('any_collection')
self.ed = EtherealData(collection=self.collection,
filter_={},
timeout=2)
class TestEtherealData(unittest.TestCase):
def setUp(self):
config = configparser.RawConfigParser()
config.read(os.path.join(root_path, DEFAULT_CONF_FILE))
self.conf = {
MongoStore.CONF_CAT: {
"host": config["DATABASE"]["host"],
"port": config["DATABASE"]["port"],
'db': config["DATABASE"]["db"],
'user': config["DATABASE"]["user"],
'pwd': config["DATABASE"]["pwd"]
}
}
self.client = MongoStore(config=self.conf)
self.collection = self.client.get_collection('any_collection')
self.ed = EtherealData(collection=self.collection,
filter_={},
timeout=2)
def tearDown(self):
"""Teardown"""
self.collection.drop()
def test_get_set(self):
self.assertIsNone(self.ed.get('mario'))
self.ed.set('mario', 'bros')
self.assertEqual(self.ed.get('mario'), 'bros')
def test_cache(self):
self.ed.set('sonic', 'hedgehog')
self.assertEqual(self.ed.get('sonic'), 'hedgehog')
self.collection.update({}, {'sonic': 'tails'})
self.assertEqual(self.ed.get('sonic'), 'hedgehog')
sleep(3)
self.assertEqual(self.ed.get('sonic'), 'tails')
class TestEtherealData(unittest.TestCase):
def setUp(self):
config = configparser.RawConfigParser()
config.read(os.path.join(root_path, DEFAULT_CONF_FILE))
self.conf = {
MongoStore.CONF_CAT: {
"host": config["DATABASE"]["host"],
"port": config["DATABASE"]["port"],
'db': config["DATABASE"]["db"],
'user': config["DATABASE"]["user"],
'pwd': config["DATABASE"]["pwd"]
}
}
self.client = MongoStore(config=self.conf)
self.collection = self.client.get_collection('any_collection')
self.ed = EtherealData(collection=self.collection,
filter_={},
timeout=2)
def tearDown(self):
"""Teardown"""
self.collection.drop()
def test_get_set(self):
self.assertIsNone(self.ed.get('mario'))
self.ed.set('mario', 'bros')
self.assertEqual(self.ed.get('mario'), 'bros')
def test_cache(self):
self.ed.set('sonic', 'hedgehog')
self.assertEqual(self.ed.get('sonic'), 'hedgehog')
self.collection.update({}, {'sonic': 'tails'})
self.assertEqual(self.ed.get('sonic'), 'hedgehog')
sleep(3)
self.assertEqual(self.ed.get('sonic'), 'tails')
def setUp(self):
config = configparser.RawConfigParser()
config.read(os.path.join(root_path, DEFAULT_CONF_FILE))
self.conf = {
MongoStore.CONF_CAT: {
"host": config["DATABASE"]["host"],
"port": config["DATABASE"]["port"],
'db': config["DATABASE"]["db"],
'user': config["DATABASE"]["user"],
'pwd': config["DATABASE"]["pwd"]
}
}
self.client = MongoStore(config=self.conf)
self.collection = self.client.get_collection('any_collection')
self.ed = EtherealData(collection=self.collection,
filter_={},
timeout=2)
def setUp(self):
self.logger = logging.getLogger('alerts')
self.alerts_storage = Middleware.get_middleware_by_uri(
'storage-periodical-testalarm://')
self.config_storage = Middleware.get_middleware_by_uri(
'storage-default-testconfig://')
self.config_storage.put_element(element={
'_id': 'test_config',
'crecord_type': 'statusmanagement',
'bagot_time': 3600,
'bagot_freq': 10,
'stealthy_time': 300,
'restore_event': True,
'auto_snooze': False,
'snooze_default_time': 300,
},
_id='test_config')
self.filter_storage = Middleware.get_middleware_by_uri(
'storage-default-testalarmfilter://')
self.context_graph_storage = Middleware.get_middleware_by_uri(
'storage-default-testentities://')
self.cg_manager = ContextGraph(self.logger)
self.cg_manager.ent_storage = self.context_graph_storage
self.watcher_manager = Watcher()
conf = Configuration.load(Alerts.CONF_PATH, Ini)
filter_ = {'crecord_type': 'statusmanagement'}
self.config_data = EtherealData(collection=MongoCollection(
self.config_storage._backend),
filter_=filter_)
self.event_publisher = Mock(spec=StatEventPublisher)
self.manager = Alerts(config=conf,
logger=self.logger,
alerts_storage=self.alerts_storage,
config_data=self.config_data,
filter_storage=self.filter_storage,
context_graph=self.cg_manager,
watcher=self.watcher_manager,
event_publisher=self.event_publisher)
def provide_default_basics(cls):
"""
Provide logger, config, storages...
! Do not use in tests !
:rtype: Union[canopsis.confng.simpleconf.Configuration
logging.Logger,
canopsis.storage.core.Storage,
canopsis.common.ethereal_data.EtherealData,
canopsis.storage.core.Storage,
canopsis.context_graph.manager.ContextGraph,
canopsis.watcher.manager.Watcher]
"""
config = Configuration.load(Alerts.CONF_PATH, Ini)
conf_store = Configuration.load(MongoStore.CONF_PATH, Ini)
mongo = MongoStore(config=conf_store)
config_collection = MongoCollection(
mongo.get_collection(name=cls.CONFIG_COLLECTION))
filter_ = {'crecord_type': 'statusmanagement'}
config_data = EtherealData(collection=config_collection,
filter_=filter_)
logger = Logger.get('alerts', cls.LOG_PATH)
alerts_storage = Middleware.get_middleware_by_uri(
cls.ALERTS_STORAGE_URI
)
filter_storage = Middleware.get_middleware_by_uri(
cls.FILTER_STORAGE_URI
)
context_manager = ContextGraph(logger)
watcher_manager = Watcher()
pbehavior_manager = PBehaviorManager(*PBehaviorManager.provide_default_basics())
amqp_pub = AmqpPublisher(get_default_amqp_conn(), logger)
event_publisher = StatEventPublisher(logger, amqp_pub)
return (config, logger, alerts_storage, config_data,
filter_storage, context_manager, watcher_manager,
event_publisher, pbehavior_manager)
def setUp(self):
super(ComputeState, self).setUp()
pbehavior_storage = Middleware.get_middleware_by_uri(
'storage-default-testpbehavior://')
filter_storage = Middleware.get_middleware_by_uri(
'storage-default-testalarmfilter://')
config_storage = Middleware.get_middleware_by_uri(
'storage-default-testconfig://')
config_storage.put_element(element={
'_id': 'test_config',
'crecord_type': 'statusmanagement',
'bagot_time': 3600,
'bagot_freq': 10,
'stealthy_time': 300,
'restore_event': True,
'auto_snooze': False,
'snooze_default_time': 300,
},
_id='test_config')
logger = Logger.get('test_pb', None, output_cls=OutputNull)
config = Configuration.load(PBehaviorManager.CONF_PATH, Ini)
self.pbm = PBehaviorManager(config=config,
logger=logger,
pb_storage=pbehavior_storage)
self.pbm.context = self.context_graph_manager
self.manager.pbehavior_manager = self.pbm
conf = Configuration.load(Alerts.CONF_PATH, Ini)
filter_ = {'crecord_type': 'statusmanagement'}
config_data = EtherealData(collection=config_storage._backend,
filter_=filter_)
event_publisher = Mock(spec=StatEventPublisher)
self.alert_manager = Alerts(config=conf,
logger=logger,
alerts_storage=self.alerts_storage,
config_data=config_data,
filter_storage=filter_storage,
context_graph=self.context_graph_manager,
watcher=self.manager,
event_publisher=event_publisher)
# Creating entity
self.type_ = 'resource'
self.name = 'morticia'
entity = ContextGraph.create_entity_dict(id=self.name,
etype=self.type_,
name=self.name)
self.context_graph_manager.create_entity(entity)
# Creating coresponding alarm
event = {
'connector': self.type_,
'connector_name': 'connector_name',
'component': self.name,
'output': 'tadaTaDA tic tic',
'timestamp': 0
}
alarm = self.alert_manager.make_alarm(self.name, event)
self.state = 2
alarm = self.alert_manager.update_state(alarm, self.state, event)
new_value = alarm[self.alert_manager.alerts_storage.VALUE]
self.alert_manager.update_current_alarm(alarm, new_value)