X-Git-Url: https://osm.etsi.org/gitweb/?a=blobdiff_plain;f=osm_mon%2Ftest%2FVMware%2Ftest_plugin_receiver.py;h=1d63bd97fd3ad954ee78700f0ad8e86886c2a914;hb=58834ab6fcbcc4039c479de89ecc82f0eb2fd2f3;hp=b32c7f6dbf04c6fbeb1db5342f958c0926b64864;hpb=b726161f9fe605ceb418d9b5df12d295bff28c3a;p=osm%2FMON.git diff --git a/osm_mon/test/VMware/test_plugin_receiver.py b/osm_mon/test/VMware/test_plugin_receiver.py index b32c7f6..1d63bd9 100644 --- a/osm_mon/test/VMware/test_plugin_receiver.py +++ b/osm_mon/test/VMware/test_plugin_receiver.py @@ -43,6 +43,7 @@ log = logging.getLogger(__name__) sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)),"..","..","..")) from osm_mon.plugins.vRealiseOps import plugin_receiver as monPluginRec +from osm_mon.core.database import VimCredentials class Message(object): @@ -64,42 +65,45 @@ class TestPluginReceiver(unittest.TestCase): """Setup the tests for plugin_receiver class methods""" super(TestPluginReceiver, self).setUp() self.plugin_receiver = monPluginRec.PluginReceiver() - #self.mon_plugin = monPlugin.MonPlugin() @mock.patch.object(monPluginRec.PluginReceiver, 'publish_create_alarm_status') @mock.patch.object(monPluginRec.PluginReceiver, 'create_alarm') - def test_consume_create_alarm_request_key(self, m_create_alarm, m_publish_create_alarm_status): + def test_consume_create_alarm_request_key(self, m_create_alarm,\ + m_publish_create_alarm_status): """Test functionality of consume for create_alarm_request key""" + vim_uuid = "f85fc39e-723d-4172-979b-de28b36465bb" # Mock a message msg = Message() msg.topic = "alarm_request" msg.key = "create_alarm_request" - msg.value = json.dumps({"alarm_create_request":"alarm_details"}) + msg.value = json.dumps({"vim_uuid":vim_uuid,"alarm_create_request":"alarm_details"}) m_create_alarm.return_value = "test_alarm_id" config_alarm_info = json.loads(msg.value) # Call the consume method of plugin_receiver - self.plugin_receiver.consume(msg) + self.plugin_receiver.consume(msg,vim_uuid) # verify if create_alarm and publish methods called with correct params - m_create_alarm.assert_called_with("alarm_details") + m_create_alarm.assert_called_with(config_alarm_info) m_publish_create_alarm_status.assert_called_with("test_alarm_id", config_alarm_info) @mock.patch.object(monPluginRec.PluginReceiver, 'publish_update_alarm_status') @mock.patch.object(monPluginRec.PluginReceiver, 'update_alarm') - def test_consume_update_alarm_request_key(self, m_update_alarm, m_publish_update_alarm_status): + def test_consume_update_alarm_request_key(self, m_update_alarm,\ + m_publish_update_alarm_status): """Test functionality of consume for update_alarm_request key""" + vim_uuid = "f85fc39e-723d-4172-979b-de28b36465bb" # Mock a message msg = Message() msg.topic = "alarm_request" msg.key = "update_alarm_request" - msg.value = json.dumps({"alarm_update_request":"alarm_details"}) + msg.value = json.dumps({"vim_uuid":vim_uuid,"alarm_update_request":"alarm_details"}) # set return value to mocked method m_update_alarm.return_value = "test_alarm_id" @@ -107,31 +111,33 @@ class TestPluginReceiver(unittest.TestCase): update_alarm_info = json.loads(msg.value) # Call the consume method of plugin_receiver - self.plugin_receiver.consume(msg) + self.plugin_receiver.consume(msg,vim_uuid) # verify update_alarm and publish method called with correct params - m_update_alarm.assert_called_with("alarm_details") + m_update_alarm.assert_called_with(update_alarm_info) m_publish_update_alarm_status.assert_called_with("test_alarm_id", update_alarm_info) @mock.patch.object(monPluginRec.PluginReceiver, 'publish_delete_alarm_status') @mock.patch.object(monPluginRec.PluginReceiver, 'delete_alarm') - def test_consume_delete_alarm_request_key(self, m_delete_alarm, m_publish_delete_alarm_status): + def test_consume_delete_alarm_request_key(self, m_delete_alarm,\ + m_publish_delete_alarm_status): """Test functionality of consume for delete_alarm_request key""" + vim_uuid = "f85fc39e-723d-4172-979b-de28b36465bb" # Mock a message msg = Message() msg.topic = "alarm_request" msg.key = "delete_alarm_request" - msg.value = json.dumps({"alarm_delete_request":"alarm_details"}) + msg.value = json.dumps({"vim_uuid":vim_uuid,"alarm_delete_request":"alarm_details"}) m_delete_alarm.return_value = "test_alarm_id" delete_alarm_info = json.loads(msg.value) # Call the consume method of plugin_receiver and check delete_alarm request - self.plugin_receiver.consume(msg) - m_delete_alarm.assert_called_with("alarm_details") + self.plugin_receiver.consume(msg,vim_uuid) + m_delete_alarm.assert_called_with(delete_alarm_info) # Check if publish method called with correct parameters m_publish_delete_alarm_status.assert_called_with("test_alarm_id", delete_alarm_info) @@ -139,23 +145,25 @@ class TestPluginReceiver(unittest.TestCase): @mock.patch.object(monPluginRec.PluginReceiver, 'publish_list_alarm_response') @mock.patch.object(monPluginRec.PluginReceiver, 'list_alarms') - def test_consume_list_alarm_request_key(self, m_list_alarms, m_publish_list_alarm_response): + def test_consume_list_alarm_request_key(self, m_list_alarms,\ + m_publish_list_alarm_response): """ Test functionality of list alarm request key""" + vim_uuid = "f85fc39e-723d-4172-979b-de28b36465bb" # Mock a message msg = Message() msg.topic = "alarm_request" msg.key = "list_alarm_request" test_alarm_list = [{"alarm_uuid":"alarm1_details"},{"alarm_uuid":"alarm2_details"}] - msg.value = json.dumps({"alarm_list_request":"alarm_details"}) + msg.value = json.dumps({"vim_uuid":vim_uuid,"alarm_list_request":"alarm_details"}) m_list_alarms.return_value = test_alarm_list list_alarms_info = json.loads(msg.value) # Call the consume method of plugin_receiver and check delete_alarm request - self.plugin_receiver.consume(msg) - m_list_alarms.assert_called_with("alarm_details") + self.plugin_receiver.consume(msg,vim_uuid) + m_list_alarms.assert_called_with(list_alarms_info) # Check if publish method called with correct parameters m_publish_list_alarm_response.assert_called_with(test_alarm_list, list_alarms_info) @@ -163,22 +171,24 @@ class TestPluginReceiver(unittest.TestCase): @mock.patch.object(monPluginRec.PluginReceiver, 'publish_access_update_response') @mock.patch.object(monPluginRec.PluginReceiver, 'update_access_credentials') - def test_consume_vim_access_request_key(self, m_update_access_credentials, m_publish_access_update_response): + def test_consume_vim_access_request_key(self, m_update_access_credentials,\ + m_publish_access_update_response): """Test functionality of consume for vim_access_credentials request key""" + vim_uuid = "f85fc39e-723d-4172-979b-de28b36465bb" # Mock a message msg = Message() msg.topic = "access_credentials" msg.key = "vim_access_credentials" - msg.value = json.dumps({"access_config":"access_details"}) + msg.value = json.dumps({"vim_uuid":vim_uuid,"access_config":"access_details"}) # set return value to mocked method m_update_access_credentials.return_value = True access_info = json.loads(msg.value) # Call the consume method of plugin_receiver - self.plugin_receiver.consume(msg) + self.plugin_receiver.consume(msg,vim_uuid) # check if mocked method called with required parameters m_update_access_credentials.assert_called_with("access_details") @@ -189,16 +199,18 @@ class TestPluginReceiver(unittest.TestCase): @mock.patch.object(monPluginRec.PluginReceiver, 'publish_create_alarm_status') @mock.patch.object(monPluginRec.PluginReceiver, 'create_alarm') - def test_consume_invalid_alarm_request_key(self, m_create_alarm, m_publish_create_alarm_status): + def test_consume_invalid_alarm_request_key(self, m_create_alarm,\ + m_publish_create_alarm_status): """Test functionality of consume for vim_access_credentials invalid request key""" + vim_uuid = "f85fc39e-723d-4172-979b-de28b36465bb" # Mock a message with invalid alarm request key msg = Message() msg.topic = "alarm_request" msg.key = "invalid_alarm_request" # invalid key # Call the consume method of plugin_receiver - self.plugin_receiver.consume(msg) + self.plugin_receiver.consume(msg,vim_uuid) # verify that create_alarm and publish_create_alarm_status methods not called m_create_alarm.assert_not_called() @@ -207,16 +219,18 @@ class TestPluginReceiver(unittest.TestCase): @mock.patch.object(monPluginRec.PluginReceiver, 'publish_metrics_data_status') @mock.patch.object(monPluginRec.MonPlugin, 'get_metrics_data') - def test_consume_invalid_metric_request_key(self, m_get_metrics_data, m_publish_metric_data_status): + def test_consume_invalid_metric_request_key(self, m_get_metrics_data,\ + m_publish_metric_data_status): """Test functionality of invalid metric key request""" + vim_uuid = "f85fc39e-723d-4172-979b-de28b36465bb" # Mock a message with invalid metric request key msg = Message() msg.topic = "metric_request" msg.key = "invalid_metric_data_request" #invalid key # Call the consume method of plugin_receiver - self.plugin_receiver.consume(msg) + self.plugin_receiver.consume(msg,vim_uuid) # verify that get martics data and publish methods not called m_get_metrics_data.assert_not_called() @@ -225,21 +239,34 @@ class TestPluginReceiver(unittest.TestCase): @mock.patch.object(monPluginRec.PluginReceiver, 'publish_metrics_data_status') @mock.patch.object(monPluginRec.MonPlugin, 'get_metrics_data') - def test_consume_read_metric_data_request_key(self, m_get_metrics_data, m_publish_metric_data_status): + @mock.patch.object(monPluginRec.PluginReceiver,'get_vim_access_config') + def test_consume_read_metric_data_request_key(self, m_get_vim_access_config,\ + m_get_metrics_data,\ + m_publish_metric_data_status): """Test functionality of consume for read_metric_data_request key""" + vim_uuid = "f85fc39e-723d-4172-979b-de28b36465bb" # Mock a message msg = Message() msg.topic = "metric_request" msg.key = "read_metric_data_request" - msg.value = json.dumps({"metric_name":"metric_details"}) + msg.value = json.dumps({"vim_uuid":vim_uuid,"metric_name":"metric_details"}) m_get_metrics_data.return_value = {"metrics_data":"metrics_details"} + m_get_vim_access_config.return_value = {'vrops_site':'abc', + 'vrops_user':'user', + 'vrops_password':'passwd', + 'vim_url':'vcd_url', + 'admin_username':'admin', + 'admin_password':'admin_passwd', + 'vim_uuid':'1', + 'tenant_id':'org_vdc_1'} + metric_request_info = json.loads(msg.value) # Call the consume method of plugin_receiver - self.plugin_receiver.consume(msg) + self.plugin_receiver.consume(msg,vim_uuid) m_get_metrics_data.assert_called_with(metric_request_info) # Check if publish method called with correct parameters @@ -248,15 +275,17 @@ class TestPluginReceiver(unittest.TestCase): @mock.patch.object(monPluginRec.PluginReceiver, 'publish_create_metric_response') @mock.patch.object(monPluginRec.PluginReceiver, 'verify_metric') - def test_consume_create_metric_request_key(self, m_verify_metric, m_publish_create_metric_response): + def test_consume_create_metric_request_key(self, m_verify_metric,\ + m_publish_create_metric_response): """Test functionality of consume for create_metric_request key""" + vim_uuid = "f85fc39e-723d-4172-979b-de28b36465bb" # Mock a message msg = Message() msg.topic = "metric_request" msg.key = "create_metric_request" - msg.value = json.dumps({"metric_create_request":"metric_details"}) + msg.value = json.dumps({"vim_uuid":vim_uuid,"metric_create":"metric_details"}) # set the return value m_verify_metric.return_value = True @@ -264,8 +293,8 @@ class TestPluginReceiver(unittest.TestCase): metric_info = json.loads(msg.value) # Call the consume method of plugin_receiver - self.plugin_receiver.consume(msg) - m_verify_metric.assert_called_with("metric_details") + self.plugin_receiver.consume(msg,vim_uuid) + m_verify_metric.assert_called_with(metric_info) # Check if publish method called with correct parameters m_publish_create_metric_response.assert_called_with(metric_info, True) @@ -273,15 +302,17 @@ class TestPluginReceiver(unittest.TestCase): @mock.patch.object(monPluginRec.PluginReceiver, 'publish_update_metric_response') @mock.patch.object(monPluginRec.PluginReceiver, 'verify_metric') - def test_consume_update_metric_request_key(self, m_verify_metric, m_publish_update_metric_response): + def test_consume_update_metric_request_key(self, m_verify_metric,\ + m_publish_update_metric_response): """Test functionality of update metric request key""" + vim_uuid = "f85fc39e-723d-4172-979b-de28b36465bb" # Mock a message msg = Message() msg.topic = "metric_request" msg.key = "update_metric_request" - msg.value = json.dumps({"metric_create_request":"metric_details"}) + msg.value = json.dumps({"vim_uuid":vim_uuid,"metric_create":"metric_details"}) # set the return value m_verify_metric.return_value = True @@ -289,10 +320,10 @@ class TestPluginReceiver(unittest.TestCase): metric_info = json.loads(msg.value) # Call the consume method of plugin_receiver - self.plugin_receiver.consume(msg) + self.plugin_receiver.consume(msg,vim_uuid) # verify mocked methods called with correct parameters - m_verify_metric.assert_called_with("metric_details") + m_verify_metric.assert_called_with(metric_info) m_publish_update_metric_response.assert_called_with(metric_info, True) @@ -301,17 +332,18 @@ class TestPluginReceiver(unittest.TestCase): """Test functionality of consume for delete_metric_request key""" # Note: vROPS doesn't support deleting metric data + vim_uuid = "f85fc39e-723d-4172-979b-de28b36465bb" # Mock a message msg = Message() msg.topic = "metric_request" msg.key = "delete_metric_request" - msg.value = json.dumps({"metric_name":"metric_details"}) + msg.value = json.dumps({"vim_uuid":vim_uuid,"metric_name":"metric_details"}) metric_info = json.loads(msg.value) # Call the consume method of plugin_receiver - self.plugin_receiver.consume(msg) + self.plugin_receiver.consume(msg,vim_uuid) # Check if publish method called with correct parameters m_publish_delete_metric_response.assert_called_with(metric_info) @@ -319,11 +351,18 @@ class TestPluginReceiver(unittest.TestCase): @mock.patch.object(monPluginRec.MonPlugin, 'configure_alarm') @mock.patch.object(monPluginRec.MonPlugin, 'configure_rest_plugin') - def test_create_alarm_successful(self, m_configure_rest_plugin, m_configure_alarm): + @mock.patch.object(monPluginRec.PluginReceiver, 'get_vim_access_config') + def test_create_alarm_successful(self, m_get_vim_access_config,\ + m_configure_rest_plugin,\ + m_configure_alarm): """ Test functionality of create alarm method-positive case""" # Mock config_alarm_info - config_alarm_info = {"correlation_id": 1, + config_alarm_info = {"schema_version":1.0, + "schema_type":"create_alarm_request", + "vim_type":"VMware", + "vim_uuid":"1", + "alarm_create_request":{"correlation_id": 1, "alarm_name": "CPU_Utilize_Threshold", "metric_name": "CPU_UTILIZATION", "tenant_uuid": "tenant_uuid", @@ -333,9 +372,18 @@ class TestPluginReceiver(unittest.TestCase): "operation": "GT", "threshold_value": 10, "unit": "%", - "statistic": "AVERAGE"} + "statistic": "AVERAGE"}} # set return value to plugin uuid + m_get_vim_access_config.return_value = {'vrops_site':'abc', + 'vrops_user':'user', + 'vrops_password':'passwd', + 'vim_url':'vcd_url', + 'admin_username':'admin', + 'admin_password':'admin_passwd', + 'vim_uuid':'1', + 'tenant_id':'org_vdc_1'} + m_configure_rest_plugin.retrun_value = "plugin_uuid" m_configure_alarm.return_value = "alarm_uuid" @@ -343,17 +391,25 @@ class TestPluginReceiver(unittest.TestCase): self.plugin_receiver.create_alarm(config_alarm_info) # verify mocked methods get called with correct params + m_get_vim_access_config.assert_called_with(config_alarm_info['vim_uuid']) m_configure_rest_plugin.assert_called_with() - m_configure_alarm.assert_called_with(config_alarm_info) + m_configure_alarm.assert_called_with(config_alarm_info["alarm_create_request"]) @mock.patch.object(monPluginRec.MonPlugin, 'configure_alarm') @mock.patch.object(monPluginRec.MonPlugin, 'configure_rest_plugin') - def test_create_alarm_failed(self, m_configure_rest_plugin, m_configure_alarm): + @mock.patch.object(monPluginRec.PluginReceiver, 'get_vim_access_config') + def test_create_alarm_failed(self, m_get_vim_access_config,\ + m_configure_rest_plugin,\ + m_configure_alarm): """ Test functionality of create alarm method negative case""" # Mock config_alarm_info - config_alarm_info = {"correlation_id": 1, + config_alarm_info = {"schema_version":1.0, + "schema_type":"create_alarm_request", + "vim_type":"VMware", + "vim_uuid":"1", + "alarm_create_request":{"correlation_id": 1, "alarm_name": "CPU_Utilize_Threshold", "metric_name": "CPU_UTILIZATION", "tenant_uuid": "tenant_uuid", @@ -363,9 +419,17 @@ class TestPluginReceiver(unittest.TestCase): "operation": "GT", "threshold_value": 10, "unit": "%", - "statistic": "AVERAGE"} + "statistic": "AVERAGE"}} # set return value to plugin uuid and alarm_uuid to None + m_get_vim_access_config.return_value = {'vrops_site':'abc', + 'vrops_user':'user', + 'vrops_password':'passwd', + 'vim_url':'vcd_url', + 'admin_username':'admin', + 'admin_password':'admin_passwd', + 'vim_uuid':'1', + 'tenant_id':'org_vdc_1'} m_configure_rest_plugin.retrun_value = "plugin_uuid" m_configure_alarm.return_value = None @@ -373,88 +437,137 @@ class TestPluginReceiver(unittest.TestCase): alarm_uuid = self.plugin_receiver.create_alarm(config_alarm_info) # verify mocked method called with correct params + m_get_vim_access_config.assert_called_with(config_alarm_info['vim_uuid']) m_configure_rest_plugin.assert_called_with() - m_configure_alarm.assert_called_with(config_alarm_info) + m_configure_alarm.assert_called_with(config_alarm_info["alarm_create_request"]) # verify create alarm method returns None when failed self.assertEqual(alarm_uuid, None) @mock.patch.object(monPluginRec.MonPlugin, 'update_alarm_configuration') - def test_update_alarm_successful(self, m_update_alarm_configuration): + @mock.patch.object(monPluginRec.PluginReceiver, 'get_vim_access_config') + def test_update_alarm_successful(self, m_get_vim_access_config, m_update_alarm_configuration): """ Test functionality of update alarm method-positive case""" # Mock update_alarm_info - update_alarm_info = {'alarm_uuid': 'abc', 'correlation_id': 14203} + update_alarm_info = {"schema_version":1.0,"schema_type":"update_alarm_request", + "vim_type":"VMware","vim_uuid":"1", + "alarm_update_request":{'alarm_uuid': 'abc', 'correlation_id': 14203}} # set return value to mocked method m_update_alarm_configuration.return_value = "alarm_uuid" + m_get_vim_access_config.return_value = {'vrops_site':'abc', + 'vrops_user':'user', + 'vrops_password':'passwd', + 'vim_url':'vcd_url', + 'admin_username':'admin', + 'admin_password':'admin_passwd', + 'vim_uuid':'1', + 'tenant_id':'org_vdc_1'} # check update alarm gets called and returned correct value ret_value = self.plugin_receiver.update_alarm(update_alarm_info) # check mocked method get called with correct param - m_update_alarm_configuration.assert_called_with(update_alarm_info) + m_get_vim_access_config.assert_called_with(update_alarm_info['vim_uuid']) + m_update_alarm_configuration.assert_called_with(update_alarm_info["alarm_update_request"]) # check return value and passed values are correct self.assertEqual(ret_value, "alarm_uuid") @mock.patch.object(monPluginRec.MonPlugin, 'update_alarm_configuration') - def test_update_alarm_failed(self, m_update_alarm_configuration): + @mock.patch.object(monPluginRec.PluginReceiver, 'get_vim_access_config') + def test_update_alarm_failed(self, m_get_vim_access_config, m_update_alarm_configuration): """ Test functionality of update alarm method negative case""" # Mock update_alarm_info - update_alarm_info = {'alarm_uuid': 'abc', 'correlation_id': 14203} + update_alarm_info = {"schema_version":1.0,"schema_type":"update_alarm_request", + "vim_type":"VMware","vim_uuid":"1", + "alarm_update_request":{'alarm_uuid': 'abc', 'correlation_id': 14203}} # set return value to mocked method m_update_alarm_configuration.return_value = None + m_get_vim_access_config.return_value = {'vrops_site':'abc', + 'vrops_user':'user', + 'vrops_password':'passwd', + 'vim_url':'vcd_url', + 'admin_username':'admin', + 'admin_password':'admin_passwd', + 'vim_uuid':'1', + 'tenant_id':'org_vdc_1'} # check update alarm gets called and returned correct value ret_value = self.plugin_receiver.update_alarm(update_alarm_info) # check mocked method get called with correct param - m_update_alarm_configuration.assert_called_with(update_alarm_info) + m_get_vim_access_config.assert_called_with(update_alarm_info['vim_uuid']) + m_update_alarm_configuration.assert_called_with(update_alarm_info["alarm_update_request"]) # check return value and passed values are correct self.assertEqual(ret_value, None) @mock.patch.object(monPluginRec.MonPlugin, 'delete_alarm_configuration') - def test_delete_alarm_successful(self, m_delete_alarm_configuration): + @mock.patch.object(monPluginRec.PluginReceiver, 'get_vim_access_config') + def test_delete_alarm_successful(self, m_get_vim_access_config, m_delete_alarm_configuration): """ Test functionality of delete alarm method-positive case""" # Mock delete_alarm_info - delete_alarm_info = {'alarm_uuid': 'abc', 'correlation_id': 14203} + delete_alarm_info = {"schema_version":1.0,"schema_type":"delete_alarm_request", + "vim_type":"VMware","vim_uuid":"1", + "alarm_delete_request":{'alarm_uuid': 'abc', 'correlation_id': 14203}} # set return value to mocked method m_delete_alarm_configuration.return_value = "alarm_uuid" + m_get_vim_access_config.return_value = {'vrops_site':'abc', + 'vrops_user':'user', + 'vrops_password':'passwd', + 'vim_url':'vcd_url', + 'admin_username':'admin', + 'admin_password':'admin_passwd', + 'vim_uuid':'1', + 'tenant_id':'org_vdc_1'} # check delete alarm gets called and returned correct value ret_value = self.plugin_receiver.delete_alarm(delete_alarm_info) # check mocked method get called with correct param - m_delete_alarm_configuration.assert_called_with(delete_alarm_info) + m_get_vim_access_config.assert_called_with(delete_alarm_info['vim_uuid']) + m_delete_alarm_configuration.assert_called_with(delete_alarm_info["alarm_delete_request"]) # check return value and passed values are correct self.assertEqual(ret_value, "alarm_uuid") @mock.patch.object(monPluginRec.MonPlugin, 'delete_alarm_configuration') - def test_delete_alarm_failed(self, m_delete_alarm_configuration): + @mock.patch.object(monPluginRec.PluginReceiver, 'get_vim_access_config') + def test_delete_alarm_failed(self, m_get_vim_access_config, m_delete_alarm_configuration): """ Test functionality of delete alarm method-negative case""" # Mock update_alarm_info - delete_alarm_info = {'alarm_uuid': 'abc', 'correlation_id': 14203} + delete_alarm_info = {"schema_version":1.0,"schema_type":"delete_alarm_request", + "vim_type":"VMware","vim_uuid":"1", + "alarm_delete_request":{'alarm_uuid': 'abc', 'correlation_id': 14203}} # set return value to mocked method m_delete_alarm_configuration.return_value = None + m_get_vim_access_config.return_value = {'vrops_site':'abc', + 'vrops_user':'user', + 'vrops_password':'passwd', + 'vim_url':'vcd_url', + 'admin_username':'admin', + 'admin_password':'admin_passwd', + 'vim_uuid':'1', + 'tenant_id':'org_vdc_1'} # check delete alarm gets called and returned correct value ret_value = self.plugin_receiver.delete_alarm(delete_alarm_info) # check mocked method get called with correct param - m_delete_alarm_configuration.assert_called_with(delete_alarm_info) + m_get_vim_access_config.assert_called_with(delete_alarm_info['vim_uuid']) + m_delete_alarm_configuration.assert_called_with(delete_alarm_info["alarm_delete_request"]) # check return value to check failed status self.assertEqual(ret_value, None) @@ -465,14 +578,15 @@ class TestPluginReceiver(unittest.TestCase): """ Test functionality of publish create alarm status method""" # Mock config_alarm_info - config_alarm_info = {'vim_type': 'VMware', - 'alarm_create_request': {'threshold_value': 0, - 'severity': 'CRITICAL', - 'alarm_name': 'CPU_Utilization_Above_Threshold', - 'resource_uuid': 'e14b203c-6bf2-4e2f-a91c-8c19d240eda4', - 'correlation_id': 1234, - 'statistic': 'AVERAGE', - 'metric_name': 'CPU_UTILIZATION'} + config_alarm_info = {'vim_type': 'VMware', "vim_uuid":"1", + 'alarm_create_request': { + 'threshold_value': 0, + 'severity': 'CRITICAL', + 'alarm_name': 'CPU_Utilization_Above_Threshold', + 'resource_uuid': 'e14b203c-6bf2-4e2f-a91c-8c19d240eda4', + 'correlation_id': 1234, + 'statistic': 'AVERAGE', + 'metric_name': 'CPU_UTILIZATION'} } alarm_uuid = "xyz" @@ -481,7 +595,9 @@ class TestPluginReceiver(unittest.TestCase): self.plugin_receiver.publish_create_alarm_status(alarm_uuid, config_alarm_info) # verify mocked method called with correct params - m_publish.assert_called_with(key='create_alarm_response', value=mock.ANY, topic='alarm_response') + m_publish.assert_called_with(key='create_alarm_response',\ + value=mock.ANY,\ + topic='alarm_response') @mock.patch.object(monPluginRec.KafkaProducer, 'publish') @@ -490,11 +606,12 @@ class TestPluginReceiver(unittest.TestCase): # Mock update_alarm_info update_alarm_info = {'vim_type' : 'VMware', + 'vim_uuid':'1', + 'schema_type': 'update_alarm_request', 'alarm_update_request':{'alarm_uuid': '6486e69', 'correlation_id': 14203, 'operation': 'GT' - }, - 'schema_type': 'update_alarm_request' + } } alarm_uuid = "xyz" @@ -503,7 +620,9 @@ class TestPluginReceiver(unittest.TestCase): self.plugin_receiver.publish_update_alarm_status(alarm_uuid, update_alarm_info) # verify mocked method called with correct params - m_publish.assert_called_with(key='update_alarm_response', value=mock.ANY, topic='alarm_response') + m_publish.assert_called_with(key='update_alarm_response',\ + value=mock.ANY,\ + topic='alarm_response') @mock.patch.object(monPluginRec.KafkaProducer, 'publish') @@ -512,11 +631,12 @@ class TestPluginReceiver(unittest.TestCase): # Mock delete_alarm_info delete_alarm_info = {'vim_type' : 'VMware', + "vim_uuid":"1", + 'schema_type': 'delete_alarm_request', 'alarm_delete_request':{'alarm_uuid': '6486e69', 'correlation_id': 14203, 'operation': 'GT' - }, - 'schema_type': 'delete_alarm_request' + } } alarm_uuid = "xyz" @@ -525,7 +645,9 @@ class TestPluginReceiver(unittest.TestCase): self.plugin_receiver.publish_delete_alarm_status(alarm_uuid, delete_alarm_info) # verify mocked method called with correct params - m_publish.assert_called_with(key='delete_alarm_response', value=mock.ANY, topic='alarm_response') + m_publish.assert_called_with(key='delete_alarm_response',\ + value=mock.ANY,\ + topic='alarm_response') @mock.patch.object(monPluginRec.KafkaProducer, 'publish') @@ -534,8 +656,9 @@ class TestPluginReceiver(unittest.TestCase): # Mock metrics data metrics_data = { + 'vim_uuid':'1', 'metric_name': 'CPU_UTILIZATION', 'metric_uuid': '0', - 'resource_uuid': 'e14b20', 'correlation_id': 'e14b2', + 'resource_uuid': 'e14b20', 'correlation_id': 14203, 'metrics_data': {'time_series': [15162011, 15162044], 'metrics_series': [0.1166666671, 0.1266666650]}, 'tenant_uuid': 123, 'unit': '%' @@ -545,44 +668,74 @@ class TestPluginReceiver(unittest.TestCase): self.plugin_receiver.publish_metrics_data_status(metrics_data) # verify mocked method called with correct params - m_publish.assert_called_with(key='read_metric_data_response', value=mock.ANY, topic='metric_response') + m_publish.assert_called_with(key='read_metric_data_response',\ + value=mock.ANY,\ + topic='metric_response') @mock.patch.object(monPluginRec.MonPlugin, 'verify_metric_support') - def test_verify_metric_supported_metric(self, m_verify_metric_support): - """ Test functionality of verify matric method""" + @mock.patch.object(monPluginRec.PluginReceiver, 'get_vim_access_config') + def test_verify_metric_supported_metric(self, m_get_vim_access_config,\ + m_verify_metric_support): + """ Test functionality of verify metric method""" # mock metric_info - metric_info = {'metric_unit': '%', 'metric_name': 'CPU_UTILIZATION', 'resource_uuid': 'e14b203'} + metric_info = {'vim_uuid':'1',\ + 'metric_create_request':{'metric_unit': '%',\ + 'metric_name': 'CPU_UTILIZATION',\ + 'resource_uuid': 'e14b203'}} - # set mocked function retrun value to true + # set mocked function return value to true m_verify_metric_support.return_value = True + m_get_vim_access_config.return_value = {'vrops_site':'abc', + 'vrops_user':'user', + 'vrops_password':'passwd', + 'vim_url':'vcd_url', + 'admin_username':'admin', + 'admin_password':'admin_passwd', + 'vim_uuid':'1', + 'tenant_id':'org_vdc_1'} # call verify_metric method under test ret_value = self.plugin_receiver.verify_metric(metric_info) # verify mocked method called with correct params - m_verify_metric_support.assert_called_with(metric_info) + m_get_vim_access_config.assert_called_with(metric_info['vim_uuid']) + m_verify_metric_support.assert_called_with(metric_info['metric_create_request']) # verify the return value self.assertEqual(ret_value, True) @mock.patch.object(monPluginRec.MonPlugin, 'verify_metric_support') - def test_verify_metric_unsupported_metric(self, m_verify_metric_support): - """ Test functionality of verify matric method-negative case""" - - # mock metric_info with unsupported matrics name - metric_info = {'metric_unit': '%', 'metric_name': 'Invalid', 'resource_uuid': 'e14b203'} - - # set mocked function retrun value to true + @mock.patch.object(monPluginRec.PluginReceiver, 'get_vim_access_config') + def test_verify_metric_unsupported_metric(self, m_get_vim_access_config,\ + m_verify_metric_support): + """ Test functionality of verify metric method-negative case""" + + # mock metric_info with unsupported metrics name + metric_info = {'vim_uuid':'1',\ + 'metric_create_request':{'metric_unit': '%',\ + 'metric_name': 'Invalid',\ + 'resource_uuid': 'e14b203'}} + + # set mocked function return value to true m_verify_metric_support.return_value = False + m_get_vim_access_config.return_value = {'vrops_site':'abc', + 'vrops_user':'user', + 'vrops_password':'passwd', + 'vim_url':'vcd_url', + 'admin_username':'admin', + 'admin_password':'admin_passwd', + 'vim_uuid':'1', + 'tenant_id':'org_vdc_1'} # call verify_metric method under test ret_value = self.plugin_receiver.verify_metric(metric_info) # verify mocked method called with correct params - m_verify_metric_support.assert_called_with(metric_info) + m_get_vim_access_config.assert_called_with(metric_info['vim_uuid']) + m_verify_metric_support.assert_called_with(metric_info['metric_create_request']) # verify the return value self.assertEqual(ret_value, False) @@ -593,13 +746,16 @@ class TestPluginReceiver(unittest.TestCase): """ Test functionality of publish create metric response method""" # Mock metric_info - metric_info = {'vim_type' : 'VMware','correlation_id': 'e14b203c', + metric_info = { + 'vim_uuid':'1', + 'vim_type' : 'VMware', + 'correlation_id': 14203, + 'schema_type': 'create_metric_request', 'metric_create_request':{ 'resource_uuid': '6486e69', 'metric_name': 'CPU_UTILIZATION', 'metric_unit': '%' - }, - 'schema_type': 'create_metric_request' + } } metric_status = True @@ -608,7 +764,9 @@ class TestPluginReceiver(unittest.TestCase): self.plugin_receiver.publish_create_metric_response(metric_info, metric_status) # verify mocked method called with correct params - m_publish.assert_called_with(key='create_metric_response', value=mock.ANY, topic='metric_response') + m_publish.assert_called_with(key='create_metric_response',\ + value=mock.ANY,\ + topic='metric_response') @mock.patch.object(monPluginRec.KafkaProducer, 'publish') @@ -616,13 +774,16 @@ class TestPluginReceiver(unittest.TestCase): """ Test functionality of publish update metric response method""" # Mock metric_info - metric_info = {'vim_type' : 'VMware','correlation_id': 'e14b203c', - 'metric_create_request':{ + metric_info = { + 'vim_uuid':'1', + 'vim_type' : 'VMware', + 'correlation_id': 14203, + 'schema_type': 'update_metric_request', + 'metric_create':{ 'resource_uuid': '6486e69', 'metric_name': 'CPU_UTILIZATION', 'metric_unit': '%' - }, - 'schema_type': 'update_metric_request' + } } metric_status = True @@ -631,7 +792,9 @@ class TestPluginReceiver(unittest.TestCase): self.plugin_receiver.publish_update_metric_response(metric_info, metric_status) # verify mocked method called with correct params - m_publish.assert_called_with(key='update_metric_response', value=mock.ANY, topic='metric_response') + m_publish.assert_called_with(key='update_metric_response',\ + value=mock.ANY,\ + topic='metric_response') @mock.patch.object(monPluginRec.KafkaProducer, 'publish') @@ -639,7 +802,7 @@ class TestPluginReceiver(unittest.TestCase): """ Test functionality of publish delete metric response method""" # Mock metric_info - metric_info = {'vim_type' : 'VMware','correlation_id': 'e14b203c', + metric_info = {'vim_uuid':'1', 'vim_type' : 'VMware','correlation_id': 14203, 'metric_uuid': 'e14b203c', 'resource_uuid': '6486e69', 'metric_name': 'CPU_UTILIZATION', 'schema_type': 'delete_metric_request'} @@ -647,40 +810,59 @@ class TestPluginReceiver(unittest.TestCase): metric_status = True # call publish delete metric method under test-vROPS doesn't support - # delete metric,just returns responce with success + # delete metric,just returns response with success self.plugin_receiver.publish_delete_metric_response(metric_info) # verify mocked method called with correct params - m_publish.assert_called_with(key='delete_metric_response', value=mock.ANY, topic='metric_response') + m_publish.assert_called_with(key='delete_metric_response',\ + value=mock.ANY,\ + topic='metric_response') @mock.patch.object(monPluginRec.MonPlugin, 'get_triggered_alarms_list') - def test_list_alarms(self, m_get_triggered_alarms_list): + @mock.patch.object(monPluginRec.PluginReceiver, 'get_vim_access_config') + def test_list_alarms(self, m_get_vim_access_config, m_get_triggered_alarms_list): """ Test functionality of list alarms method""" # Mock list alarm input - list_alarm_input = {'severity': 'CRITICAL', - 'correlation_id': 'e14b203c', - 'alarm_name': 'CPU_Utilization_Above_Threshold', - 'resource_uuid': 'd14b203c'} + list_alarm_input = { + 'vim_uuid':'1', + 'vim_type' : 'VMware', + 'alarm_list_request':{ + 'severity': 'CRITICAL', + 'correlation_id': 14203, + 'alarm_name': 'CPU_Utilization_Above_Threshold', + 'resource_uuid': 'd14b203c'}} # set return value to mocked method - m_return = m_get_triggered_alarms_list.return_value = [{'status': 'ACTIVE', 'update_date': '2018-01-12T08:34:05', - 'severity': 'CRITICAL', 'resource_uuid': 'e14b203c', - 'cancel_date': '0000-00-00T00:00:00','alarm_instance_uuid': 'd9e3bc84', - 'alarm_uuid': '5714977d', 'vim_type': 'VMware', - 'start_date': '2018-01-12T08:34:05'}, - {'status': 'CANCELED', 'update_date': '2017-12-20T09:37:57', - 'severity': 'CRITICAL', 'resource_uuid': 'e14b203c', - 'cancel_date': '2018-01-12T06:49:19', 'alarm_instance_uuid': 'd3bbeef6', - 'alarm_uuid': '7ba1bf3e', 'vim_type': 'VMware', - 'start_date': '2017-12-20T09:37:57'}] + m_return = [{'status': 'ACTIVE', 'update_date': '2018-01-12T08:34:05', + 'severity': 'CRITICAL', 'resource_uuid': 'e14b203c', + 'cancel_date': '0000-00-00T00:00:00','alarm_instance_uuid': 'd9e3bc84', + 'alarm_uuid': '5714977d', 'vim_type': 'VMware', + 'start_date': '2018-01-12T08:34:05'}, + {'status': 'CANCELED', 'update_date': '2017-12-20T09:37:57', + 'severity': 'CRITICAL', 'resource_uuid': 'e14b203c', + 'cancel_date': '2018-01-12T06:49:19', 'alarm_instance_uuid': 'd3bbeef6', + 'alarm_uuid': '7ba1bf3e', 'vim_type': 'VMware', + 'start_date': '2017-12-20T09:37:57'}] + m_get_triggered_alarms_list.return_value = m_return + + m_get_vim_access_config.return_value = {'vrops_site':'abc', + 'vrops_user':'user', + 'vrops_password':'passwd', + 'vim_url':'vcd_url', + 'admin_username':'admin', + 'admin_password':'admin_passwd', + 'vim_uuid':'1', + 'tenant_id':'org_vdc_1'} + # call list alarms method under test return_value = self.plugin_receiver.list_alarms(list_alarm_input) # verify mocked method called with correct params - m_get_triggered_alarms_list.assert_called_with(list_alarm_input) + m_get_vim_access_config.assert_called_with(list_alarm_input['vim_uuid']) + m_get_triggered_alarms_list.assert_called_with(list_alarm_input['alarm_list_request']) # verify list alarm method returns correct list self.assertEqual(return_value, m_return) @@ -693,14 +875,22 @@ class TestPluginReceiver(unittest.TestCase): # Mock list alarm input msg_key = 'list_alarm_response' topic = 'alarm_response' - list_alarm_input = {'alarm_list_request': {'severity': 'CRITICAL', - 'correlation_id': 'e14b203c', - 'alarm_name': 'CPU_Utilization_Above_Threshold', - 'resource_uuid': 'd14b203c'},'vim_type' : 'VMware'} - - triggered_alarm_list = [{'status': 'ACTIVE', 'update_date': '2018-01-12T08:34:05', 'severity': 'CRITICAL', - 'resource_uuid': 'e14b203c', 'cancel_date': '0000-00-00T00:00:00','alarm_instance_uuid': 'd9e3bc84', - 'alarm_uuid': '5714977d', 'vim_type': 'VMware', 'start_date': '2018-01-12T08:34:05'}] + list_alarm_input = {'vim_uuid':'1', + 'vim_type' : 'VMware', + 'alarm_list_request':{ + 'severity': 'CRITICAL', + 'correlation_id': 14203, + 'alarm_name': 'CPU_Utilization_Above_Threshold', + 'resource_uuid': 'd14b203c'}} + + triggered_alarm_list = [{'status': 'ACTIVE', 'update_date': '2018-01-12T08:34:05', + 'severity': 'CRITICAL','resource_uuid': 'e14b203c', + 'cancel_date': '0000-00-00T00:00:00', + 'start_date': '2018-01-12T08:34:05', + 'alarm_instance_uuid': 'd9e3bc84', + 'alarm_uuid': '5714977d', + 'vim_type': 'VMware' + }] # call publish list alarm response method under test self.plugin_receiver.publish_list_alarm_response(triggered_alarm_list, list_alarm_input) @@ -717,8 +907,13 @@ class TestPluginReceiver(unittest.TestCase): access_update_status = True msg_key = 'vim_access_credentials_response' topic = 'access_credentials' - access_info_req = {'access_config': {'vrops_password': 'vmware', 'vcloud-site': 'https://192.169.241.105', - 'vrops_user': 'Admin', 'correlation_id': 'e14b203c', 'tenant_id': 'Org2'}, 'vim_type': u'VMware'} + access_info_req = {'vim_type': 'VMware', + 'vim_uuid':'1', + 'access_config': {'vrops_password': 'vmware', + 'vcloud-site': 'https://192.169.241.105', + 'vrops_user': 'Admin', 'correlation_id': 14203, + 'tenant_id': 'Org2'} + } # call publish access update response method under test self.plugin_receiver.publish_access_update_response(access_update_status, access_info_req) @@ -732,15 +927,17 @@ class TestPluginReceiver(unittest.TestCase): """ Test functionality of update access credentials-positive case""" # Mock access_info - access_info = {'vrops_site':'https://192.169.241.13','vrops_user':'admin', 'vrops_password':'vmware', - 'vcloud-site':'https://192.169.241.15','admin_username':'admin','admin_password':'vmware', - 'vcenter_ip':'192.169.241.13','vcenter_port':'443','vcenter_user':'admin','vcenter_password':'vmware', + access_info = {'vrops_site':'https://192.169.241.13','vrops_user':'admin', + 'vrops_password':'vmware','vcloud-site':'https://192.169.241.15', + 'admin_username':'admin','admin_password':'vmware', + 'vcenter_ip':'192.169.241.13','vcenter_port':'443', + 'vcenter_user':'admin','vcenter_password':'vmware', 'vim_tenant_name':'Org2','orgname':'Org2','tenant_id':'Org2'} # Mock return values expected_status = m_write_access_config.return_value = True - # call publish update acccess credentials method under test + # call publish update access credentials method under test actual_status = self.plugin_receiver.update_access_credentials(access_info) # check write_access_config called with correct params @@ -755,15 +952,16 @@ class TestPluginReceiver(unittest.TestCase): """ Test functionality of update access credentials-negative case""" # Mock access_info - access_info = {'vrops_site':'https://192.169.241.13','vrops_user':'admin', 'vrops_password':'vmware', - 'vcloud-site':'https://192.169.241.15','admin_username':'admin','admin_password':'vmware', + access_info = {'vrops_site':'https://192.169.241.13','vrops_user':'admin', + 'vrops_password':'vmware','vcloud-site':'https://192.169.241.15', + 'admin_username':'admin','admin_password':'vmware', 'vcenter_ip':'192.169.241.13','vcenter_port':'443','vcenter_user':'admin', 'vim_tenant_name':'Org2','orgname':'Org2','tenant_id':'Org2'} # Mock return values expected_status = m_write_access_config.return_value = False - # call publish update acccess credentials method under test + # call publish update access credentials method under test actual_status = self.plugin_receiver.update_access_credentials(access_info) # check if mocked method not called @@ -778,15 +976,17 @@ class TestPluginReceiver(unittest.TestCase): """ Test functionality of update access credentials-failed case """ # Mock access_info - access_info = {'vrops_site':'https://192.169.241.13','vrops_user':'admin', 'vrops_password':'vmware', - 'vcloud-site':'https://192.169.241.15','admin_username':'admin','admin_password':'vmware', - 'vcenter_ip':'192.169.241.13','vcenter_port':'443','vcenter_user':'admin','vcenter_password':'vmware', + access_info = {'vrops_site':'https://192.169.241.13','vrops_user':'admin', + 'vrops_password':'vmware','vcloud-site':'https://192.169.241.15', + 'admin_username':'admin','admin_password':'vmware', + 'vcenter_ip':'192.169.241.13','vcenter_port':'443', + 'vcenter_user':'admin','vcenter_password':'vmware', 'vim_tenant_name':'Org2','orgname':'Org2','tenant_id':'Org2'} # Mock return values expected_status = m_write_access_config.return_value = False - # call publish update acccess credentials method under test + # call publish update access credentials method under test actual_status = self.plugin_receiver.update_access_credentials(access_info) # check write_access_config called with correct params @@ -800,12 +1000,14 @@ class TestPluginReceiver(unittest.TestCase): """ Test functionality of write access config method-positive case""" # Mock access_info - access_info = {'vrops_sit':'https://192.169.241.13','vrops_user':'admin', 'vrops_password':'vmware', - 'vcloud-site':'https://192.169.241.15','admin_username':'admin','admin_password':'vmware', - 'vcenter_ip':'192.169.241.13','vcenter_port':'443','vcenter_user':'admin','vcenter_password':'vmware', + access_info = {'vrops_sit':'https://192.169.241.13','vrops_user':'admin', + 'vrops_password':'vmware','vcloud-site':'https://192.169.241.15', + 'admin_username':'admin','admin_password':'vmware', + 'vcenter_ip':'192.169.241.13','vcenter_port':'443', + 'vcenter_user':'admin','vcenter_password':'vmware', 'vim_tenant_name':'Org2','orgname':'Org2','tenant_id':'Org2'} - # call write acccess config method under test + # call write access config method under test actual_status = self.plugin_receiver.write_access_config(access_info) # verify write access config returns correct status @@ -818,13 +1020,56 @@ class TestPluginReceiver(unittest.TestCase): # Mock access_info access_info = [] # provided incorrect info to generate error - # call write acccess config method under test + # call write access config method under test actual_status = self.plugin_receiver.write_access_config(access_info) # verify write access config returns correct status self.assertEqual(False, actual_status) + @mock.patch.object(monPluginRec.AuthManager, 'get_credentials') + def test_get_vim_access_config(self, m_get_credentials): + """ Test functionality of get_vim_access_config method-positive case""" + + # Mock vim_uuid & access_info + vim_uuid = '1' + vim_details = VimCredentials() + vim_details.name = "vrops_vcd82" + vim_details.password = "passwd" + vim_details.tenant_name = "MANO-VDC" + vim_details.type = "VMware" + vim_details.url = "https://10.10.1.1" + vim_details.user = "admin" + vim_details.uuid = "1" + vim_details.config = '{"orgname": "MANO-Org", "tenant_id": "MANO-VDC",\ + "admin_username": "administrator","admin_password": "vcd_pwd",\ + "vrops_user": "admin", "vrops_password": "vrops_pwd",\ + "vrops_site": "https://10.10.1.2","nsx_user": "admin",\ + "nsx_manager": "https://10.10.1.3", "nsx_password":"nsx_pwd",\ + "sdn_controller": "None", "sdn_port_mapping": "None",\ + "vcenter_ip": "10.10.1.4", "vcenter_user": "admin@vsphere.local",\ + "vcenter_password": "vcenter_pwd", "vcenter_port": "443"}' + m_get_credentials.return_value = vim_details + expected_config = {'vrops_password': 'vrops_pwd', 'vcenter_password': 'vcenter_pwd', + 'name': 'vrops_vcd82', 'org_user': 'admin', + 'org_password': 'passwd', 'nsx_user': 'admin', 'vim_tenant_name': 'MANO-VDC', + 'admin_username': 'administrator', 'vcenter_port': '443', + 'vim_url': 'https://10.10.1.1', 'orgname': 'MANO-Org', + 'admin_password':'vcd_pwd', 'vrops_user':'admin', 'vcenter_ip':'10.10.1.4', + 'vrops_site': 'https://10.10.1.2', 'nsx_manager': 'https://10.10.1.3', + 'nsx_password': 'nsx_pwd', 'vim_type': 'VMware', 'vim_uuid': '1', + 'vcenter_user': 'admin@vsphere.local'} + + # call get_vim_access_config method under test + actual_config = self.plugin_receiver.get_vim_access_config('1') + + #verify that mocked method is called + m_get_credentials.assert_called_with(vim_uuid) + + #Verify return value with expected value + self.assertEqual(expected_config, actual_config) + + # For testing purpose #if __name__ == '__main__':