def test_set_tag_filters(self): """Test that tag filters are created properly.""" filters = QueryFilterCollection() # '?' query_params = FakeQueryParameters({}, tenant=self.tenant) handler = OCPTagQueryHandler(query_params.mock_qp) tag_keys = handler.get_tag_keys(filters=False) filter_key = tag_keys[0] filter_value = 'filter' group_by_key = tag_keys[1] group_by_value = 'group_By' # '?filter[tag:some_key]=some_value&group_by[tag:some_key]=some_value' params = { 'filter': { filter_key: [filter_value] }, 'group_by': { group_by_key: [group_by_value] } } query_params = FakeQueryParameters(params, report_type='cpu', tag_keys=tag_keys, tenant=self.tenant) handler = OCPReportQueryHandler(query_params.mock_qp) filters = handler._set_tag_filters(filters) expected = f"""<class 'api.query_filter.QueryFilterCollection'>: (AND: ('pod_labels__{filter_key}__icontains', '{filter_value}')), (AND: ('pod_labels__{group_by_key}__icontains', '{group_by_value}')), """ # noqa: E501 self.assertEqual(repr(filters), expected)
def test_get_tag_group_by_keys(self): """Test that group_by params with tag keys are returned.""" # '?' query_params = FakeQueryParameters({}, tenant=self.tenant) handler = OCPTagQueryHandler(query_params.mock_qp) tag_keys = handler.get_tag_keys(filters=False) params = {'group_by': {tag_keys[0]: ['*']}} query_params = FakeQueryParameters(params, report_type='cpu', tag_keys=tag_keys, tenant=self.tenant) handler = OCPReportQueryHandler(query_params.mock_qp) results = handler.get_tag_group_by_keys() self.assertEqual(results, [tag_keys[0]])
def test_strip_label_column_name(self): """Test that the tag column name is stripped from results.""" # '?' query_params = FakeQueryParameters({}, report_type='cpu', tenant=self.tenant) handler = OCPReportQueryHandler(query_params.mock_qp) tag_column = handler._mapper.provider_map.get('tag_column') data = [{ f'{tag_column}__tag_key1': 'value' }, { f'{tag_column}__tag_key2': 'value' }] group_by = [ 'date', f'{tag_column}__tag_key1', f'{tag_column}__tag_key2' ] expected_data = [{'tag_key1': 'value'}, {'tag_key2': 'value'}] expected_group_by = ['date', 'tag_key1', 'tag_key2'] result_data, result_group_by = handler.strip_label_column_name( data, group_by) self.assertEqual(result_data, expected_data) self.assertEqual(result_group_by, expected_group_by)
def test_get_tag_keys_filter_false(self): """Test that all tag keys are returned with no filter.""" # '?filter[time_scope_units]=month&filter[time_scope_value]=-2&filter[resolution]=monthly' params = { 'filter': { 'resolution': 'monthly', 'time_scope_value': -2, 'time_scope_units': 'month' } } query_params = FakeQueryParameters(params, tenant=self.tenant) handler = AzureTagQueryHandler(query_params.mock_qp) tag_keys = set() with tenant_context(self.tenant): tags = AzureCostEntryLineItemDailySummary.objects\ .annotate(tag_keys=JSONBObjectKeys('tags'))\ .values('tags')\ .distinct()\ .all() for tag in tags: for key in tag.get('tags').keys(): tag_keys.add(key) result = handler.get_tag_keys(filters=False) self.assertEqual(sorted(result), sorted(list(tag_keys)))
def test_ocp_cpu_query_group_by_cluster(self): """Test that group by cluster includes cluster and cluster_alias.""" for _ in range(1, 5): OCPReportDataGenerator(self.tenant).add_data_to_tenant() # '?filter[time_scope_units]=month&filter[time_scope_value]=-1&filter[resolution]=monthly&group_by[cluster]=*' params = { 'filter': { 'resolution': 'monthly', 'time_scope_value': -1, 'time_scope_units': 'month', 'limit': 3 }, 'group_by': { 'cluster': ['*'] } } query_params = FakeQueryParameters(params, report_type='cpu', tenant=self.tenant) handler = OCPReportQueryHandler(query_params.mock_qp) query_data = handler.execute_query() for data in query_data.get('data'): self.assertIn('clusters', data) for cluster_data in data.get('clusters'): self.assertIn('cluster', cluster_data) self.assertIn('values', cluster_data) for cluster_value in cluster_data.get('values'): self.assertIn('cluster', cluster_value) self.assertIn('cluster_alias', cluster_value) self.assertIsNotNone('cluster', cluster_value) self.assertIsNotNone('cluster_alias', cluster_value)
def test_get_tag_type_filter_storage(self): """Test that all storage tags are returned with storage type filter.""" # '?filter[time_scope_units]=month&filter[time_scope_value]=-2&filter[resolution]=monthly&filter[type]=storage' params = { 'filter': { 'resolution': 'monthly', 'time_scope_value': -2, 'time_scope_units': 'month', 'type': 'storage' } } query_params = FakeQueryParameters(params, tenant=self.tenant) handler = OCPTagQueryHandler(query_params.mock_qp) with tenant_context(self.tenant): storage_tag_keys = OCPUsageLineItemDailySummary.objects\ .annotate(tag_keys=JSONBObjectKeys('volume_labels'))\ .values('tag_keys')\ .distinct()\ .all() storage_tag_keys = [ tag.get('tag_keys') for tag in storage_tag_keys ] tag_keys = storage_tag_keys result = handler.get_tag_keys(filters=False) self.assertEqual(sorted(result), sorted(tag_keys))
def test_execute_query_no_query_parameters(self): """Test that the execute query runs properly with no query.""" # '?' handler = OCPTagQueryHandler( FakeQueryParameters({}, tenant=self.tenant).mock_qp) query_output = handler.execute_query() self.assertIsNotNone(query_output.get('data')) self.assertEqual(handler.time_scope_units, 'day') self.assertEqual(handler.time_scope_value, -10)
def test_get_exclusions(self): """Test that exclusions are properly set.""" # '?' query_params = FakeQueryParameters({}, tenant=self.tenant) handler = OCPTagQueryHandler(query_params.mock_qp) tag_keys = handler.get_tag_keys(filters=False) group_by_key = tag_keys[0] group_by_value = 'group_By' # '?group_by[tag:some_key]=some_value' params = {'group_by': {group_by_key: [group_by_value]}} query_params = FakeQueryParameters(params, report_type='cpu', tag_keys=tag_keys, tenant=self.tenant) handler = OCPReportQueryHandler(query_params.mock_qp) exclusions = handler._get_exclusions() expected = f"<Q: (AND: ('pod_labels__{group_by_key}__isnull', True))>" self.assertEqual(repr(exclusions), expected)
def test_add_deltas_current_month(self, mock_current_deltas, mock_deltas): """Test that the current month method is called for deltas.""" # '?' query_params = FakeQueryParameters({}, report_type='cpu', tenant=self.tenant) handler = OCPReportQueryHandler(query_params.mock_qp) handler._delta = 'usage__request' handler.add_deltas([], []) mock_current_deltas.assert_called() mock_deltas.assert_not_called()
def test_get_cluster_capacity_daily_resolution_group_by_clusters(self): """Test that cluster capacity returns daily capacity by cluster.""" # '?filter[time_scope_units]=month&filter[time_scope_value]=-1&filter[resolution]=daily&group_by[cluster]=*' params = { 'filter': { 'resolution': 'daily', 'time_scope_value': -1, 'time_scope_units': 'month' }, 'group_by': { 'cluster': ['*'] } } query_params = FakeQueryParameters(params, report_type='cpu', tenant=self.tenant) handler = OCPReportQueryHandler(query_params.mock_qp) query_data = handler.execute_query() daily_capacity_by_cluster = defaultdict(dict) total_capacity = Decimal(0) query_filter = handler.query_filter query_group_by = ['usage_start', 'cluster_id'] annotations = {'capacity': Max('cluster_capacity_cpu_core_hours')} cap_key = list(annotations.keys())[0] q_table = handler._mapper.query_table query = q_table.objects.filter(query_filter) with tenant_context(self.tenant): cap_data = query.values(*query_group_by).annotate(**annotations) for entry in cap_data: date = handler.date_to_string(entry.get('usage_start')) cluster_id = entry.get('cluster_id', '') if cluster_id in daily_capacity_by_cluster[date]: daily_capacity_by_cluster[date][cluster_id] += entry.get( cap_key, 0) else: daily_capacity_by_cluster[date][cluster_id] = entry.get( cap_key, 0) total_capacity += entry.get(cap_key, 0) for entry in query_data.get('data', []): date = entry.get('date') for cluster in entry.get('clusters', []): cluster_name = cluster.get('cluster', '') capacity = cluster.get('values')[0].get('capacity', {}).get('value') self.assertEqual(capacity, daily_capacity_by_cluster[date][cluster_name]) self.assertEqual( query_data.get('total', {}).get('capacity', {}).get('value'), total_capacity)
def test_get_tag_group_by(self): """Test that tag based group bys work.""" # '?' query_params = FakeQueryParameters({}, tenant=self.tenant) handler = OCPTagQueryHandler(query_params.mock_qp) tag_keys = handler.get_tag_keys(filters=False) group_by_key = tag_keys[0] group_by_value = 'group_by' # '?group_by[tag:some_key]=some_value' params = {'group_by': {group_by_key: [group_by_value]}} query_params = FakeQueryParameters(params, report_type='cpu', tag_keys=tag_keys, tenant=self.tenant) handler = OCPReportQueryHandler(query_params.mock_qp) group_by = handler._get_tag_group_by() group = group_by[0] expected = 'pod_labels__' + group_by_key self.assertEqual(len(group_by), 1) self.assertEqual(group[0], expected)
def test_get_tag_filter_keys(self): """Test that filter params with tag keys are returned.""" # '?' query_params = FakeQueryParameters({}, tenant=self.tenant) handler = OCPTagQueryHandler(query_params.mock_qp) tag_keys = handler.get_tag_keys(filters=False) # '?filter[time_scope_value]=-1&filter[resolution]=monthly&filter[time_scope_units]=month&filter[tag:some_tag]=*' params = { 'filter': { 'resolution': 'monthly', 'time_scope_value': -1, 'time_scope_units': 'month', tag_keys[0]: ['*'] } } query_params = FakeQueryParameters(params, report_type='cpu', tag_keys=tag_keys, tenant=self.tenant) handler = OCPReportQueryHandler(query_params.mock_qp) results = handler.get_tag_filter_keys() self.assertEqual(results, [tag_keys[0]])
def test_get_tag_order_by(self): """Verify that a propery order by is returned.""" tag = 'pod_labels__key' expected_param = (tag.split('__')[1], ) # '?' query_params = FakeQueryParameters({}, tenant=self.tenant) handler = OCPReportQueryHandler(query_params.mock_qp) result = handler.get_tag_order_by(tag) expression = result.expression self.assertIsInstance(result, OrderBy) self.assertEqual(expression.sql, 'pod_labels -> %s') self.assertEqual(expression.params, expected_param)
def test_execute_sum_query_costs(self): """Test that the sum query runs properly for the costs endpoint.""" # '?' query_params = FakeQueryParameters({}, tenant=self.tenant) handler = OCPReportQueryHandler(query_params.mock_qp) aggregates = handler._mapper.report_type_map.get('aggregates') current_totals = self.get_totals_costs_by_time_scope( aggregates, self.ten_day_filter) query_output = handler.execute_query() self.assertIsNotNone(query_output.get('data')) self.assertIsNotNone(query_output.get('total')) total = query_output.get('total') self.assertEqual( total.get('cost', {}).get('value'), current_totals.get('cost'))
def test_execute_query_month_parameters(self): """Test that the execute query runs properly with single month query.""" params = { 'filter': { 'resolution': 'monthly', 'time_scope_value': -1, 'time_scope_units': 'month' } } query_params = FakeQueryParameters(params, tenant=self.tenant) handler = AzureTagQueryHandler(query_params.mock_qp) query_output = handler.execute_query() self.assertIsNotNone(query_output.get('data')) self.assertEqual(handler.time_scope_units, 'month') self.assertEqual(handler.time_scope_value, -1)
def test_get_cluster_capacity_daily_resolution(self): """Test that total capacity is returned daily resolution.""" # '?filter[time_scope_units]=month&filter[time_scope_value]=-1&filter[resolution]=daily' params = { 'filter': { 'resolution': 'daily', 'time_scope_value': -1, 'time_scope_units': 'month' } } query_params = FakeQueryParameters(params, report_type='cpu', tenant=self.tenant) handler = OCPReportQueryHandler(query_params.mock_qp) query_data = handler.execute_query() daily_capacity = defaultdict(Decimal) total_capacity = Decimal(0) query_filter = handler.query_filter query_group_by = ['usage_start'] annotations = {'capacity': Max('total_capacity_cpu_core_hours')} cap_key = list(annotations.keys())[0] q_table = handler._mapper.provider_map.get('tables').get('query') query = q_table.objects.filter(query_filter) with tenant_context(self.tenant): cap_data = query.values(*query_group_by).annotate(**annotations) for entry in cap_data: date = handler.date_to_string(entry.get('usage_start')) daily_capacity[date] += entry.get(cap_key, 0) # This is a hack because the total capacity in the test data # is artificial but the total should still be a sum of # cluster capacities annotations = {'capacity': Max('cluster_capacity_cpu_core_hours')} cap_data = query.values(*query_group_by).annotate(**annotations) for entry in cap_data: total_capacity += entry.get(cap_key, 0) self.assertEqual( query_data.get('total', {}).get('capacity', {}).get('value'), total_capacity) for entry in query_data.get('data', []): date = entry.get('date') values = entry.get('values') if values: capacity = values[0].get('capacity', {}).get('value') self.assertEqual(capacity, daily_capacity[date])
def test_execute_query_30_day_parameters(self): """Test that the execute query runs properly with 30 day query.""" # '?filter[time_scope_units]=day&filter[time_scope_value]=-30&filter[resolution]=daily' params = { 'filter': { 'resolution': 'daily', 'time_scope_value': -30, 'time_scope_units': 'day' } } query_params = FakeQueryParameters(params, tenant=self.tenant) handler = OCPTagQueryHandler(query_params.mock_qp) query_output = handler.execute_query() self.assertIsNotNone(query_output.get('data')) self.assertEqual(handler.time_scope_units, 'day') self.assertEqual(handler.time_scope_value, -30)
def test_execute_sum_query_storage(self): """Test that the sum query runs properly.""" # '?' query_params = FakeQueryParameters({}, report_type='storage', tenant=self.tenant) handler = OCPAWSReportQueryHandler(query_params.mock_qp) filt = {'product_family__contains': 'Storage'} filt.update(self.ten_day_filter) aggregates = handler._mapper.report_type_map.get('aggregates') current_totals = self.get_totals_by_time_scope(aggregates, filt) query_output = handler.execute_query() self.assertIsNotNone(query_output.get('data')) self.assertIsNotNone(query_output.get('total')) total = query_output.get('total') self.assertEqual(total.get('total'), current_totals.get('total'))
def test_execute_query_two_month_parameters(self): """Test that the execute query runs properly with two month query.""" # '?filter[time_scope_units]=month&filter[time_scope_value]=-2&filter[resolution]=monthly' params = { 'filter': { 'resolution': 'monthly', 'time_scope_value': -2, 'time_scope_units': 'month' } } query_params = FakeQueryParameters(params, tenant=self.tenant) handler = OCPTagQueryHandler(query_params.mock_qp) query_output = handler.execute_query() self.assertIsNotNone(query_output.get('data')) self.assertEqual(handler.time_scope_units, 'month') self.assertEqual(handler.time_scope_value, -2)
def test_10_day(self): """Test that the execute_query() succeeds with 10 day parameters.""" # '?filter[time_scope_units]=day&filter[time_scope_value]=-10&filter[resolution]=daily' params = { 'filter': { 'resolution': 'daily', 'time_scope_value': -10, 'time_scope_units': 'day' } } query_params = FakeQueryParameters(params, tenant=self.tenant) handler = OCPAWSTagQueryHandler(query_params.mock_qp) query_output = handler.execute_query() self.assertIsNotNone(query_output.get('data')) self.assertEqual(handler.time_scope_units, 'day') self.assertEqual(handler.time_scope_value, -10)
def test_last_month(self): """Test that execute_query() succeeds with last-month parameters.""" # '?filter[time_scope_units]=month&filter[time_scope_value]=-2&filter[resolution]=monthly' params = { 'filter': { 'resolution': 'monthly', 'time_scope_value': -2, 'time_scope_units': 'month' } } query_params = FakeQueryParameters(params, tenant=self.tenant) handler = OCPAWSTagQueryHandler(query_params.mock_qp) query_output = handler.execute_query() self.assertIsNotNone(query_output.get('data')) self.assertEqual(handler.time_scope_units, 'month') self.assertEqual(handler.time_scope_value, -2)
def test_execute_query_10_day_parameters_only_keys(self): """Test that the execute query runs properly with 10 day query.""" # '?filter[time_scope_units]=day&filter[time_scope_value]=-10&filter[resolution]=daily&key_only=True' params = { 'filter': { 'resolution': 'daily', 'time_scope_value': -10, 'time_scope_units': 'day' }, 'key_only': True } query_params = FakeQueryParameters(params, tenant=self.tenant) handler = AzureTagQueryHandler(query_params.mock_qp) query_output = handler.execute_query() self.assertIsNotNone(query_output.get('data')) self.assertEqual(handler.time_scope_units, 'day') self.assertEqual(handler.time_scope_value, -10)
def test_specific_account(self): """Test that execute_query() succeeds with account parameter.""" # '?filter[time_scope_units]=day&filter[time_scope_value]=-10&filter[resolution]=daily&filter[account]=some_account' params = { 'filter': { 'resolution': 'daily', 'time_scope_value': -10, 'time_scope_units': 'day', 'account': str(self.fake.ean8()) } } query_params = FakeQueryParameters(params, tenant=self.tenant) handler = OCPAWSTagQueryHandler(query_params.mock_qp) query_output = handler.execute_query() self.assertIsNotNone(query_output.get('data')) self.assertEqual(handler.time_scope_units, 'day') self.assertEqual(handler.time_scope_value, -10)
def test_add_current_month_deltas_no_previous_data_wo_query_data(self): """Test that current month deltas are calculated with no previous month data.""" OCPReportDataGenerator(self.tenant).remove_data_from_tenant() OCPReportDataGenerator(self.tenant, current_month_only=True).add_data_to_tenant() # '?filter[time_scope_value]=-2&filter[resolution]=monthly&filter[time_scope_units]=month&filter[limit]=1&delta=usage__request' params = { 'filter': { 'resolution': 'monthly', 'time_scope_value': -2, 'time_scope_units': 'month', 'limit': 1 }, 'delta': 'usage__request' } query_params = FakeQueryParameters(params, report_type='cpu', tenant=self.tenant) handler = OCPReportQueryHandler(query_params.mock_qp) q_table = handler._mapper.provider_map.get('tables').get('query') with tenant_context(self.tenant): query = q_table.objects.filter(handler.query_filter) query_data = query.annotate(**handler.annotations) group_by_value = handler._get_group_by() query_group_by = ['date'] + group_by_value query_order_by = ('-date', ) query_order_by += (handler.order, ) annotations = annotations = handler.report_annotations query_data = query_data.values(*query_group_by).annotate( **annotations) aggregates = handler._mapper.report_type_map.get('aggregates') metric_sum = query.aggregate(**aggregates) query_sum = { key: metric_sum.get(key) if metric_sum.get(key) else Decimal(0) for key in aggregates } result = handler.add_current_month_deltas(query_data, query_sum) self.assertEqual(result, query_data) self.assertEqual(handler.query_delta['value'], Decimal(0)) self.assertIsNone(handler.query_delta['percent'])
def test_order_by_null_values(self): """Test that order_by returns properly sorted data with null data.""" # '?filter[time_scope_units]=month&filter[time_scope_value]=-1&filter[resolution]=monthly' params = { 'filter': { 'resolution': 'monthly', 'time_scope_value': -1, 'time_scope_units': 'month' } } query_params = FakeQueryParameters(params) handler = OCPReportQueryHandler(query_params.mock_qp) unordered_data = [{ 'node': None, 'cluster': 'cluster-1' }, { 'node': 'alpha', 'cluster': 'cluster-2' }, { 'node': 'bravo', 'cluster': 'cluster-3' }, { 'node': 'oscar', 'cluster': 'cluster-4' }] order_fields = ['node'] expected = [{ 'node': 'alpha', 'cluster': 'cluster-2' }, { 'node': 'bravo', 'cluster': 'cluster-3' }, { 'node': 'no-node', 'cluster': 'cluster-1' }, { 'node': 'oscar', 'cluster': 'cluster-4' }] ordered_data = handler.order_by(unordered_data, order_fields) self.assertEqual(ordered_data, expected)
def test_add_current_month_deltas(self): """Test that current month deltas are calculated.""" # '?' query_params = FakeQueryParameters({}, report_type='cpu', tenant=self.tenant) handler = OCPReportQueryHandler(query_params.mock_qp) handler._delta = 'usage__request' q_table = handler._mapper.provider_map.get('tables').get('query') with tenant_context(self.tenant): query = q_table.objects.filter(handler.query_filter) query_data = query.annotate(**handler.annotations) group_by_value = handler._get_group_by() query_group_by = ['date'] + group_by_value query_order_by = ('-date', ) query_order_by += (handler.order, ) annotations = handler.report_annotations query_data = query_data.values(*query_group_by).annotate( **annotations) aggregates = handler._mapper.report_type_map.get('aggregates') metric_sum = query.aggregate(**aggregates) query_sum = {key: metric_sum.get(key) for key in aggregates} result = handler.add_current_month_deltas(query_data, query_sum) delta_field_one, delta_field_two = handler._delta.split('__') field_one_total = Decimal(0) field_two_total = Decimal(0) for entry in result: field_one_total += entry.get(delta_field_one, 0) field_two_total += entry.get(delta_field_two, 0) delta_percent = entry.get('delta_percent') expected = (entry.get(delta_field_one, 0) / entry.get(delta_field_two, 0) * 100) \ if entry.get(delta_field_two) else 0 self.assertEqual(delta_percent, expected) expected_total = field_one_total / field_two_total * 100 if field_two_total != 0 else 0 self.assertEqual(handler.query_delta.get('percent'), expected_total)
def test_get_cluster_capacity_monthly_resolution(self): """Test that cluster capacity returns a full month's capacity.""" # '?filter[time_scope_units]=month&filter[time_scope_value]=-1&filter[resolution]=monthly' params = { 'filter': { 'resolution': 'monthly', 'time_scope_value': -1, 'time_scope_units': 'month' } } query_params = FakeQueryParameters(params, report_type='cpu', tenant=self.tenant) handler = OCPReportQueryHandler(query_params.mock_qp) query_data = [{'row': 1}] query_data, total_capacity = handler.get_cluster_capacity(query_data) self.assertTrue('capacity' in total_capacity) self.assertTrue(isinstance(total_capacity['capacity'], Decimal)) self.assertTrue('capacity' in query_data[0]) self.assertEqual(query_data[0].get('capacity'), total_capacity.get('capacity'))
def test_query_by_partial_filtered_service(self): """Test execute_query monthly breakdown by filtered service.""" # '?filter[time_scope_units]=month&filter[time_scope_value]=-1&filter[resolution]=monthly&group_by[service]=eC2' params = { 'filter': { 'resolution': 'monthly', 'time_scope_value': -1, 'time_scope_units': 'month' }, 'group_by': { 'service': ['eC2'] } } query_params = FakeQueryParameters(params, tenant=self.tenant) handler = OCPAWSReportQueryHandler(query_params.mock_qp) query_output = handler.execute_query() data = query_output.get('data') self.assertIsNotNone(data) self.assertIsNotNone(query_output.get('total')) total = query_output.get('total') self.assertIsNotNone(total.get('cost')) aggregates = handler._mapper.report_type_map.get('aggregates') current_totals = self.get_totals_by_time_scope(aggregates, self.this_month_filter) self.assertEqual( total.get('cost', {}).get('value'), current_totals.get('cost')) cmonth_str = DateHelper().this_month_start.strftime('%Y-%m') for data_item in data: month_val = data_item.get('date') month_data = data_item.get('services') self.assertEqual(month_val, cmonth_str) self.assertIsInstance(month_data, list) for month_item in month_data: compute = month_item.get('service') self.assertEqual(compute, 'AmazonEC2') self.assertIsInstance(month_item.get('values'), list)
def test_get_tag_keys(self): """Test that all OCP-on-AWS tag keys are returned.""" # '?filter[time_scope_units]=month&filter[time_scope_value]=-2&filter[resolution]=monthly' params = { 'filter': { 'resolution': 'monthly', 'time_scope_value': -2, 'time_scope_units': 'month' } } query_params = FakeQueryParameters(params, tenant=self.tenant) handler = OCPAWSTagQueryHandler(query_params.mock_qp) with tenant_context(self.tenant): tag_keys = OCPAWSCostLineItemDailySummary.objects\ .annotate(tag_keys=JSONBObjectKeys('tags'))\ .values('tag_keys')\ .distinct()\ .all() tag_keys = [tag.get('tag_keys') for tag in tag_keys] result = handler.get_tag_keys() self.assertEqual(sorted(result), sorted(tag_keys))
def test_execute_sum_query_instance_types(self): """Test that the sum query runs properly for instance-types.""" # '?' query_params = FakeQueryParameters({}, report_type='instance_type', tenant=self.tenant) handler = OCPAWSReportQueryHandler(query_params.mock_qp) query_output = handler.execute_query() self.assertIsNotNone(query_output.get('data')) self.assertIsNotNone(query_output.get('total')) total = query_output.get('total') self.assertIsNotNone(total.get('cost')) self.assertIsInstance(total.get('cost'), dict) self.assertEqual(total.get('cost').get('value'), 0) self.assertEqual(total.get('cost').get('units'), 'USD') self.assertIsNotNone(total.get('usage')) self.assertIsInstance(total.get('usage'), dict) self.assertEqual(total.get('usage').get('value'), 0) self.assertEqual(total.get('usage').get('units'), 'Hrs') self.assertIsNotNone(total.get('count')) self.assertIsInstance(total.get('count'), dict) self.assertEqual(total.get('count').get('value'), 0) self.assertEqual(total.get('count').get('units'), 'instances')