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-parameter'] = [
  65             {"id": "ubuntu_vnf_cpu_util", "performance-metric": "cpu_utilization"},
  66             {"id": "ubuntu_vnf_average_memory_utilization", "performance-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, method='POST',
  72                                url_pattern='/suite-api/api/auth/token/acquire',
  73                                response_file='vrops_token.json')
  74             mock_http_response(mock_requests,
  75                                url_pattern='/suite-api/api/resources\\?resourceKind=VirtualMachine',
  76                                response_file='vrops_resources.json')
  77             mock_http_response(mock_requests,
  78                                url_pattern='/suite-api/api/resources/stats.*',
  79                                response_file='vrops_multi.json')
  80             metrics = self.collector.collect(self.vnfr)
  81         self.assertEqual(len(metrics), 2, "Number of metrics returned")
  82         self.assertEqual(metrics[0].name, "cpu_utilization", "First metric name")
  83         self.assertEqual(metrics[0].value, 100.0, "CPU metric value")
  84         self.assertEqual(metrics[1].name, "average_memory_utilization", "Second metric name")
  85         self.assertEqual(metrics[1].value, 20.515941619873047, "Memory metric value")
  86
  87     def test_collect_no_moref(self, mock_vm_moref_id):
  88         mock_vm_moref_id.return_value = None
  89         self.mock_db.return_value.get_vnfd.return_value = self.vnfd
  90         with requests_mock.Mocker() as mock_requests:
  91             mock_http_response(mock_requests, method='POST',
  92                                url_pattern='/suite-api/api/auth/token/acquire',
  93                                response_file='vrops_token.json')
  94             mock_http_response(mock_requests,
  95                                url_pattern='/suite-api/api/resources\\?resourceKind=VirtualMachine',
  96                                response_file='404.txt', status_code=404)
  97             metrics = self.collector.collect(self.vnfr)
  98         self.assertEqual(len(metrics), 0, "Number of metrics returned")
  99
 100     def test_collect_no_monitoring_param(self, _):
 101         self.vnfd['vdu'][0]['monitoring-parameter'] = []
 102         self.mock_db.return_value.get_vnfd.return_value = self.vnfd
 103         with requests_mock.Mocker() as mock_requests:
 104             mock_http_response(mock_requests, method='POST',
 105                                url_pattern='/suite-api/api/auth/token/acquire',
 106                                response_file='vrops_token.json')
 107             mock_http_response(mock_requests,
 108                                url_pattern='/suite-api/api/resources\\?resourceKind=VirtualMachine',
 109                                response_file='vrops_resources.json')
 110             mock_http_response(mock_requests,
 111                                url_pattern='/suite-api/api/resources/stats.*',
 112                                response_file='vrops_multi.json')
 113             metrics = self.collector.collect(self.vnfr)
 114         self.assertEqual(len(metrics), 0, "Number of metrics returned")
 115
 116     def test_collect_empty_monitoring_param(self, _):
 117         del self.vnfd['vdu'][0]['monitoring-parameter']
 118         self.mock_db.return_value.get_vnfd.return_value = self.vnfd
 119         with requests_mock.Mocker() as mock_requests:
 120             mock_http_response(mock_requests, method='POST',
 121                                url_pattern='/suite-api/api/auth/token/acquire',
 122                                response_file='vrops_token.json')
 123             mock_http_response(mock_requests,
 124                                url_pattern='/suite-api/api/resources\\?resourceKind=VirtualMachine',
 125                                response_file='vrops_resources.json')
 126             mock_http_response(mock_requests,
 127                                url_pattern='/suite-api/api/resources/stats.*',
 128                                response_file='vrops_multi.json')
 129             metrics = self.collector.collect(self.vnfr)
 130         self.assertEqual(len(metrics), 0, "Number of metrics returned")
 131
 132     def test_collect_no_name(self, _):
 133         del self.vnfr['vdur'][0]['name']
 134         del self.vnfr['vdur'][1]['name']
 135         self.mock_db.return_value.get_vnfd.return_value = self.vnfd
 136         with requests_mock.Mocker() as mock_requests:
 137             mock_http_response(mock_requests, method='POST',
 138                                url_pattern='/suite-api/api/auth/token/acquire',
 139                                response_file='vrops_token.json')
 140             mock_http_response(mock_requests,
 141                                url_pattern='/suite-api/api/resources\\?resourceKind=VirtualMachine',
 142                                response_file='vrops_resources.json')
 143             mock_http_response(mock_requests,
 144                                url_pattern='/suite-api/api/resources/stats.*',
 145                                response_file='vrops_multi.json')
 146             metrics = self.collector.collect(self.vnfr)
 147         self.assertEqual(len(metrics), 0, "Number of metrics returned")
 148
 149
 150 class VApp_Details_Test(TestCase):
 151
 152     @mock.patch.object(VMwareCollector, 'get_vim_account',
 153                        spec_set=True, autospec=True)
 154     @mock.patch('osm_mon.collector.vnf_collectors.vmware.CommonDbClient')
 155     def setUp(self, mock_db, mock_get_vim_account):
 156         super().setUp()
 157         self.mock_db = mock_db
 158         mock_get_vim_account.return_value = VIM_ACCOUNT
 159         self.collector = VMwareCollector(Config(), "9de6df67-b820-48c3-bcae-ee4838c5c5f4")
 160
 161     def tearDown(self):
 162         super().tearDown()
 163
 164     @mock.patch('osm_mon.collector.vnf_collectors.vmware.Client')
 165     def test_get_vapp_details(self, mock_vcd_client):
 166         mock_vcd_client.return_value._session.headers = {'x-vcloud-authorization': ''}
 167         with requests_mock.Mocker() as mock_requests:
 168             mock_http_response(mock_requests,
 169                                site='https://vcd',
 170                                url_pattern='/api/vApp/.*',
 171                                response_file='vcd_vapp_response.xml')
 172             response = self.collector.get_vapp_details_rest('')
 173         self.assertDictContainsSubset({'vm_vcenter_info': {'vm_moref_id': 'vm-4055'}},
 174                                       response, 'Managed object reference id incorrect')
 175
 176     def test_no_admin_connect(self):
 177         response = self.collector.get_vapp_details_rest('')
 178         self.assertDictEqual(response, {}, 'Failed to connect should return empty dictionary')
 179
 180     def test_no_id(self):
 181         response = self.collector.get_vapp_details_rest()
 182         self.assertDictEqual(response, {}, 'No id supplied should return empty dictionary')
 183
 184     @mock.patch('osm_mon.collector.vnf_collectors.vmware.Client')
 185     def test_get_vapp_details_404(self, mock_vcd_client):
 186         mock_vcd_client.return_value._session.headers = {'x-vcloud-authorization': ''}
 187         with requests_mock.Mocker() as mock_requests:
 188             mock_http_response(mock_requests,
 189                                site='https://vcd',
 190                                url_pattern='/api/vApp/.*',
 191                                response_file='404.txt', status_code=404)
 192             response = self.collector.get_vapp_details_rest('')
 193         self.assertDictEqual(response, {}, 'HTTP error should return empty dictionary')
 194
 195     @mock.patch('osm_mon.collector.vnf_collectors.vmware.Client')
 196     def test_get_vapp_details_xml_parse_error(self, mock_vcd_client):
 197         mock_vcd_client.return_value._session.headers = {'x-vcloud-authorization': ''}
 198         with requests_mock.Mocker() as mock_requests:
 199             mock_http_response(mock_requests,
 200                                site='https://vcd',
 201                                url_pattern='/api/vApp/.*',
 202                                response_file='404.txt')
 203             response = self.collector.get_vapp_details_rest('')
 204         self.assertDictEqual(response, {}, 'XML parse error should return empty dictionary')
 205
 206
 207 class Get_VM_Moref_Test(TestCase):
 208
 209     @mock.patch.object(VMwareCollector, 'get_vim_account',
 210                        spec_set=True, autospec=True)
 211     @mock.patch('osm_mon.collector.vnf_collectors.vmware.CommonDbClient')
 212     def setUp(self, mock_db, mock_get_vim_account):
 213         super().setUp()
 214         self.mock_db = mock_db
 215         mock_get_vim_account.return_value = VIM_ACCOUNT
 216         self.collector = VMwareCollector(Config(), "9de6df67-b820-48c3-bcae-ee4838c5c5f4")
 217
 218     def tearDown(self):
 219         super().tearDown()
 220
 221     @mock.patch.object(VMwareCollector, 'get_vapp_details_rest',
 222                        spec_set=True, autospec=True)
 223     def test_get_vm_moref_id(self, mock_vapp_details):
 224         mock_vapp_details.return_value = {'vm_vcenter_info': {'vm_moref_id': 'vm-4055'}}
 225         response = self.collector.get_vm_moref_id('1234')
 226         self.assertEqual(response, 'vm-4055', 'Did not fetch correct ref id from dictionary')
 227
 228     @mock.patch.object(VMwareCollector, 'get_vapp_details_rest',
 229                        spec_set=True, autospec=True)
 230     def test_get_vm_moref_bad_content(self, mock_vapp_details):
 231         mock_vapp_details.return_value = {}
 232         response = self.collector.get_vm_moref_id('1234')
 233         self.assertEqual(response, None, 'Error fetching vapp details should return None')
 234
 235     @mock.patch.object(VMwareCollector, 'get_vapp_details_rest',
 236                        spec_set=True, autospec=True)
 237     def test_get_vm_moref_has_exception(self, mock_vapp_details):
 238         mock_vapp_details.side_effect = Exception('Testing')
 239         response = self.collector.get_vm_moref_id('1234')
 240         self.assertEqual(response, None, 'Exception while fetching vapp details should return None')