osm_mon/test/OpenStack/unit/test_metric_calls.py

   1 # Copyright 2017 iIntel Research and Development Ireland Limited
   2 # *************************************************************
   3
   4 # This file is part of OSM Monitoring module
   5 # All Rights Reserved to Intel Corporation
   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: helena.mcgough@intel.com or adrian.hoban@intel.com
  21 ##
  22 """Tests for all metric request message keys."""
  23
  24 import json
  25
  26 import logging
  27
  28 import unittest
  29
  30 import mock
  31
  32 from osm_mon.core.auth import AuthManager
  33 from osm_mon.plugins.OpenStack.Gnocchi import metrics as metric_req
  34
  35 from osm_mon.plugins.OpenStack.common import Common
  36
  37 log = logging.getLogger(__name__)
  38
  39 # Mock auth_token and endpoint
  40 endpoint = mock.ANY
  41 auth_token = mock.ANY
  42
  43 # Mock a valid metric list for some tests, and a resultant list
  44 metric_list = [{"name": "disk.write.requests",
  45                 "id": "metric_id",
  46                 "unit": "units",
  47                 "resource_id": "r_id"}]
  48 result_list = ["metric_id", "r_id", "units", "disk_write_ops"]
  49
  50
  51 class Response(object):
  52     """Mock a response object for requests."""
  53
  54     def __init__(self):
  55         """Initialise test and status code values."""
  56         self.text = json.dumps([{"id": "test_id"}])
  57         self.status_code = "STATUS_CODE"
  58
  59
  60 def perform_request_side_effect(*args, **kwargs):
  61     resp = Response()
  62     if 'marker' in args[0]:
  63         resp.text = json.dumps([])
  64     if 'resource/generic' in args[0]:
  65         resp.text = json.dumps({'metrics': {'cpu_util': 'test_id'}})
  66     return resp
  67
  68
  69 class TestMetricCalls(unittest.TestCase):
  70     """Integration test for metric request keys."""
  71
  72     def setUp(self):
  73         """Setup the tests for metric request keys."""
  74         super(TestMetricCalls, self).setUp()
  75         self.metrics = metric_req.Metrics()
  76         self.metrics._common = Common()
  77
  78     @mock.patch.object(metric_req.Metrics, "get_metric_id")
  79     @mock.patch.object(Common, "perform_request")
  80     def test_invalid_config_metric_req(
  81             self, perf_req, get_metric):
  82         """Test the configure metric function, for an invalid metric."""
  83         # Test invalid configuration for creating a metric
  84         values = {"metric_details": "invalid_metric"}
  85
  86         m_id, r_id, status = self.metrics.configure_metric(
  87             endpoint, auth_token, values, verify_ssl=False)
  88
  89         perf_req.assert_not_called()
  90         self.assertEqual(status, False)
  91
  92         # Test with an invalid metric name, will not perform request
  93         values = {"resource_uuid": "r_id"}
  94
  95         m_id, r_id, status = self.metrics.configure_metric(
  96             endpoint, auth_token, values, verify_ssl=False)
  97
  98         perf_req.assert_not_called()
  99         self.assertEqual(status, False)
 100
 101         # If metric exists, it won't be recreated
 102         get_metric.return_value = "metric_id"
 103
 104         m_id, r_id, status = self.metrics.configure_metric(
 105             endpoint, auth_token, values, verify_ssl=False)
 106
 107         perf_req.assert_not_called()
 108         self.assertEqual(status, False)
 109
 110     @mock.patch.object(metric_req.Metrics, "get_metric_id")
 111     @mock.patch.object(Common, "perform_request")
 112     @mock.patch.object(AuthManager, "get_credentials")
 113     def test_valid_config_metric_req(
 114             self, get_creds, perf_req, get_metric):
 115         """Test the configure metric function, for a valid metric."""
 116         # Test valid configuration and payload for creating a metric
 117         get_creds.return_value = type('obj', (object,), {'config': '{"insecure":true}'})
 118         values = {"resource_uuid": "r_id",
 119                   "metric_unit": "units",
 120                   "metric_name": "cpu_util"}
 121         get_metric.return_value = None
 122         payload = {"id": "r_id",
 123                    "metrics": {"cpu_util":
 124                                    {"archive_policy_name": "high",
 125                                     "name": "cpu_util",
 126                                     "unit": "units"}}}
 127
 128         perf_req.return_value = type('obj', (object,), {'text': '{"metrics":{"cpu_util":1}, "id":1}'})
 129
 130         self.metrics.configure_metric(endpoint, auth_token, values, verify_ssl=False)
 131
 132         perf_req.assert_called_with(
 133             "<ANY>/v1/resource/generic", auth_token, req_type="post", verify_ssl=False,
 134             payload=json.dumps(payload, sort_keys=True))
 135
 136     @mock.patch.object(Common, "perform_request")
 137     def test_delete_metric_req(self, perf_req):
 138         """Test the delete metric function."""
 139         self.metrics.delete_metric(endpoint, auth_token, "metric_id", verify_ssl=False)
 140
 141         perf_req.assert_called_with(
 142             "<ANY>/v1/metric/metric_id", auth_token, req_type="delete", verify_ssl=False)
 143
 144     @mock.patch.object(Common, "perform_request")
 145     def test_delete_metric_invalid_status(self, perf_req):
 146         """Test invalid response for delete request."""
 147         perf_req.return_value = type('obj', (object,), {"status_code": "404"})
 148
 149         status = self.metrics.delete_metric(endpoint, auth_token, "metric_id", verify_ssl=False)
 150
 151         self.assertEqual(status, False)
 152
 153     @mock.patch.object(metric_req.Metrics, "response_list")
 154     @mock.patch.object(Common, "perform_request")
 155     def test_complete_list_metric_req(self, perf_req, resp_list):
 156         """Test the complete list metric function."""
 157         # Test listing metrics without any configuration options
 158         values = {}
 159         perf_req.side_effect = perform_request_side_effect
 160         self.metrics.list_metrics(endpoint, auth_token, values, verify_ssl=False)
 161
 162         perf_req.assert_any_call(
 163             "<ANY>/v1/metric?sort=name:asc", auth_token, req_type="get", verify_ssl=False)
 164         resp_list.assert_called_with([{u'id': u'test_id'}])
 165
 166     @mock.patch.object(metric_req.Metrics, "response_list")
 167     @mock.patch.object(Common, "perform_request")
 168     def test_resource_list_metric_req(self, perf_req, resp_list):
 169         """Test the resource list metric function."""
 170         # Test listing metrics with a resource id specified
 171         values = {"resource_uuid": "resource_id"}
 172         perf_req.side_effect = perform_request_side_effect
 173         self.metrics.list_metrics(endpoint, auth_token, values, verify_ssl=False)
 174
 175         perf_req.assert_any_call(
 176             "<ANY>/v1/metric/test_id", auth_token, req_type="get", verify_ssl=False)
 177
 178     @mock.patch.object(metric_req.Metrics, "response_list")
 179     @mock.patch.object(Common, "perform_request")
 180     def test_name_list_metric_req(self, perf_req, resp_list):
 181         """Test the metric_name list metric function."""
 182         # Test listing metrics with a metric_name specified
 183         values = {"metric_name": "disk_write_bytes"}
 184         perf_req.side_effect = perform_request_side_effect
 185         self.metrics.list_metrics(endpoint, auth_token, values, verify_ssl=False)
 186
 187         perf_req.assert_any_call(
 188             "<ANY>/v1/metric?sort=name:asc", auth_token, req_type="get", verify_ssl=False)
 189         resp_list.assert_called_with(
 190             [{u'id': u'test_id'}], metric_name="disk_write_bytes")
 191
 192     @mock.patch.object(metric_req.Metrics, "response_list")
 193     @mock.patch.object(Common, "perform_request")
 194     def test_combined_list_metric_req(self, perf_req, resp_list):
 195         """Test the combined resource and metric list metric function."""
 196         # Test listing metrics with a resource id and metric name specified
 197
 198         values = {"resource_uuid": "resource_id",
 199                   "metric_name": "cpu_utilization"}
 200         perf_req.side_effect = perform_request_side_effect
 201         self.metrics.list_metrics(endpoint, auth_token, values, verify_ssl=False)
 202
 203         perf_req.assert_any_call(
 204             "<ANY>/v1/metric/test_id", auth_token, req_type="get", verify_ssl=False)
 205
 206     @mock.patch.object(Common, "perform_request")
 207     def test_get_metric_id(self, perf_req):
 208         """Test get_metric_id function."""
 209         perf_req.return_value = type('obj', (object,), {'text': '{"alarm_id":"1"}'})
 210         self.metrics.get_metric_id(endpoint, auth_token, "my_metric", "r_id", verify_ssl=False)
 211
 212         perf_req.assert_called_with(
 213             "<ANY>/v1/resource/generic/r_id", auth_token, req_type="get", verify_ssl=False)
 214
 215     @mock.patch.object(metric_req.Metrics, "get_metric_id")
 216     @mock.patch.object(Common, "perform_request")
 217     def test_valid_read_data_req(self, perf_req, get_metric):
 218         """Test the read metric data function, for a valid call."""
 219         values = {"metric_name": "disk_write_ops",
 220                   "resource_uuid": "resource_id",
 221                   "collection_unit": "DAY",
 222                   "collection_period": 1}
 223
 224         perf_req.return_value = type('obj', (object,), {'text': '{"metric_data":"[]"}'})
 225
 226         get_metric.return_value = "metric_id"
 227         self.metrics.read_metric_data(endpoint, auth_token, values, verify_ssl=False)
 228
 229         perf_req.assert_called_once()
 230
 231     @mock.patch.object(Common, "perform_request")
 232     def test_invalid_read_data_req(self, perf_req):
 233         """Test the read metric data function, for an invalid call."""
 234         # Teo empty lists wil be returned because the values are invalid
 235         values = {}
 236
 237         times, data = self.metrics.read_metric_data(
 238             endpoint, auth_token, values, verify_ssl=False)
 239
 240         self.assertEqual(times, [])
 241         self.assertEqual(data, [])
 242
 243     def test_complete_response_list(self):
 244         """Test the response list function for formatting metric lists."""
 245         # Mock a list for testing purposes, with valid OSM metric
 246         resp_list = self.metrics.response_list(metric_list)
 247
 248         # Check for the expected values in the resulting list
 249         for l in result_list:
 250             self.assertIn(l, resp_list[0].values())
 251
 252     def test_name_response_list(self):
 253         """Test the response list with metric name configured."""
 254         # Mock the metric name to test a metric name list
 255         # Test with a name that is not in the list
 256         invalid_name = "my_metric"
 257         resp_list = self.metrics.response_list(
 258             metric_list, metric_name=invalid_name)
 259
 260         self.assertEqual(resp_list, [])
 261
 262         # Test with a name on the list
 263         valid_name = "disk_write_ops"
 264         resp_list = self.metrics.response_list(
 265             metric_list, metric_name=valid_name)
 266
 267         # Check for the expected values in the resulting list
 268         for l in result_list:
 269             self.assertIn(l, resp_list[0].values())
 270
 271     def test_resource_response_list(self):
 272         """Test the response list with resource_id configured."""
 273         # Mock a resource_id to test a resource list
 274         # Test with resource not on the list
 275         invalid_id = "mock_resource"
 276         resp_list = self.metrics.response_list(metric_list, resource=invalid_id)
 277
 278         self.assertEqual(resp_list, [])
 279
 280         # Test with a resource on the list
 281         valid_id = "r_id"
 282         resp_list = self.metrics.response_list(metric_list, resource=valid_id)
 283
 284         # Check for the expected values in the resulting list
 285         for l in result_list:
 286             self.assertIn(l, resp_list[0].values())
 287
 288     def test_combined_response_list(self):
 289         """Test the response list function with resource_id and metric_name."""
 290         # Test for a combined resource and name list
 291         # resource and name are on the list
 292         valid_name = "disk_write_ops"
 293         valid_id = "r_id"
 294         resp_list = self.metrics.response_list(
 295             metric_list, metric_name=valid_name, resource=valid_id)
 296
 297         # Check for the expected values in the resulting list
 298         for l in result_list:
 299             self.assertIn(l, resp_list[0].values())
 300
 301         # resource not on list
 302         invalid_id = "mock_resource"
 303         resp_list = self.metrics.response_list(
 304             metric_list, metric_name=valid_name, resource=invalid_id)
 305
 306         self.assertEqual(resp_list, [])
 307
 308         # metric name not on list
 309         invalid_name = "mock_metric"
 310         resp_list = self.metrics.response_list(
 311             metric_list, metric_name=invalid_name, resource=valid_id)
 312
 313         self.assertEqual(resp_list, [])