X-Git-Url: https://osm.etsi.org/gitweb/?a=blobdiff_plain;ds=sidebyside;f=osm_mon%2Ftest%2Fplugins%2FVMware%2Ftest_plugin_receiver.py;fp=osm_mon%2Ftest%2Fplugins%2FVMware%2Ftest_plugin_receiver.py;h=0000000000000000000000000000000000000000;hb=51f4486b06781541ee15ea332261247ed3e930f6;hp=cc5dea9bc44958ce0cc070d9d2d6c2a47138c66b;hpb=e27def0d99cc73c5c0b7550a28e95abd6c1cd996;p=osm%2FMON.git diff --git a/osm_mon/test/plugins/VMware/test_plugin_receiver.py b/osm_mon/test/plugins/VMware/test_plugin_receiver.py deleted file mode 100644 index cc5dea9..0000000 --- a/osm_mon/test/plugins/VMware/test_plugin_receiver.py +++ /dev/null @@ -1,927 +0,0 @@ -# -*- coding: utf-8 -*- - -## -# Copyright 2017-2018 VMware Inc. -# This file is part of ETSI OSM -# All Rights Reserved. -# -# Licensed under the Apache License, Version 2.0 (the "License"); you may -# not use this file except in compliance with the License. You may obtain -# a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT -# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the -# License for the specific language governing permissions and limitations -# under the License. -# -# For those usages not covered by the Apache License, Version 2.0 please -# contact: osslegalrouting@vmware.com -## - -""" Mock tests for VMware vROPs plugin recevier """ - -import json -import logging -import os -import sys -import unittest -from io import UnsupportedOperation - -import mock - -# sys.path.append("/root/MON/") - -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): - """A class to mock a message object value for alarm and matric requests""" - - def __init__(self): - """Initialize a mocked message instance""" - self.topic = "alarm_or_metric_request" - self.key = None - self.value = json.dumps({"mock_value": "mock_details"}) - self.partition = 1 - self.offset = 100 - - -class TestPluginReceiver(unittest.TestCase): - """Test class for Plugin Receiver class methods""" - - def setUp(self): - """Setup the tests for plugin_receiver class methods""" - super(TestPluginReceiver, self).setUp() - self.plugin_receiver = monPluginRec.PluginReceiver() - - @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): - """Test functionality of consume for create_alarm_request key""" - - vim_uuid = "f85fc39e-723d-4172-979b-de28b36465bb" - - value = {"vim_uuid": vim_uuid, "alarm_create_request": "alarm_details"} - m_create_alarm.return_value = "test_alarm_id" - - # Call the consume method of plugin_receiver - self.plugin_receiver.handle_alarm_requests('create_alarm_request', value, vim_uuid) - - # verify if create_alarm and publish methods called with correct params - m_create_alarm.assert_called_with(value) - m_publish_create_alarm_status.assert_called_with("test_alarm_id", value) - - @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): - """Test functionality of consume for update_alarm_request key""" - - vim_uuid = "f85fc39e-723d-4172-979b-de28b36465bb" - - value = {"vim_uuid": vim_uuid, "alarm_update_request": "alarm_details"} - - # set return value to mocked method - m_update_alarm.return_value = "test_alarm_id" - - # Call the consume method of plugin_receiver - self.plugin_receiver.handle_alarm_requests('update_alarm_request', value, vim_uuid) - - # verify update_alarm and publish method called with correct params - m_update_alarm.assert_called_with(value) - m_publish_update_alarm_status.assert_called_with("test_alarm_id", value) - - @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): - """Test functionality of consume for delete_alarm_request key""" - - vim_uuid = "f85fc39e-723d-4172-979b-de28b36465bb" - - value = {"vim_uuid": vim_uuid, "alarm_delete_request": "alarm_details"} - m_delete_alarm.return_value = "test_alarm_id" - - # Call the consume method of plugin_receiver and check delete_alarm request - self.plugin_receiver.handle_alarm_requests('delete_alarm_request', value, vim_uuid) - m_delete_alarm.assert_called_with(value) - - # Check if publish method called with correct parameters - m_publish_delete_alarm_status.assert_called_with("test_alarm_id", value) - - @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): - """ Test functionality of list alarm request key""" - - vim_uuid = "f85fc39e-723d-4172-979b-de28b36465bb" - value = {"vim_uuid": vim_uuid, "alarm_list_request": "alarm_details"} - - test_alarm_list = [{"alarm_uuid": "alarm1_details"}, {"alarm_uuid": "alarm2_details"}] - - m_list_alarms.return_value = test_alarm_list - - # Call the consume method of plugin_receiver and check delete_alarm request - self.plugin_receiver.handle_alarm_requests('list_alarm_request', value, vim_uuid) - m_list_alarms.assert_called_with(value) - - # Check if publish method called with correct parameters - m_publish_list_alarm_response.assert_called_with(test_alarm_list, value) - - @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): - """Test functionality of consume for vim_access_credentials invalid request key""" - - vim_uuid = "f85fc39e-723d-4172-979b-de28b36465bb" - - # Call the consume method of plugin_receiver - with self.assertRaises(UnsupportedOperation): - self.plugin_receiver.handle_alarm_requests('invalid_key', {}, vim_uuid) - - # verify that create_alarm and publish_create_alarm_status methods not called - m_create_alarm.assert_not_called() - m_publish_create_alarm_status.assert_not_called() - - @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): - """Test functionality of invalid metric key request""" - - vim_uuid = "f85fc39e-723d-4172-979b-de28b36465bb" - - # Call the consume method of plugin_receiver - with self.assertRaises(UnsupportedOperation): - self.plugin_receiver.handle_metric_requests('invalid_key', {}, vim_uuid) - - # verify that get metrics data and publish methods not called - m_get_metrics_data.assert_not_called() - m_publish_metric_data_status.assert_not_called() - - @mock.patch.object(monPluginRec.PluginReceiver, 'publish_metrics_data_status') - @mock.patch.object(monPluginRec.MonPlugin, 'get_metrics_data') - @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" - - value = {"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'} - - # Call the consume method of plugin_receiver - self.plugin_receiver.handle_metric_requests('read_metric_data_request', value, vim_uuid) - m_get_metrics_data.assert_called_with(value) - - # Check if publish method called with correct parameters - m_publish_metric_data_status.assert_called_with({"metrics_data": "metrics_details"}) - - @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): - """Test functionality of consume for create_metric_request key""" - - vim_uuid = "f85fc39e-723d-4172-979b-de28b36465bb" - value = {"vim_uuid": vim_uuid, "metric_create": "metric_details"} - - # set the return value - m_verify_metric.return_value = True - - # Call the consume method of plugin_receiver - self.plugin_receiver.handle_metric_requests('create_metric_request', value, vim_uuid) - m_verify_metric.assert_called_with(value) - - # Check if publish method called with correct parameters - m_publish_create_metric_response.assert_called_with(value, True) - - @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): - """Test functionality of update metric request key""" - - vim_uuid = "f85fc39e-723d-4172-979b-de28b36465bb" - - value = {"vim_uuid": vim_uuid, "metric_create": "metric_details"} - - # set the return value - m_verify_metric.return_value = True - - # Call the consume method of plugin_receiver - self.plugin_receiver.handle_metric_requests('update_metric_request', value, vim_uuid) - - # verify mocked methods called with correct parameters - m_verify_metric.assert_called_with(value) - m_publish_update_metric_response.assert_called_with(value, True) - - @mock.patch.object(monPluginRec.PluginReceiver, 'publish_delete_metric_response') - def test_consume_delete_metric_request_key(self, m_publish_delete_metric_response): - """Test functionality of consume for delete_metric_request key""" - - # Note: vROPS doesn't support deleting metric data - vim_uuid = "f85fc39e-723d-4172-979b-de28b36465bb" - - value = {"vim_uuid": vim_uuid, "metric_name": "metric_details"} - - # Call the consume method of plugin_receiver - self.plugin_receiver.handle_metric_requests('delete_metric_request', value, vim_uuid) - - # Check if publish method called with correct parameters - m_publish_delete_metric_response.assert_called_with(value) - - @mock.patch.object(monPluginRec.MonPlugin, 'configure_alarm') - @mock.patch.object(monPluginRec.MonPlugin, 'configure_rest_plugin') - @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 = {"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", - "resource_uuid": "resource_uuid", - "description": "test_create_alarm", - "severity": "CRITICAL", - "operation": "GT", - "threshold_value": 10, - "unit": "%", - "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" - - # call create alarm method under test - 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["alarm_create_request"]) - - @mock.patch.object(monPluginRec.MonPlugin, 'configure_alarm') - @mock.patch.object(monPluginRec.MonPlugin, 'configure_rest_plugin') - @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 = {"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", - "resource_uuid": "resource_uuid", - "description": "test_create_alarm", - "severity": "CRITICAL", - "operation": "GT", - "threshold_value": 10, - "unit": "%", - "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 - - # call create alarm method under test - 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["alarm_create_request"]) - - # verify create alarm method returns None when failed - self.assertEqual(alarm_uuid, None) - - @mock.patch.object(monPluginRec.MonPlugin, '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 = {"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_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') - @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 = {"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_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') - @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 = {"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_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') - @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 = {"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_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) - - def test_publish_create_alarm_status(self): - """ Test functionality of publish create alarm status method""" - - # Mock config_alarm_info - 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" - - # call publish create status method under test - self.plugin_receiver.publish_create_alarm_status(alarm_uuid, config_alarm_info) - - # verify mocked method called with correct params - # TODO(diazb): Validate payload generation (self.assertEquals(response, expected_message)) - - def test_publish_update_alarm_status(self): - """ Test functionality of publish update alarm status method""" - - # 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' - } - } - - alarm_uuid = "xyz" - - # call publish update alarm status method under test - self.plugin_receiver.publish_update_alarm_status(alarm_uuid, update_alarm_info) - - # verify mocked method called with correct params - # TODO(diazb): Validate payload generation (self.assertEquals(response, expected_message)) - - def test_publish_delete_alarm_status(self): - """ Test functionality of publish delete alarm status method""" - - # 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' - } - } - - alarm_uuid = "xyz" - - # call publish delete alarm status method under test - self.plugin_receiver.publish_delete_alarm_status(alarm_uuid, delete_alarm_info) - - # verify mocked method called with correct params - # TODO(diazb): Validate payload generation (self.assertEquals(response, expected_message)) - - def test_publish_metrics_data_status(self): - """ Test functionality of publish metrics data status method""" - - # Mock metrics data - metrics_data = { - 'vim_uuid': '1', - 'metric_name': 'CPU_UTILIZATION', 'metric_uuid': '0', - 'resource_uuid': 'e14b20', 'correlation_id': 14203, - 'metrics_data': {'time_series': [15162011, 15162044], - 'metrics_series': [0.1166666671, 0.1266666650]}, - 'tenant_uuid': 123, 'unit': '%' - } - - # call publish metrics data status method under test - self.plugin_receiver.publish_metrics_data_status(metrics_data) - - # verify mocked method called with correct params - # TODO(diazb): Validate payload generation (self.assertEquals(response, expected_message)) - - @mock.patch.object(monPluginRec.MonPlugin, 'verify_metric_support') - @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 = {'vim_uuid': '1', - 'metric_create_request': {'metric_unit': '%', - 'metric_name': 'CPU_UTILIZATION', - 'resource_uuid': 'e14b203'}} - - # 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_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') - @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_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) - - def test_publish_create_metric_response(self): - """ Test functionality of publish create metric response method""" - - # Mock metric_info - 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': '%' - } - } - - metric_status = True - - # call publish create metric method under test - self.plugin_receiver.publish_create_metric_response(metric_info, metric_status) - - # verify mocked method called with correct params - # TODO(diazb): Validate payload generation (self.assertEquals(response, expected_message)) - - def test_publish_update_metric_response(self): - """ Test functionality of publish update metric response method""" - - # Mock metric_info - 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': '%' - } - } - - metric_status = True - - # call publish update metric method under test - self.plugin_receiver.publish_update_metric_response(metric_info, metric_status) - - # verify mocked method called with correct params - # TODO(diazb): Validate payload generation (self.assertEquals(response, expected_message)) - - def test_publish_delete_metric_response(self): - """ Test functionality of publish delete metric response method""" - - # Mock metric_info - 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'} - - # call publish delete metric method under test-vROPS doesn't support - # delete metric,just returns response with success - self.plugin_receiver.publish_delete_metric_response(metric_info) - - # verify mocked method called with correct params - # TODO(diazb): Validate payload generation (self.assertEquals(response, expected_message)) - - @mock.patch.object(monPluginRec.MonPlugin, '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 = { - '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 = [{'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_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) - - def test_publish_list_alarm_response(self): - """ Test functionality of publish list alarm response method""" - - # Mock list alarm input - msg_key = 'list_alarm_response' - topic = 'alarm_response' - 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 - response = self.plugin_receiver.publish_list_alarm_response(triggered_alarm_list, list_alarm_input) - - # verify mocked method called with correct params - # TODO(diazb): Validate payload generation (self.assertEquals(response, expected_message)) - - def test_publish_access_update_response(self): - """ Test functionality of publish access update response method""" - - # Mock required inputs - access_update_status = True - 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 - response = self.plugin_receiver.publish_access_update_response(access_update_status, access_info_req) - - # verify mocked method called with correct params - # TODO(diazb): Validate payload generation (self.assertEquals(response, expected_message)) - - @mock.patch.object(monPluginRec.PluginReceiver, 'write_access_config') - def test_update_access_credentials_successful(self, m_write_access_config): - """ 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', - 'vim_tenant_name': 'Org2', 'orgname': 'Org2', 'tenant_id': 'Org2'} - - # Mock return values - expected_status = m_write_access_config.return_value = True - - # 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 - m_write_access_config.assert_called_with(access_info) - - # verify update access credentials returns correct status - self.assertEqual(expected_status, actual_status) - - @mock.patch.object(monPluginRec.PluginReceiver, 'write_access_config') - def test_update_access_credentials_less_config_params(self, m_write_access_config): - """ 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', - '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 access credentials method under test - actual_status = self.plugin_receiver.update_access_credentials(access_info) - - # check if mocked method not called - m_write_access_config.assert_not_called() - - # verify update access credentials returns correct status - self.assertEqual(expected_status, actual_status) - - @mock.patch.object(monPluginRec.PluginReceiver, 'write_access_config') - def test_update_access_credentials_failed(self, m_write_access_config): - """ 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', - 'vim_tenant_name': 'Org2', 'orgname': 'Org2', 'tenant_id': 'Org2'} - - # Mock return values - expected_status = m_write_access_config.return_value = False - - # 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 - m_write_access_config.assert_called_with(access_info) - - # verify update access credentials returns correct status - self.assertEqual(expected_status, actual_status) - - def test_write_access_config_successful(self): - """ 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', - 'vim_tenant_name': 'Org2', 'orgname': 'Org2', 'tenant_id': 'Org2'} - - # 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(True, actual_status) - - def test_write_access_config_failed(self): - """ Test functionality of write access config method-negative case""" - - # Mock access_info - access_info = [] # provided incorrect info to generate error - - # 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__': - -# unittest.main()