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(Common
, "perform_request")
242 def test_valid_read_data_req(self
, perf_req
):
243 """Test the read metric data function, for a valid call."""
244 values
= {"metric_uuid": "metric_id",
245 "collection_unit": "DAY",
246 "collection_period": 1}
248 self
.metrics
.read_metric_data(endpoint
, auth_token
, values
)
250 perf_req
.assert_called_once()
252 @mock.patch
.object(Common
, "perform_request")
253 def test_invalid_read_data_req(self
, perf_req
):
254 """Test the read metric data function, for an invalid call."""
255 # Teo empty lists wil be returned because the values are invalid
258 times
, data
= self
.metrics
.read_metric_data(
259 endpoint
, auth_token
, values
)
261 self
.assertEqual(times
, [])
262 self
.assertEqual(data
, [])
264 def test_complete_response_list(self
):
265 """Test the response list function for formating metric lists."""
266 # Mock a list for testing purposes, with valid OSM metric
267 resp_list
= self
.metrics
.response_list(metric_list
)
269 # Check for the expected values in the resulting list
270 for l
in result_list
:
271 self
.assertIn(l
, resp_list
[0].values())
273 def test_name_response_list(self
):
274 """Test the response list with metric name configured."""
275 # Mock the metric name to test a metric name list
276 # Test with a name that is not in the list
277 invalid_name
= "my_metric"
278 resp_list
= self
.metrics
.response_list(
279 metric_list
, metric_name
=invalid_name
)
281 self
.assertEqual(resp_list
, [])
283 # Test with a name on the list
284 valid_name
= "disk_write_ops"
285 resp_list
= self
.metrics
.response_list(
286 metric_list
, metric_name
=valid_name
)
288 # Check for the expected values in the resulting list
289 for l
in result_list
:
290 self
.assertIn(l
, resp_list
[0].values())
292 def test_resource_response_list(self
):
293 """Test the response list with resource_id configured."""
294 # Mock a resource_id to test a resource list
295 # Test with resource not on the list
296 invalid_id
= "mock_resource"
297 resp_list
= self
.metrics
.response_list(metric_list
, resource
=invalid_id
)
299 self
.assertEqual(resp_list
, [])
301 # Test with a resource on the list
303 resp_list
= self
.metrics
.response_list(metric_list
, resource
=valid_id
)
305 # Check for the expected values in the resulting list
306 for l
in result_list
:
307 self
.assertIn(l
, resp_list
[0].values())
309 def test_combined_response_list(self
):
310 """Test the response list function with resource_id and metric_name."""
311 # Test for a combined resource and name list
312 # resource and name are on the list
313 valid_name
= "disk_write_ops"
315 resp_list
= self
.metrics
.response_list(
316 metric_list
, metric_name
=valid_name
, resource
=valid_id
)
318 # Check for the expected values in the resulting list
319 for l
in result_list
:
320 self
.assertIn(l
, resp_list
[0].values())
322 # resource not on list
323 invalid_id
= "mock_resource"
324 resp_list
= self
.metrics
.response_list(
325 metric_list
, metric_name
=valid_name
, resource
=invalid_id
)
327 self
.assertEqual(resp_list
, [])
329 # metric name not on list
330 invalid_name
= "mock_metric"
331 resp_list
= self
.metrics
.response_list(
332 metric_list
, metric_name
=invalid_name
, resource
=valid_id
)
334 self
.assertEqual(resp_list
, [])