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