163 lines
6.6 KiB
Python
163 lines
6.6 KiB
Python
# (C) Copyright 2015-2017 Hewlett Packard Enterprise Development LP
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License. You may obtain
|
|
# a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
|
|
import time
|
|
|
|
from monasca_tempest_tests.tests.api import base
|
|
from monasca_tempest_tests.tests.api import constants
|
|
from monasca_tempest_tests.tests.api import helpers
|
|
from tempest.lib.common.utils import data_utils
|
|
from tempest.lib import decorators
|
|
from urllib import urlencode
|
|
|
|
|
|
class TestMetricsNames(base.BaseMonascaTest):
|
|
|
|
@classmethod
|
|
def resource_setup(cls):
|
|
super(TestMetricsNames, cls).resource_setup()
|
|
name1 = data_utils.rand_name('name1')
|
|
name2 = data_utils.rand_name('name2')
|
|
name3 = data_utils.rand_name('name3')
|
|
key = data_utils.rand_name()
|
|
key1 = data_utils.rand_name()
|
|
value = data_utils.rand_name()
|
|
value1 = data_utils.rand_name()
|
|
|
|
timestamp = int(round(time.time() * 1000))
|
|
time_iso = helpers.timestamp_to_iso(timestamp)
|
|
|
|
metric1 = helpers.create_metric(name=name1,
|
|
dimensions={key: value})
|
|
metric2 = helpers.create_metric(name=name2,
|
|
dimensions={key1: value1})
|
|
metric3 = helpers.create_metric(name=name3,
|
|
dimensions={key: value})
|
|
cls._test_metric_names = {name1, name2, name3}
|
|
cls._expected_names_list = list(cls._test_metric_names)
|
|
cls._expected_names_list.sort()
|
|
cls._test_metric_names_with_same_dim = [name1, name3]
|
|
cls._test_metrics = [metric1, metric2, metric3]
|
|
cls._dimensions_param = key + ':' + value
|
|
|
|
cls.monasca_client.create_metrics(cls._test_metrics)
|
|
|
|
query_param = '?start_time=' + time_iso
|
|
returned_name_set = set()
|
|
for i in range(constants.MAX_RETRIES):
|
|
resp, response_body = cls.monasca_client.list_metrics(query_param)
|
|
elements = response_body['elements']
|
|
for element in elements:
|
|
returned_name_set.add(str(element['name']))
|
|
if cls._test_metric_names.issubset(returned_name_set):
|
|
return
|
|
time.sleep(constants.RETRY_WAIT_SECS)
|
|
|
|
assert False, 'Unable to initialize metrics'
|
|
|
|
@classmethod
|
|
def resource_cleanup(cls):
|
|
super(TestMetricsNames, cls).resource_cleanup()
|
|
|
|
@decorators.attr(type='gate')
|
|
def test_list_metrics_names(self):
|
|
resp, response_body = self.monasca_client.list_metrics_names()
|
|
metric_names = self._verify_response(resp, response_body)
|
|
self.assertEqual(metric_names, self._expected_names_list)
|
|
|
|
@decorators.attr(type='gate')
|
|
def test_list_metrics_names_with_dimensions(self):
|
|
query_params = '?dimensions=' + self._dimensions_param
|
|
resp, response_body = self.monasca_client.list_metrics_names(
|
|
query_params)
|
|
metric_names = self._verify_response(resp, response_body)
|
|
self.assertEqual(metric_names,
|
|
self._test_metric_names_with_same_dim)
|
|
|
|
@decorators.attr(type='gate')
|
|
def test_list_metrics_names_with_limit_offset(self):
|
|
resp, response_body = self.monasca_client.list_metrics_names()
|
|
self.assertEqual(200, resp.status)
|
|
elements = response_body['elements']
|
|
num_names = len(elements)
|
|
|
|
for limit in range(1, num_names):
|
|
start_index = 0
|
|
params = [('limit', limit)]
|
|
offset = None
|
|
while True:
|
|
num_expected_elements = limit
|
|
if (num_expected_elements + start_index) > num_names:
|
|
num_expected_elements = num_names - start_index
|
|
|
|
these_params = list(params)
|
|
# If not the first call, use the offset returned by the last
|
|
# call
|
|
if offset:
|
|
these_params.extend([('offset', str(offset))])
|
|
query_params = '?' + urlencode(these_params)
|
|
|
|
resp, response_body = \
|
|
self.monasca_client.list_metrics_names(query_params)
|
|
new_elements = self._verify_response(resp, response_body)
|
|
self.assertEqual(num_expected_elements, len(new_elements))
|
|
|
|
expected_elements = elements[start_index:start_index + limit]
|
|
expected_names = \
|
|
[expected_elements[i]['name'] for i in range(
|
|
len(expected_elements))]
|
|
|
|
self.assertEqual(expected_names, new_elements)
|
|
start_index += num_expected_elements
|
|
if start_index >= num_names:
|
|
break
|
|
# Get the next set
|
|
offset = self._get_offset(response_body)
|
|
|
|
@decorators.attr(type='gate')
|
|
def test_list_metrics_names_with_offset_not_in_metrics_names_list(self):
|
|
offset1 = 'tempest-abc'
|
|
offset2 = 'tempest-name111'
|
|
offset3 = 'tempest-name4-random'
|
|
query_param1 = '?' + urlencode([('offset', offset1)])
|
|
query_param2 = '?' + urlencode([('offset', offset2)])
|
|
query_param3 = '?' + urlencode([('offset', offset3)])
|
|
|
|
resp, response_body = self.monasca_client.list_metrics_names(
|
|
query_param1)
|
|
metric_names = self._verify_response(resp, response_body)
|
|
|
|
self.assertEqual(metric_names, self._expected_names_list[:])
|
|
|
|
resp, response_body = self.monasca_client.list_metrics_names(
|
|
query_param2)
|
|
metric_names = self._verify_response(resp, response_body)
|
|
self.assertEqual(metric_names, self._expected_names_list[1:])
|
|
|
|
resp, response_body = self.monasca_client.list_metrics_names(
|
|
query_param3)
|
|
self.assertEqual(response_body['elements'], [])
|
|
|
|
def _verify_response(self, resp, response_body):
|
|
self.assertEqual(200, resp.status)
|
|
self.assertTrue(set(['links', 'elements']) == set(response_body))
|
|
|
|
response_names_length = len(response_body['elements'])
|
|
if response_names_length == 0:
|
|
self.fail("No metric names returned")
|
|
|
|
metric_names = [str(response_body['elements'][i]['name']) for i in
|
|
range(response_names_length)]
|
|
return metric_names
|