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/resource/generic/resource_id", auth_token
, req_type
="get")
184 @mock.patch
.object(metric_req
.Metrics
, "response_list")
185 @mock.patch
.object(Common
, "perform_request")
186 def test_name_list_metric_req(self
, perf_req
, resp_list
):
187 """Test the metric_name list metric function."""
188 # Test listing metrics with a metric_name specified
189 values
= {"metric_name": "disk_write_bytes"}
190 perf_req
.side_effect
= perform_request_side_effect
191 self
.metrics
.list_metrics(endpoint
, auth_token
, values
)
193 perf_req
.assert_any_call(
194 "<ANY>/v1/metric?sort=name:asc", auth_token
, req_type
="get")
195 resp_list
.assert_called_with(
196 [{u
'id': u
'test_id'}], metric_name
="disk_write_bytes")
198 @mock.patch
.object(metric_req
.Metrics
, "response_list")
199 @mock.patch
.object(Common
, "perform_request")
200 def test_combined_list_metric_req(self
, perf_req
, resp_list
):
201 """Test the combined resource and metric list metric function."""
202 # Test listing metrics with a resource id and metric name specified
204 values
= {"resource_uuid": "resource_id",
205 "metric_name": "packets_sent"}
206 perf_req
.side_effect
= perform_request_side_effect
207 self
.metrics
.list_metrics(endpoint
, auth_token
, values
)
209 perf_req
.assert_any_call(
210 "<ANY>/v1/resource/generic/resource_id", auth_token
, req_type
="get")
212 @mock.patch
.object(Common
, "perform_request")
213 def test_get_metric_id(self
, perf_req
):
214 """Test get_metric_id function."""
215 self
.metrics
.get_metric_id(endpoint
, auth_token
, "my_metric", "r_id")
217 perf_req
.assert_called_with(
218 "<ANY>/v1/resource/generic/r_id", auth_token
, req_type
="get")
220 def test_get_metric_name(self
):
221 """Test the result from the get_metric_name function."""
222 # test with a valid metric_name
223 values
= {"metric_name": "disk_write_ops"}
225 metric_name
, norm_name
= self
.metrics
.get_metric_name(values
)
227 self
.assertEqual(metric_name
, "disk_write_ops")
228 self
.assertEqual(norm_name
, "disk.write.requests")
230 # test with an invalid metric name
231 values
= {"metric_name": "my_invalid_metric"}
233 metric_name
, norm_name
= self
.metrics
.get_metric_name(values
)
235 self
.assertEqual(metric_name
, "my_invalid_metric")
236 self
.assertEqual(norm_name
, None)
238 @mock.patch
.object(metric_req
.Metrics
, "get_metric_id")
239 @mock.patch
.object(Common
, "perform_request")
240 def test_valid_read_data_req(self
, perf_req
, get_metric
):
241 """Test the read metric data function, for a valid call."""
242 values
= {"metric_name": "disk_write_ops",
243 "resource_uuid": "resource_id",
244 "collection_unit": "DAY",
245 "collection_period": 1}
247 perf_req
.return_value
= type('obj', (object,), {'text': '{"metric_data":"[]"}'})
249 get_metric
.return_value
= "metric_id"
250 self
.metrics
.read_metric_data(endpoint
, auth_token
, values
)
252 perf_req
.assert_called_once()
254 @mock.patch
.object(Common
, "perform_request")
255 def test_invalid_read_data_req(self
, perf_req
):
256 """Test the read metric data function, for an invalid call."""
257 # Teo empty lists wil be returned because the values are invalid
260 times
, data
= self
.metrics
.read_metric_data(
261 endpoint
, auth_token
, values
)
263 self
.assertEqual(times
, [])
264 self
.assertEqual(data
, [])
266 def test_complete_response_list(self
):
267 """Test the response list function for formating metric lists."""
268 # Mock a list for testing purposes, with valid OSM metric
269 resp_list
= self
.metrics
.response_list(metric_list
)
271 # Check for the expected values in the resulting list
272 for l
in result_list
:
273 self
.assertIn(l
, resp_list
[0].values())
275 def test_name_response_list(self
):
276 """Test the response list with metric name configured."""
277 # Mock the metric name to test a metric name list
278 # Test with a name that is not in the list
279 invalid_name
= "my_metric"
280 resp_list
= self
.metrics
.response_list(
281 metric_list
, metric_name
=invalid_name
)
283 self
.assertEqual(resp_list
, [])
285 # Test with a name on the list
286 valid_name
= "disk_write_ops"
287 resp_list
= self
.metrics
.response_list(
288 metric_list
, metric_name
=valid_name
)
290 # Check for the expected values in the resulting list
291 for l
in result_list
:
292 self
.assertIn(l
, resp_list
[0].values())
294 def test_resource_response_list(self
):
295 """Test the response list with resource_id configured."""
296 # Mock a resource_id to test a resource list
297 # Test with resource not on the list
298 invalid_id
= "mock_resource"
299 resp_list
= self
.metrics
.response_list(metric_list
, resource
=invalid_id
)
301 self
.assertEqual(resp_list
, [])
303 # Test with a resource on the list
305 resp_list
= self
.metrics
.response_list(metric_list
, resource
=valid_id
)
307 # Check for the expected values in the resulting list
308 for l
in result_list
:
309 self
.assertIn(l
, resp_list
[0].values())
311 def test_combined_response_list(self
):
312 """Test the response list function with resource_id and metric_name."""
313 # Test for a combined resource and name list
314 # resource and name are on the list
315 valid_name
= "disk_write_ops"
317 resp_list
= self
.metrics
.response_list(
318 metric_list
, metric_name
=valid_name
, resource
=valid_id
)
320 # Check for the expected values in the resulting list
321 for l
in result_list
:
322 self
.assertIn(l
, resp_list
[0].values())
324 # resource not on list
325 invalid_id
= "mock_resource"
326 resp_list
= self
.metrics
.response_list(
327 metric_list
, metric_name
=valid_name
, resource
=invalid_id
)
329 self
.assertEqual(resp_list
, [])
331 # metric name not on list
332 invalid_name
= "mock_metric"
333 resp_list
= self
.metrics
.response_list(
334 metric_list
, metric_name
=invalid_name
, resource
=valid_id
)
336 self
.assertEqual(resp_list
, [])