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_vim_session = mock.Mock()
  52         mock_get_vim_account.return_value = VIM_ACCOUNT
  53         self.collector = VMwareCollector(
  54             Config(), "9de6df67-b820-48c3-bcae-ee4838c5c5f4", mock_vim_session
  55         )
  56         self.mock_db = mock_db
  57         with open(
  58             os.path.join(os.path.dirname(__file__), "osm_mocks", "VNFR.json"), "r"
  59         ) as f:
  60             self.vnfr = json.load(f)
  61         with open(
  62             os.path.join(os.path.dirname(__file__), "osm_mocks", "VNFD.json"), "r"
  63         ) as f:
  64             self.vnfd = json.load(f)
  65
  66     def tearDown(self):
  67         super().tearDown()
  68
  69     def test_collect_cpu_and_memory(self, mock_vm_moref_id):
  70
  71         mock_vm_moref_id.return_value = "VMWARE-OID-VM-1"
  72         self.vnfd["vdu"][0]["monitoring-parameter"] = [
  73             {"id": "ubuntu_vnf_cpu_util", "performance-metric": "cpu_utilization"},
  74             {
  75                 "id": "ubuntu_vnf_average_memory_utilization",
  76                 "performance-metric": "average_memory_utilization",
  77             },
  78         ]
  79         self.mock_db.return_value.get_vnfd.return_value = self.vnfd
  80
  81         with requests_mock.Mocker() as mock_requests:
  82             mock_http_response(
  83                 mock_requests,
  84                 method="POST",
  85                 url_pattern="/suite-api/api/auth/token/acquire",
  86                 response_file="vrops_token.json",
  87             )
  88             mock_http_response(
  89                 mock_requests,
  90                 url_pattern="/suite-api/api/resources\\?resourceKind=VirtualMachine",
  91                 response_file="vrops_resources.json",
  92             )
  93             mock_http_response(
  94                 mock_requests,
  95                 url_pattern="/suite-api/api/resources/stats.*",
  96                 response_file="vrops_multi.json",
  97             )
  98             metrics = self.collector.collect(self.vnfr)
  99         self.assertEqual(len(metrics), 2, "Number of metrics returned")
 100         self.assertEqual(metrics[0].name, "cpu_utilization", "First metric name")
 101         self.assertEqual(metrics[0].value, 100.0, "CPU metric value")
 102         self.assertEqual(
 103             metrics[1].name, "average_memory_utilization", "Second metric name"
 104         )
 105         self.assertEqual(metrics[1].value, 20.515941619873047, "Memory metric value")
 106
 107     def test_collect_no_moref(self, mock_vm_moref_id):
 108         mock_vm_moref_id.return_value = None
 109         self.mock_db.return_value.get_vnfd.return_value = self.vnfd
 110         with requests_mock.Mocker() as mock_requests:
 111             mock_http_response(
 112                 mock_requests,
 113                 method="POST",
 114                 url_pattern="/suite-api/api/auth/token/acquire",
 115                 response_file="vrops_token.json",
 116             )
 117             mock_http_response(
 118                 mock_requests,
 119                 url_pattern="/suite-api/api/resources\\?resourceKind=VirtualMachine",
 120                 response_file="404.txt",
 121                 status_code=404,
 122             )
 123             metrics = self.collector.collect(self.vnfr)
 124         self.assertEqual(len(metrics), 0, "Number of metrics returned")
 125
 126     def test_collect_no_monitoring_param(self, _):
 127         self.vnfd["vdu"][0]["monitoring-parameter"] = []
 128         self.mock_db.return_value.get_vnfd.return_value = self.vnfd
 129         with requests_mock.Mocker() as mock_requests:
 130             mock_http_response(
 131                 mock_requests,
 132                 method="POST",
 133                 url_pattern="/suite-api/api/auth/token/acquire",
 134                 response_file="vrops_token.json",
 135             )
 136             mock_http_response(
 137                 mock_requests,
 138                 url_pattern="/suite-api/api/resources\\?resourceKind=VirtualMachine",
 139                 response_file="vrops_resources.json",
 140             )
 141             mock_http_response(
 142                 mock_requests,
 143                 url_pattern="/suite-api/api/resources/stats.*",
 144                 response_file="vrops_multi.json",
 145             )
 146             metrics = self.collector.collect(self.vnfr)
 147         self.assertEqual(len(metrics), 0, "Number of metrics returned")
 148
 149     def test_collect_empty_monitoring_param(self, _):
 150         del self.vnfd["vdu"][0]["monitoring-parameter"]
 151         self.mock_db.return_value.get_vnfd.return_value = self.vnfd
 152         with requests_mock.Mocker() as mock_requests:
 153             mock_http_response(
 154                 mock_requests,
 155                 method="POST",
 156                 url_pattern="/suite-api/api/auth/token/acquire",
 157                 response_file="vrops_token.json",
 158             )
 159             mock_http_response(
 160                 mock_requests,
 161                 url_pattern="/suite-api/api/resources\\?resourceKind=VirtualMachine",
 162                 response_file="vrops_resources.json",
 163             )
 164             mock_http_response(
 165                 mock_requests,
 166                 url_pattern="/suite-api/api/resources/stats.*",
 167                 response_file="vrops_multi.json",
 168             )
 169             metrics = self.collector.collect(self.vnfr)
 170         self.assertEqual(len(metrics), 0, "Number of metrics returned")
 171
 172     def test_collect_no_name(self, _):
 173         del self.vnfr["vdur"][0]["name"]
 174         del self.vnfr["vdur"][1]["name"]
 175         self.mock_db.return_value.get_vnfd.return_value = self.vnfd
 176         with requests_mock.Mocker() as mock_requests:
 177             mock_http_response(
 178                 mock_requests,
 179                 method="POST",
 180                 url_pattern="/suite-api/api/auth/token/acquire",
 181                 response_file="vrops_token.json",
 182             )
 183             mock_http_response(
 184                 mock_requests,
 185                 url_pattern="/suite-api/api/resources\\?resourceKind=VirtualMachine",
 186                 response_file="vrops_resources.json",
 187             )
 188             mock_http_response(
 189                 mock_requests,
 190                 url_pattern="/suite-api/api/resources/stats.*",
 191                 response_file="vrops_multi.json",
 192             )
 193             metrics = self.collector.collect(self.vnfr)
 194         self.assertEqual(len(metrics), 0, "Number of metrics returned")
 195
 196
 197 class VApp_Details_Test(TestCase):
 198     @mock.patch.object(VMwareCollector, "get_vim_account", spec_set=True, autospec=True)
 199     @mock.patch("osm_mon.collector.vnf_collectors.vmware.CommonDbClient")
 200     def setUp(self, mock_db, mock_get_vim_account):
 201         super().setUp()
 202         self.mock_db = mock_db
 203         mock_vim_session = mock.Mock()
 204         mock_get_vim_account.return_value = VIM_ACCOUNT
 205         self.collector = VMwareCollector(
 206             Config(), "9de6df67-b820-48c3-bcae-ee4838c5c5f4", mock_vim_session
 207         )
 208
 209     def tearDown(self):
 210         super().tearDown()
 211
 212     @mock.patch("osm_mon.collector.vnf_collectors.vmware.Client")
 213     def test_get_vapp_details(self, mock_vcd_client):
 214         mock_vcd_client.return_value._session.headers = {"x-vcloud-authorization": ""}
 215         with requests_mock.Mocker() as mock_requests:
 216             mock_http_response(
 217                 mock_requests,
 218                 site="https://vcd",
 219                 url_pattern="/api/vApp/.*",
 220                 response_file="vcd_vapp_response.xml",
 221             )
 222             response = self.collector.get_vapp_details_rest("")
 223         self.assertDictContainsSubset(
 224             {"vm_vcenter_info": {"vm_moref_id": "vm-4055"}},
 225             response,
 226             "Managed object reference id incorrect",
 227         )
 228
 229     def test_no_admin_connect(self):
 230         response = self.collector.get_vapp_details_rest("")
 231         self.assertDictEqual(
 232             response, {}, "Failed to connect should return empty dictionary"
 233         )
 234
 235     def test_no_id(self):
 236         response = self.collector.get_vapp_details_rest()
 237         self.assertDictEqual(
 238             response, {}, "No id supplied should return empty dictionary"
 239         )
 240
 241     @mock.patch("osm_mon.collector.vnf_collectors.vmware.Client")
 242     def test_get_vapp_details_404(self, mock_vcd_client):
 243         mock_vcd_client.return_value._session.headers = {"x-vcloud-authorization": ""}
 244         with requests_mock.Mocker() as mock_requests:
 245             mock_http_response(
 246                 mock_requests,
 247                 site="https://vcd",
 248                 url_pattern="/api/vApp/.*",
 249                 response_file="404.txt",
 250                 status_code=404,
 251             )
 252             response = self.collector.get_vapp_details_rest("")
 253         self.assertDictEqual(response, {}, "HTTP error should return empty dictionary")
 254
 255     @mock.patch("osm_mon.collector.vnf_collectors.vmware.Client")
 256     def test_get_vapp_details_xml_parse_error(self, mock_vcd_client):
 257         mock_vcd_client.return_value._session.headers = {"x-vcloud-authorization": ""}
 258         with requests_mock.Mocker() as mock_requests:
 259             mock_http_response(
 260                 mock_requests,
 261                 site="https://vcd",
 262                 url_pattern="/api/vApp/.*",
 263                 response_file="404.txt",
 264             )
 265             response = self.collector.get_vapp_details_rest("")
 266         self.assertDictEqual(
 267             response, {}, "XML parse error should return empty dictionary"
 268         )
 269
 270
 271 class Get_VM_Moref_Test(TestCase):
 272     @mock.patch.object(VMwareCollector, "get_vim_account", spec_set=True, autospec=True)
 273     @mock.patch("osm_mon.collector.vnf_collectors.vmware.CommonDbClient")
 274     def setUp(self, mock_db, mock_get_vim_account):
 275         super().setUp()
 276         self.mock_db = mock_db
 277         mock_vim_session = mock.Mock()
 278         mock_get_vim_account.return_value = VIM_ACCOUNT
 279         self.collector = VMwareCollector(
 280             Config(), "9de6df67-b820-48c3-bcae-ee4838c5c5f4", mock_vim_session
 281         )
 282
 283     def tearDown(self):
 284         super().tearDown()
 285
 286     @mock.patch.object(
 287         VMwareCollector, "get_vapp_details_rest", spec_set=True, autospec=True
 288     )
 289     def test_get_vm_moref_id(self, mock_vapp_details):
 290         mock_vapp_details.return_value = {"vm_vcenter_info": {"vm_moref_id": "vm-4055"}}
 291         response = self.collector.get_vm_moref_id("1234")
 292         self.assertEqual(
 293             response, "vm-4055", "Did not fetch correct ref id from dictionary"
 294         )
 295
 296     @mock.patch.object(
 297         VMwareCollector, "get_vapp_details_rest", spec_set=True, autospec=True
 298     )
 299     def test_get_vm_moref_bad_content(self, mock_vapp_details):
 300         mock_vapp_details.return_value = {}
 301         response = self.collector.get_vm_moref_id("1234")
 302         self.assertEqual(
 303             response, None, "Error fetching vapp details should return None"
 304         )
 305
 306     @mock.patch.object(
 307         VMwareCollector, "get_vapp_details_rest", spec_set=True, autospec=True
 308     )
 309     def test_get_vm_moref_has_exception(self, mock_vapp_details):
 310         mock_vapp_details.side_effect = Exception("Testing")
 311         response = self.collector.get_vm_moref_id("1234")
 312         self.assertEqual(
 313             response, None, "Exception while fetching vapp details should return None"
 314         )