def test_get_cluster_capacity_monthly_resolution_group_by_cluster(self): """Test that cluster capacity returns capacity by cluster.""" # Add data for a second cluster OCPReportDataGenerator(self.tenant).add_data_to_tenant() query_params = { 'filter': { 'resolution': 'monthly', 'time_scope_value': -1, 'time_scope_units': 'month' }, 'group_by': { 'cluster': ['*'] }, } query_string = '?filter[resolution]=monthly&' + \ 'filter[time_scope_value]=-1&' + \ 'filter[time_scope_units]=month&' + \ 'group_by[cluster]=*' handler = OCPReportQueryHandler(query_params, query_string, self.tenant, **{'report_type': 'cpu'}) query_data = handler.execute_query() capacity_by_cluster = defaultdict(Decimal) 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.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: cluster_id = entry.get('cluster_id', '') capacity_by_cluster[cluster_id] += entry.get(cap_key, 0) total_capacity += entry.get(cap_key, 0) for entry in query_data.get('data', []): for cluster in entry.get('clusters', []): cluster_name = cluster.get('cluster', '') capacity = cluster.get('values')[0].get('capacity', {}).get('value') self.assertEqual(capacity, capacity_by_cluster[cluster_name]) self.assertEqual( query_data.get('total', {}).get('capacity', {}).get('value'), total_capacity)
def test_subtotals_add_up_to_total(self): """Test the apply_group_by handles different grouping scenerios.""" group_by_list = [ ("project", "cluster", "node"), ("project", "node", "cluster"), ("cluster", "project", "node"), ("cluster", "node", "project"), ("node", "cluster", "project"), ("node", "project", "cluster"), ] base_url = ( "?filter[time_scope_units]=month&filter[time_scope_value]=-1&filter[resolution]=monthly&filter[limit]=3" ) # noqa: E501 tolerance = 1 for group_by in group_by_list: sub_url = "&group_by[%s]=*&group_by[%s]=*&group_by[%s]=*" % group_by url = base_url + sub_url query_params = self.mocked_query_params(url, OCPCpuView) handler = OCPReportQueryHandler(query_params) query_data = handler.execute_query() the_sum = handler.query_sum data = query_data["data"][0] result_cost, result_infra, result_sup = _calculate_subtotals( data, [], [], []) test_dict = { "cost": { "expected": the_sum.get("cost", {}).get("total", {}).get("value"), "result": sum(result_cost), }, "infra": { "expected": the_sum.get("infrastructure", {}).get("total", {}).get("value"), "result": sum(result_infra), }, "sup": { "expected": the_sum.get("supplementary", {}).get("total", {}).get("value"), "result": sum(result_sup), }, } for _, data in test_dict.items(): expected = data["expected"] result = data["result"] self.assertIsNotNone(expected) self.assertIsNotNone(result) self.assertLessEqual(abs(expected - result), tolerance)
def test_filter_by_infrastructure_ocp(self): """Test that filter by infrastructure for ocp not on aws.""" url = "?filter[resolution]=monthly&filter[time_scope_value]=-1&filter[time_scope_units]=month&filter[cluster]=OCP-On-Azure&filter[infrastructures]=aws" # noqa: E501 query_params = self.mocked_query_params(url, OCPCpuView) handler = OCPReportQueryHandler(query_params) query_data = handler.execute_query() self.assertTrue(query_data.get("data")) # check that returned list is not empty for entry in query_data.get("data"): for value in entry.get("values"): self.assertEqual(value.get("usage").get("value"), 0) self.assertEqual(value.get("request").get("value"), 0)
def test_add_deltas_super_delta(self, mock_current_deltas, mock_deltas): """Test that the super delta method is called for deltas.""" # '?' query_params = FakeQueryParameters({}, report_type='cpu', tenant=self.tenant) handler = OCPReportQueryHandler(query_params.mock_qp) handler._delta = 'usage' handler.add_deltas([], []) mock_current_deltas.assert_not_called() mock_deltas.assert_called()
def test_get_cluster_capacity_monthly_resolution(self): """Test that cluster capacity returns a full month's capacity.""" url = "?filter[time_scope_units]=month&filter[time_scope_value]=-1&filter[resolution]=monthly" query_params = self.mocked_query_params(url, OCPCpuView) handler = OCPReportQueryHandler(query_params) 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.assertIsNotNone(query_data[0].get("capacity")) self.assertIsNotNone(total_capacity.get("capacity")) self.assertEqual(query_data[0].get("capacity"), total_capacity.get("capacity"))
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_get_tag_order_by(self): """Verify that a propery order by is returned.""" tag = "pod_labels__key" expected_param = (tag.split("__")[1], ) url = "?" query_params = self.mocked_query_params(url, OCPCpuView) handler = OCPReportQueryHandler(query_params) 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.""" url = "?" query_params = self.mocked_query_params(url, OCPCostView) handler = OCPReportQueryHandler(query_params) 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_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_get_tag_order_by(self): """Verify that a propery order by is returned.""" tag = 'pod_labels__key' expected_param = (tag.split('__')[1], ) query_params = {} handler = OCPReportQueryHandler(query_params, '', self.tenant, **{'report_type': 'cpu'}) 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_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_add_current_month_deltas(self): """Test that current month deltas are calculated.""" url = '?' query_params = self.mocked_query_params(url, OCPCpuView) handler = OCPReportQueryHandler(query_params) 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_group_by_project_w_limit(self): """COST-1252: Test that grouping by project with limit works as expected.""" url = "?group_by[project]=*&order_by[project]=asc&filter[limit]=2" # noqa: E501 query_params = self.mocked_query_params(url, OCPCostView) handler = OCPReportQueryHandler(query_params) aggregates = handler._mapper.report_type_map.get("aggregates") current_totals = self.get_totals_costs_by_time_scope(aggregates, self.ten_day_filter) expected_cost_total = current_totals.get("cost_total") self.assertIsNotNone(expected_cost_total) query_output = handler.execute_query() self.assertIsNotNone(query_output.get("data")) self.assertIsNotNone(query_output.get("total")) total = query_output.get("total") result_cost_total = total.get("cost", {}).get("total", {}).get("value") self.assertIsNotNone(result_cost_total) self.assertEqual(result_cost_total, expected_cost_total)
def test_execute_sum_query(self): """Test that the sum query runs properly.""" url = "?" query_params = self.mocked_query_params(url, OCPCpuView) handler = OCPReportQueryHandler(query_params) aggregates = handler._mapper.report_type_map.get("aggregates") current_totals = self.get_totals_by_time_scope(aggregates) 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("usage", {}).get("value"), current_totals.get("usage")) self.assertEqual(total.get("request", {}).get("value"), current_totals.get("request")) self.assertEqual(total.get("cost", {}).get("value"), current_totals.get("cost")) self.assertEqual(total.get("limit", {}).get("value"), current_totals.get("limit"))
def test_set_tag_filters(self): """Test that tag filters are created properly.""" filters = QueryFilterCollection() handler = OCPTagQueryHandler('', {}, self.tenant) 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' query_params = { 'filter': { filter_key: [filter_value] }, 'group_by': { group_by_key: [group_by_value] } } param_string = urlencode(query_params, quote_via=quote_plus) handler = OCPReportQueryHandler( query_params, param_string, self.tenant, **{ 'report_type': 'cpu', 'tag_keys': tag_keys }) 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_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_filter_by_infrastructure_ocp(self): """Test that filter by infrastructure for ocp not on aws.""" data_generator = OCPReportDataGenerator( self.tenant, self.provider, current_month_only=True ) data_generator.add_data_to_tenant() url = '?filter[resolution]=monthly&filter[time_scope_value]=-1&filter[time_scope_units]=month&filter[infrastructures]=aws' # noqa: E501 query_params = self.mocked_query_params(url, OCPCpuView) handler = OCPReportQueryHandler(query_params) query_data = handler.execute_query() for entry in query_data.get('data', []): for value in entry.get('values', []): self.assertEqual(value.get('usage').get('value'), 0) self.assertEqual(value.get('request').get('value'), 0) data_generator.remove_data_from_tenant()
def test_order_by_null_values(self): """Test that order_by returns properly sorted data with null data.""" url = "?filter[time_scope_units]=month&filter[time_scope_value]=-1&filter[resolution]=monthly" # noqa: E501 query_params = self.mocked_query_params(url, OCPCpuView) handler = OCPReportQueryHandler(query_params) 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_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_add_current_month_deltas_no_previous_data_w_query_data(self): """Test that current month deltas are calculated with no previous data for field two.""" OCPReportDataGenerator(self.tenant).remove_data_from_tenant() OCPReportDataGenerator(self.tenant, current_month_only=True).add_data_to_tenant() query_params = { 'filter': { 'resolution': 'monthly', 'time_scope_value': -1, 'limit': 1 }, } query_string = '?filter[resolution]=monthly&' + \ 'filter[time_scope_value]=-1&' + \ 'filter[limit]=1' handler = OCPReportQueryHandler(query_params, query_string, self.tenant, **{'report_type': 'cpu'}) handler._delta = 'usage__foo' 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.assertIsNotNone(handler.query_delta['value']) self.assertIsNone(handler.query_delta['percent'])
def test_order_by_null_values(self): """Test that order_by returns properly sorted data with null data.""" url = '?filter[time_scope_units]=month&filter[time_scope_value]=-1&filter[resolution]=monthly' # noqa: E501 query_params = self.mocked_query_params(url, OCPCpuView) handler = OCPReportQueryHandler(query_params) 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_ocp_cpu_query_group_by_cluster(self): """Test that group by cluster includes cluster and cluster_alias.""" url = "?filter[time_scope_units]=month&filter[time_scope_value]=-1&filter[resolution]=monthly&filter[limit]=3&group_by[cluster]=*" # noqa: E501 query_params = self.mocked_query_params(url, OCPCpuView) handler = OCPReportQueryHandler(query_params) 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"): # cluster_value is a dictionary self.assertIn("cluster", cluster_value.keys()) self.assertIn("clusters", cluster_value.keys()) self.assertIsNotNone(cluster_value["cluster"]) self.assertIsNotNone(cluster_value["clusters"])
def test_other_clusters(self): """Test that group by cluster includes cluster and cluster_alias.""" url = "?filter[time_scope_units]=month&filter[time_scope_value]=-1&filter[resolution]=monthly&filter[limit]=1&group_by[cluster]=*" # noqa: E501 query_params = self.mocked_query_params(url, OCPCpuView) handler = OCPReportQueryHandler(query_params) query_data = handler.execute_query() for data in query_data.get("data"): for cluster_data in data.get("clusters"): cluster_name = cluster_data.get("cluster", "") if cluster_name == "Other": for cluster_value in cluster_data.get("values"): self.assertTrue(len(cluster_value.get("clusters", [])) == 1) self.assertTrue(len(cluster_value.get("source_uuid", [])) == 1) elif cluster_name == "Others": for cluster_value in cluster_data.get("values"): self.assertTrue(len(cluster_value.get("clusters", [])) > 1) self.assertTrue(len(cluster_value.get("source_uuid", [])) > 1)
def test_get_cluster_capacity_daily_resolution_group_by_clusters(self): """Test that cluster capacity returns daily capacity by cluster.""" url = ( "?filter[time_scope_units]=month&filter[time_scope_value]=-1&filter[resolution]=daily&group_by[cluster]=*" ) query_params = self.mocked_query_params(url, OCPCpuView) handler = OCPReportQueryHandler(query_params) 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_filter_by_infrastructure_ocp(self): """Test that filter by infrastructure for ocp not on aws.""" data_generator = OCPReportDataGenerator(self.tenant, self.provider, current_month_only=True) data_generator.add_data_to_tenant() url = "?filter[resolution]=monthly&filter[time_scope_value]=-1&filter[time_scope_units]=month&filter[infrastructures]=aws" # noqa: E501 query_params = self.mocked_query_params(url, OCPCpuView) handler = OCPReportQueryHandler(query_params) query_data = handler.execute_query() self.assertTrue( query_data.get("data")) # check that returned list is not empty for entry in query_data.get("data"): for value in entry.get("values"): self.assertEqual(value.get("usage").get("value"), 0) self.assertEqual(value.get("request").get("value"), 0) data_generator.remove_data_from_tenant()
def test_filter_by_infrastructure_ocp_on_azure(self): """Test that filter by infrastructure for ocp on azure.""" data_generator = OCPAzureReportDataGenerator( self.tenant, self.provider, current_month_only=True ) data_generator.add_data_to_tenant() data_generator.add_ocp_data_to_tenant() url = '?filter[resolution]=monthly&filter[time_scope_value]=-1&filter[time_scope_units]=month&filter[infrastructures]=azure' # noqa: E501 query_params = self.mocked_query_params(url, OCPCpuView) handler = OCPReportQueryHandler(query_params) query_data = handler.execute_query() self.assertTrue(query_data.get('data')) # check that returned list is not empty for entry in query_data.get('data'): self.assertTrue(entry.get('values')) for value in entry.get('values'): self.assertIsNotNone(value.get('usage').get('value')) self.assertIsNotNone(value.get('request').get('value')) data_generator.remove_data_from_tenant()
def test_strip_label_column_name(self): """Test that the tag column name is stripped from results.""" url = '?' query_params = self.mocked_query_params(url, OCPCpuView) handler = OCPReportQueryHandler(query_params) 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_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_get_cluster_capacity_monthly_resolution_start_end_date(self): """Test that cluster capacity returns capacity by month.""" start_date = self.dh.last_month_end.date() end_date = self.dh.today.date() url = f"?start_date={start_date}&end_date={end_date}&filter[resolution]=monthly" query_params = self.mocked_query_params(url, OCPCpuView) handler = OCPReportQueryHandler(query_params) query_data = handler.execute_query() with tenant_context(self.tenant): total_capacity = (OCPUsageLineItemDailySummary.objects.filter( usage_start__gte=start_date, usage_start__lte=end_date, data_source="Pod").values( "usage_start", "cluster_id").annotate(capacity=Max( "cluster_capacity_cpu_core_hours")).aggregate( total=Sum("capacity"))) self.assertAlmostEqual( query_data.get("total", {}).get("capacity", {}).get("value"), total_capacity.get("total"), 6)
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, self.provider).add_data_to_tenant() url = '?filter[time_scope_units]=month&filter[time_scope_value]=-1&filter[resolution]=monthly&filter[limit]=3&group_by[cluster]=*' # noqa: E501 query_params = self.mocked_query_params(url, OCPCpuView) handler = OCPReportQueryHandler(query_params) 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)