1 # Copyright 2017 iIntel Research and Development Ireland Limited
2 # *************************************************************
4 # This file is part of OSM Monitoring module
5 # All Rights Reserved to Intel Corporation
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
11 # http://www.apache.org/licenses/LICENSE-2.0
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
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
22 """Tests for all metric request message keys."""
32 from osm_mon
.plugins
.OpenStack
.Gnocchi
import metrics
as metric_req
34 from osm_mon
.plugins
.OpenStack
.common
import Common
36 log
= logging
.getLogger(__name__
)
38 # Mock auth_token and endpoint
42 # Mock a valid metric list for some tests, and a resultant list
43 metric_list
= [{"name": "disk.write.requests",
46 "resource_id": "r_id"}]
47 result_list
= ["metric_id", "r_id", "units", "disk_write_ops"]
50 class Response(object):
51 """Mock a response object for requests."""
54 """Initialise test and status code values."""
55 self
.text
= json
.dumps([{"id": "test_id"}])
56 self
.status_code
= "STATUS_CODE"
59 def perform_request_side_effect(*args
, **kwargs
):
61 if 'marker' in args
[0]:
62 resp
.text
= json
.dumps([])
66 class TestMetricCalls(unittest
.TestCase
):
67 """Integration test for metric request keys."""
70 """Setup the tests for metric request keys."""
71 super(TestMetricCalls
, self
).setUp()
72 self
.metrics
= metric_req
.Metrics()
73 self
.metrics
._common
= Common()
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"}
84 m_id
, r_id
, status
= self
.metrics
.configure_metric(
85 endpoint
, auth_token
, values
)
87 perf_req
.assert_not_called()
88 self
.assertEqual(m_id
, None)
89 self
.assertEqual(r_id
, None)
90 self
.assertEqual(status
, False)
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
96 m_id
, r_id
, status
= self
.metrics
.configure_metric(
97 endpoint
, auth_token
, values
)
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()
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"
109 m_id
, r_id
, status
= self
.metrics
.configure_metric(
110 endpoint
, auth_token
, values
)
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)
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",
134 perf_req
.return_value
= type('obj', (object,), {'text': '{"id":"1"}'})
136 self
.metrics
.configure_metric(endpoint
, auth_token
, values
)
138 perf_req
.assert_called_with(
139 "<ANY>/v1/resource/generic", auth_token
, req_type
="post",
140 payload
=json
.dumps(payload
, sort_keys
=True))
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")
147 perf_req
.assert_called_with(
148 "<ANY>/v1/metric/metric_id", auth_token
, req_type
="delete")
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"})
155 status
= self
.metrics
.delete_metric(endpoint
, auth_token
, "metric_id")
157 self
.assertEqual(status
, False)
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
165 perf_req
.side_effect
= perform_request_side_effect
166 self
.metrics
.list_metrics(endpoint
, auth_token
, values
)
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'}])
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
)
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")
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
)
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")
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
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
)
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")
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")
222 perf_req
.assert_called_with(
223 "<ANY>/v1/resource/generic/r_id", auth_token
, req_type
="get")
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"}
230 metric_name
, norm_name
= self
.metrics
.get_metric_name(values
)
232 self
.assertEqual(metric_name
, "disk_write_ops")
233 self
.assertEqual(norm_name
, "disk.write.requests")
235 # test with an invalid metric name
236 values
= {"metric_name": "my_invalid_metric"}
238 metric_name
, norm_name
= self
.metrics
.get_metric_name(values
)
240 self
.assertEqual(metric_name
, "my_invalid_metric")
241 self
.assertEqual(norm_name
, None)
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}
252 perf_req
.return_value
= type('obj', (object,), {'text': '{"metric_data":"[]"}'})
254 get_metric
.return_value
= "metric_id"
255 self
.metrics
.read_metric_data(endpoint
, auth_token
, values
)
257 perf_req
.assert_called_once()
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
265 times
, data
= self
.metrics
.read_metric_data(
266 endpoint
, auth_token
, values
)
268 self
.assertEqual(times
, [])
269 self
.assertEqual(data
, [])
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
)
276 # Check for the expected values in the resulting list
277 for l
in result_list
:
278 self
.assertIn(l
, resp_list
[0].values())
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
)
288 self
.assertEqual(resp_list
, [])
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
)
295 # Check for the expected values in the resulting list
296 for l
in result_list
:
297 self
.assertIn(l
, resp_list
[0].values())
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
)
306 self
.assertEqual(resp_list
, [])
308 # Test with a resource on the list
310 resp_list
= self
.metrics
.response_list(metric_list
, resource
=valid_id
)
312 # Check for the expected values in the resulting list
313 for l
in result_list
:
314 self
.assertIn(l
, resp_list
[0].values())
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"
322 resp_list
= self
.metrics
.response_list(
323 metric_list
, metric_name
=valid_name
, resource
=valid_id
)
325 # Check for the expected values in the resulting list
326 for l
in result_list
:
327 self
.assertIn(l
, resp_list
[0].values())
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
)
334 self
.assertEqual(resp_list
, [])
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
)
341 self
.assertEqual(resp_list
, [])