def test_list_alarms_by_offset_limit(self):
definition_ids, expected_metric = self._create_alarms_for_test_alarms(
num=3)
resp, response_body = self.monasca_client.list_alarms(
'?metric_name=' + expected_metric['name'])
self._verify_list_alarms_elements(resp,
response_body,
expect_num_elements=3)
elements = response_body['elements']
second_element = elements[1]
offset = 1
limit = 1
query_parms = '?metric_name=' + expected_metric['name'] + \
'&offset=' + str(offset) + '&limit=' + str(limit)
resp, response_body1 = self.monasca_client.list_alarms(query_parms)
elements = response_body1['elements']
self.assertEqual(1, len(elements))
self.assertEqual(elements[0]['id'], second_element['id'])
self.assertEqual(elements[0], second_element)
links = response_body1['links']
next_offset = None
next_limit = None
for link in links:
if link['rel'] == 'next':
next_offset = helpers.get_query_param(link['href'], 'offset')
next_limit = helpers.get_query_param(link['href'], 'limit')
self.assertEqual(str(offset + limit), next_offset)
self.assertEqual(str(limit), next_limit)
def test_list_alarms_by_offset_limit(self):
definition_ids, expected_metric = self._create_alarms_for_test_alarms(num=3)
resp, response_body = self.monasca_client.list_alarms('?metric_name=' + expected_metric['name'])
self._verify_list_alarms_elements(resp, response_body,
expect_num_elements=3)
elements = response_body['elements']
second_element = elements[1]
offset = 1
limit = 1
query_parms = '?metric_name=' + expected_metric['name'] + \
'&offset=' + str(offset) + '&limit=' + str(limit)
resp, response_body1 = self.monasca_client.list_alarms(query_parms)
elements = response_body1['elements']
self.assertEqual(1, len(elements))
self.assertEqual(elements[0]['id'], second_element['id'])
self.assertEqual(elements[0], second_element)
links = response_body1['links']
next_offset = None
next_limit = None
for link in links:
if link['rel'] == 'next':
next_offset = helpers.get_query_param(link['href'], 'offset')
next_limit = helpers.get_query_param(link['href'], 'limit')
self.assertEqual(str(offset + limit), next_offset)
self.assertEqual(str(limit), next_limit)
def test_list_measurements_with_offset_limit(self):
query_parms = '?name=' + str(self._names_list[1]) + \
'&merge_metrics=true&start_time=' + self._start_time + \
'&end_time=' + self._end_time
resp, response_body = self.monasca_client.list_measurements(
query_parms)
self._verify_list_measurements(resp, response_body)
elements = response_body['elements']
self._verify_list_measurements_elements(elements=elements,
test_key=None,
test_value=None)
measurements = elements[0]['measurements']
self._verify_list_measurements_meas_len(measurements=measurements,
test_len=4)
for measurement_index in range(1, len(measurements) - 3):
max_limit = len(measurements) - measurement_index
# Get first offset from api
query_parms = '?name=' + str(self._names_list[1]) + \
'&merge_metrics=true&start_time=' + \
measurements[measurement_index - 1][0] + \
'&end_time=' + self._end_time + \
'&limit=1'
resp, response_body = self.monasca_client.list_measurements(
query_parms)
for link in response_body['links']:
if link['rel'] == 'next':
next_link = link['href']
if not next_link:
self.fail(
"No next link returned with query parameters: {}".formet(
query_parms))
offset = helpers.get_query_param(next_link, "offset")
first_index = measurement_index + 1
for limit in range(1, max_limit):
last_index = measurement_index + limit + 1
expected_measurements = measurements[first_index:last_index]
query_parms = '?name=' + str(self._names_list[1]) + \
'&merge_metrics=true&start_time=' + \
self._start_time + '&end_time=' + \
self._end_time + '&limit=' + str(limit) + \
'&offset=' + str(offset)
resp, response_body = self.monasca_client.list_measurements(
query_parms)
self._verify_list_measurements(resp, response_body)
new_measurements = response_body['elements'][0]['measurements']
self.assertEqual(limit, len(new_measurements))
for i in range(len(expected_measurements)):
self.assertEqual(expected_measurements[i],
new_measurements[i])
def test_list_alarm_definitions_with_offset_limit(self):
helpers.delete_alarm_definitions(self.monasca_client)
expression = "max(cpu.system_perc) > 0"
self._create_alarm_definitions(
expression=expression, number_of_definitions=NUM_ALARM_DEFINITIONS)
resp, response_body = self.monasca_client.list_alarm_definitions()
self._verify_list_alarm_definitions_response_body(resp, response_body)
first_element = response_body['elements'][0]
last_element = response_body['elements'][1]
query_parms = '?limit=2'
resp, response_body = self.monasca_client.list_alarm_definitions(
query_parms)
self.assertEqual(200, resp.status)
elements = response_body['elements']
self.assertEqual(2, len(elements))
self.assertEqual(first_element, elements[0])
self.assertEqual(last_element, elements[1])
for offset in xrange(0, 2):
for limit in xrange(1, 3 - offset):
query_parms = '?offset=' + str(offset) + '&limit=' + str(limit)
resp, response_body = self.monasca_client.list_alarm_definitions(
query_parms)
self.assertEqual(200, resp.status)
new_elements = response_body['elements']
self.assertEqual(limit, len(new_elements))
self.assertEqual(elements[offset], new_elements[0])
self.assertEqual(elements[offset + limit - 1],
new_elements[-1])
links = response_body['links']
for link in links:
if link['rel'] == 'next':
next_offset = helpers.get_query_param(
link['href'], 'offset')
next_limit = helpers.get_query_param(
link['href'], 'limit')
self.assertEqual(str(offset + limit), next_offset)
self.assertEqual(str(limit), next_limit)
def test_list_measurements_with_offset_limit(self):
query_parms = '?name=' + str(self._names_list[1]) + \
'&merge_metrics=true&start_time=' + self._start_time + \
'&end_time=' + self._end_time
resp, response_body = self.monasca_client.list_measurements(
query_parms)
self._verify_list_measurements(resp, response_body)
elements = response_body['elements']
self._verify_list_measurements_elements(elements=elements,
test_key=None, test_value=None)
measurements = elements[0]['measurements']
self._verify_list_measurements_meas_len(measurements=measurements,
test_len=4)
for measurement_index in xrange(1, len(measurements) - 3):
max_limit = len(measurements) - measurement_index
# Get first offset from api
query_parms = '?name=' + str(self._names_list[1]) + \
'&merge_metrics=true&start_time=' + measurements[measurement_index - 1][0] + \
'&end_time=' + self._end_time + \
'&limit=1'
resp, response_body = self.monasca_client.list_measurements(query_parms)
for link in response_body['links']:
if link['rel'] == 'next':
next_link = link['href']
if not next_link:
self.fail("No next link returned with query parameters: {}".formet(query_parms))
offset = helpers.get_query_param(next_link, "offset")
first_index = measurement_index + 1
for limit in xrange(1, max_limit):
last_index = measurement_index + limit + 1
expected_measurements = measurements[first_index:last_index]
query_parms = '?name=' + str(self._names_list[1]) + \
'&merge_metrics=true&start_time=' + \
self._start_time + '&end_time=' + \
self._end_time + '&limit=' + str(limit) + \
'&offset=' + str(offset)
resp, response_body = self.monasca_client.list_measurements(
query_parms)
self._verify_list_measurements(resp, response_body)
new_measurements = response_body['elements'][0]['measurements']
self.assertEqual(limit, len(new_measurements))
for i in xrange(len(expected_measurements)):
self.assertEqual(expected_measurements[i],
new_measurements[i])
def test_list_alarm_definitions_with_offset_limit(self):
helpers.delete_alarm_definitions(self.monasca_client)
expression = "max(cpu.system_perc) > 0"
self._create_alarm_definitions(
expression=expression, number_of_definitions=NUM_ALARM_DEFINITIONS)
resp, response_body = self.monasca_client.list_alarm_definitions()
self._verify_list_alarm_definitions_response_body(resp, response_body)
first_element = response_body['elements'][0]
last_element = response_body['elements'][1]
query_parms = '?limit=2'
resp, response_body = self.monasca_client.list_alarm_definitions(
query_parms)
self.assertEqual(200, resp.status)
elements = response_body['elements']
self.assertEqual(2, len(elements))
self.assertEqual(first_element, elements[0])
self.assertEqual(last_element, elements[1])
for offset in xrange(0, 2):
for limit in xrange(1, 3 - offset):
query_parms = '?offset=' + str(offset) + '&limit=' + str(limit)
resp, response_body = self.monasca_client.list_alarm_definitions(query_parms)
self.assertEqual(200, resp.status)
new_elements = response_body['elements']
self.assertEqual(limit, len(new_elements))
self.assertEqual(elements[offset], new_elements[0])
self.assertEqual(elements[offset + limit - 1],
new_elements[-1])
links = response_body['links']
for link in links:
if link['rel'] == 'next':
next_offset = helpers.get_query_param(link['href'], 'offset')
next_limit = helpers.get_query_param(link['href'], 'limit')
self.assertEqual(str(offset + limit), next_offset)
self.assertEqual(str(limit), next_limit)
def test_list_statistics_with_offset_limit(self):
start_timestamp = int(time.time() * 1000)
name = data_utils.rand_name()
metric = [
helpers.create_metric(name=name, timestamp=start_timestamp + 0,
dimensions={'key1': 'value-1',
'key2': 'value-1'},
value=1),
helpers.create_metric(name=name, timestamp=start_timestamp + 1000,
dimensions={'key1': 'value-2',
'key2': 'value-2'},
value=2),
helpers.create_metric(name=name, timestamp=start_timestamp + 2000,
dimensions={'key1': 'value-3',
'key2': 'value-3'},
value=3),
helpers.create_metric(name=name, timestamp=start_timestamp + 3000,
dimensions={'key1': 'value-4',
'key2': 'value-4'},
value=4)
]
self.monasca_client.create_metrics(metric)
query_parms = '?name=' + name
for i in xrange(constants.MAX_RETRIES):
resp, response_body = self.monasca_client.list_metrics(query_parms)
self.assertEqual(200, resp.status)
elements = response_body['elements']
if elements:
break
else:
time.sleep(constants.RETRY_WAIT_SECS)
self._check_timeout(i, constants.MAX_RETRIES, elements, 4)
start_time = helpers.timestamp_to_iso(start_timestamp)
end_timestamp = start_timestamp + 4000
end_time = helpers.timestamp_to_iso(end_timestamp)
query_parms = '?name=' + name + '&merge_metrics=true&statistics=avg' \
+ '&start_time=' + str(start_time) + '&end_time=' + \
str(end_time) + '&period=1'
resp, body = self.monasca_client.list_statistics(query_parms)
self.assertEqual(200, resp.status)
elements = body['elements'][0]['statistics']
first_element = elements[0]
query_parms = '?name=' + name + '&merge_metrics=true&statistics=avg'\
+ '&start_time=' + str(start_time) + '&end_time=' + \
str(end_time) + '&period=1' + '&limit=4'
resp, response_body = self.monasca_client.list_statistics(
query_parms)
self.assertEqual(200, resp.status)
elements = response_body['elements'][0]['statistics']
self.assertEqual(4, len(elements))
self.assertEqual(first_element, elements[0])
for index in xrange(1, 4):
max_limit = 4 - index
# Get first offset from api
query_parms = '?name=' + str(name) + \
'&merge_metrics=true&start_time=' + elements[index - 1][0] + \
'&end_time=' + end_time + \
'&limit=1'
resp, response_body = self.monasca_client.list_measurements(query_parms)
for link in response_body['links']:
if link['rel'] == 'next':
next_link = link['href']
if not next_link:
self.fail("No next link returned with query parameters: {}".formet(query_parms))
offset = helpers.get_query_param(next_link, "offset")
# python api returns exact timestamp, but the test needs a rounded number
offset_period_index = offset.find('.')
offset = offset[:offset_period_index] + 'Z'
for limit in xrange(1, max_limit):
expected_elements = [elem for elem in elements if elem[0] > offset]
expected_elements = expected_elements[:limit]
query_parms = '?name=' + name + '&merge_metrics=true' + \
'&statistics=avg' + '&start_time=' + \
str(start_time) + '&end_time=' + \
str(end_time) + '&period=1' + '&limit=' + \
str(limit) + '&offset=' + str(offset)
resp, response_body = self.monasca_client.list_statistics(query_parms)
self.assertEqual(200, resp.status)
if not response_body['elements']:
self.fail("No metrics returned")
if not response_body['elements'][0]['statistics']:
self.fail("No statistics returned")
new_elements = response_body['elements'][0]['statistics']
self.assertEqual(limit, len(new_elements))
# bug in the python API causes limit 1 to not have matching timestamps
if limit > 1:
self.assertEqual(expected_elements, new_elements)
