osm_mon/tests/plugins/VMware/test_plugin_receiver.py

   1 # -*- coding: utf-8 -*-
   2
   3 ##
   4 # Copyright 2017-2018 VMware Inc.
   5 # This file is part of ETSI OSM
   6 # All Rights Reserved.
   7 #
   8 # Licensed under the Apache License, Version 2.0 (the "License"); you may
   9 # not use this file except in compliance with the License. You may obtain
  10 # a copy of the License at
  11 #
  12 #         http://www.apache.org/licenses/LICENSE-2.0
  13 #
  14 # Unless required by applicable law or agreed to in writing, software
  15 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  16 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  17 # License for the specific language governing permissions and limitations
  18 # under the License.
  19 #
  20 # For those usages not covered by the Apache License, Version 2.0 please
  21 # contact:  osslegalrouting@vmware.com
  22 ##
  23
  24 """ Mock tests for VMware vROPs plugin recevier """
  25
  26 import json
  27 import logging
  28 import os
  29 import sys
  30 import unittest
  31 from io import UnsupportedOperation
  32
  33 import mock
  34
  35 # sys.path.append("/root/MON/")
  36
  37 log = logging.getLogger(__name__)
  38
  39 sys.path.append(os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", ".."))
  40
  41 from osm_mon.plugins.vRealiseOps import plugin_receiver as monPluginRec
  42 from osm_mon.core.database import VimCredentials
  43
  44
  45 class Message(object):
  46     """A class to mock a message object value for alarm and matric requests"""
  47
  48     def __init__(self):
  49         """Initialize a mocked message instance"""
  50         self.topic = "alarm_or_metric_request"
  51         self.key = None
  52         self.value = json.dumps({"mock_value": "mock_details"})
  53         self.partition = 1
  54         self.offset = 100
  55
  56
  57 class TestPluginReceiver(unittest.TestCase):
  58     """Test class for Plugin Receiver class methods"""
  59
  60     def setUp(self):
  61         """Setup the tests for plugin_receiver class methods"""
  62         super(TestPluginReceiver, self).setUp()
  63         self.plugin_receiver = monPluginRec.PluginReceiver()
  64
  65     @mock.patch.object(monPluginRec.PluginReceiver, 'publish_create_alarm_status')
  66     @mock.patch.object(monPluginRec.PluginReceiver, 'create_alarm')
  67     def test_consume_create_alarm_request_key(self, m_create_alarm, m_publish_create_alarm_status):
  68         """Test functionality of consume for create_alarm_request key"""
  69
  70         vim_uuid = "f85fc39e-723d-4172-979b-de28b36465bb"
  71
  72         value = {"vim_uuid": vim_uuid, "alarm_create_request": "alarm_details"}
  73         m_create_alarm.return_value = "test_alarm_id"
  74
  75         # Call the consume method of plugin_receiver
  76         self.plugin_receiver.handle_alarm_requests('create_alarm_request', value, vim_uuid)
  77
  78         # verify if create_alarm and publish methods called with correct params
  79         m_create_alarm.assert_called_with(value)
  80         m_publish_create_alarm_status.assert_called_with("test_alarm_id", value)
  81
  82     @mock.patch.object(monPluginRec.PluginReceiver, 'publish_update_alarm_status')
  83     @mock.patch.object(monPluginRec.PluginReceiver, 'update_alarm')
  84     def test_consume_update_alarm_request_key(self, m_update_alarm,
  85                                               m_publish_update_alarm_status):
  86         """Test functionality of consume for update_alarm_request key"""
  87
  88         vim_uuid = "f85fc39e-723d-4172-979b-de28b36465bb"
  89
  90         value = {"vim_uuid": vim_uuid, "alarm_update_request": "alarm_details"}
  91
  92         # set return value to mocked method
  93         m_update_alarm.return_value = "test_alarm_id"
  94
  95         # Call the consume method of plugin_receiver
  96         self.plugin_receiver.handle_alarm_requests('update_alarm_request', value, vim_uuid)
  97
  98         # verify update_alarm and publish method called with correct params
  99         m_update_alarm.assert_called_with(value)
 100         m_publish_update_alarm_status.assert_called_with("test_alarm_id", value)
 101
 102     @mock.patch.object(monPluginRec.PluginReceiver, 'publish_delete_alarm_status')
 103     @mock.patch.object(monPluginRec.PluginReceiver, 'delete_alarm')
 104     def test_consume_delete_alarm_request_key(self, m_delete_alarm,
 105                                               m_publish_delete_alarm_status):
 106         """Test functionality of consume for delete_alarm_request key"""
 107
 108         vim_uuid = "f85fc39e-723d-4172-979b-de28b36465bb"
 109
 110         value = {"vim_uuid": vim_uuid, "alarm_delete_request": "alarm_details"}
 111         m_delete_alarm.return_value = "test_alarm_id"
 112
 113         # Call the consume method of plugin_receiver and check delete_alarm request
 114         self.plugin_receiver.handle_alarm_requests('delete_alarm_request', value, vim_uuid)
 115         m_delete_alarm.assert_called_with(value)
 116
 117         # Check if publish method called with correct parameters
 118         m_publish_delete_alarm_status.assert_called_with("test_alarm_id", value)
 119
 120     @mock.patch.object(monPluginRec.PluginReceiver, 'publish_list_alarm_response')
 121     @mock.patch.object(monPluginRec.PluginReceiver, 'list_alarms')
 122     def test_consume_list_alarm_request_key(self, m_list_alarms,
 123                                             m_publish_list_alarm_response):
 124         """ Test functionality of list alarm request key"""
 125
 126         vim_uuid = "f85fc39e-723d-4172-979b-de28b36465bb"
 127         value = {"vim_uuid": vim_uuid, "alarm_list_request": "alarm_details"}
 128
 129         test_alarm_list = [{"alarm_uuid": "alarm1_details"}, {"alarm_uuid": "alarm2_details"}]
 130
 131         m_list_alarms.return_value = test_alarm_list
 132
 133         # Call the consume method of plugin_receiver and check delete_alarm request
 134         self.plugin_receiver.handle_alarm_requests('list_alarm_request', value, vim_uuid)
 135         m_list_alarms.assert_called_with(value)
 136
 137         # Check if publish method called with correct parameters
 138         m_publish_list_alarm_response.assert_called_with(test_alarm_list, value)
 139
 140     @mock.patch.object(monPluginRec.PluginReceiver, 'publish_create_alarm_status')
 141     @mock.patch.object(monPluginRec.PluginReceiver, 'create_alarm')
 142     def test_consume_invalid_alarm_request_key(self, m_create_alarm,
 143                                                m_publish_create_alarm_status):
 144         """Test functionality of consume for vim_access_credentials invalid request key"""
 145
 146         vim_uuid = "f85fc39e-723d-4172-979b-de28b36465bb"
 147
 148         # Call the consume method of plugin_receiver
 149         with self.assertRaises(UnsupportedOperation):
 150             self.plugin_receiver.handle_alarm_requests('invalid_key', {}, vim_uuid)
 151
 152         # verify that create_alarm and publish_create_alarm_status methods not called
 153         m_create_alarm.assert_not_called()
 154         m_publish_create_alarm_status.assert_not_called()
 155
 156     @mock.patch.object(monPluginRec.PluginReceiver, 'publish_metrics_data_status')
 157     @mock.patch.object(monPluginRec.MonPlugin, 'get_metrics_data')
 158     def test_consume_invalid_metric_request_key(self, m_get_metrics_data,
 159                                                 m_publish_metric_data_status):
 160         """Test functionality of invalid metric key request"""
 161
 162         vim_uuid = "f85fc39e-723d-4172-979b-de28b36465bb"
 163
 164         # Call the consume method of plugin_receiver
 165         with self.assertRaises(UnsupportedOperation):
 166             self.plugin_receiver.handle_metric_requests('invalid_key', {}, vim_uuid)
 167
 168         # verify that get metrics data and publish methods not called
 169         m_get_metrics_data.assert_not_called()
 170         m_publish_metric_data_status.assert_not_called()
 171
 172     @mock.patch.object(monPluginRec.PluginReceiver, 'publish_metrics_data_status')
 173     @mock.patch.object(monPluginRec.MonPlugin, 'get_metrics_data')
 174     @mock.patch.object(monPluginRec.PluginReceiver, 'get_vim_access_config')
 175     def test_consume_read_metric_data_request_key(self, m_get_vim_access_config,
 176                                                   m_get_metrics_data,
 177                                                   m_publish_metric_data_status):
 178         """Test functionality of consume for read_metric_data_request key"""
 179
 180         vim_uuid = "f85fc39e-723d-4172-979b-de28b36465bb"
 181
 182         value = {"vim_uuid": vim_uuid, "metric_name": "metric_details"}
 183         m_get_metrics_data.return_value = {"metrics_data": "metrics_details"}
 184
 185         m_get_vim_access_config.return_value = {'vrops_site': 'abc',
 186                                                 'vrops_user': 'user',
 187                                                 'vrops_password': 'passwd',
 188                                                 'vim_url': 'vcd_url',
 189                                                 'admin_username': 'admin',
 190                                                 'admin_password': 'admin_passwd',
 191                                                 'vim_uuid': '1',
 192                                                 'tenant_id': 'org_vdc_1'}
 193
 194         # Call the consume method of plugin_receiver
 195         self.plugin_receiver.handle_metric_requests('read_metric_data_request', value, vim_uuid)
 196         m_get_metrics_data.assert_called_with(value)
 197
 198         # Check if publish method called with correct parameters
 199         m_publish_metric_data_status.assert_called_with({"metrics_data": "metrics_details"})
 200
 201     @mock.patch.object(monPluginRec.PluginReceiver, 'publish_create_metric_response')
 202     @mock.patch.object(monPluginRec.PluginReceiver, 'verify_metric')
 203     def test_consume_create_metric_request_key(self, m_verify_metric,
 204                                                m_publish_create_metric_response):
 205         """Test functionality of consume for create_metric_request key"""
 206
 207         vim_uuid = "f85fc39e-723d-4172-979b-de28b36465bb"
 208         value = {"vim_uuid": vim_uuid, "metric_create": "metric_details"}
 209
 210         # set the return value
 211         m_verify_metric.return_value = True
 212
 213         # Call the consume method of plugin_receiver
 214         self.plugin_receiver.handle_metric_requests('create_metric_request', value, vim_uuid)
 215         m_verify_metric.assert_called_with(value)
 216
 217         # Check if publish method called with correct parameters
 218         m_publish_create_metric_response.assert_called_with(value, True)
 219
 220     @mock.patch.object(monPluginRec.PluginReceiver, 'publish_update_metric_response')
 221     @mock.patch.object(monPluginRec.PluginReceiver, 'verify_metric')
 222     def test_consume_update_metric_request_key(self, m_verify_metric,
 223                                                m_publish_update_metric_response):
 224         """Test functionality of update metric request key"""
 225
 226         vim_uuid = "f85fc39e-723d-4172-979b-de28b36465bb"
 227
 228         value = {"vim_uuid": vim_uuid, "metric_create": "metric_details"}
 229
 230         # set the return value
 231         m_verify_metric.return_value = True
 232
 233         # Call the consume method of plugin_receiver
 234         self.plugin_receiver.handle_metric_requests('update_metric_request', value, vim_uuid)
 235
 236         # verify mocked methods called with correct parameters
 237         m_verify_metric.assert_called_with(value)
 238         m_publish_update_metric_response.assert_called_with(value, True)
 239
 240     @mock.patch.object(monPluginRec.PluginReceiver, 'publish_delete_metric_response')
 241     def test_consume_delete_metric_request_key(self, m_publish_delete_metric_response):
 242         """Test functionality of consume for delete_metric_request key"""
 243
 244         # Note: vROPS doesn't support deleting metric data
 245         vim_uuid = "f85fc39e-723d-4172-979b-de28b36465bb"
 246
 247         value = {"vim_uuid": vim_uuid, "metric_name": "metric_details"}
 248
 249         # Call the consume method of plugin_receiver
 250         self.plugin_receiver.handle_metric_requests('delete_metric_request', value, vim_uuid)
 251
 252         # Check if publish method called with correct parameters
 253         m_publish_delete_metric_response.assert_called_with(value)
 254
 255     @mock.patch.object(monPluginRec.MonPlugin, 'configure_alarm')
 256     @mock.patch.object(monPluginRec.MonPlugin, 'configure_rest_plugin')
 257     @mock.patch.object(monPluginRec.PluginReceiver, 'get_vim_access_config')
 258     def test_create_alarm_successful(self, m_get_vim_access_config,
 259                                      m_configure_rest_plugin,
 260                                      m_configure_alarm):
 261         """ Test functionality of create alarm method-positive case"""
 262
 263         # Mock config_alarm_info
 264         config_alarm_info = {"schema_version": 1.0,
 265                              "schema_type": "create_alarm_request",
 266                              "vim_type": "VMware",
 267                              "vim_uuid": "1",
 268                              "alarm_create_request": {"correlation_id": 1,
 269                                                       "alarm_name": "CPU_Utilize_Threshold",
 270                                                       "metric_name": "CPU_UTILIZATION",
 271                                                       "tenant_uuid": "tenant_uuid",
 272                                                       "resource_uuid": "resource_uuid",
 273                                                       "description": "test_create_alarm",
 274                                                       "severity": "CRITICAL",
 275                                                       "operation": "GT",
 276                                                       "threshold_value": 10,
 277                                                       "unit": "%",
 278                                                       "statistic": "AVERAGE"}}
 279
 280         # set return value to plugin uuid
 281         m_get_vim_access_config.return_value = {'vrops_site': 'abc',
 282                                                 'vrops_user': 'user',
 283                                                 'vrops_password': 'passwd',
 284                                                 'vim_url': 'vcd_url',
 285                                                 'admin_username': 'admin',
 286                                                 'admin_password': 'admin_passwd',
 287                                                 'vim_uuid': '1',
 288                                                 'tenant_id': 'org_vdc_1'}
 289
 290         m_configure_rest_plugin.retrun_value = "plugin_uuid"
 291         m_configure_alarm.return_value = "alarm_uuid"
 292
 293         # call create alarm method under test
 294         self.plugin_receiver.create_alarm(config_alarm_info)
 295
 296         # verify mocked methods get called with correct params
 297         m_get_vim_access_config.assert_called_with(config_alarm_info['vim_uuid'])
 298         m_configure_rest_plugin.assert_called_with()
 299         m_configure_alarm.assert_called_with(config_alarm_info["alarm_create_request"])
 300
 301     @mock.patch.object(monPluginRec.MonPlugin, 'configure_alarm')
 302     @mock.patch.object(monPluginRec.MonPlugin, 'configure_rest_plugin')
 303     @mock.patch.object(monPluginRec.PluginReceiver, 'get_vim_access_config')
 304     def test_create_alarm_failed(self, m_get_vim_access_config,
 305                                  m_configure_rest_plugin,
 306                                  m_configure_alarm):
 307         """ Test functionality of create alarm method negative case"""
 308
 309         # Mock config_alarm_info
 310         config_alarm_info = {"schema_version": 1.0,
 311                              "schema_type": "create_alarm_request",
 312                              "vim_type": "VMware",
 313                              "vim_uuid": "1",
 314                              "alarm_create_request": {"correlation_id": 1,
 315                                                       "alarm_name": "CPU_Utilize_Threshold",
 316                                                       "metric_name": "CPU_UTILIZATION",
 317                                                       "tenant_uuid": "tenant_uuid",
 318                                                       "resource_uuid": "resource_uuid",
 319                                                       "description": "test_create_alarm",
 320                                                       "severity": "CRITICAL",
 321                                                       "operation": "GT",
 322                                                       "threshold_value": 10,
 323                                                       "unit": "%",
 324                                                       "statistic": "AVERAGE"}}
 325
 326         # set return value to plugin uuid and alarm_uuid to None
 327         m_get_vim_access_config.return_value = {'vrops_site': 'abc',
 328                                                 'vrops_user': 'user',
 329                                                 'vrops_password': 'passwd',
 330                                                 'vim_url': 'vcd_url',
 331                                                 'admin_username': 'admin',
 332                                                 'admin_password': 'admin_passwd',
 333                                                 'vim_uuid': '1',
 334                                                 'tenant_id': 'org_vdc_1'}
 335         m_configure_rest_plugin.retrun_value = "plugin_uuid"
 336         m_configure_alarm.return_value = None
 337
 338         # call create alarm method under test
 339         alarm_uuid = self.plugin_receiver.create_alarm(config_alarm_info)
 340
 341         # verify mocked method called with correct params
 342         m_get_vim_access_config.assert_called_with(config_alarm_info['vim_uuid'])
 343         m_configure_rest_plugin.assert_called_with()
 344         m_configure_alarm.assert_called_with(config_alarm_info["alarm_create_request"])
 345
 346         # verify create alarm method returns None when failed
 347         self.assertEqual(alarm_uuid, None)
 348
 349     @mock.patch.object(monPluginRec.MonPlugin, 'update_alarm_configuration')
 350     @mock.patch.object(monPluginRec.PluginReceiver, 'get_vim_access_config')
 351     def test_update_alarm_successful(self, m_get_vim_access_config, m_update_alarm_configuration):
 352         """ Test functionality of update alarm method-positive case"""
 353
 354         # Mock update_alarm_info
 355         update_alarm_info = {"schema_version": 1.0, "schema_type": "update_alarm_request",
 356                              "vim_type": "VMware", "vim_uuid": "1",
 357                              "alarm_update_request": {'alarm_uuid': 'abc', 'correlation_id': 14203}}
 358
 359         # set return value to mocked method
 360         m_update_alarm_configuration.return_value = "alarm_uuid"
 361         m_get_vim_access_config.return_value = {'vrops_site': 'abc',
 362                                                 'vrops_user': 'user',
 363                                                 'vrops_password': 'passwd',
 364                                                 'vim_url': 'vcd_url',
 365                                                 'admin_username': 'admin',
 366                                                 'admin_password': 'admin_passwd',
 367                                                 'vim_uuid': '1',
 368                                                 'tenant_id': 'org_vdc_1'}
 369
 370         # check update alarm gets called and returned correct value
 371         ret_value = self.plugin_receiver.update_alarm(update_alarm_info)
 372
 373         # check mocked method get called with correct param
 374         m_get_vim_access_config.assert_called_with(update_alarm_info['vim_uuid'])
 375         m_update_alarm_configuration.assert_called_with(update_alarm_info["alarm_update_request"])
 376
 377         # check return value and passed values are correct
 378         self.assertEqual(ret_value, "alarm_uuid")
 379
 380     @mock.patch.object(monPluginRec.MonPlugin, 'update_alarm_configuration')
 381     @mock.patch.object(monPluginRec.PluginReceiver, 'get_vim_access_config')
 382     def test_update_alarm_failed(self, m_get_vim_access_config, m_update_alarm_configuration):
 383         """ Test functionality of update alarm method negative case"""
 384
 385         # Mock update_alarm_info
 386         update_alarm_info = {"schema_version": 1.0, "schema_type": "update_alarm_request",
 387                              "vim_type": "VMware", "vim_uuid": "1",
 388                              "alarm_update_request": {'alarm_uuid': 'abc', 'correlation_id': 14203}}
 389
 390         # set return value to mocked method
 391         m_update_alarm_configuration.return_value = None
 392         m_get_vim_access_config.return_value = {'vrops_site': 'abc',
 393                                                 'vrops_user': 'user',
 394                                                 'vrops_password': 'passwd',
 395                                                 'vim_url': 'vcd_url',
 396                                                 'admin_username': 'admin',
 397                                                 'admin_password': 'admin_passwd',
 398                                                 'vim_uuid': '1',
 399                                                 'tenant_id': 'org_vdc_1'}
 400
 401         # check update alarm gets called and returned correct value
 402         ret_value = self.plugin_receiver.update_alarm(update_alarm_info)
 403
 404         # check mocked method get called with correct param
 405         m_get_vim_access_config.assert_called_with(update_alarm_info['vim_uuid'])
 406         m_update_alarm_configuration.assert_called_with(update_alarm_info["alarm_update_request"])
 407
 408         # check return value and passed values are correct
 409         self.assertEqual(ret_value, None)
 410
 411     @mock.patch.object(monPluginRec.MonPlugin, 'delete_alarm_configuration')
 412     @mock.patch.object(monPluginRec.PluginReceiver, 'get_vim_access_config')
 413     def test_delete_alarm_successful(self, m_get_vim_access_config, m_delete_alarm_configuration):
 414         """ Test functionality of delete alarm method-positive case"""
 415
 416         # Mock delete_alarm_info
 417         delete_alarm_info = {"schema_version": 1.0, "schema_type": "delete_alarm_request",
 418                              "vim_type": "VMware", "vim_uuid": "1",
 419                              "alarm_delete_request": {'alarm_uuid': 'abc', 'correlation_id': 14203}}
 420
 421         # set return value to mocked method
 422         m_delete_alarm_configuration.return_value = "alarm_uuid"
 423         m_get_vim_access_config.return_value = {'vrops_site': 'abc',
 424                                                 'vrops_user': 'user',
 425                                                 'vrops_password': 'passwd',
 426                                                 'vim_url': 'vcd_url',
 427                                                 'admin_username': 'admin',
 428                                                 'admin_password': 'admin_passwd',
 429                                                 'vim_uuid': '1',
 430                                                 'tenant_id': 'org_vdc_1'}
 431
 432         # check delete alarm gets called and returned correct value
 433         ret_value = self.plugin_receiver.delete_alarm(delete_alarm_info)
 434
 435         # check mocked method get called with correct param
 436         m_get_vim_access_config.assert_called_with(delete_alarm_info['vim_uuid'])
 437         m_delete_alarm_configuration.assert_called_with(delete_alarm_info["alarm_delete_request"])
 438
 439         # check return value and passed values are correct
 440         self.assertEqual(ret_value, "alarm_uuid")
 441
 442     @mock.patch.object(monPluginRec.MonPlugin, 'delete_alarm_configuration')
 443     @mock.patch.object(monPluginRec.PluginReceiver, 'get_vim_access_config')
 444     def test_delete_alarm_failed(self, m_get_vim_access_config, m_delete_alarm_configuration):
 445         """ Test functionality of delete alarm method-negative case"""
 446
 447         # Mock update_alarm_info
 448         delete_alarm_info = {"schema_version": 1.0, "schema_type": "delete_alarm_request",
 449                              "vim_type": "VMware", "vim_uuid": "1",
 450                              "alarm_delete_request": {'alarm_uuid': 'abc', 'correlation_id': 14203}}
 451
 452         # set return value to mocked method
 453         m_delete_alarm_configuration.return_value = None
 454         m_get_vim_access_config.return_value = {'vrops_site': 'abc',
 455                                                 'vrops_user': 'user',
 456                                                 'vrops_password': 'passwd',
 457                                                 'vim_url': 'vcd_url',
 458                                                 'admin_username': 'admin',
 459                                                 'admin_password': 'admin_passwd',
 460                                                 'vim_uuid': '1',
 461                                                 'tenant_id': 'org_vdc_1'}
 462
 463         # check delete alarm gets called and returned correct value
 464         ret_value = self.plugin_receiver.delete_alarm(delete_alarm_info)
 465
 466         # check mocked method get called with correct param
 467         m_get_vim_access_config.assert_called_with(delete_alarm_info['vim_uuid'])
 468         m_delete_alarm_configuration.assert_called_with(delete_alarm_info["alarm_delete_request"])
 469
 470         # check return value to check failed status
 471         self.assertEqual(ret_value, None)
 472
 473     def test_publish_create_alarm_status(self):
 474         """ Test functionality of publish create alarm status method"""
 475
 476         # Mock config_alarm_info
 477         config_alarm_info = {'vim_type': 'VMware', "vim_uuid": "1",
 478                              'alarm_create_request': {
 479                                  'threshold_value': 0,
 480                                  'severity': 'CRITICAL',
 481                                  'alarm_name': 'CPU_Utilization_Above_Threshold',
 482                                  'resource_uuid': 'e14b203c-6bf2-4e2f-a91c-8c19d240eda4',
 483                                  'correlation_id': 1234,
 484                                  'statistic': 'AVERAGE',
 485                                  'metric_name': 'CPU_UTILIZATION'}
 486                              }
 487
 488         alarm_uuid = "xyz"
 489
 490         # call publish create status method under test
 491         self.plugin_receiver.publish_create_alarm_status(alarm_uuid, config_alarm_info)
 492
 493         # verify mocked method called with correct params
 494         # TODO(diazb): Validate payload generation (self.assertEquals(response, expected_message))
 495
 496     def test_publish_update_alarm_status(self):
 497         """ Test functionality of publish update alarm status method"""
 498
 499         # Mock update_alarm_info
 500         update_alarm_info = {'vim_type': 'VMware',
 501                              'vim_uuid': '1',
 502                              'schema_type': 'update_alarm_request',
 503                              'alarm_update_request': {'alarm_uuid': '6486e69',
 504                                                       'correlation_id': 14203,
 505                                                       'operation': 'GT'
 506                                                       }
 507                              }
 508
 509         alarm_uuid = "xyz"
 510
 511         # call publish update alarm status method under test
 512         self.plugin_receiver.publish_update_alarm_status(alarm_uuid, update_alarm_info)
 513
 514         # verify mocked method called with correct params
 515         # TODO(diazb): Validate payload generation (self.assertEquals(response, expected_message))
 516
 517     def test_publish_delete_alarm_status(self):
 518         """ Test functionality of publish delete alarm status method"""
 519
 520         # Mock delete_alarm_info
 521         delete_alarm_info = {'vim_type': 'VMware',
 522                              "vim_uuid": "1",
 523                              'schema_type': 'delete_alarm_request',
 524                              'alarm_delete_request': {'alarm_uuid': '6486e69',
 525                                                       'correlation_id': 14203,
 526                                                       'operation': 'GT'
 527                                                       }
 528                              }
 529
 530         alarm_uuid = "xyz"
 531
 532         # call publish delete alarm status method under test
 533         self.plugin_receiver.publish_delete_alarm_status(alarm_uuid, delete_alarm_info)
 534
 535         # verify mocked method called with correct params
 536         # TODO(diazb): Validate payload generation (self.assertEquals(response, expected_message))
 537
 538     def test_publish_metrics_data_status(self):
 539         """ Test functionality of publish metrics data status method"""
 540
 541         # Mock metrics data
 542         metrics_data = {
 543             'vim_uuid': '1',
 544             'metric_name': 'CPU_UTILIZATION', 'metric_uuid': '0',
 545             'resource_uuid': 'e14b20', 'correlation_id': 14203,
 546             'metrics_data': {'time_series': [15162011, 15162044],
 547                              'metrics_series': [0.1166666671, 0.1266666650]},
 548             'tenant_uuid': 123, 'unit': '%'
 549         }
 550
 551         # call publish metrics data status method under test
 552         self.plugin_receiver.publish_metrics_data_status(metrics_data)
 553
 554         # verify mocked method called with correct params
 555         # TODO(diazb): Validate payload generation (self.assertEquals(response, expected_message))
 556
 557     @mock.patch.object(monPluginRec.MonPlugin, 'verify_metric_support')
 558     @mock.patch.object(monPluginRec.PluginReceiver, 'get_vim_access_config')
 559     def test_verify_metric_supported_metric(self, m_get_vim_access_config,
 560                                             m_verify_metric_support):
 561         """ Test functionality of verify metric method"""
 562
 563         # mock metric_info
 564         metric_info = {'vim_uuid': '1',
 565                        'metric_create_request': {'metric_unit': '%',
 566                                                  'metric_name': 'CPU_UTILIZATION',
 567                                                  'resource_uuid': 'e14b203'}}
 568
 569         # set mocked function return value to true
 570         m_verify_metric_support.return_value = True
 571         m_get_vim_access_config.return_value = {'vrops_site': 'abc',
 572                                                 'vrops_user': 'user',
 573                                                 'vrops_password': 'passwd',
 574                                                 'vim_url': 'vcd_url',
 575                                                 'admin_username': 'admin',
 576                                                 'admin_password': 'admin_passwd',
 577                                                 'vim_uuid': '1',
 578                                                 'tenant_id': 'org_vdc_1'}
 579
 580         # call verify_metric method under test
 581         ret_value = self.plugin_receiver.verify_metric(metric_info)
 582
 583         # verify mocked method called with correct params
 584         m_get_vim_access_config.assert_called_with(metric_info['vim_uuid'])
 585         m_verify_metric_support.assert_called_with(metric_info['metric_create_request'])
 586
 587         # verify the return value
 588         self.assertEqual(ret_value, True)
 589
 590     @mock.patch.object(monPluginRec.MonPlugin, 'verify_metric_support')
 591     @mock.patch.object(monPluginRec.PluginReceiver, 'get_vim_access_config')
 592     def test_verify_metric_unsupported_metric(self, m_get_vim_access_config,
 593                                               m_verify_metric_support):
 594         """ Test functionality of verify metric method-negative case"""
 595
 596         # mock metric_info with unsupported metrics name
 597         metric_info = {'vim_uuid': '1',
 598                        'metric_create_request': {'metric_unit': '%',
 599                                                  'metric_name': 'Invalid',
 600                                                  'resource_uuid': 'e14b203'}}
 601
 602         # set mocked function return value to true
 603         m_verify_metric_support.return_value = False
 604         m_get_vim_access_config.return_value = {'vrops_site': 'abc',
 605                                                 'vrops_user': 'user',
 606                                                 'vrops_password': 'passwd',
 607                                                 'vim_url': 'vcd_url',
 608                                                 'admin_username': 'admin',
 609                                                 'admin_password': 'admin_passwd',
 610                                                 'vim_uuid': '1',
 611                                                 'tenant_id': 'org_vdc_1'}
 612
 613         # call verify_metric method under test
 614         ret_value = self.plugin_receiver.verify_metric(metric_info)
 615
 616         # verify mocked method called with correct params
 617         m_get_vim_access_config.assert_called_with(metric_info['vim_uuid'])
 618         m_verify_metric_support.assert_called_with(metric_info['metric_create_request'])
 619
 620         # verify the return value
 621         self.assertEqual(ret_value, False)
 622
 623     def test_publish_create_metric_response(self):
 624         """ Test functionality of publish create metric response method"""
 625
 626         # Mock metric_info
 627         metric_info = {
 628             'vim_uuid': '1',
 629             'vim_type': 'VMware',
 630             'correlation_id': 14203,
 631             'schema_type': 'create_metric_request',
 632             'metric_create_request': {
 633                 'resource_uuid': '6486e69',
 634                 'metric_name': 'CPU_UTILIZATION',
 635                 'metric_unit': '%'
 636             }
 637         }
 638
 639         metric_status = True
 640
 641         # call publish create metric method under test
 642         self.plugin_receiver.publish_create_metric_response(metric_info, metric_status)
 643
 644         # verify mocked method called with correct params
 645         # TODO(diazb): Validate payload generation (self.assertEquals(response, expected_message))
 646
 647     def test_publish_update_metric_response(self):
 648         """ Test functionality of publish update metric response method"""
 649
 650         # Mock metric_info
 651         metric_info = {
 652             'vim_uuid': '1',
 653             'vim_type': 'VMware',
 654             'correlation_id': 14203,
 655             'schema_type': 'update_metric_request',
 656             'metric_create': {
 657                 'resource_uuid': '6486e69',
 658                 'metric_name': 'CPU_UTILIZATION',
 659                 'metric_unit': '%'
 660             }
 661         }
 662
 663         metric_status = True
 664
 665         # call publish update metric method under test
 666         self.plugin_receiver.publish_update_metric_response(metric_info, metric_status)
 667
 668         # verify mocked method called with correct params
 669         # TODO(diazb): Validate payload generation (self.assertEquals(response, expected_message))
 670
 671     def test_publish_delete_metric_response(self):
 672         """ Test functionality of publish delete metric response method"""
 673
 674         # Mock metric_info
 675         metric_info = {'vim_uuid': '1', 'vim_type': 'VMware', 'correlation_id': 14203,
 676                        'metric_uuid': 'e14b203c', 'resource_uuid': '6486e69',
 677                        'metric_name': 'CPU_UTILIZATION',
 678                        'schema_type': 'delete_metric_request'}
 679
 680         # call publish delete metric method under test-vROPS doesn't support
 681         # delete metric,just returns response with success
 682         self.plugin_receiver.publish_delete_metric_response(metric_info)
 683
 684         # verify mocked method called with correct params
 685         # TODO(diazb): Validate payload generation (self.assertEquals(response, expected_message))
 686
 687     @mock.patch.object(monPluginRec.MonPlugin, 'get_triggered_alarms_list')
 688     @mock.patch.object(monPluginRec.PluginReceiver, 'get_vim_access_config')
 689     def test_list_alarms(self, m_get_vim_access_config, m_get_triggered_alarms_list):
 690         """ Test functionality of list alarms method"""
 691
 692         # Mock list alarm input
 693         list_alarm_input = {
 694             'vim_uuid': '1',
 695             'vim_type': 'VMware',
 696             'alarm_list_request': {
 697                 'severity': 'CRITICAL',
 698                 'correlation_id': 14203,
 699                 'alarm_name': 'CPU_Utilization_Above_Threshold',
 700                 'resource_uuid': 'd14b203c'}}
 701
 702         # set return value to mocked method
 703         m_return = [{'status': 'ACTIVE', 'update_date': '2018-01-12T08:34:05',
 704                      'severity': 'CRITICAL', 'resource_uuid': 'e14b203c',
 705                      'cancel_date': '0000-00-00T00:00:00', 'alarm_instance_uuid': 'd9e3bc84',
 706                      'alarm_uuid': '5714977d', 'vim_type': 'VMware',
 707                      'start_date': '2018-01-12T08:34:05'},
 708                     {'status': 'CANCELED', 'update_date': '2017-12-20T09:37:57',
 709                      'severity': 'CRITICAL', 'resource_uuid': 'e14b203c',
 710                      'cancel_date': '2018-01-12T06:49:19', 'alarm_instance_uuid': 'd3bbeef6',
 711                      'alarm_uuid': '7ba1bf3e', 'vim_type': 'VMware',
 712                      'start_date': '2017-12-20T09:37:57'}]
 713         m_get_triggered_alarms_list.return_value = m_return
 714
 715         m_get_vim_access_config.return_value = {'vrops_site': 'abc',
 716                                                 'vrops_user': 'user',
 717                                                 'vrops_password': 'passwd',
 718                                                 'vim_url': 'vcd_url',
 719                                                 'admin_username': 'admin',
 720                                                 'admin_password': 'admin_passwd',
 721                                                 'vim_uuid': '1',
 722                                                 'tenant_id': 'org_vdc_1'}
 723
 724         # call list alarms method under test
 725         return_value = self.plugin_receiver.list_alarms(list_alarm_input)
 726
 727         # verify mocked method called with correct params
 728         m_get_vim_access_config.assert_called_with(list_alarm_input['vim_uuid'])
 729         m_get_triggered_alarms_list.assert_called_with(list_alarm_input['alarm_list_request'])
 730
 731         # verify list alarm method returns correct list
 732         self.assertEqual(return_value, m_return)
 733
 734     def test_publish_list_alarm_response(self):
 735         """ Test functionality of publish list alarm response method"""
 736
 737         # Mock list alarm input
 738         msg_key = 'list_alarm_response'
 739         topic = 'alarm_response'
 740         list_alarm_input = {'vim_uuid': '1',
 741                             'vim_type': 'VMware',
 742                             'alarm_list_request': {
 743                                 'severity': 'CRITICAL',
 744                                 'correlation_id': 14203,
 745                                 'alarm_name': 'CPU_Utilization_Above_Threshold',
 746                                 'resource_uuid': 'd14b203c'}}
 747
 748         triggered_alarm_list = [{'status': 'ACTIVE', 'update_date': '2018-01-12T08:34:05',
 749                                  'severity': 'CRITICAL', 'resource_uuid': 'e14b203c',
 750                                  'cancel_date': '0000-00-00T00:00:00',
 751                                  'start_date': '2018-01-12T08:34:05',
 752                                  'alarm_instance_uuid': 'd9e3bc84',
 753                                  'alarm_uuid': '5714977d',
 754                                  'vim_type': 'VMware'
 755                                  }]
 756
 757         # call publish list alarm response method under test
 758         response = self.plugin_receiver.publish_list_alarm_response(triggered_alarm_list, list_alarm_input)
 759
 760         # verify mocked method called with correct params
 761         # TODO(diazb): Validate payload generation (self.assertEquals(response, expected_message))
 762
 763     def test_publish_access_update_response(self):
 764         """ Test functionality of publish access update response method"""
 765
 766         # Mock required inputs
 767         access_update_status = True
 768         access_info_req = {'vim_type': 'VMware',
 769                            'vim_uuid': '1',
 770                            'access_config': {'vrops_password': 'vmware',
 771                                              'vcloud-site': 'https://192.169.241.105',
 772                                              'vrops_user': 'Admin', 'correlation_id': 14203,
 773                                              'tenant_id': 'Org2'}
 774                            }
 775
 776         # call publish access update response method under test
 777         response = self.plugin_receiver.publish_access_update_response(access_update_status, access_info_req)
 778
 779         # verify mocked method called with correct params
 780         # TODO(diazb): Validate payload generation (self.assertEquals(response, expected_message))
 781
 782     @mock.patch.object(monPluginRec.PluginReceiver, 'write_access_config')
 783     def test_update_access_credentials_successful(self, m_write_access_config):
 784         """ Test functionality of update access credentials-positive case"""
 785
 786         # Mock access_info
 787         access_info = {'vrops_site': 'https://192.169.241.13', 'vrops_user': 'admin',
 788                        'vrops_password': 'vmware', 'vcloud-site': 'https://192.169.241.15',
 789                        'admin_username': 'admin', 'admin_password': 'vmware',
 790                        'vcenter_ip': '192.169.241.13', 'vcenter_port': '443',
 791                        'vcenter_user': 'admin', 'vcenter_password': 'vmware',
 792                        'vim_tenant_name': 'Org2', 'orgname': 'Org2', 'tenant_id': 'Org2'}
 793
 794         # Mock return values
 795         expected_status = m_write_access_config.return_value = True
 796
 797         # call publish update access credentials method under test
 798         actual_status = self.plugin_receiver.update_access_credentials(access_info)
 799
 800         # check write_access_config called with correct params
 801         m_write_access_config.assert_called_with(access_info)
 802
 803         # verify update access credentials returns correct status
 804         self.assertEqual(expected_status, actual_status)
 805
 806     @mock.patch.object(monPluginRec.PluginReceiver, 'write_access_config')
 807     def test_update_access_credentials_less_config_params(self, m_write_access_config):
 808         """ Test functionality of update access credentials-negative case"""
 809
 810         # Mock access_info
 811         access_info = {'vrops_site': 'https://192.169.241.13', 'vrops_user': 'admin',
 812                        'vrops_password': 'vmware', 'vcloud-site': 'https://192.169.241.15',
 813                        'admin_username': 'admin', 'admin_password': 'vmware',
 814                        'vcenter_ip': '192.169.241.13', 'vcenter_port': '443', 'vcenter_user': 'admin',
 815                        'vim_tenant_name': 'Org2', 'orgname': 'Org2', 'tenant_id': 'Org2'}
 816
 817         # Mock return values
 818         expected_status = m_write_access_config.return_value = False
 819
 820         # call publish update access credentials method under test
 821         actual_status = self.plugin_receiver.update_access_credentials(access_info)
 822
 823         # check if mocked method not called
 824         m_write_access_config.assert_not_called()
 825
 826         # verify update access credentials returns correct status
 827         self.assertEqual(expected_status, actual_status)
 828
 829     @mock.patch.object(monPluginRec.PluginReceiver, 'write_access_config')
 830     def test_update_access_credentials_failed(self, m_write_access_config):
 831         """ Test functionality of update access credentials-failed case """
 832
 833         # Mock access_info
 834         access_info = {'vrops_site': 'https://192.169.241.13', 'vrops_user': 'admin',
 835                        'vrops_password': 'vmware', 'vcloud-site': 'https://192.169.241.15',
 836                        'admin_username': 'admin', 'admin_password': 'vmware',
 837                        'vcenter_ip': '192.169.241.13', 'vcenter_port': '443',
 838                        'vcenter_user': 'admin', 'vcenter_password': 'vmware',
 839                        'vim_tenant_name': 'Org2', 'orgname': 'Org2', 'tenant_id': 'Org2'}
 840
 841         # Mock return values
 842         expected_status = m_write_access_config.return_value = False
 843
 844         # call publish update access credentials method under test
 845         actual_status = self.plugin_receiver.update_access_credentials(access_info)
 846
 847         # check write_access_config called with correct params
 848         m_write_access_config.assert_called_with(access_info)
 849
 850         # verify update access credentials returns correct status
 851         self.assertEqual(expected_status, actual_status)
 852
 853     def test_write_access_config_successful(self):
 854         """ Test functionality of write access config method-positive case"""
 855
 856         # Mock access_info
 857         access_info = {'vrops_sit': 'https://192.169.241.13', 'vrops_user': 'admin',
 858                        'vrops_password': 'vmware', 'vcloud-site': 'https://192.169.241.15',
 859                        'admin_username': 'admin', 'admin_password': 'vmware',
 860                        'vcenter_ip': '192.169.241.13', 'vcenter_port': '443',
 861                        'vcenter_user': 'admin', 'vcenter_password': 'vmware',
 862                        'vim_tenant_name': 'Org2', 'orgname': 'Org2', 'tenant_id': 'Org2'}
 863
 864         # call write access config method under test
 865         actual_status = self.plugin_receiver.write_access_config(access_info)
 866
 867         # verify write access config returns correct status
 868         self.assertEqual(True, actual_status)
 869
 870     def test_write_access_config_failed(self):
 871         """ Test functionality of write access config method-negative case"""
 872
 873         # Mock access_info
 874         access_info = []  # provided incorrect info to generate error
 875
 876         # call write access config method under test
 877         actual_status = self.plugin_receiver.write_access_config(access_info)
 878
 879         # verify write access config returns correct status
 880         self.assertEqual(False, actual_status)
 881
 882     @mock.patch.object(monPluginRec.AuthManager, 'get_credentials')
 883     def test_get_vim_access_config(self, m_get_credentials):
 884         """ Test functionality of get_vim_access_config method-positive case"""
 885
 886         # Mock vim_uuid & access_info
 887         vim_uuid = '1'
 888         vim_details = VimCredentials()
 889         vim_details.name = "vrops_vcd82"
 890         vim_details.password = "passwd"
 891         vim_details.tenant_name = "MANO-VDC"
 892         vim_details.type = "VMware"
 893         vim_details.url = "https://10.10.1.1"
 894         vim_details.user = "admin"
 895         vim_details.uuid = "1"
 896         vim_details.config = '{"orgname": "MANO-Org", "tenant_id": "MANO-VDC",\
 897                         "admin_username": "administrator","admin_password": "vcd_pwd",\
 898                         "vrops_user": "admin", "vrops_password": "vrops_pwd",\
 899                         "vrops_site": "https://10.10.1.2","nsx_user": "admin",\
 900                         "nsx_manager": "https://10.10.1.3", "nsx_password":"nsx_pwd",\
 901                         "sdn_controller": "None", "sdn_port_mapping": "None",\
 902                         "vcenter_ip": "10.10.1.4", "vcenter_user": "admin@vsphere.local",\
 903                         "vcenter_password": "vcenter_pwd", "vcenter_port": "443"}'
 904         m_get_credentials.return_value = vim_details
 905         expected_config = {'vrops_password': 'vrops_pwd', 'vcenter_password': 'vcenter_pwd',
 906                            'name': 'vrops_vcd82', 'org_user': 'admin',
 907                            'org_password': 'passwd', 'nsx_user': 'admin', 'vim_tenant_name': 'MANO-VDC',
 908                            'admin_username': 'administrator', 'vcenter_port': '443',
 909                            'vim_url': 'https://10.10.1.1', 'orgname': 'MANO-Org',
 910                            'admin_password': 'vcd_pwd', 'vrops_user': 'admin', 'vcenter_ip': '10.10.1.4',
 911                            'vrops_site': 'https://10.10.1.2', 'nsx_manager': 'https://10.10.1.3',
 912                            'nsx_password': 'nsx_pwd', 'vim_type': 'VMware', 'vim_uuid': '1',
 913                            'vcenter_user': 'admin@vsphere.local'}
 914
 915         # call get_vim_access_config method under test
 916         actual_config = self.plugin_receiver.get_vim_access_config('1')
 917
 918         # verify that mocked method is called
 919         m_get_credentials.assert_called_with(vim_uuid)
 920
 921         # Verify return value with expected value
 922         self.assertEqual(expected_config, actual_config)
 923
 924 # For testing purpose
 925 # if __name__ == '__main__':
 926
 927 #    unittest.main()