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