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 (
  25     mock_http_response,
  26 )
  27 from unittest import TestCase
  28
  29 import json
  30 import os
  31 import requests_mock
  32
  33
  34 class vROPS_Helper_Resource_List_Test(TestCase):
  35     def setUp(self):
  36         super().setUp()
  37         self.vrops = vROPS_Helper()
  38
  39     def tearDown(self):
  40         super().tearDown()
  41
  42     def test_get_vm_resource_list_from_vrops(self):
  43         with requests_mock.Mocker() as mock_requests:
  44             mock_http_response(
  45                 mock_requests,
  46                 method="POST",
  47                 url_pattern="/suite-api/api/auth/token/acquire",
  48                 response_file="vrops_token.json",
  49             )
  50             mock_http_response(
  51                 mock_requests,
  52                 url_pattern="/suite-api/api/resources\\?resourceKind=VirtualMachine",
  53                 response_file="vrops_resources.json",
  54             )
  55             resource_list = self.vrops.get_vm_resource_list_from_vrops()
  56             self.assertEqual(
  57                 len(resource_list),
  58                 3,
  59                 "List of resources from canned vrops_resources.json",
  60             )
  61
  62     def test_get_vm_resource_list_from_vrops_http_404(self):
  63         with requests_mock.Mocker() as mock_requests:
  64             mock_http_response(
  65                 mock_requests,
  66                 method="POST",
  67                 url_pattern="/suite-api/api/auth/token/acquire",
  68                 response_file="vrops_token.json",
  69             )
  70             mock_http_response(
  71                 mock_requests,
  72                 url_pattern="/suite-api/api/resources\\?resourceKind=VirtualMachine",
  73                 response_file="404.txt",
  74                 status_code=404,
  75             )
  76             resource_list = self.vrops.get_vm_resource_list_from_vrops()
  77             self.assertEqual(len(resource_list), 0, "Should return an empty list")
  78
  79     def test_get_vm_resource_list_from_vrops_bad_json(self):
  80         with requests_mock.Mocker() as mock_requests:
  81             mock_http_response(
  82                 mock_requests,
  83                 method="POST",
  84                 url_pattern="/suite-api/api/auth/token/acquire",
  85                 response_file="vrops_token.json",
  86             )
  87             mock_http_response(
  88                 mock_requests,
  89                 url_pattern="/suite-api/api/resources\\?resourceKind=VirtualMachine",
  90                 response_file="malformed.json",
  91             )
  92             resource_list = self.vrops.get_vm_resource_list_from_vrops()
  93             self.assertEqual(len(resource_list), 0, "Should return an empty list")
  94
  95
  96 class vROPS_Helper_Get_Metrics_Test(TestCase):
  97     def setUp(self):
  98         super().setUp()
  99         self.vrops = vROPS_Helper()
 100         with open(
 101             os.path.join(os.path.dirname(__file__), "osm_mocks", "VNFR.json"), "r"
 102         ) as f:
 103             self.vnfr = json.load(f)
 104
 105     def tearDown(self):
 106         super().tearDown()
 107
 108     def test_collect_one_metric_only(self):
 109         vdu_mappings = {
 110             "VMWARE-OID-VM-1": {
 111                 "name": "vmware-scaling-1-ubuntu_vnfd-VM-2",
 112                 "vrops_id": "VROPS-UUID-1",
 113             }
 114         }
 115         monitoring_params = [
 116             {"id": "ubuntu_vnf_cpu_util", "performance-metric": "cpu_utilization"},
 117         ]
 118
 119         with requests_mock.Mocker() as mock_requests:
 120             mock_http_response(
 121                 mock_requests,
 122                 method="POST",
 123                 url_pattern="/suite-api/api/auth/token/acquire",
 124                 response_file="vrops_token.json",
 125             )
 126             mock_http_response(
 127                 mock_requests,
 128                 url_pattern="/suite-api/api/resources/stats.*",
 129                 response_file="vrops_multi.json",
 130             )
 131
 132             metrics = self.vrops.get_metrics(vdu_mappings, monitoring_params, self.vnfr)
 133         self.assertEqual(len(metrics), 1, "Number of metrics returned")
 134         self.assertEqual(metrics[0].name, "cpu_utilization", "First metric name")
 135         self.assertEqual(metrics[0].value, 100.0, "CPU metric value")
 136
 137     def test_collect_cpu_and_memory(self):
 138         vdu_mappings = {
 139             "VMWARE-OID-VM-1": {
 140                 "name": "vmware-scaling-1-ubuntu_vnfd-VM-2",
 141                 "vrops_id": "VROPS-UUID-1",
 142             }
 143         }
 144         monitoring_params = [
 145             {"id": "ubuntu_vnf_cpu_util", "performance-metric": "cpu_utilization"},
 146             {
 147                 "id": "ubuntu_vnf_average_memory_utilization",
 148                 "performance-metric": "average_memory_utilization",
 149             },
 150         ]
 151
 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/stats.*",
 162                 response_file="vrops_multi.json",
 163             )
 164
 165             metrics = self.vrops.get_metrics(vdu_mappings, monitoring_params, self.vnfr)
 166
 167         self.assertEqual(len(metrics), 2, "Number of metrics returned")
 168         self.assertEqual(metrics[0].name, "cpu_utilization", "First metric name")
 169         self.assertEqual(metrics[0].value, 100.0, "CPU metric value")
 170         self.assertEqual(
 171             metrics[1].name, "average_memory_utilization", "Second metric name"
 172         )
 173         self.assertEqual(metrics[1].value, 20.515941619873047, "Memory metric value")
 174
 175     def test_collect_adjusted_metric(self):
 176         vdu_mappings = {
 177             "VMWARE-OID-VM-1": {
 178                 "name": "vmware-scaling-1-ubuntu_vnfd-VM-2",
 179                 "vrops_id": "VROPS-UUID-1",
 180             }
 181         }
 182         monitoring_params = [
 183             {"id": "ubuntu_vnf_cpu_util", "performance-metric": "disk_read_bytes"}
 184         ]
 185
 186         with requests_mock.Mocker() as mock_requests:
 187             mock_http_response(
 188                 mock_requests,
 189                 method="POST",
 190                 url_pattern="/suite-api/api/auth/token/acquire",
 191                 response_file="vrops_token.json",
 192             )
 193             mock_http_response(
 194                 mock_requests,
 195                 url_pattern="/suite-api/api/resources/stats.*",
 196                 response_file="vrops_multi.json",
 197             )
 198
 199             metrics = self.vrops.get_metrics(vdu_mappings, monitoring_params, self.vnfr)
 200
 201         self.assertEqual(len(metrics), 1, "Number of metrics returned")
 202         self.assertEqual(metrics[0].name, "disk_read_bytes", "First metric name")
 203         self.assertEqual(metrics[0].value, 10240.0, "Disk read bytes (not KB/s)")
 204
 205     def test_collect_not_provided_metric(self):
 206         vdu_mappings = {
 207             "VMWARE-OID-VM-1": {
 208                 "name": "vmware-scaling-1-ubuntu_vnfd-VM-2",
 209                 "vrops_id": "VROPS-UUID-1",
 210             }
 211         }
 212         monitoring_params = [
 213             {
 214                 "id": "cirros_vnf_packets_sent",
 215                 "performance-metric": "packets_in_dropped",
 216             },
 217         ]
 218
 219         with requests_mock.Mocker() as mock_requests:
 220             mock_http_response(
 221                 mock_requests,
 222                 method="POST",
 223                 url_pattern="/suite-api/api/auth/token/acquire",
 224                 response_file="vrops_token.json",
 225             )
 226             mock_http_response(
 227                 mock_requests,
 228                 url_pattern="/suite-api/api/resources/stats.*",
 229                 response_file="vrops_multi.json",
 230             )
 231
 232             metrics = self.vrops.get_metrics(vdu_mappings, monitoring_params, self.vnfr)
 233
 234         self.assertEqual(len(metrics), 0, "Number of metrics returned")
 235
 236     def test_collect_unkown_metric(self):
 237         vdu_mappings = {
 238             "VMWARE-OID-VM-1": {
 239                 "name": "vmware-scaling-1-ubuntu_vnfd-VM-2",
 240                 "vrops_id": "VROPS-UUID-1",
 241             }
 242         }
 243         monitoring_params = [
 244             {"id": "cirros_vnf-Unknown_Metric", "performance-metric": "unknown"},
 245         ]
 246
 247         with requests_mock.Mocker() as mock_requests:
 248             mock_http_response(
 249                 mock_requests,
 250                 method="POST",
 251                 url_pattern="/suite-api/api/auth/token/acquire",
 252                 response_file="vrops_token.json",
 253             )
 254             mock_http_response(
 255                 mock_requests,
 256                 url_pattern="/suite-api/api/resources/stats.*",
 257                 response_file="vrops_multi.json",
 258             )
 259
 260             metrics = self.vrops.get_metrics(vdu_mappings, monitoring_params, self.vnfr)
 261
 262         self.assertEqual(len(metrics), 0, "Number of metrics returned")
 263
 264     def test_collect_vrops_no_data(self):
 265         vdu_mappings = {
 266             "VMWARE-OID-VM-1": {
 267                 "name": "vmware-scaling-1-ubuntu_vnfd-VM-2",
 268                 "vrops_id": "VROPS-UUID-1",
 269             }
 270         }
 271         monitoring_params = [
 272             {"id": "ubuntu_vnf_cpu_util", "performance-metric": "cpu_utilization"},
 273         ]
 274
 275         with requests_mock.Mocker() as mock_requests:
 276             mock_http_response(
 277                 mock_requests,
 278                 method="POST",
 279                 url_pattern="/suite-api/api/auth/token/acquire",
 280                 response_file="vrops_token.json",
 281             )
 282             mock_http_response(
 283                 mock_requests,
 284                 url_pattern="/suite-api/api/resources/stats.*",
 285                 response_file="OK.json",
 286             )
 287
 288             metrics = self.vrops.get_metrics(vdu_mappings, monitoring_params, self.vnfr)
 289
 290         self.assertEqual(len(metrics), 0, "Number of metrics returned")
 291
 292     def test_collect_vrops_unknown_vim_id(self):
 293         vdu_mappings = {
 294             "VMWARE-OID-VM-1": {"name": "vmware-scaling-1-ubuntu_vnfd-VM-2"}
 295         }
 296         monitoring_params = [
 297             {"id": "ubuntu_vnf_cpu_util", "performance-metric": "cpu_utilization"},
 298         ]
 299
 300         with requests_mock.Mocker() as mock_requests:
 301             mock_http_response(
 302                 mock_requests,
 303                 method="POST",
 304                 url_pattern="/suite-api/api/auth/token/acquire",
 305                 response_file="vrops_token.json",
 306             )
 307             mock_http_response(
 308                 mock_requests,
 309                 url_pattern="/suite-api/api/resources/stats.*",
 310                 response_file="vrops_multi.json",
 311             )
 312
 313             metrics = self.vrops.get_metrics(vdu_mappings, monitoring_params, self.vnfr)
 314
 315         self.assertEqual(len(metrics), 0, "Number of metrics returned")
 316
 317     def test_collect_vrops_http_error(self):
 318         vdu_mappings = {
 319             "VMWARE-OID-VM-1": {
 320                 "name": "vmware-scaling-1-ubuntu_vnfd-VM-2",
 321                 "vrops_id": "VROPS-UUID-1",
 322             }
 323         }
 324         monitoring_params = [
 325             {"id": "ubuntu_vnf_cpu_util", "performance-metric": "cpu_utilization"},
 326         ]
 327
 328         with requests_mock.Mocker() as mock_requests:
 329             mock_http_response(
 330                 mock_requests,
 331                 method="POST",
 332                 url_pattern="/suite-api/api/auth/token/acquire",
 333                 response_file="vrops_token.json",
 334             )
 335             mock_http_response(
 336                 mock_requests,
 337                 url_pattern="/suite-api/api/resources/stats.*",
 338                 response_file="404.txt",
 339                 status_code=404,
 340             )
 341
 342             metrics = self.vrops.get_metrics(vdu_mappings, monitoring_params, self.vnfr)
 343
 344         self.assertEqual(len(metrics), 0, "Number of metrics returned")
 345
 346     def test_collect_vrops_json_parse_error(self):
 347         vdu_mappings = {
 348             "VMWARE-OID-VM-1": {
 349                 "name": "vmware-scaling-1-ubuntu_vnfd-VM-2",
 350                 "vrops_id": "VROPS-UUID-1",
 351             }
 352         }
 353         monitoring_params = [
 354             {"id": "ubuntu_vnf_cpu_util", "performance-metric": "cpu_utilization"},
 355         ]
 356
 357         with requests_mock.Mocker() as mock_requests:
 358             mock_http_response(
 359                 mock_requests,
 360                 method="POST",
 361                 url_pattern="/suite-api/api/auth/token/acquire",
 362                 response_file="vrops_token.json",
 363             )
 364             mock_http_response(
 365                 mock_requests,
 366                 url_pattern="/suite-api/api/resources/stats.*",
 367                 response_file="404.txt",
 368             )
 369
 370             metrics = self.vrops.get_metrics(vdu_mappings, monitoring_params, self.vnfr)
 371
 372         self.assertEqual(len(metrics), 0, "Number of metrics returned")
 373
 374     def test_collect_multi_vdu(self):
 375         vdu_mappings = {
 376             "VMWARE-UUID-VM-1": {
 377                 "name": "vmware-scaling-1-ubuntu_vnfd-VM-1",
 378                 "vrops_id": "VROPS-UUID-1",
 379             },
 380             "VMWARE-UUID-VM-2": {
 381                 "name": "vmware-scaling-1-ubuntu_vnfd-VM-2",
 382                 "vrops_id": "VROPS-UUID-2",
 383             },
 384             "VMWARE-UUID-VM-3": {
 385                 "name": "vmware-scaling-1-ubuntu_vnfd-VM-2",
 386                 "vrops_id": "VROPS-UUID-3",
 387             },
 388         }
 389         monitoring_params = [
 390             {"id": "ubuntu_vnf_cpu_util", "performance-metric": "cpu_utilization"},
 391             {
 392                 "id": "ubuntu_vnf_average_memory_utilization",
 393                 "performance-metric": "average_memory_utilization",
 394             },
 395             {"id": "ubuntu_vnf_disk_read_ops", "performance-metric": "disk_read_ops"},
 396             {"id": "ubuntu_vnf_disk_write_ops", "performance-metric": "disk_write_ops"},
 397             {
 398                 "id": "ubuntu_vnf_disk_read_bytes",
 399                 "performance-metric": "disk_read_bytes",
 400             },
 401             {
 402                 "id": "ubuntu_vnf_disk_write_bytes",
 403                 "performance-metric": "disk_write_bytes",
 404             },
 405             {
 406                 "id": "ubuntu_vnf_packets_out_dropped",
 407                 "performance-metric": "packets_out_dropped",
 408             },
 409             {
 410                 "id": "ubuntu_vnf_packets_received",
 411                 "performance-metric": "packets_received",
 412             },
 413             {"id": "ubuntu_vnf_packets_sent", "performance-metric": "packets_sent"},
 414         ]
 415
 416         with requests_mock.Mocker() as mock_requests:
 417             mock_http_response(
 418                 mock_requests,
 419                 method="POST",
 420                 url_pattern="/suite-api/api/auth/token/acquire",
 421                 response_file="vrops_token.json",
 422             )
 423             mock_http_response(
 424                 mock_requests,
 425                 url_pattern="/suite-api/api/resources/stats.*",
 426                 response_file="vrops_multi.json",
 427             )
 428             metrics = self.vrops.get_metrics(vdu_mappings, monitoring_params, self.vnfr)
 429
 430         self.assertEqual(
 431             len(metrics),
 432             len(monitoring_params) * len(vdu_mappings),
 433             "Number of metrics returned",
 434         )