osm_mon/tests/unit/collector/vnf_collectors/vmware/test_vcd_collector.py

   1 # -*- coding: utf-8 -*-
   2 # #
   3 # Copyright 2016-2019 VMware Inc.
   4 # This file is part of ETSI OSM
   5 # All Rights Reserved.
   6 #
   7 # Licensed under the Apache License, Version 2.0 (the "License"); you may
   8 # not use this file except in compliance with the License. You may obtain
   9 # a copy of the License at
  10 #
  11 #         http://www.apache.org/licenses/LICENSE-2.0
  12 #
  13 # Unless required by applicable law or agreed to in writing, software
  14 # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  15 # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
  16 # License for the specific language governing permissions and limitations
  17 # under the License.
  18 #
  19 # For those usages not covered by the Apache License, Version 2.0 please
  20 # contact:  osslegalrouting@vmware.com
  21 # #
  22
  23 from osm_mon.collector.vnf_collectors.vmware import VMwareCollector
  24 from osm_mon.core.config import Config
  25 from osm_mon.tests.unit.collector.vnf_collectors.vmware.mock_http import (
  26     mock_http_response,
  27 )
  28 from unittest import TestCase, mock
  29
  30 import json
  31 import os
  32 import requests_mock
  33
  34 VIM_ACCOUNT = {
  35     "vrops_site": "https://vrops",
  36     "vrops_user": "",
  37     "vrops_password": "",
  38     "vim_url": "https://vcd",
  39     "admin_username": "",
  40     "admin_password": "",
  41     "vim_uuid": "",
  42 }
  43
  44
  45 @mock.patch.object(VMwareCollector, "get_vm_moref_id", spec_set=True, autospec=True)
  46 class CollectorTest(TestCase):
  47     @mock.patch.object(VMwareCollector, "get_vim_account", spec_set=True, autospec=True)
  48     @mock.patch("osm_mon.collector.vnf_collectors.vmware.CommonDbClient")
  49     def setUp(self, mock_db, mock_get_vim_account):
  50         super().setUp()
  51         mock_get_vim_account.return_value = VIM_ACCOUNT
  52         self.collector = VMwareCollector(
  53             Config(), "9de6df67-b820-48c3-bcae-ee4838c5c5f4"
  54         )
  55         self.mock_db = mock_db
  56         with open(
  57             os.path.join(os.path.dirname(__file__), "osm_mocks", "VNFR.json"), "r"
  58         ) as f:
  59             self.vnfr = json.load(f)
  60         with open(
  61             os.path.join(os.path.dirname(__file__), "osm_mocks", "VNFD.json"), "r"
  62         ) as f:
  63             self.vnfd = json.load(f)
  64
  65     def tearDown(self):
  66         super().tearDown()
  67
  68     def test_collect_cpu_and_memory(self, mock_vm_moref_id):
  69
  70         mock_vm_moref_id.return_value = "VMWARE-OID-VM-1"
  71         self.vnfd["vdu"][0]["monitoring-parameter"] = [
  72             {"id": "ubuntu_vnf_cpu_util", "performance-metric": "cpu_utilization"},
  73             {
  74                 "id": "ubuntu_vnf_average_memory_utilization",
  75                 "performance-metric": "average_memory_utilization",
  76             },
  77         ]
  78         self.mock_db.return_value.get_vnfd.return_value = self.vnfd
  79
  80         with requests_mock.Mocker() as mock_requests:
  81             mock_http_response(
  82                 mock_requests,
  83                 method="POST",
  84                 url_pattern="/suite-api/api/auth/token/acquire",
  85                 response_file="vrops_token.json",
  86             )
  87             mock_http_response(
  88                 mock_requests,
  89                 url_pattern="/suite-api/api/resources\\?resourceKind=VirtualMachine",
  90                 response_file="vrops_resources.json",
  91             )
  92             mock_http_response(
  93                 mock_requests,
  94                 url_pattern="/suite-api/api/resources/stats.*",
  95                 response_file="vrops_multi.json",
  96             )
  97             metrics = self.collector.collect(self.vnfr)
  98         self.assertEqual(len(metrics), 2, "Number of metrics returned")
  99         self.assertEqual(metrics[0].name, "cpu_utilization", "First metric name")
 100         self.assertEqual(metrics[0].value, 100.0, "CPU metric value")
 101         self.assertEqual(
 102             metrics[1].name, "average_memory_utilization", "Second metric name"
 103         )
 104         self.assertEqual(metrics[1].value, 20.515941619873047, "Memory metric value")
 105
 106     def test_collect_no_moref(self, mock_vm_moref_id):
 107         mock_vm_moref_id.return_value = None
 108         self.mock_db.return_value.get_vnfd.return_value = self.vnfd
 109         with requests_mock.Mocker() as mock_requests:
 110             mock_http_response(
 111                 mock_requests,
 112                 method="POST",
 113                 url_pattern="/suite-api/api/auth/token/acquire",
 114                 response_file="vrops_token.json",
 115             )
 116             mock_http_response(
 117                 mock_requests,
 118                 url_pattern="/suite-api/api/resources\\?resourceKind=VirtualMachine",
 119                 response_file="404.txt",
 120                 status_code=404,
 121             )
 122             metrics = self.collector.collect(self.vnfr)
 123         self.assertEqual(len(metrics), 0, "Number of metrics returned")
 124
 125     def test_collect_no_monitoring_param(self, _):
 126         self.vnfd["vdu"][0]["monitoring-parameter"] = []
 127         self.mock_db.return_value.get_vnfd.return_value = self.vnfd
 128         with requests_mock.Mocker() as mock_requests:
 129             mock_http_response(
 130                 mock_requests,
 131                 method="POST",
 132                 url_pattern="/suite-api/api/auth/token/acquire",
 133                 response_file="vrops_token.json",
 134             )
 135             mock_http_response(
 136                 mock_requests,
 137                 url_pattern="/suite-api/api/resources\\?resourceKind=VirtualMachine",
 138                 response_file="vrops_resources.json",
 139             )
 140             mock_http_response(
 141                 mock_requests,
 142                 url_pattern="/suite-api/api/resources/stats.*",
 143                 response_file="vrops_multi.json",
 144             )
 145             metrics = self.collector.collect(self.vnfr)
 146         self.assertEqual(len(metrics), 0, "Number of metrics returned")
 147
 148     def test_collect_empty_monitoring_param(self, _):
 149         del self.vnfd["vdu"][0]["monitoring-parameter"]
 150         self.mock_db.return_value.get_vnfd.return_value = self.vnfd
 151         with requests_mock.Mocker() as mock_requests:
 152             mock_http_response(
 153                 mock_requests,
 154                 method="POST",
 155                 url_pattern="/suite-api/api/auth/token/acquire",
 156                 response_file="vrops_token.json",
 157             )
 158             mock_http_response(
 159                 mock_requests,
 160                 url_pattern="/suite-api/api/resources\\?resourceKind=VirtualMachine",
 161                 response_file="vrops_resources.json",
 162             )
 163             mock_http_response(
 164                 mock_requests,
 165                 url_pattern="/suite-api/api/resources/stats.*",
 166                 response_file="vrops_multi.json",
 167             )
 168             metrics = self.collector.collect(self.vnfr)
 169         self.assertEqual(len(metrics), 0, "Number of metrics returned")
 170
 171     def test_collect_no_name(self, _):
 172         del self.vnfr["vdur"][0]["name"]
 173         del self.vnfr["vdur"][1]["name"]
 174         self.mock_db.return_value.get_vnfd.return_value = self.vnfd
 175         with requests_mock.Mocker() as mock_requests:
 176             mock_http_response(
 177                 mock_requests,
 178                 method="POST",
 179                 url_pattern="/suite-api/api/auth/token/acquire",
 180                 response_file="vrops_token.json",
 181             )
 182             mock_http_response(
 183                 mock_requests,
 184                 url_pattern="/suite-api/api/resources\\?resourceKind=VirtualMachine",
 185                 response_file="vrops_resources.json",
 186             )
 187             mock_http_response(
 188                 mock_requests,
 189                 url_pattern="/suite-api/api/resources/stats.*",
 190                 response_file="vrops_multi.json",
 191             )
 192             metrics = self.collector.collect(self.vnfr)
 193         self.assertEqual(len(metrics), 0, "Number of metrics returned")
 194
 195
 196 class VApp_Details_Test(TestCase):
 197     @mock.patch.object(VMwareCollector, "get_vim_account", spec_set=True, autospec=True)
 198     @mock.patch("osm_mon.collector.vnf_collectors.vmware.CommonDbClient")
 199     def setUp(self, mock_db, mock_get_vim_account):
 200         super().setUp()
 201         self.mock_db = mock_db
 202         mock_get_vim_account.return_value = VIM_ACCOUNT
 203         self.collector = VMwareCollector(
 204             Config(), "9de6df67-b820-48c3-bcae-ee4838c5c5f4"
 205         )
 206
 207     def tearDown(self):
 208         super().tearDown()
 209
 210     @mock.patch("osm_mon.collector.vnf_collectors.vmware.Client")
 211     def test_get_vapp_details(self, mock_vcd_client):
 212         mock_vcd_client.return_value._session.headers = {"x-vcloud-authorization": ""}
 213         with requests_mock.Mocker() as mock_requests:
 214             mock_http_response(
 215                 mock_requests,
 216                 site="https://vcd",
 217                 url_pattern="/api/vApp/.*",
 218                 response_file="vcd_vapp_response.xml",
 219             )
 220             response = self.collector.get_vapp_details_rest("")
 221         self.assertDictContainsSubset(
 222             {"vm_vcenter_info": {"vm_moref_id": "vm-4055"}},
 223             response,
 224             "Managed object reference id incorrect",
 225         )
 226
 227     def test_no_admin_connect(self):
 228         response = self.collector.get_vapp_details_rest("")
 229         self.assertDictEqual(
 230             response, {}, "Failed to connect should return empty dictionary"
 231         )
 232
 233     def test_no_id(self):
 234         response = self.collector.get_vapp_details_rest()
 235         self.assertDictEqual(
 236             response, {}, "No id supplied should return empty dictionary"
 237         )
 238
 239     @mock.patch("osm_mon.collector.vnf_collectors.vmware.Client")
 240     def test_get_vapp_details_404(self, mock_vcd_client):
 241         mock_vcd_client.return_value._session.headers = {"x-vcloud-authorization": ""}
 242         with requests_mock.Mocker() as mock_requests:
 243             mock_http_response(
 244                 mock_requests,
 245                 site="https://vcd",
 246                 url_pattern="/api/vApp/.*",
 247                 response_file="404.txt",
 248                 status_code=404,
 249             )
 250             response = self.collector.get_vapp_details_rest("")
 251         self.assertDictEqual(response, {}, "HTTP error should return empty dictionary")
 252
 253     @mock.patch("osm_mon.collector.vnf_collectors.vmware.Client")
 254     def test_get_vapp_details_xml_parse_error(self, mock_vcd_client):
 255         mock_vcd_client.return_value._session.headers = {"x-vcloud-authorization": ""}
 256         with requests_mock.Mocker() as mock_requests:
 257             mock_http_response(
 258                 mock_requests,
 259                 site="https://vcd",
 260                 url_pattern="/api/vApp/.*",
 261                 response_file="404.txt",
 262             )
 263             response = self.collector.get_vapp_details_rest("")
 264         self.assertDictEqual(
 265             response, {}, "XML parse error should return empty dictionary"
 266         )
 267
 268
 269 class Get_VM_Moref_Test(TestCase):
 270     @mock.patch.object(VMwareCollector, "get_vim_account", spec_set=True, autospec=True)
 271     @mock.patch("osm_mon.collector.vnf_collectors.vmware.CommonDbClient")
 272     def setUp(self, mock_db, mock_get_vim_account):
 273         super().setUp()
 274         self.mock_db = mock_db
 275         mock_get_vim_account.return_value = VIM_ACCOUNT
 276         self.collector = VMwareCollector(
 277             Config(), "9de6df67-b820-48c3-bcae-ee4838c5c5f4"
 278         )
 279
 280     def tearDown(self):
 281         super().tearDown()
 282
 283     @mock.patch.object(
 284         VMwareCollector, "get_vapp_details_rest", spec_set=True, autospec=True
 285     )
 286     def test_get_vm_moref_id(self, mock_vapp_details):
 287         mock_vapp_details.return_value = {"vm_vcenter_info": {"vm_moref_id": "vm-4055"}}
 288         response = self.collector.get_vm_moref_id("1234")
 289         self.assertEqual(
 290             response, "vm-4055", "Did not fetch correct ref id from dictionary"
 291         )
 292
 293     @mock.patch.object(
 294         VMwareCollector, "get_vapp_details_rest", spec_set=True, autospec=True
 295     )
 296     def test_get_vm_moref_bad_content(self, mock_vapp_details):
 297         mock_vapp_details.return_value = {}
 298         response = self.collector.get_vm_moref_id("1234")
 299         self.assertEqual(
 300             response, None, "Error fetching vapp details should return None"
 301         )
 302
 303     @mock.patch.object(
 304         VMwareCollector, "get_vapp_details_rest", spec_set=True, autospec=True
 305     )
 306     def test_get_vm_moref_has_exception(self, mock_vapp_details):
 307         mock_vapp_details.side_effect = Exception("Testing")
 308         response = self.collector.get_vm_moref_id("1234")
 309         self.assertEqual(
 310             response, None, "Exception while fetching vapp details should return None"
 311         )