osm_mon/tests/unit/collector/vnf_collectors/vmware/test_vrops_helper.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.vrops.vrops_helper import vROPS_Helper
  24 from osm_mon.tests.unit.collector.vnf_collectors.vmware.mock_http import mock_http_response
  25 from unittest import TestCase
  26
  27 import json
  28 import os
  29 import requests_mock
  30
  31
  32 class vROPS_Helper_Resource_List_Test(TestCase):
  33
  34     def setUp(self):
  35         super().setUp()
  36         self.vrops = vROPS_Helper()
  37
  38     def tearDown(self):
  39         super().tearDown()
  40
  41     def test_get_vm_resource_list_from_vrops(self):
  42         with requests_mock.Mocker() as mock_requests:
  43             mock_http_response(mock_requests, method='POST',
  44                                url_pattern='/suite-api/api/auth/token/acquire',
  45                                response_file='vrops_token.json')
  46             mock_http_response(mock_requests,
  47                                url_pattern='/suite-api/api/resources\\?resourceKind=VirtualMachine',
  48                                response_file='vrops_resources.json')
  49             resource_list = self.vrops.get_vm_resource_list_from_vrops()
  50             self.assertEqual(len(resource_list), 3, "List of resources from canned vrops_resources.json")
  51
  52     def test_get_vm_resource_list_from_vrops_http_404(self):
  53         with requests_mock.Mocker() as mock_requests:
  54             mock_http_response(mock_requests, method='POST',
  55                                url_pattern='/suite-api/api/auth/token/acquire',
  56                                response_file='vrops_token.json')
  57             mock_http_response(mock_requests,
  58                                url_pattern='/suite-api/api/resources\\?resourceKind=VirtualMachine',
  59                                response_file='404.txt', status_code=404)
  60             resource_list = self.vrops.get_vm_resource_list_from_vrops()
  61             self.assertEqual(len(resource_list), 0, "Should return an empty list")
  62
  63     def test_get_vm_resource_list_from_vrops_bad_json(self):
  64         with requests_mock.Mocker() as mock_requests:
  65             mock_http_response(mock_requests, method='POST',
  66                                url_pattern='/suite-api/api/auth/token/acquire',
  67                                response_file='vrops_token.json')
  68             mock_http_response(mock_requests,
  69                                url_pattern='/suite-api/api/resources\\?resourceKind=VirtualMachine',
  70                                response_file='malformed.json')
  71             resource_list = self.vrops.get_vm_resource_list_from_vrops()
  72             self.assertEqual(len(resource_list), 0, "Should return an empty list")
  73
  74
  75 class vROPS_Helper_Get_Metrics_Test(TestCase):
  76
  77     def setUp(self):
  78         super().setUp()
  79         self.vrops = vROPS_Helper()
  80         with open(os.path.join(os.path.dirname(__file__), 'osm_mocks', 'VNFR.json'), 'r') as f:
  81             self.vnfr = json.load(f)
  82
  83     def tearDown(self):
  84         super().tearDown()
  85
  86     def test_collect_one_metric_only(self):
  87         vdu_mappings = {'VMWARE-OID-VM-1':
  88                         {'name': 'vmware-scaling-1-ubuntu_vnfd-VM-2',
  89                          'vrops_id': 'VROPS-UUID-1'}}
  90         monitoring_params = [
  91             {"id": "ubuntu_vnf_cpu_util", "performance-metric": "cpu_utilization"},
  92             ]
  93
  94         with requests_mock.Mocker() as mock_requests:
  95             mock_http_response(mock_requests, method='POST',
  96                                url_pattern='/suite-api/api/auth/token/acquire',
  97                                response_file='vrops_token.json')
  98             mock_http_response(mock_requests,
  99                                url_pattern='/suite-api/api/resources/stats.*',
 100                                response_file='vrops_multi.json')
 101
 102             metrics = self.vrops.get_metrics(vdu_mappings, monitoring_params, self.vnfr)
 103         self.assertEqual(len(metrics), 1, "Number of metrics returned")
 104         self.assertEqual(metrics[0].name, "cpu_utilization", "First metric name")
 105         self.assertEqual(metrics[0].value, 100.0, "CPU metric value")
 106
 107     def test_collect_cpu_and_memory(self):
 108         vdu_mappings = {'VMWARE-OID-VM-1':
 109                         {'name': 'vmware-scaling-1-ubuntu_vnfd-VM-2',
 110                          'vrops_id': 'VROPS-UUID-1'}}
 111         monitoring_params = [
 112             {"id": "ubuntu_vnf_cpu_util", "performance-metric": "cpu_utilization"},
 113             {"id": "ubuntu_vnf_average_memory_utilization", "performance-metric": "average_memory_utilization"}
 114             ]
 115
 116         with requests_mock.Mocker() as mock_requests:
 117             mock_http_response(mock_requests, method='POST',
 118                                url_pattern='/suite-api/api/auth/token/acquire',
 119                                response_file='vrops_token.json')
 120             mock_http_response(mock_requests,
 121                                url_pattern='/suite-api/api/resources/stats.*',
 122                                response_file='vrops_multi.json')
 123
 124             metrics = self.vrops.get_metrics(vdu_mappings, monitoring_params, self.vnfr)
 125
 126         self.assertEqual(len(metrics), 2, "Number of metrics returned")
 127         self.assertEqual(metrics[0].name, "cpu_utilization", "First metric name")
 128         self.assertEqual(metrics[0].value, 100.0, "CPU metric value")
 129         self.assertEqual(metrics[1].name, "average_memory_utilization", "Second metric name")
 130         self.assertEqual(metrics[1].value, 20.515941619873047, "Memory metric value")
 131
 132     def test_collect_adjusted_metric(self):
 133         vdu_mappings = {'VMWARE-OID-VM-1':
 134                         {'name': 'vmware-scaling-1-ubuntu_vnfd-VM-2',
 135                          'vrops_id': 'VROPS-UUID-1'}}
 136         monitoring_params = [
 137             {'id': 'ubuntu_vnf_cpu_util', 'performance-metric': 'disk_read_bytes'}
 138             ]
 139
 140         with requests_mock.Mocker() as mock_requests:
 141             mock_http_response(mock_requests, method='POST',
 142                                url_pattern='/suite-api/api/auth/token/acquire',
 143                                response_file='vrops_token.json')
 144             mock_http_response(mock_requests,
 145                                url_pattern='/suite-api/api/resources/stats.*',
 146                                response_file='vrops_multi.json')
 147
 148             metrics = self.vrops.get_metrics(vdu_mappings, monitoring_params, self.vnfr)
 149
 150         self.assertEqual(len(metrics), 1, "Number of metrics returned")
 151         self.assertEqual(metrics[0].name, "disk_read_bytes", "First metric name")
 152         self.assertEqual(metrics[0].value, 10240.0, "Disk read bytes (not KB/s)")
 153
 154     def test_collect_not_provided_metric(self):
 155         vdu_mappings = {'VMWARE-OID-VM-1':
 156                         {'name': 'vmware-scaling-1-ubuntu_vnfd-VM-2',
 157                          'vrops_id': 'VROPS-UUID-1'}}
 158         monitoring_params = [
 159             {'id': 'cirros_vnf_packets_sent', 'performance-metric': 'packets_in_dropped'},
 160             ]
 161
 162         with requests_mock.Mocker() as mock_requests:
 163             mock_http_response(mock_requests, method='POST',
 164                                url_pattern='/suite-api/api/auth/token/acquire',
 165                                response_file='vrops_token.json')
 166             mock_http_response(mock_requests,
 167                                url_pattern='/suite-api/api/resources/stats.*',
 168                                response_file='vrops_multi.json')
 169
 170             metrics = self.vrops.get_metrics(vdu_mappings, monitoring_params, self.vnfr)
 171
 172         self.assertEqual(len(metrics), 0, "Number of metrics returned")
 173
 174     def test_collect_unkown_metric(self):
 175         vdu_mappings = {'VMWARE-OID-VM-1':
 176                         {'name': 'vmware-scaling-1-ubuntu_vnfd-VM-2',
 177                          'vrops_id': 'VROPS-UUID-1'}}
 178         monitoring_params = [
 179             {'id': 'cirros_vnf-Unknown_Metric', 'performance-metric': 'unknown'},
 180             ]
 181
 182         with requests_mock.Mocker() as mock_requests:
 183             mock_http_response(mock_requests, method='POST',
 184                                url_pattern='/suite-api/api/auth/token/acquire',
 185                                response_file='vrops_token.json')
 186             mock_http_response(mock_requests,
 187                                url_pattern='/suite-api/api/resources/stats.*',
 188                                response_file='vrops_multi.json')
 189
 190             metrics = self.vrops.get_metrics(vdu_mappings, monitoring_params, self.vnfr)
 191
 192         self.assertEqual(len(metrics), 0, "Number of metrics returned")
 193
 194     def test_collect_vrops_no_data(self):
 195         vdu_mappings = {'VMWARE-OID-VM-1':
 196                         {'name': 'vmware-scaling-1-ubuntu_vnfd-VM-2',
 197                          'vrops_id': 'VROPS-UUID-1'}}
 198         monitoring_params = [
 199             {"id": "ubuntu_vnf_cpu_util", "performance-metric": "cpu_utilization"},
 200             ]
 201
 202         with requests_mock.Mocker() as mock_requests:
 203             mock_http_response(mock_requests, method='POST',
 204                                url_pattern='/suite-api/api/auth/token/acquire',
 205                                response_file='vrops_token.json')
 206             mock_http_response(mock_requests,
 207                                url_pattern='/suite-api/api/resources/stats.*',
 208                                response_file='OK.json')
 209
 210             metrics = self.vrops.get_metrics(vdu_mappings, monitoring_params, self.vnfr)
 211
 212         self.assertEqual(len(metrics), 0, "Number of metrics returned")
 213
 214     def test_collect_vrops_unknown_vim_id(self):
 215         vdu_mappings = {'VMWARE-OID-VM-1':
 216                         {'name': 'vmware-scaling-1-ubuntu_vnfd-VM-2'}}
 217         monitoring_params = [
 218             {"id": "ubuntu_vnf_cpu_util", "performance-metric": "cpu_utilization"},
 219             ]
 220
 221         with requests_mock.Mocker() as mock_requests:
 222             mock_http_response(mock_requests, method='POST',
 223                                url_pattern='/suite-api/api/auth/token/acquire',
 224                                response_file='vrops_token.json')
 225             mock_http_response(mock_requests,
 226                                url_pattern='/suite-api/api/resources/stats.*',
 227                                response_file='vrops_multi.json')
 228
 229             metrics = self.vrops.get_metrics(vdu_mappings, monitoring_params, self.vnfr)
 230
 231         self.assertEqual(len(metrics), 0, "Number of metrics returned")
 232
 233     def test_collect_vrops_http_error(self):
 234         vdu_mappings = {'VMWARE-OID-VM-1':
 235                         {'name': 'vmware-scaling-1-ubuntu_vnfd-VM-2',
 236                          'vrops_id': 'VROPS-UUID-1'}}
 237         monitoring_params = [
 238             {"id": "ubuntu_vnf_cpu_util", "performance-metric": "cpu_utilization"},
 239             ]
 240
 241         with requests_mock.Mocker() as mock_requests:
 242             mock_http_response(mock_requests, method='POST',
 243                                url_pattern='/suite-api/api/auth/token/acquire',
 244                                response_file='vrops_token.json')
 245             mock_http_response(mock_requests,
 246                                url_pattern='/suite-api/api/resources/stats.*',
 247                                response_file='404.txt', status_code=404)
 248
 249             metrics = self.vrops.get_metrics(vdu_mappings, monitoring_params, self.vnfr)
 250
 251         self.assertEqual(len(metrics), 0, "Number of metrics returned")
 252
 253     def test_collect_vrops_json_parse_error(self):
 254         vdu_mappings = {'VMWARE-OID-VM-1':
 255                         {'name': 'vmware-scaling-1-ubuntu_vnfd-VM-2',
 256                          'vrops_id': 'VROPS-UUID-1'}}
 257         monitoring_params = [
 258             {"id": "ubuntu_vnf_cpu_util", "performance-metric": "cpu_utilization"},
 259             ]
 260
 261         with requests_mock.Mocker() as mock_requests:
 262             mock_http_response(mock_requests, method='POST',
 263                                url_pattern='/suite-api/api/auth/token/acquire',
 264                                response_file='vrops_token.json')
 265             mock_http_response(mock_requests,
 266                                url_pattern='/suite-api/api/resources/stats.*',
 267                                response_file='404.txt')
 268
 269             metrics = self.vrops.get_metrics(vdu_mappings, monitoring_params, self.vnfr)
 270
 271         self.assertEqual(len(metrics), 0, "Number of metrics returned")
 272
 273     def test_collect_multi_vdu(self):
 274         vdu_mappings = {'VMWARE-UUID-VM-1':
 275                         {'name': 'vmware-scaling-1-ubuntu_vnfd-VM-1', 'vrops_id': 'VROPS-UUID-1'},
 276                         'VMWARE-UUID-VM-2':
 277                         {'name': 'vmware-scaling-1-ubuntu_vnfd-VM-2', 'vrops_id': 'VROPS-UUID-2'},
 278                         'VMWARE-UUID-VM-3':
 279                         {'name': 'vmware-scaling-1-ubuntu_vnfd-VM-2', 'vrops_id': 'VROPS-UUID-3'}
 280                         }
 281         monitoring_params = [
 282             {'id': 'ubuntu_vnf_cpu_util', 'performance-metric': 'cpu_utilization'},
 283             {'id': 'ubuntu_vnf_average_memory_utilization', 'performance-metric': 'average_memory_utilization'},
 284             {'id': 'ubuntu_vnf_disk_read_ops', 'performance-metric': 'disk_read_ops'},
 285             {'id': 'ubuntu_vnf_disk_write_ops', 'performance-metric': 'disk_write_ops'},
 286             {'id': 'ubuntu_vnf_disk_read_bytes', 'performance-metric': 'disk_read_bytes'},
 287             {'id': 'ubuntu_vnf_disk_write_bytes', 'performance-metric': 'disk_write_bytes'},
 288             {'id': 'ubuntu_vnf_packets_out_dropped', 'performance-metric': 'packets_out_dropped'},
 289             {'id': 'ubuntu_vnf_packets_received', 'performance-metric': 'packets_received'},
 290             {'id': 'ubuntu_vnf_packets_sent', 'performance-metric': 'packets_sent'}
 291             ]
 292
 293         with requests_mock.Mocker() as mock_requests:
 294             mock_http_response(mock_requests, method='POST',
 295                                url_pattern='/suite-api/api/auth/token/acquire',
 296                                response_file='vrops_token.json')
 297             mock_http_response(mock_requests,
 298                                url_pattern='/suite-api/api/resources/stats.*',
 299                                response_file='vrops_multi.json')
 300             metrics = self.vrops.get_metrics(vdu_mappings, monitoring_params, self.vnfr)
 301
 302         self.assertEqual(len(metrics), len(monitoring_params) * len(vdu_mappings), "Number of metrics returned")