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 mock_http_response
  26 from unittest import TestCase, mock
  27
  28 import json
  29 import os
  30 import requests_mock
  31
  32 VIM_ACCOUNT = {"vrops_site": "https://vrops",
  33                "vrops_user": "",
  34                "vrops_password": "",
  35                "vim_url": "https://vcd",
  36                "admin_username": "",
  37                "admin_password": "",
  38                "vim_uuid": ""}
  39
  40
  41 @mock.patch.object(VMwareCollector, 'get_vm_moref_id',
  42                    spec_set=True, autospec=True)
  43 class CollectorTest(TestCase):
  44
  45     @mock.patch.object(VMwareCollector, 'get_vim_account',
  46                        spec_set=True, autospec=True)
  47     @mock.patch('osm_mon.collector.vnf_collectors.vmware.CommonDbClient')
  48     def setUp(self, mock_db, mock_get_vim_account):
  49         super().setUp()
  50         mock_get_vim_account.return_value = VIM_ACCOUNT
  51         self.collector = VMwareCollector(Config(), "9de6df67-b820-48c3-bcae-ee4838c5c5f4")
  52         self.mock_db = mock_db
  53         with open(os.path.join(os.path.dirname(__file__), 'osm_mocks', 'VNFR.json'), 'r') as f:
  54             self.vnfr = json.load(f)
  55         with open(os.path.join(os.path.dirname(__file__), 'osm_mocks', 'VNFD.json'), 'r') as f:
  56             self.vnfd = json.load(f)
  57
  58     def tearDown(self):
  59         super().tearDown()
  60
  61     def test_collect_cpu_and_memory(self, mock_vm_moref_id):
  62
  63         mock_vm_moref_id.return_value = "VMWARE-OID-VM-1"
  64         self.vnfd['vdu'][0]['monitoring-param'] = [
  65             {"id": "ubuntu_vnfd-VM_cpu_util", "nfvi-metric": "cpu_utilization"},
  66             {"id": "ubuntu_vnfd-VM_average_memory_utilization", "nfvi-metric": "average_memory_utilization"}
  67             ]
  68         self.mock_db.return_value.get_vnfd.return_value = self.vnfd
  69
  70         with requests_mock.Mocker() as mock_requests:
  71             mock_http_response(mock_requests,
  72                                url_pattern='/suite-api/api/resources\\?resourceKind=VirtualMachine',
  73                                response_file='vrops_resources.json')
  74             mock_http_response(mock_requests,
  75                                url_pattern='/suite-api/api/resources/stats.*',
  76                                response_file='vrops_multi.json')
  77             metrics = self.collector.collect(self.vnfr)
  78         self.assertEqual(len(metrics), 2, "Number of metrics returned")
  79         self.assertEqual(metrics[0].name, "cpu_utilization", "First metric name")
  80         self.assertEqual(metrics[0].value, 100.0, "CPU metric value")
  81         self.assertEqual(metrics[1].name, "average_memory_utilization", "Second metric name")
  82         self.assertEqual(metrics[1].value, 20.515941619873047, "Memory metric value")
  83
  84     def test_collect_no_moref(self, mock_vm_moref_id):
  85         mock_vm_moref_id.return_value = None
  86         self.mock_db.return_value.get_vnfd.return_value = self.vnfd
  87         with requests_mock.Mocker() as mock_requests:
  88             mock_http_response(mock_requests,
  89                                url_pattern='/suite-api/api/resources\\?resourceKind=VirtualMachine',
  90                                response_file='404.txt', status_code=404)
  91             metrics = self.collector.collect(self.vnfr)
  92         self.assertEqual(len(metrics), 0, "Number of metrics returned")
  93
  94     def test_collect_no_monitoring_param(self, _):
  95         self.vnfd['vdu'][0]['monitoring-param'] = []
  96         self.mock_db.return_value.get_vnfd.return_value = self.vnfd
  97         with requests_mock.Mocker() as mock_requests:
  98             mock_http_response(mock_requests,
  99                                url_pattern='/suite-api/api/resources\\?resourceKind=VirtualMachine',
 100                                response_file='vrops_resources.json')
 101             mock_http_response(mock_requests,
 102                                url_pattern='/suite-api/api/resources/stats.*',
 103                                response_file='vrops_multi.json')
 104             metrics = self.collector.collect(self.vnfr)
 105         self.assertEqual(len(metrics), 0, "Number of metrics returned")
 106
 107     def test_collect_empty_monitoring_param(self, _):
 108         del self.vnfd['vdu'][0]['monitoring-param']
 109         self.mock_db.return_value.get_vnfd.return_value = self.vnfd
 110         with requests_mock.Mocker() as mock_requests:
 111             mock_http_response(mock_requests,
 112                                url_pattern='/suite-api/api/resources\\?resourceKind=VirtualMachine',
 113                                response_file='vrops_resources.json')
 114             mock_http_response(mock_requests,
 115                                url_pattern='/suite-api/api/resources/stats.*',
 116                                response_file='vrops_multi.json')
 117             metrics = self.collector.collect(self.vnfr)
 118         self.assertEqual(len(metrics), 0, "Number of metrics returned")
 119
 120     def test_collect_no_name(self, _):
 121         del self.vnfr['vdur'][0]['name']
 122         del self.vnfr['vdur'][1]['name']
 123         self.mock_db.return_value.get_vnfd.return_value = self.vnfd
 124         with requests_mock.Mocker() as mock_requests:
 125             mock_http_response(mock_requests,
 126                                url_pattern='/suite-api/api/resources\\?resourceKind=VirtualMachine',
 127                                response_file='vrops_resources.json')
 128             mock_http_response(mock_requests,
 129                                url_pattern='/suite-api/api/resources/stats.*',
 130                                response_file='vrops_multi.json')
 131             metrics = self.collector.collect(self.vnfr)
 132         self.assertEqual(len(metrics), 0, "Number of metrics returned")
 133
 134
 135 class VApp_Details_Test(TestCase):
 136
 137     @mock.patch.object(VMwareCollector, 'get_vim_account',
 138                        spec_set=True, autospec=True)
 139     @mock.patch('osm_mon.collector.vnf_collectors.vmware.CommonDbClient')
 140     def setUp(self, mock_db, mock_get_vim_account):
 141         super().setUp()
 142         self.mock_db = mock_db
 143         mock_get_vim_account.return_value = VIM_ACCOUNT
 144         self.collector = VMwareCollector(Config(), "9de6df67-b820-48c3-bcae-ee4838c5c5f4")
 145
 146     def tearDown(self):
 147         super().tearDown()
 148
 149     @mock.patch('osm_mon.collector.vnf_collectors.vmware.Client')
 150     def test_get_vapp_details(self, mock_vcd_client):
 151         mock_vcd_client.return_value._session.headers = {'x-vcloud-authorization': ''}
 152         with requests_mock.Mocker() as mock_requests:
 153             mock_http_response(mock_requests,
 154                                site='https://vcd',
 155                                url_pattern='/api/vApp/.*',
 156                                response_file='vcd_vapp_response.xml')
 157             response = self.collector.get_vapp_details_rest('')
 158         self.assertDictContainsSubset({'vm_vcenter_info': {'vm_moref_id': 'vm-4055'}},
 159                                       response, 'Managed object reference id incorrect')
 160
 161     def test_no_admin_connect(self):
 162         response = self.collector.get_vapp_details_rest('')
 163         self.assertDictEqual(response, {}, 'Failed to connect should return empty dictionary')
 164
 165     def test_no_id(self):
 166         response = self.collector.get_vapp_details_rest()
 167         self.assertDictEqual(response, {}, 'No id supplied should return empty dictionary')
 168
 169     @mock.patch('osm_mon.collector.vnf_collectors.vmware.Client')
 170     def test_get_vapp_details_404(self, mock_vcd_client):
 171         mock_vcd_client.return_value._session.headers = {'x-vcloud-authorization': ''}
 172         with requests_mock.Mocker() as mock_requests:
 173             mock_http_response(mock_requests,
 174                                site='https://vcd',
 175                                url_pattern='/api/vApp/.*',
 176                                response_file='404.txt', status_code=404)
 177             response = self.collector.get_vapp_details_rest('')
 178         self.assertDictEqual(response, {}, 'HTTP error should return empty dictionary')
 179
 180     @mock.patch('osm_mon.collector.vnf_collectors.vmware.Client')
 181     def test_get_vapp_details_xml_parse_error(self, mock_vcd_client):
 182         mock_vcd_client.return_value._session.headers = {'x-vcloud-authorization': ''}
 183         with requests_mock.Mocker() as mock_requests:
 184             mock_http_response(mock_requests,
 185                                site='https://vcd',
 186                                url_pattern='/api/vApp/.*',
 187                                response_file='404.txt')
 188             response = self.collector.get_vapp_details_rest('')
 189         self.assertDictEqual(response, {}, 'XML parse error should return empty dictionary')
 190
 191
 192 class Get_VM_Moref_Test(TestCase):
 193
 194     @mock.patch.object(VMwareCollector, 'get_vim_account',
 195                        spec_set=True, autospec=True)
 196     @mock.patch('osm_mon.collector.vnf_collectors.vmware.CommonDbClient')
 197     def setUp(self, mock_db, mock_get_vim_account):
 198         super().setUp()
 199         self.mock_db = mock_db
 200         mock_get_vim_account.return_value = VIM_ACCOUNT
 201         self.collector = VMwareCollector(Config(), "9de6df67-b820-48c3-bcae-ee4838c5c5f4")
 202
 203     def tearDown(self):
 204         super().tearDown()
 205
 206     @mock.patch.object(VMwareCollector, 'get_vapp_details_rest',
 207                        spec_set=True, autospec=True)
 208     def test_get_vm_moref_id(self, mock_vapp_details):
 209         mock_vapp_details.return_value = {'vm_vcenter_info': {'vm_moref_id': 'vm-4055'}}
 210         response = self.collector.get_vm_moref_id('1234')
 211         self.assertEqual(response, 'vm-4055', 'Did not fetch correct ref id from dictionary')
 212
 213     @mock.patch.object(VMwareCollector, 'get_vapp_details_rest',
 214                        spec_set=True, autospec=True)
 215     def test_get_vm_moref_bad_content(self, mock_vapp_details):
 216         mock_vapp_details.return_value = {}
 217         response = self.collector.get_vm_moref_id('1234')
 218         self.assertEqual(response, None, 'Error fetching vapp details should return None')
 219
 220     @mock.patch.object(VMwareCollector, 'get_vapp_details_rest',
 221                        spec_set=True, autospec=True)
 222     def test_get_vm_moref_has_exception(self, mock_vapp_details):
 223         mock_vapp_details.side_effect = Exception('Testing')
 224         response = self.collector.get_vm_moref_id('1234')
 225         self.assertEqual(response, None, 'Exception while fetching vapp details should return None')