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 self
.metrics
.configure_metric(endpoint
, auth_token
, values
)
136 perf_req
.assert_called_with(
137 "<ANY>/v1/resource/generic", auth_token
, req_type
="post",
138 payload
=json
.dumps(payload
))
140 @mock.patch
.object(Common
, "perform_request")
141 def test_delete_metric_req(self
, perf_req
):
142 """Test the delete metric function."""
143 self
.metrics
.delete_metric(endpoint
, auth_token
, "metric_id")
145 perf_req
.assert_called_with(
146 "<ANY>/v1/metric/metric_id", auth_token
, req_type
="delete")
148 @mock.patch
.object(Common
, "perform_request")
149 def test_delete_metric_invalid_status(self
, perf_req
):
150 """Test invalid response for delete request."""
151 perf_req
.return_value
= "404"
153 status
= self
.metrics
.delete_metric(endpoint
, auth_token
, "metric_id")
155 self
.assertEqual(status
, False)
157 @mock.patch
.object(metric_req
.Metrics
, "response_list")
158 @mock.patch
.object(Common
, "perform_request")
159 def test_complete_list_metric_req(self
, perf_req
, resp_list
):
160 """Test the complete list metric function."""
161 # Test listing metrics without any configuration options
163 perf_req
.side_effect
= perform_request_side_effect
164 self
.metrics
.list_metrics(endpoint
, auth_token
, values
)
166 perf_req
.assert_any_call(
167 "<ANY>/v1/metric?sort=name:asc", auth_token
, req_type
="get")
168 resp_list
.assert_called_with([{u
'id': u
'test_id'}])
170 @mock.patch
.object(metric_req
.Metrics
, "response_list")
171 @mock.patch
.object(Common
, "perform_request")
172 def test_resource_list_metric_req(self
, perf_req
, resp_list
):
173 """Test the resource list metric function."""
174 # Test listing metrics with a resource id specified
175 values
= {"resource_uuid": "resource_id"}
176 perf_req
.side_effect
= perform_request_side_effect
177 self
.metrics
.list_metrics(endpoint
, auth_token
, values
)
179 perf_req
.assert_any_call(
180 "<ANY>/v1/metric?sort=name:asc", auth_token
, req_type
="get")
181 resp_list
.assert_called_with(
182 [{u
'id': u
'test_id'}], resource
="resource_id")
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/metric?sort=name:asc", auth_token
, req_type
="get")
211 resp_list
.assert_called_with(
212 [{u
'id': u
'test_id'}], resource
="resource_id",
213 metric_name
="packets_sent")
215 @mock.patch
.object(Common
, "perform_request")
216 def test_get_metric_id(self
, perf_req
):
217 """Test get_metric_id function."""
218 self
.metrics
.get_metric_id(endpoint
, auth_token
, "my_metric", "r_id")
220 perf_req
.assert_called_with(
221 "<ANY>/v1/resource/generic/r_id", auth_token
, req_type
="get")
223 def test_get_metric_name(self
):
224 """Test the result from the get_metric_name function."""
225 # test with a valid metric_name
226 values
= {"metric_name": "disk_write_ops"}
228 metric_name
, norm_name
= self
.metrics
.get_metric_name(values
)
230 self
.assertEqual(metric_name
, "disk_write_ops")
231 self
.assertEqual(norm_name
, "disk.write.requests")
233 # test with an invalid metric name
234 values
= {"metric_name": "my_invalid_metric"}
236 metric_name
, norm_name
= self
.metrics
.get_metric_name(values
)
238 self
.assertEqual(metric_name
, "my_invalid_metric")
239 self
.assertEqual(norm_name
, None)
241 @mock.patch
.object(metric_req
.Metrics
, "get_metric_id")
242 @mock.patch
.object(Common
, "perform_request")
243 def test_valid_read_data_req(self
, perf_req
, get_metric
):
244 """Test the read metric data function, for a valid call."""
245 values
= {"metric_name": "disk_write_ops",
246 "resource_uuid": "resource_id",
247 "collection_unit": "DAY",
248 "collection_period": 1}
250 get_metric
.return_value
= "metric_id"
251 self
.metrics
.read_metric_data(endpoint
, auth_token
, values
)
253 perf_req
.assert_called_once()
255 @mock.patch
.object(Common
, "perform_request")
256 def test_invalid_read_data_req(self
, perf_req
):
257 """Test the read metric data function, for an invalid call."""
258 # Teo empty lists wil be returned because the values are invalid
261 times
, data
= self
.metrics
.read_metric_data(
262 endpoint
, auth_token
, values
)
264 self
.assertEqual(times
, [])
265 self
.assertEqual(data
, [])
267 def test_complete_response_list(self
):
268 """Test the response list function for formating metric lists."""
269 # Mock a list for testing purposes, with valid OSM metric
270 resp_list
= self
.metrics
.response_list(metric_list
)
272 # Check for the expected values in the resulting list
273 for l
in result_list
:
274 self
.assertIn(l
, resp_list
[0].values())
276 def test_name_response_list(self
):
277 """Test the response list with metric name configured."""
278 # Mock the metric name to test a metric name list
279 # Test with a name that is not in the list
280 invalid_name
= "my_metric"
281 resp_list
= self
.metrics
.response_list(
282 metric_list
, metric_name
=invalid_name
)
284 self
.assertEqual(resp_list
, [])
286 # Test with a name on the list
287 valid_name
= "disk_write_ops"
288 resp_list
= self
.metrics
.response_list(
289 metric_list
, metric_name
=valid_name
)
291 # Check for the expected values in the resulting list
292 for l
in result_list
:
293 self
.assertIn(l
, resp_list
[0].values())
295 def test_resource_response_list(self
):
296 """Test the response list with resource_id configured."""
297 # Mock a resource_id to test a resource list
298 # Test with resource not on the list
299 invalid_id
= "mock_resource"
300 resp_list
= self
.metrics
.response_list(metric_list
, resource
=invalid_id
)
302 self
.assertEqual(resp_list
, [])
304 # Test with a resource on the list
306 resp_list
= self
.metrics
.response_list(metric_list
, resource
=valid_id
)
308 # Check for the expected values in the resulting list
309 for l
in result_list
:
310 self
.assertIn(l
, resp_list
[0].values())
312 def test_combined_response_list(self
):
313 """Test the response list function with resource_id and metric_name."""
314 # Test for a combined resource and name list
315 # resource and name are on the list
316 valid_name
= "disk_write_ops"
318 resp_list
= self
.metrics
.response_list(
319 metric_list
, metric_name
=valid_name
, resource
=valid_id
)
321 # Check for the expected values in the resulting list
322 for l
in result_list
:
323 self
.assertIn(l
, resp_list
[0].values())
325 # resource not on list
326 invalid_id
= "mock_resource"
327 resp_list
= self
.metrics
.response_list(
328 metric_list
, metric_name
=valid_name
, resource
=invalid_id
)
330 self
.assertEqual(resp_list
, [])
332 # metric name not on list
333 invalid_name
= "mock_metric"
334 resp_list
= self
.metrics
.response_list(
335 metric_list
, metric_name
=invalid_name
, resource
=valid_id
)
337 self
.assertEqual(resp_list
, [])