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,
  44                                url_pattern='/suite-api/api/resources\\?resourceKind=VirtualMachine',
  45                                response_file='vrops_resources.json')
  46             resource_list = self.vrops.get_vm_resource_list_from_vrops()
  47             self.assertEqual(len(resource_list), 3, "List of resources from canned vrops_resources.json")
  48
  49     def test_get_vm_resource_list_from_vrops_http_404(self):
  50         with requests_mock.Mocker() as mock_requests:
  51             mock_http_response(mock_requests,
  52                                url_pattern='/suite-api/api/resources\\?resourceKind=VirtualMachine',
  53                                response_file='404.txt', status_code=404)
  54             resource_list = self.vrops.get_vm_resource_list_from_vrops()
  55             self.assertEqual(len(resource_list), 0, "Should return an empty list")
  56
  57     def test_get_vm_resource_list_from_vrops_bad_json(self):
  58         with requests_mock.Mocker() as mock_requests:
  59             mock_http_response(mock_requests,
  60                                url_pattern='/suite-api/api/resources\\?resourceKind=VirtualMachine',
  61                                response_file='malformed.json')
  62             resource_list = self.vrops.get_vm_resource_list_from_vrops()
  63             self.assertEqual(len(resource_list), 0, "Should return an empty list")
  64
  65
  66 class vROPS_Helper_Get_Metrics_Test(TestCase):
  67
  68     def setUp(self):
  69         super().setUp()
  70         self.vrops = vROPS_Helper()
  71         with open(os.path.join(os.path.dirname(__file__), 'osm_mocks', 'VNFR.json'), 'r') as f:
  72             self.vnfr = json.load(f)
  73
  74     def tearDown(self):
  75         super().tearDown()
  76
  77     def test_collect_one_metric_only(self):
  78         vdu_mappings = {'VMWARE-OID-VM-1':
  79                         {'name': 'vmware-scaling-1-ubuntu_vnfd-VM-2',
  80                          'vrops_id': 'VROPS-UUID-1'}}
  81         monitoring_params = [
  82             {"id": "ubuntu_vnfd-VM_cpu_util", "nfvi-metric": "cpu_utilization"},
  83             ]
  84
  85         with requests_mock.Mocker() as mock_requests:
  86             mock_http_response(mock_requests,
  87                                url_pattern='/suite-api/api/resources/stats.*',
  88                                response_file='vrops_multi.json')
  89
  90             metrics = self.vrops.get_metrics(vdu_mappings, monitoring_params, self.vnfr)
  91         self.assertEqual(len(metrics), 1, "Number of metrics returned")
  92         self.assertEqual(metrics[0].name, "cpu_utilization", "First metric name")
  93         self.assertEqual(metrics[0].value, 100.0, "CPU metric value")
  94
  95     def test_collect_cpu_and_memory(self):
  96         vdu_mappings = {'VMWARE-OID-VM-1':
  97                         {'name': 'vmware-scaling-1-ubuntu_vnfd-VM-2',
  98                          'vrops_id': 'VROPS-UUID-1'}}
  99         monitoring_params = [
 100             {"id": "ubuntu_vnfd-VM_cpu_util", "nfvi-metric": "cpu_utilization"},
 101             {"id": "ubuntu_vnfd-VM_average_memory_utilization", "nfvi-metric": "average_memory_utilization"}
 102             ]
 103
 104         with requests_mock.Mocker() as mock_requests:
 105             mock_http_response(mock_requests,
 106                                url_pattern='/suite-api/api/resources/stats.*',
 107                                response_file='vrops_multi.json')
 108
 109             metrics = self.vrops.get_metrics(vdu_mappings, monitoring_params, self.vnfr)
 110
 111         self.assertEqual(len(metrics), 2, "Number of metrics returned")
 112         self.assertEqual(metrics[0].name, "cpu_utilization", "First metric name")
 113         self.assertEqual(metrics[0].value, 100.0, "CPU metric value")
 114         self.assertEqual(metrics[1].name, "average_memory_utilization", "Second metric name")
 115         self.assertEqual(metrics[1].value, 20.515941619873047, "Memory metric value")
 116
 117     def test_collect_adjusted_metric(self):
 118         vdu_mappings = {'VMWARE-OID-VM-1':
 119                         {'name': 'vmware-scaling-1-ubuntu_vnfd-VM-2',
 120                          'vrops_id': 'VROPS-UUID-1'}}
 121         monitoring_params = [
 122             {'id': 'ubuntu_vnfd-VM_cpu_util', 'nfvi-metric': 'disk_read_bytes'}
 123             ]
 124
 125         with requests_mock.Mocker() as mock_requests:
 126             mock_http_response(mock_requests,
 127                                url_pattern='/suite-api/api/resources/stats.*',
 128                                response_file='vrops_multi.json')
 129
 130             metrics = self.vrops.get_metrics(vdu_mappings, monitoring_params, self.vnfr)
 131
 132         self.assertEqual(len(metrics), 1, "Number of metrics returned")
 133         self.assertEqual(metrics[0].name, "disk_read_bytes", "First metric name")
 134         self.assertEqual(metrics[0].value, 10240.0, "Disk read bytes (not KB/s)")
 135
 136     def test_collect_not_provided_metric(self):
 137         vdu_mappings = {'VMWARE-OID-VM-1':
 138                         {'name': 'vmware-scaling-1-ubuntu_vnfd-VM-2',
 139                          'vrops_id': 'VROPS-UUID-1'}}
 140         monitoring_params = [
 141             {'id': 'cirros_vnfd-VM_packets_sent', 'nfvi-metric': 'packets_in_dropped'},
 142             ]
 143
 144         with requests_mock.Mocker() as mock_requests:
 145             mock_http_response(mock_requests,
 146                                url_pattern='/suite-api/api/resources/stats.*',
 147                                response_file='vrops_multi.json')
 148
 149             metrics = self.vrops.get_metrics(vdu_mappings, monitoring_params, self.vnfr)
 150
 151         self.assertEqual(len(metrics), 0, "Number of metrics returned")
 152
 153     def test_collect_unkown_metric(self):
 154         vdu_mappings = {'VMWARE-OID-VM-1':
 155                         {'name': 'vmware-scaling-1-ubuntu_vnfd-VM-2',
 156                          'vrops_id': 'VROPS-UUID-1'}}
 157         monitoring_params = [
 158             {'id': 'cirros_vnfd-Unknown_Metric', 'nfvi-metric': 'unknown'},
 159             ]
 160
 161         with requests_mock.Mocker() as mock_requests:
 162             mock_http_response(mock_requests,
 163                                url_pattern='/suite-api/api/resources/stats.*',
 164                                response_file='vrops_multi.json')
 165
 166             metrics = self.vrops.get_metrics(vdu_mappings, monitoring_params, self.vnfr)
 167
 168         self.assertEqual(len(metrics), 0, "Number of metrics returned")
 169
 170     def test_collect_vrops_no_data(self):
 171         vdu_mappings = {'VMWARE-OID-VM-1':
 172                         {'name': 'vmware-scaling-1-ubuntu_vnfd-VM-2',
 173                          'vrops_id': 'VROPS-UUID-1'}}
 174         monitoring_params = [
 175             {"id": "ubuntu_vnfd-VM_cpu_util", "nfvi-metric": "cpu_utilization"},
 176             ]
 177
 178         with requests_mock.Mocker() as mock_requests:
 179             mock_http_response(mock_requests,
 180                                url_pattern='/suite-api/api/resources/stats.*',
 181                                response_file='OK.json')
 182
 183             metrics = self.vrops.get_metrics(vdu_mappings, monitoring_params, self.vnfr)
 184
 185         self.assertEqual(len(metrics), 0, "Number of metrics returned")
 186
 187     def test_collect_vrops_unknown_vim_id(self):
 188         vdu_mappings = {'VMWARE-OID-VM-1':
 189                         {'name': 'vmware-scaling-1-ubuntu_vnfd-VM-2'}}
 190         monitoring_params = [
 191             {"id": "ubuntu_vnfd-VM_cpu_util", "nfvi-metric": "cpu_utilization"},
 192             ]
 193
 194         with requests_mock.Mocker() as mock_requests:
 195             mock_http_response(mock_requests,
 196                                url_pattern='/suite-api/api/resources/stats.*',
 197                                response_file='vrops_multi.json')
 198
 199             metrics = self.vrops.get_metrics(vdu_mappings, monitoring_params, self.vnfr)
 200
 201         self.assertEqual(len(metrics), 0, "Number of metrics returned")
 202
 203     def test_collect_vrops_http_error(self):
 204         vdu_mappings = {'VMWARE-OID-VM-1':
 205                         {'name': 'vmware-scaling-1-ubuntu_vnfd-VM-2',
 206                          'vrops_id': 'VROPS-UUID-1'}}
 207         monitoring_params = [
 208             {"id": "ubuntu_vnfd-VM_cpu_util", "nfvi-metric": "cpu_utilization"},
 209             ]
 210
 211         with requests_mock.Mocker() as mock_requests:
 212             mock_http_response(mock_requests,
 213                                url_pattern='/suite-api/api/resources/stats.*',
 214                                response_file='404.txt', status_code=404)
 215
 216             metrics = self.vrops.get_metrics(vdu_mappings, monitoring_params, self.vnfr)
 217
 218         self.assertEqual(len(metrics), 0, "Number of metrics returned")
 219
 220     def test_collect_vrops_json_parse_error(self):
 221         vdu_mappings = {'VMWARE-OID-VM-1':
 222                         {'name': 'vmware-scaling-1-ubuntu_vnfd-VM-2',
 223                          'vrops_id': 'VROPS-UUID-1'}}
 224         monitoring_params = [
 225             {"id": "ubuntu_vnfd-VM_cpu_util", "nfvi-metric": "cpu_utilization"},
 226             ]
 227
 228         with requests_mock.Mocker() as mock_requests:
 229             mock_http_response(mock_requests,
 230                                url_pattern='/suite-api/api/resources/stats.*',
 231                                response_file='404.txt')
 232
 233             metrics = self.vrops.get_metrics(vdu_mappings, monitoring_params, self.vnfr)
 234
 235         self.assertEqual(len(metrics), 0, "Number of metrics returned")
 236
 237     def test_collect_multi_vdu(self):
 238         vdu_mappings = {'VMWARE-UUID-VM-1':
 239                         {'name': 'vmware-scaling-1-ubuntu_vnfd-VM-1', 'vrops_id': 'VROPS-UUID-1'},
 240                         'VMWARE-UUID-VM-2':
 241                         {'name': 'vmware-scaling-1-ubuntu_vnfd-VM-2', 'vrops_id': 'VROPS-UUID-2'},
 242                         'VMWARE-UUID-VM-3':
 243                         {'name': 'vmware-scaling-1-ubuntu_vnfd-VM-2', 'vrops_id': 'VROPS-UUID-3'}
 244                         }
 245         monitoring_params = [
 246             {'id': 'ubuntu_vnfd-VM_cpu_util', 'nfvi-metric': 'cpu_utilization'},
 247             {'id': 'ubuntu_vnfd-VM_average_memory_utilization', 'nfvi-metric': 'average_memory_utilization'},
 248             {'id': 'ubuntu_vnfd-VM_disk_read_ops', 'nfvi-metric': 'disk_read_ops'},
 249             {'id': 'ubuntu_vnfd-VM_disk_write_ops', 'nfvi-metric': 'disk_write_ops'},
 250             {'id': 'ubuntu_vnfd-VM_disk_read_bytes', 'nfvi-metric': 'disk_read_bytes'},
 251             {'id': 'ubuntu_vnfd-VM_disk_write_bytes', 'nfvi-metric': 'disk_write_bytes'},
 252             {'id': 'ubuntu_vnfd-VM_packets_out_dropped', 'nfvi-metric': 'packets_out_dropped'},
 253             {'id': 'ubuntu_vnfd-VM_packets_received', 'nfvi-metric': 'packets_received'},
 254             {'id': 'ubuntu_vnfd-VM_packets_sent', 'nfvi-metric': 'packets_sent'}
 255             ]
 256
 257         with requests_mock.Mocker() as mock_requests:
 258             mock_http_response(mock_requests,
 259                                url_pattern='/suite-api/api/resources/stats.*',
 260                                response_file='vrops_multi.json')
 261             metrics = self.vrops.get_metrics(vdu_mappings, monitoring_params, self.vnfr)
 262
 263         self.assertEqual(len(metrics), len(monitoring_params) * len(vdu_mappings), "Number of metrics returned")