def _create_metrics_for_match_by_sub_expressions_list( self, num, alarm_definition_id): # create some metrics metric1 = helpers.create_metric(name='cpu.idle_perc', dimensions={ 'service': 'monitoring', 'hostname': 'mini-mon', 'device': '/dev/sda1' }) metric2 = helpers.create_metric(name='cpu.idle_perc', dimensions={ 'service': 'monitoring', 'hostname': 'devstack', 'device': '/dev/sda1' }) metric3 = helpers.create_metric(name='cpu.idle_perc', dimensions={ 'service': 'monitoring', 'hostname': 'mini-mon', 'device': 'tmpfs' }) metric4 = helpers.create_metric(name='cpu.idle_perc', dimensions={ 'service': 'monitoring', 'hostname': 'devstack', 'device': 'tmpfs' }) self.monasca_client.create_metrics(metric1) self.monasca_client.create_metrics(metric2) self.monasca_client.create_metrics(metric3) self.monasca_client.create_metrics(metric4) self._wait_for_alarms(num, alarm_definition_id)
def _create_metrics_for_match_by_sub_expressions(self, num, alarm_definition_id): metric1 = helpers.create_metric(name='cpu.idle_perc', dimensions={ 'service': 'monitoring', 'hostname': 'mini-mon' }) metric2 = helpers.create_metric(name='cpu.idle_perc', dimensions={ 'service': 'monitoring', 'hostname': 'devstack' }) self.monasca_client.create_metrics(metric1) self.monasca_client.create_metrics(metric2) metric3 = helpers.create_metric(name='cpu.user_perc', dimensions={ 'service': 'monitoring', 'hostname': 'mini-mon' }) metric4 = helpers.create_metric(name='cpu.user_perc', dimensions={ 'service': 'monitoring', 'hostname': 'devstack' }) self.monasca_client.create_metrics(metric3) self.monasca_client.create_metrics(metric4) self._waiting_for_alarms(num, alarm_definition_id)
def test_create_metrics(self): metrics = [ helpers.create_metric(), helpers.create_metric() ] resp, body = self.monasca_client.create_metrics(metrics) self.assertEqual(204, resp.status)
def _create_metrics_for_match_by_sub_expressions_list(self, num, alarm_definition_id): # create some metrics metric1 = helpers.create_metric( name='cpu.idle_perc', dimensions={'service': 'monitoring', 'hostname': 'mini-mon', 'device': '/dev/sda1'}) metric2 = helpers.create_metric( name='cpu.idle_perc', dimensions={'service': 'monitoring', 'hostname': 'devstack', 'device': '/dev/sda1'}) metric3 = helpers.create_metric( name='cpu.idle_perc', dimensions={'service': 'monitoring', 'hostname': 'mini-mon', 'device': 'tmpfs'}) metric4 = helpers.create_metric( name='cpu.idle_perc', dimensions={'service': 'monitoring', 'hostname': 'devstack', 'device': 'tmpfs'}) self.monasca_client.create_metrics(metric1) self.monasca_client.create_metrics(metric2) self.monasca_client.create_metrics(metric3) self.monasca_client.create_metrics(metric4) self._waiting_for_alarms(num, alarm_definition_id)
def test_list_metrics_with_offset_limit(self): name = data_utils.rand_name() key1 = data_utils.rand_name() key2 = data_utils.rand_name() metrics = [ helpers.create_metric(name=name, dimensions={ key1: 'value-1', key2: 'value-1'}), helpers.create_metric(name=name, dimensions={ key1: 'value-2', key2: 'value-2'}), helpers.create_metric(name=name, dimensions={ key1: 'value-3', key2: 'value-3'}), helpers.create_metric(name=name, dimensions={ key1: 'value-4', key2: 'value-4'}) ] self.monasca_client.create_metrics(metrics) query_param = '?name=' + name for i in xrange(constants.MAX_RETRIES): resp, response_body = self.monasca_client.list_metrics(query_param) elements = response_body['elements'] if elements and len(elements) == 4: break time.sleep(constants.RETRY_WAIT_SECS) if i == constants.MAX_RETRIES - 1: error_msg = ("Failed test_list_metrics_with_offset_limit: " "timeout on waiting for metrics: 4 metrics " "are needed. Current number of elements = " "{}").format(len(elements)) self.fail(error_msg) first_element = elements[0] query_parms = '?name=' + name + '&limit=4' resp, response_body = self.monasca_client.list_metrics(query_parms) self.assertEqual(200, resp.status) elements = response_body['elements'] self.assertEqual(4, len(elements)) self.assertEqual(first_element, elements[0]) for metric_index in xrange(len(elements) - 1): metric = elements[metric_index] max_limit = 3 - metric_index for limit in xrange(1, max_limit): first_index = metric_index + 1 last_index = first_index + limit expected_elements = elements[first_index:last_index] query_parms = '?name=' + name + '&offset=' + \ str(metric['id']) + '&limit=' + \ str(limit) resp, response_body = self.\ monasca_client.list_metrics(query_parms) self.assertEqual(200, resp.status) new_elements = response_body['elements'] self.assertEqual(limit, len(new_elements)) for i in xrange(len(expected_elements)): self.assertEqual(expected_elements[i], new_elements[i])
def test_create_metrics(self): name = data_utils.rand_name('name') key = data_utils.rand_name('key') value = data_utils.rand_name('value') timestamp = int(round(time.time() * 1000)) time_iso = helpers.timestamp_to_iso(timestamp) end_timestamp = int(round(timestamp + 3600 * 24 * 1000)) end_time_iso = helpers.timestamp_to_iso(end_timestamp) value_meta_key1 = data_utils.rand_name('meta_key') value_meta_value1 = data_utils.rand_name('meta_value') value_meta_key2 = data_utils.rand_name('value_meta_key') value_meta_value2 = data_utils.rand_name('value_meta_value') metrics = [ helpers.create_metric(name=name, dimensions={key: value}, timestamp=timestamp, value=1.23, value_meta={ value_meta_key1: value_meta_value1 }), helpers.create_metric(name=name, dimensions={key: value}, timestamp=timestamp + 6000, value=4.56, value_meta={ value_meta_key2: value_meta_value2 }) ] resp, response_body = self.monasca_client.create_metrics(metrics) self.assertEqual(204, resp.status) query_param = '?name=' + name + '&start_time=' + str(time_iso) + \ '&end_time=' + str(end_time_iso) for i in xrange(constants.MAX_RETRIES): resp, response_body = self.monasca_client.\ list_measurements(query_param) self.assertEqual(200, resp.status) elements = response_body['elements'] for element in elements: if str(element['name']) == name \ and len(element['measurements']) == 2: self._verify_list_measurements_element(element, key, value) first_measurement = element['measurements'][0] second_measurement = element['measurements'][1] self._verify_list_measurements_measurement( first_measurement, metrics[0], value_meta_key1, value_meta_value1) self._verify_list_measurements_measurement( second_measurement, metrics[1], value_meta_key2, value_meta_value2) return time.sleep(constants.RETRY_WAIT_SECS) if i == constants.MAX_RETRIES - 1: error_msg = "Failed test_create_metrics: " \ "timeout on waiting for metrics: at least " \ "one metric is needed. Current number of " \ "metrics = 0" self.fail(error_msg)
def test_create_metric_with_invalid_chars_in_dimensions(self): for invalid_char in constants.INVALID_CHARS: metric = helpers.create_metric('name-1', {'key-1': invalid_char}) self.assertRaises(exceptions.UnprocessableEntity, self.monasca_client.create_metrics, metric) for invalid_char in constants.INVALID_CHARS: metric = helpers.create_metric('name-1', {invalid_char: 'value-1'}) self.assertRaises(exceptions.UnprocessableEntity, self.monasca_client.create_metrics, metric)
def test_verify_deterministic_alarm(self): metric_name = data_utils.rand_name('log.fancy') metric_dimensions = {'service': 'monitoring', 'hostname': 'mini-mon'} name = data_utils.rand_name('alarm_definition') expression = ('count(%s{service=monitoring},deterministic) > 10' % metric_name) match_by = ['hostname', 'device'] description = 'deterministic' alarm_definition = helpers.create_alarm_definition( name=name, description=description, expression=expression, match_by=match_by) resp, response_body = self.monasca_client.create_alarm_definitions( alarm_definition) alarm_definition_id = response_body['id'] query_param = '?alarm_definition_id=' + str(alarm_definition_id) # 1. ensure alarm was not created resp, response_body = self.monasca_client.list_alarms(query_param) self._verify_list_alarms_elements(resp, response_body, 0) # 2. put some metrics here to create it, should be in ok metrics_count = 5 for it in range(0, metrics_count): metric = helpers.create_metric(name=metric_name, value=1.0, dimensions=metric_dimensions) self.monasca_client.create_metrics(metric) self._wait_for_alarms(1, alarm_definition_id) resp, response_body = self.monasca_client.list_alarms(query_param) self._verify_list_alarms_elements(resp, response_body, 1) element = response_body['elements'][0] self.assertEqual('OK', element['state']) # 3. exceed threshold metrics_count = 20 for it in range(0, metrics_count): metric = helpers.create_metric(name=metric_name, value=1.0, dimensions=metric_dimensions) self.monasca_client.create_metrics(metric) self._wait_for_alarms(1, alarm_definition_id) resp, response_body = self.monasca_client.list_alarms(query_param) self._verify_list_alarms_elements(resp, response_body, 1) element = response_body['elements'][0] self.assertEqual('ALARM', element['state'])
def resource_setup(cls): super(TestDimensions, cls).resource_setup() metric_name1 = data_utils.rand_name() name1 = "name_1" name2 = "name_2" value1 = "value_1" value2 = "value_2" timestamp = int(round(time.time() * 1000)) time_iso = helpers.timestamp_to_iso(timestamp) metric1 = helpers.create_metric(name=metric_name1, dimensions={name1: value1, name2: value2 }) cls.monasca_client.create_metrics(metric1) metric1 = helpers.create_metric(name=metric_name1, dimensions={name1: value2}) cls.monasca_client.create_metrics(metric1) metric_name2 = data_utils.rand_name() name3 = "name_3" value3 = "value_3" metric2 = helpers.create_metric(name=metric_name2, dimensions={name3: value3}) cls.monasca_client.create_metrics(metric2) metric_name3 = data_utils.rand_name() metric3 = helpers.create_metric(name=metric_name3, dimensions={name1: value3}) cls.monasca_client.create_metrics(metric3) cls._test_metric1 = metric1 cls._test_metric2 = metric2 cls._test_metric_names = {metric_name1, metric_name2, metric_name3} cls._dim_names_metric1 = [name1, name2] cls._dim_names_metric2 = [name3] cls._dim_names = cls._dim_names_metric1 + cls._dim_names_metric2 cls._dim_values_for_metric1 = [value1, value2] cls._dim_values = [value1, value2, value3] param = '?start_time=' + time_iso returned_name_set = set() for i in xrange(constants.MAX_RETRIES): resp, response_body = cls.monasca_client.list_metrics( 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'
def resource_setup(cls): super(TestDimensions, cls).resource_setup() metric_name1 = data_utils.rand_name() name1 = "name_1" name2 = "name_2" value1 = "value_1" value2 = "value_2" timestamp = int(round(time.time() * 1000)) time_iso = helpers.timestamp_to_iso(timestamp) metric1 = helpers.create_metric(name=metric_name1, dimensions={name1: value1, name2: value2 }) cls.monasca_client.create_metrics(metric1) metric1 = helpers.create_metric(name=metric_name1, dimensions={name1: value2}) cls.monasca_client.create_metrics(metric1) metric_name2 = data_utils.rand_name() name3 = "name_3" value3 = "value_3" metric2 = helpers.create_metric(name=metric_name2, dimensions={name3: value3}) cls.monasca_client.create_metrics(metric2) metric_name3 = data_utils.rand_name() metric3 = helpers.create_metric(name=metric_name3, dimensions={name1: value3}) cls.monasca_client.create_metrics(metric3) cls._test_metric1 = metric1 cls._test_metric2 = metric2 cls._test_metric_names = {metric_name1, metric_name2, metric_name3} cls._dim_names_metric1 = [name1, name2] cls._dim_names_metric2 = [name3] cls._dim_names = cls._dim_names_metric1 + cls._dim_names_metric2 cls._dim_values_for_metric1 = [value1, value2] cls._dim_values = [value1, value2, value3] param = '?start_time=' + time_iso returned_name_set = set() for i in range(constants.MAX_RETRIES): resp, response_body = cls.monasca_client.list_metrics( 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'
def test_list_metrics_with_offset_limit(self): name = data_utils.rand_name() key1 = data_utils.rand_name() key2 = data_utils.rand_name() metrics = [ helpers.create_metric(name=name, dimensions={ key1: 'value-1', key2: 'value-1'}), helpers.create_metric(name=name, dimensions={ key1: 'value-2', key2: 'value-2'}), helpers.create_metric(name=name, dimensions={ key1: 'value-3', key2: 'value-3'}), helpers.create_metric(name=name, dimensions={ key1: 'value-4', key2: 'value-4'}) ] resp, body = self.monasca_client.create_metrics(metrics) time.sleep(WAIT_TIME) query_parms = '?name=' + name resp, response_body = self.monasca_client.list_metrics(query_parms) self.assertEqual(200, resp.status) elements = response_body['elements'] first_element = elements[0] last_element = elements[3] query_parms = '?name=' + name + '&limit=4' resp, response_body = self.monasca_client.list_metrics(query_parms) self.assertEqual(200, resp.status) elements = response_body['elements'] self.assertEqual(4, len(elements)) self.assertEqual(first_element, elements[0]) for limit in xrange(1, 5): next_element = elements[limit - 1] while True: query_parms = '?name=' + name + '&offset=' +\ str(next_element['id']) + '&limit=' + str(limit) resp, response_body = self.monasca_client.list_metrics( query_parms) self.assertEqual(200, resp.status) new_elements = response_body['elements'] if len(new_elements) > limit - 1: self.assertEqual(limit, len(new_elements)) next_element = new_elements[limit - 1] elif len(new_elements) > 0 and len(new_elements) <= limit - 1: self.assertEqual(last_element, new_elements[0]) break else: self.assertEqual(last_element, next_element) break
def test_list_alarms_by_metric_dimensions_multi_value(self): metric_name = data_utils.rand_name('metric') match_by_key = data_utils.rand_name('key') dim_key = data_utils.rand_name('key') dim_value_1 = data_utils.rand_name('value') dim_value_2 = data_utils.rand_name('value') alarm_def = helpers.create_alarm_definition( name=data_utils.rand_name('definition'), expression=metric_name + " > 1", match_by=[match_by_key]) metric_1 = helpers.create_metric( metric_name, { match_by_key: data_utils.rand_name('value'), dim_key: dim_value_1 }) metric_2 = helpers.create_metric( metric_name, { match_by_key: data_utils.rand_name('value'), dim_key: dim_value_2 }) metric_3 = helpers.create_metric( metric_name, {match_by_key: data_utils.rand_name('value')}) metrics = [metric_1, metric_2, metric_3] resp, response_body = self.monasca_client.create_alarm_definitions( alarm_def) self.assertEqual(201, resp.status) for i in xrange(constants.MAX_RETRIES): resp, alarm_def_result = self.monasca_client.create_metrics( metrics) self.assertEqual(204, resp.status) resp, response_body = self.monasca_client.list_alarms( '?metric_name=' + metric_name) self.assertEqual(200, resp.status) if len(response_body['elements']) >= 3: break time.sleep(constants.RETRY_WAIT_SECS) if i >= constants.MAX_RETRIES - 1: self.fail( "Timeout creating alarms, required 3 but found {}".format( len(response_body['elements']))) query_parms = '?metric_dimensions=' + dim_key + ':' + dim_value_1 + '|' + dim_value_2 resp, response_body = self.monasca_client.list_alarms(query_parms) self._verify_list_alarms_elements(resp, response_body, expect_num_elements=2) dimension_sets = [] for element in response_body['elements']: self.assertEqual(metric_name, element['metrics'][0]['name']) dimension_sets.append(element['metrics'][0]['dimensions']) self.assertIn(metric_1['dimensions'], dimension_sets) self.assertIn(metric_2['dimensions'], dimension_sets) self.assertNotIn(metric_3['dimensions'], dimension_sets)
def _create_metrics_for_match_by(self, num, alarm_definition_id): metric1 = helpers.create_metric( name='cpu.idle_perc', dimensions={'service': 'monitoring', 'hostname': 'mini-mon'}) metric2 = helpers.create_metric( name='cpu.idle_perc', dimensions={'service': 'monitoring', 'hostname': 'devstack'}) self.monasca_client.create_metrics(metric1) self.monasca_client.create_metrics(metric2) self._waiting_for_alarms(num, alarm_definition_id)
def _create_metrics_with_different_dimensions(self, same_name=True): name1 = data_utils.rand_name('name1') name2 = name1 if same_name else data_utils.rand_name('name2') name3 = name1 if same_name else data_utils.rand_name('name3') key_service = data_utils.rand_name('service') values = [data_utils.rand_name('value1'), data_utils.rand_name('value2')] metrics = [helpers.create_metric(name1, {key_service: values[0]}), helpers.create_metric(name2, {key_service: values[1]}), helpers.create_metric(name3, {'key3': 'value3'})] resp, response_body = self.monasca_client.create_metrics(metrics) self.assertEqual(204, resp.status) return metrics, name1, key_service, values
def resource_setup(cls): super(TestStatistics, cls).resource_setup() name = data_utils.rand_name('name') key = data_utils.rand_name('key') value1 = data_utils.rand_name('value1') value2 = data_utils.rand_name('value2') cls._test_name = name cls._test_key = key cls._test_value1 = value1 cls._start_timestamp = int(time.time() * 1000) metrics = [ helpers.create_metric(name=name, dimensions={key: value1}, timestamp=cls._start_timestamp, value=metric_value1), helpers.create_metric(name=name, dimensions={key: value2}, timestamp=cls._start_timestamp + 1000, value=metric_value2) ] cls.monasca_client.create_metrics(metrics) start_time_iso = helpers.timestamp_to_iso(cls._start_timestamp) query_param = '?name=' + str(name) + '&start_time=' + \ start_time_iso + '&merge_metrics=true' + '&end_time=' + \ helpers.timestamp_to_iso(cls._start_timestamp + 1000 * 2) start_time_iso = helpers.timestamp_to_iso(cls._start_timestamp) cls._start_time_iso = start_time_iso num_measurements = 0 for i in xrange(constants.MAX_RETRIES): resp, response_body = cls.monasca_client.\ list_measurements(query_param) elements = response_body['elements'] for element in elements: if str(element['name']) == name: if len(element['measurements'] ) >= MIN_REQUIRED_MEASUREMENTS: cls._end_timestamp = cls._start_timestamp + 1000 * 3 cls._end_time_iso = helpers.timestamp_to_iso( cls._end_timestamp) return else: num_measurements = len(element['measurements']) break time.sleep(constants.RETRY_WAIT_SECS) assert False, "Required {} measurements, found {}".format( MIN_REQUIRED_MEASUREMENTS, num_measurements)
def resource_setup(cls): super(TestMetricsNames, cls).resource_setup() name = data_utils.rand_name() key = data_utils.rand_name() value = data_utils.rand_name() cls._param = key + ':' + value metric = helpers.create_metric(name=name, dimensions={key: value}) cls._test_metric = metric cls.monasca_client.create_metrics(metric) start_time = str(timeutils.iso8601_from_timestamp( metric['timestamp'] / 1000.0)) query_params = '?name=' + str(cls._test_metric['name']) +\ '&start_time=' + start_time for i in xrange(constants.MAX_RETRIES): resp, response_body = cls.monasca_client.list_metrics( query_params) elements = response_body['elements'] for element in elements: if str(element['name']) == cls._test_metric['name']: return time.sleep(constants.RETRY_WAIT_SECS) assert False, 'Unable to initialize metrics'
def test_create_metric_with_empty_key_in_dimensions(self): name = data_utils.rand_name('name') metric = helpers.create_metric(name=name, dimensions={'': 'value'}) self.assertRaises(exceptions.UnprocessableEntity, self.monasca_client.create_metrics, metric)
def test_list_alarms_by_multiple_metric_dimensions(self): metric = helpers.create_metric( name=data_utils.rand_name("multi-dimension"), dimensions={data_utils.rand_name("key-1"): data_utils.rand_name("value-1"), data_utils.rand_name("key-2"): data_utils.rand_name("value-2")}, value=20 ) dimension_strings = [key + '=' + value for key, value in metric['dimensions'].items()] alarm_def = helpers.create_alarm_definition( name=data_utils.rand_name("multi-dimensions"), expression=metric['name'] + "{" + ','.join(dimension_strings) + '} > 15' ) resp, response_body = self.monasca_client.create_alarm_definitions(alarm_def) self.assertEqual(201, resp.status) alarm_def_id = response_body['id'] resp, response_body = self.monasca_client.create_metrics(metric) self.assertEqual(204, resp.status) self._wait_for_alarms(1, alarm_def_id) query_dimensions = [key + ':' + value for key, value in metric['dimensions'].items()] query_parms="?metric_dimensions=" + ','.join(query_dimensions) resp, response_body = self.monasca_client.list_alarms(query_parms) self._verify_list_alarms_elements(resp, response_body, expect_num_elements=1) element = response_body['elements'][0] metric = element['metrics'][0] self._verify_metric_in_alarm(metric, metric) self.assertEqual(alarm_def_id, element['alarm_definition']['id'])
def resource_setup(cls): super(TestAlarmsStateHistoryOneTransition, cls).resource_setup() for i in xrange(MIN_HISTORY): alarm_definition = helpers.create_alarm_definition( name=data_utils.rand_name('alarm_state_history' + str(i + 1)), expression="min(name-" + str(i + 1) + ") < " + str(i + 1)) cls.monasca_client.create_alarm_definitions(alarm_definition) num_transitions = 0 for timer in xrange(constants.MAX_RETRIES): for i in xrange(MIN_HISTORY): # Create some metrics to prime the system and waiting for the # alarms to be created and then for them to change state. # MIN_HISTORY number of Alarms State History are needed. metric = helpers.create_metric(name="name-" + str(i + 1)) cls.monasca_client.create_metrics(metric) # sleep 0.05 second between metrics to make sure timestamps # are different time.sleep(0.05) resp, response_body = cls.monasca_client.\ list_alarms_state_history() elements = response_body['elements'] if len(elements) >= MIN_HISTORY: return else: num_transitions = len(elements) time.sleep(constants.RETRY_WAIT_SECS) assert False, "Required {} alarm state transitions, but found {}".\ format(MIN_HISTORY, num_transitions)
def test_create_metric_no_value(self): timestamp = int(round(time.time() * 1000)) metric = helpers.create_metric(timestamp=timestamp, value=None) self.assertRaises(exceptions.UnprocessableEntity, self.monasca_client.create_metrics, metric)
def test_create_metric_with_value_meta_name_exceeds_max_length(self): long_value_meta_name = "x" * (constants.MAX_VALUE_META_NAME_LENGTH + 1) value_meta_dict = {long_value_meta_name: "value_meta_value"} metric = helpers.create_metric(name='name', value_meta=value_meta_dict) self.assertRaises(exceptions.UnprocessableEntity, self.monasca_client.create_metrics, metric)
def resource_setup(cls): super(TestMetricsNames, cls).resource_setup() name = data_utils.rand_name() key = data_utils.rand_name() value = data_utils.rand_name() cls._param = key + ':' + value metric = helpers.create_metric(name=name, dimensions={key: value}) cls._test_metric = metric cls.monasca_client.create_metrics(metric) start_time = str(timeutils.iso8601_from_timestamp( metric['timestamp'] / 1000.0)) query_params = '?name=' + str(cls._test_metric['name']) +\ '&start_time=' + start_time for i in xrange(constants.MAX_RETRIES): resp, response_body = cls.monasca_client.list_metrics( query_params) elements = response_body['elements'] for element in elements: if str(element['name']) == cls._test_metric['name']: return time.sleep(constants.RETRY_WAIT_SECS) cls.fail('Unable to initialize metrics')
def test_list_metrics_with_tenant(self): name = data_utils.rand_name('name') key = data_utils.rand_name('key') value = data_utils.rand_name('value') tenant = self.tenants_client.create_tenant( name=data_utils.rand_name('test_tenant'))['tenant'] # Delete the tenant at the end of the test self.addCleanup(self.tenants_client.delete_tenant, tenant['id']) metric = helpers.create_metric(name=name, dimensions={key: value}) resp, response_body = self.monasca_client.create_metrics( metric, tenant_id=tenant['id']) self.assertEqual(204, resp.status) query_param = '?tenant_id=' + str(tenant['id']) for i in xrange(constants.MAX_RETRIES): resp, response_body = self.monasca_client.list_metrics(query_param) self.assertEqual(200, resp.status) elements = response_body['elements'] for element in elements: if str(element['name']) == name: self._verify_list_metrics_element(element, test_key=key, test_value=value) return time.sleep(constants.RETRY_WAIT_SECS) if i == constants.MAX_RETRIES - 1: error_msg = "Failed test_list_metrics_with_tenant: " \ "timeout on waiting for metrics: at least " \ "one metric is needed. Current number of " \ "metrics = 0" self.fail(error_msg)
def test_list_statistics_with_no_merge_metrics(self): key = data_utils.rand_name('key') value = data_utils.rand_name('value') metric3 = helpers.create_metric( name=self._test_name, dimensions={key: value}, timestamp=self._start_timestamp + 2000) self.monasca_client.create_metrics(metric3) query_param = '?name=' + str(self._test_name) + '&start_time=' + \ self._start_time_iso + '&end_time=' + helpers.\ timestamp_to_iso(self._start_timestamp + 1000 * 4) + \ '&merge_metrics=True' for i in xrange(constants.MAX_RETRIES): resp, response_body = self.monasca_client.\ list_measurements(query_param) elements = response_body['elements'] for element in elements: if str(element['name']) == self._test_name and len( element['measurements']) == 3: end_time_iso = helpers.timestamp_to_iso( self._start_timestamp + 1000 * 4) query_parms = '?name=' + str(self._test_name) + \ '&statistics=avg' + '&start_time=' + \ str(self._start_time_iso) + '&end_time=' +\ str(end_time_iso) + '&period=100000' self.assertRaises(exceptions.Conflict, self.monasca_client.list_statistics, query_parms) return time.sleep(constants.RETRY_WAIT_SECS) self._check_timeout(i, constants.MAX_RETRIES, elements, 3)
def _create_alarms_for_test_alarms(self, num): metric_name = data_utils.rand_name('name') key = data_utils.rand_name('key') value = data_utils.rand_name('value') alarm_definition_ids = [] for i in xrange(num): # create an alarm definition expression = "max(" + metric_name + ") > 0" name = data_utils.rand_name('name-1') alarm_definition = helpers.create_alarm_definition( name=name, expression=expression) resp, response_body = self.monasca_client.create_alarm_definitions( alarm_definition) alarm_definition_ids.append(response_body['id']) expected_metric = helpers.create_metric(name=metric_name, dimensions={key: value}) # create some metrics for j in xrange(num): for i in xrange(constants.MAX_RETRIES): self.monasca_client.create_metrics(expected_metric) time.sleep(constants.RETRY_WAIT_SECS) query_param = '?alarm_definition_id=' + \ str(alarm_definition_ids[j]) resp, response_body = self.monasca_client.list_alarms( query_param) elements = response_body['elements'] if len(elements) >= 1: break return alarm_definition_ids, expected_metric
def test_list_statistics_with_no_merge_metrics(self): key = data_utils.rand_name('key') value = data_utils.rand_name('value') metric3 = helpers.create_metric( name=self._test_name, dimensions={key: value}, timestamp=self._start_timestamp + 2000) self.monasca_client.create_metrics(metric3) query_param = '?name=' + str(self._test_name) + '&start_time=' + \ self._start_time_iso + '&end_time=' + helpers.\ timestamp_to_iso(self._start_timestamp + 1000 * 4) + \ '&merge_metrics=True' for i in range(constants.MAX_RETRIES): resp, response_body = self.monasca_client.\ list_measurements(query_param) elements = response_body['elements'] for element in elements: if str(element['name']) == self._test_name and len( element['measurements']) == 3: end_time_iso = helpers.timestamp_to_iso( self._start_timestamp + 1000 * 4) query_parms = '?name=' + str(self._test_name) + \ '&statistics=avg' + '&start_time=' + \ str(self._start_time_iso) + '&end_time=' +\ str(end_time_iso) + '&period=100000' self.assertRaises(exceptions.Conflict, self.monasca_client.list_statistics, query_parms) return time.sleep(constants.RETRY_WAIT_SECS) self._check_timeout(i, constants.MAX_RETRIES, elements, 3)
def test_list_metrics_with_name(self): name = data_utils.rand_name(u'name') key = data_utils.rand_name(u'key') value = data_utils.rand_name(u'value') metric = helpers.create_metric(name=name, dimensions={key: value}) resp, response_body = self.monasca_client.create_metrics(metric) self.assertEqual(204, resp.status) query_param = '?name=' + str(name) for i in range(constants.MAX_RETRIES): resp, response_body = self.monasca_client.list_metrics(query_param) self.assertEqual(200, resp.status) elements = response_body['elements'] for element in elements: if element['name'] == name: self._verify_list_metrics_element(element, test_key=key, test_value=value) return time.sleep(constants.RETRY_WAIT_SECS) if i == constants.MAX_RETRIES - 1: error_msg = "Failed test_list_metrics_with_name: " \ "timeout on waiting for metrics: at least " \ "one metric is needed. Current number of " \ "metrics = 0" self.fail(error_msg)
def resource_setup(cls): super(TestAlarmsStateHistoryOneTransition, cls).resource_setup() for i in range(MIN_HISTORY): alarm_definition = helpers.create_alarm_definition( name=data_utils.rand_name('alarm_state_history' + str(i + 1)), expression="min(name-" + str(i + 1) + ") < " + str(i + 1)) cls.monasca_client.create_alarm_definitions(alarm_definition) # Ensure the new Alarm Definitions get to the Threshold Engine time.sleep(constants.ALARM_DEFINITION_CREATION_WAIT) num_transitions = 0 for timer in range(constants.MAX_RETRIES): for i in range(MIN_HISTORY): # Create some metrics to prime the system and waiting for the # alarms to be created and then for them to change state. # MIN_HISTORY number of Alarms State History are needed. metric = helpers.create_metric(name="name-" + str(i + 1)) cls.monasca_client.create_metrics(metric) # Ensure alarms transition at different times time.sleep(0.1) resp, response_body = cls.monasca_client.\ list_alarms_state_history() elements = response_body['elements'] if len(elements) >= MIN_HISTORY: return else: num_transitions = len(elements) time.sleep(constants.RETRY_WAIT_SECS) assert False, "Required {} alarm state transitions, but found {}".\ format(MIN_HISTORY, num_transitions)
def test_create_metric_with_value_meta_exceeds_max_length(self): value_meta_name = "x" long_value_meta_value = "y" * constants.MAX_VALUE_META_TOTAL_LENGTH metric = helpers.create_metric( name='name', value_meta={value_meta_name: long_value_meta_value}) self.assertRaises(exceptions.UnprocessableEntity, self.monasca_client.create_metrics, metric)
def test_create_metric_with_colon_in_dimension_value(self): name = data_utils.rand_name('name') key = 'url' value = 'http://localhost:8070/v2.0' timestamp = int(round(time.time() * 1000)) time_iso = helpers.timestamp_to_iso(timestamp) end_timestamp = int(round((time.time() + 3600 * 24) * 1000)) end_time_iso = helpers.timestamp_to_iso(end_timestamp) metric = helpers.create_metric(name=name, dimensions={key: value}) resp, response_body = self.monasca_client.create_metrics(metric) self.assertEqual(204, resp.status) query_param = '?name=' + name + '&start_time=' + time_iso + \ '&end_time=' + end_time_iso + \ '&dimensions=' + key + ':' + value for i in range(constants.MAX_RETRIES): resp, response_body = self.monasca_client. \ list_measurements(query_param) self.assertEqual(200, resp.status) elements = response_body['elements'] for element in elements: if str(element['name']) == name: self._verify_list_measurements_element(element, key, value) measurement = element['measurements'][0] self._verify_list_measurements_measurement( measurement, metric, None, None) return time.sleep(constants.RETRY_WAIT_SECS) if i == constants.MAX_RETRIES - 1: error_msg = "Failed test_create_metric: " \ "timeout on waiting for metrics: at least " \ "one metric is needed. Current number of " \ "metrics = 0" self.fail(error_msg)
def test_create_metric_with_value_meta_exceeds_max_length(self): value_meta_name = "x" long_value_meta_value = "y" * constants.MAX_VALUE_META_TOTAL_LENGTH value_meta_dict = {value_meta_name: long_value_meta_value} metric = helpers.create_metric(name='name', value_meta=value_meta_dict) self.assertRaises(exceptions.UnprocessableEntity, self.monasca_client.create_metrics, metric)
def resource_setup(cls): super(TestStatistics, cls).resource_setup() name = data_utils.rand_name('name') key = data_utils.rand_name('key') value1 = data_utils.rand_name('value1') value2 = data_utils.rand_name('value2') cls._test_name = name cls._test_key = key cls._test_value1 = value1 cls._start_timestamp = int(time.time() * 1000) metrics = [ helpers.create_metric(name=name, dimensions={key: value1}, timestamp=cls._start_timestamp, value=metric_value1), helpers.create_metric(name=name, dimensions={key: value2}, timestamp=cls._start_timestamp + 1000, value=metric_value2) ] cls.monasca_client.create_metrics(metrics) start_time_iso = helpers.timestamp_to_iso(cls._start_timestamp) query_param = '?name=' + str(name) + '&start_time=' + \ start_time_iso + '&merge_metrics=true' + '&end_time=' + \ helpers.timestamp_to_iso(cls._start_timestamp + 1000 * 2) start_time_iso = helpers.timestamp_to_iso(cls._start_timestamp) cls._start_time_iso = start_time_iso num_measurements = 0 for i in xrange(constants.MAX_RETRIES): resp, response_body = cls.monasca_client.\ list_measurements(query_param) elements = response_body['elements'] for element in elements: if str(element['name']) == name: if len(element['measurements']) >= MIN_REQUIRED_MEASUREMENTS: cls._end_timestamp = cls._start_timestamp + 1000 * 3 cls._end_time_iso = helpers.timestamp_to_iso( cls._end_timestamp) return else: num_measurements = len(element['measurements']) break time.sleep(constants.RETRY_WAIT_SECS) assert False, "Required {} measurements, found {}".format(MIN_REQUIRED_MEASUREMENTS, num_measurements)
def resource_setup(cls): super(TestAlarmStateHistoryMultipleTransitions, cls).resource_setup() alarm_definition = helpers.create_alarm_definition( name=data_utils.rand_name('alarm_state_history'), expression="min(name-1) < 1.0") cls.monasca_client.create_alarm_definitions(alarm_definition) for timer in xrange(constants.MAX_RETRIES): # create some metrics to prime the system and create # MIN_HISTORY alarms metric = helpers.create_metric(name="name-1", dimensions={'key1': 'value1'}, value=0.0) cls.monasca_client.create_metrics(metric) # sleep 1 second between metrics to make sure timestamps # are different in the second field. Influxdb has a bug # where it does not sort properly by milliseconds. .014 # is sorted as greater than .138 time.sleep(1.0) resp, response_body = cls.monasca_client.\ list_alarms_state_history() elements = response_body['elements'] if len(elements) >= 1: break time.sleep(constants.RETRY_WAIT_SECS) time.sleep(constants.MAX_RETRIES) for timer in xrange(constants.MAX_RETRIES * 2): metric = helpers.create_metric(name="name-1", dimensions={'key2': 'value2'}, value=2.0) cls.monasca_client.create_metrics(metric) # sleep 0.05 second between metrics to make sure timestamps # are different time.sleep(0.05) resp, response_body = \ cls.monasca_client.list_alarms_state_history() elements = response_body['elements'] if len(elements) >= 2: return else: num_transitions = len(elements) time.sleep(constants.RETRY_WAIT_SECS) assert False, "Required {} alarm state transitions, but found {}".\ format(MIN_HISTORY, num_transitions)
def test_list_alarms_by_metric_dimensions_no_value(self): metric_name = data_utils.rand_name('metric') match_by_key = data_utils.rand_name('key') dim_key = data_utils.rand_name('key') alarm_def = helpers.create_alarm_definition( name=data_utils.rand_name('definition'), expression=metric_name + " > 1", match_by=[match_by_key]) metric_1 = helpers.create_metric(metric_name, {match_by_key: data_utils.rand_name('value'), dim_key: data_utils.rand_name('value')}) metric_2 = helpers.create_metric(metric_name, {match_by_key: data_utils.rand_name('value'), dim_key: data_utils.rand_name('value')}) metric_3 = helpers.create_metric(metric_name, {match_by_key: data_utils.rand_name('value')}) metrics = [metric_1, metric_2, metric_3] resp, response_body = self.monasca_client.create_alarm_definitions(alarm_def) self.assertEqual(201, resp.status) for i in xrange(constants.MAX_RETRIES): resp, alarm_def_result = self.monasca_client.create_metrics(metrics) self.assertEqual(204, resp.status) resp, response_body = self.monasca_client.list_alarms('?metric_name=' + metric_name) self.assertEqual(200, resp.status) if len(response_body['elements']) >= 3: break time.sleep(constants.RETRY_WAIT_SECS) if i >= constants.MAX_RETRIES - 1: self.fail("Timeout creating alarms, required 3 but found {}".format( len(response_body['elements']))) query_parms = '?metric_dimensions=' + dim_key resp, response_body = self.monasca_client.list_alarms(query_parms) self._verify_list_alarms_elements(resp, response_body, expect_num_elements=2) dimension_sets = [] for element in response_body['elements']: self.assertEqual(metric_name, element['metrics'][0]['name']) dimension_sets.append(element['metrics'][0]['dimensions']) self.assertIn(metric_1['dimensions'], dimension_sets) self.assertIn(metric_2['dimensions'], dimension_sets) self.assertNotIn(metric_3['dimensions'], dimension_sets)
def resource_setup(cls): super(TestAlarmStateHistoryMultipleTransitions, cls).resource_setup() alarm_definition = helpers.create_alarm_definition( name=data_utils.rand_name('alarm_state_history'), expression="min(name-1) < 1.0") cls.monasca_client.create_alarm_definitions(alarm_definition) for timer in xrange(constants.MAX_RETRIES): # create some metrics to prime the system and create # MIN_HISTORY alarms metric = helpers.create_metric( name="name-1", dimensions={'key1': 'value1'}, value=0.0) cls.monasca_client.create_metrics(metric) # sleep 1 second between metrics to make sure timestamps # are different in the second field. Influxdb has a bug # where it does not sort properly by milliseconds. .014 # is sorted as greater than .138 time.sleep(1.0) resp, response_body = cls.monasca_client.\ list_alarms_state_history() elements = response_body['elements'] if len(elements) >= 1: break time.sleep(constants.RETRY_WAIT_SECS) time.sleep(constants.MAX_RETRIES) for timer in xrange(constants.MAX_RETRIES * 2): metric = helpers.create_metric( name="name-1", dimensions={'key2': 'value2'}, value=2.0) cls.monasca_client.create_metrics(metric) # sleep 0.05 second between metrics to make sure timestamps # are different time.sleep(0.05) resp, response_body = \ cls.monasca_client.list_alarms_state_history() elements = response_body['elements'] if len(elements) >= 2: return else: num_transitions = len(elements) time.sleep(constants.RETRY_WAIT_SECS) assert False, "Required {} alarm state transitions, but found {}".\ format(MIN_HISTORY, num_transitions)
def test_list_alarms_by_severity(self): metric_name = data_utils.rand_name("severity-metric") alarm_defs = [] alarm_defs.append( helpers.create_alarm_definition( name=data_utils.rand_name("alarm-severity"), expression=metric_name + " > 12", severity='LOW')) alarm_defs.append( helpers.create_alarm_definition( name=data_utils.rand_name("alarm-severity"), expression=metric_name + " > 12", severity='MEDIUM')) alarm_defs.append( helpers.create_alarm_definition( name=data_utils.rand_name("alarm-severity"), expression=metric_name + " > 12", severity='HIGH')) alarm_defs.append( helpers.create_alarm_definition( name=data_utils.rand_name("alarm-severity"), expression=metric_name + " > 12", severity='CRITICAL')) alarm_def_ids = [] for definition in alarm_defs: resp, response_body = self.monasca_client.create_alarm_definitions( definition) self.assertEqual(201, resp.status) alarm_def_ids.append(response_body['id']) metric = helpers.create_metric(name=metric_name, value=14) resp, response_body = self.monasca_client.create_metrics(metric) self.assertEqual(204, resp.status) for def_id in alarm_def_ids: self._wait_for_alarms(1, def_id) query_parms = '?severity=LOW' resp, response_body = self.monasca_client.list_alarms(query_parms) self.assertEqual(200, resp.status) for alarm in response_body['elements']: self.assertEqual('LOW', alarm['alarm_definition']['severity']) query_parms = '?severity=HIGH' resp, response_body = self.monasca_client.list_alarms(query_parms) self.assertEqual(200, resp.status) for alarm in response_body['elements']: self.assertEqual('HIGH', alarm['alarm_definition']['severity']) query_parms = '?severity=CRITICAL' resp, response_body = self.monasca_client.list_alarms(query_parms) self.assertEqual(200, resp.status) for alarm in response_body['elements']: self.assertEqual('CRITICAL', alarm['alarm_definition']['severity'])
def test_list_alarms_by_severity(self): metric_name = data_utils.rand_name("severity-metric") alarm_defs = [] alarm_defs.append(helpers.create_alarm_definition( name=data_utils.rand_name("alarm-severity"), expression=metric_name + " > 12", severity='LOW' )) alarm_defs.append(helpers.create_alarm_definition( name=data_utils.rand_name("alarm-severity"), expression=metric_name + " > 12", severity='MEDIUM' )) alarm_defs.append(helpers.create_alarm_definition( name=data_utils.rand_name("alarm-severity"), expression=metric_name + " > 12", severity='HIGH' )) alarm_defs.append(helpers.create_alarm_definition( name=data_utils.rand_name("alarm-severity"), expression=metric_name + " > 12", severity='CRITICAL' )) alarm_def_ids = [] for definition in alarm_defs: resp, response_body = self.monasca_client.create_alarm_definitions(definition) self.assertEqual(201, resp.status) alarm_def_ids.append(response_body['id']) metric = helpers.create_metric(name=metric_name, value=14) resp, response_body = self.monasca_client.create_metrics(metric) self.assertEqual(204, resp.status) for def_id in alarm_def_ids: self._wait_for_alarms(1, def_id) query_parms = '?severity=LOW' resp, response_body = self.monasca_client.list_alarms(query_parms) self.assertEqual(200, resp.status) for alarm in response_body['elements']: self.assertEqual('LOW', alarm['alarm_definition']['severity']) query_parms = '?severity=HIGH' resp, response_body = self.monasca_client.list_alarms(query_parms) self.assertEqual(200, resp.status) for alarm in response_body['elements']: self.assertEqual('HIGH', alarm['alarm_definition']['severity']) query_parms = '?severity=CRITICAL' resp, response_body = self.monasca_client.list_alarms(query_parms) self.assertEqual(200, resp.status) for alarm in response_body['elements']: self.assertEqual('CRITICAL', alarm['alarm_definition']['severity'])
def resource_setup(cls): super(TestStatistics, cls).resource_setup() name = data_utils.rand_name('name') key = data_utils.rand_name('key') value = data_utils.rand_name('value') cls._test_name = name cls._test_key = key cls._test_value = value cls._start_timestamp = int(time.time() * 1000) metrics = [ helpers.create_metric(name=cls._test_name, dimensions={cls._test_key: cls._test_value}, timestamp=cls._start_timestamp, value=metric_value1), helpers.create_metric(name=cls._test_name, dimensions={cls._test_key: cls._test_value}, timestamp=cls._start_timestamp + 1000, value=metric_value2) ] cls.monasca_client.create_metrics(metrics) start_time_iso = helpers.timestamp_to_iso(cls._start_timestamp) query_param = '?name=' + str(name) + '&start_time=' + \ start_time_iso + '&end_time=' + \ helpers.timestamp_to_iso(cls._start_timestamp + 1000 * 2) start_time_iso = helpers.timestamp_to_iso(cls._start_timestamp) cls._start_time_iso = start_time_iso for i in xrange(constants.MAX_RETRIES): resp, response_body = cls.monasca_client.\ list_measurements(query_param) elements = response_body['elements'] for element in elements: if str(element['name']) == name and len( element['measurements']) == 2: cls._end_timestamp = cls._start_timestamp + 1000 * 3 cls._end_time_iso = helpers.timestamp_to_iso( cls._end_timestamp) return time.sleep(constants.RETRY_WAIT_SECS) assert False, "Failed to find enough measurements to test"
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 xrange(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'
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'
def resource_setup(cls): super(TestStatistics, cls).resource_setup() start_timestamp = int(time.time() * 1000) end_timestamp = int(time.time() * 1000) + NUM_MEASUREMENTS * 1000 metrics = [] for i in xrange(NUM_MEASUREMENTS): metric = helpers.create_metric(name="name-1", timestamp=start_timestamp + i) metrics.append(metric) resp, response_body = cls.monasca_client.create_metrics(metric) cls._start_timestamp = start_timestamp cls._end_timestamp = end_timestamp cls._metrics = metrics
def test_list_metrics_with_name(self): name_org = data_utils.rand_name('name') key = data_utils.rand_name('key') metric = helpers.create_metric(name=name_org, dimensions={key: 'value-1'}) resp, body = self.monasca_client.create_metrics(metric) time.sleep(WAIT_TIME) query_parms = '?dimensions=' + str(key) + ':value-1' resp, response_body = self.monasca_client.list_metrics(query_parms) self.assertEqual(200, resp.status) elements = response_body['elements'] dimensions = elements[0] name = dimensions['name'] self.assertEqual(name_org, str(name))
def resource_setup(cls): super(TestAlarmsStateHistory, cls).resource_setup() start_timestamp = int(time.time() * 1000) end_timestamp = int(time.time() * 1000) + 1000 # create an alarm definition expression = "avg(name-1) > 0" name = data_utils.rand_name('alarm_definition') alarm_definition = helpers.create_alarm_definition( name=name, expression=expression) resp, response_body = cls.monasca_client.create_alarm_definitions( alarm_definition) # create another alarm definition name1 = data_utils.rand_name('alarm_definition1') expression1 = "max(cpu.system_perc) > 0" alarm_definition1 = helpers.create_alarm_definition( name=name1, expression=expression1) resp, response_body1 = cls.monasca_client.create_alarm_definitions( alarm_definition1) # create another alarm definition name2 = data_utils.rand_name('alarm_definition2') expression1 = "avg(mysql.performance.slow_queries) > 10.0" alarm_definition2 = helpers.create_alarm_definition( name=name2, expression=expression1) resp, response_body2 = cls.monasca_client.create_alarm_definitions( alarm_definition2) # create some metrics for i in xrange(180): metric = helpers.create_metric() resp, body = cls.monasca_client.create_metrics(metric) cls._start_timestamp = start_timestamp + i cls._end_timestamp = end_timestamp + i time.sleep(1) resp, response_body = cls.monasca_client.\ list_alarms_state_history() elements = response_body['elements'] if len(elements) > 4: break if len(elements) < 3: cls.assertEqual(1, False)
def resource_setup(cls): super(TestMeasurements, cls).resource_setup() start_timestamp = int(time.time() * 1000) end_timestamp = int(time.time() * 1000) + NUM_MEASUREMENTS * 1000 metrics = [] for i in xrange(NUM_MEASUREMENTS): metric = helpers.create_metric(name="name-1", timestamp=start_timestamp + i) metrics.append(metric) resp, response_body = cls.monasca_client.create_metrics(metrics) cls._start_timestamp = start_timestamp cls._end_timestamp = end_timestamp cls._metrics = metrics
def create_alarms_for_test_alarms(cls): # create an alarm definition expression = "avg(name-1) > 0" name = data_utils.rand_name('name-1') alarm_definition = helpers.create_alarm_definition( name=name, expression=expression) resp, response_body = cls.monasca_client.create_alarm_definitions( alarm_definition) # create some metrics for i in xrange(30): metric = helpers.create_metric() resp, response_body = cls.monasca_client.create_metrics(metric) time.sleep(1) resp, response_body = cls.monasca_client.list_alarms() elements = response_body['elements'] if len(elements) > 0: break
def test_list_metrics_with_dimensions(self): name = data_utils.rand_name('name') key = data_utils.rand_name('key') value_org = data_utils.rand_name('value') metric = helpers.create_metric(name=name, dimensions={key: value_org}) resp, body = self.monasca_client.create_metrics(metric) time.sleep(WAIT_TIME) query_parms = '?name=' + name resp, response_body = self.monasca_client.list_metrics(query_parms) self.assertEqual(200, resp.status) elements = response_body['elements'] dimensions = elements[0] dimension = dimensions['dimensions'] value = dimension[unicode(key)] self.assertEqual(value_org, str(value))