def test_get_cluster_capacity_monthly_resolution_group_by_cluster(self): """Test that cluster capacity returns capacity by cluster.""" url = "?filter[time_scope_units]=month&filter[time_scope_value]=-1&filter[resolution]=monthly&group_by[cluster]=*" # noqa: E501 query_params = self.mocked_query_params(url, OCPCpuView) handler = OCPReportQueryHandler(query_params) 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_source_uuid_mapping(self): # noqa: C901 """Test source_uuid is mapped to the correct source.""" endpoints = [OCPCostView, OCPCpuView, OCPVolumeView, OCPMemoryView] with tenant_context(self.tenant): expected_source_uuids = list( OCPUsageReportPeriod.objects.all().values_list("provider_id", flat=True)) source_uuid_list = [] for endpoint in endpoints: urls = ["?", "?group_by[project]=*"] if endpoint == OCPCostView: urls.append("?group_by[node]=*") for url in urls: query_params = self.mocked_query_params(url, endpoint) handler = OCPReportQueryHandler(query_params) query_output = handler.execute_query() for dictionary in query_output.get("data"): for _, value in dictionary.items(): if isinstance(value, list): for item in value: if isinstance(item, dict): if "values" in item.keys(): self.assertEqual( len(item["values"]), 1) value = item["values"][0] source_uuid_list.extend( value.get("source_uuid")) self.assertNotEquals(source_uuid_list, []) for source_uuid in source_uuid_list: self.assertIn(source_uuid, expected_source_uuids)
def test_get_cluster_capacity_daily_resolution(self): """Test that total capacity is returned daily resolution.""" url = "?filter[time_scope_units]=month&filter[time_scope_value]=-1&filter[resolution]=daily" query_params = self.mocked_query_params(url, OCPCpuView) handler = OCPReportQueryHandler(query_params) query_data = handler.execute_query() daily_capacity = 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: date = handler.date_to_string(entry.get("usage_start")) daily_capacity[date] += entry.get(cap_key, 0) 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_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_filter_by_infrastructure_ocp(self): """Test that filter by infrastructure for ocp not on aws.""" data_generator = OCPReportDataGenerator(self.tenant, current_month_only=True) data_generator.add_data_to_tenant() query_params = { 'filter': { 'resolution': 'monthly', 'time_scope_value': -1, 'time_scope_units': 'month', 'infrastructures': ['AWS'] }, } query_string = '?filter[resolution]=monthly&' + \ 'filter[time_scope_value]=-1&' + \ 'filter[time_scope_units]=month&' + \ 'filter[infrastructures]=aws' handler = OCPReportQueryHandler(query_params, query_string, self.tenant, **{'report_type': 'cpu'}) 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_get_cluster_capacity_daily_resolution_group_by_clusters(self): """Test that cluster capacity returns daily capacity by cluster.""" query_params = { 'filter': { 'resolution': 'daily', 'time_scope_value': -1, 'time_scope_units': 'month' }, 'group_by': { 'cluster': ['*'] }, } query_string = '?filter[resolution]=daily&' + \ '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() 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_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_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_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_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_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_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_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_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_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_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_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)
def test_get_cluster_capacity_monthly_resolution_start_end_date_group_by_cluster( self): """Test that cluster capacity returns capacity by cluster.""" url = ( f"?start_date={self.dh.last_month_end.date()}&end_date={self.dh.today.date()}" f"&filter[resolution]=monthly&group_by[cluster]=*") query_params = self.mocked_query_params(url, OCPCpuView) handler = OCPReportQueryHandler(query_params) query_data = handler.execute_query() capacity_by_month_cluster = defaultdict(lambda: 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", "") month = entry.get("usage_start", "").month capacity_by_month_cluster[month][cluster_id] += entry.get( cap_key, 0) total_capacity += entry.get(cap_key, 0) for entry in query_data.get("data", []): month = int(entry.get("date").split("-")[1]) 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_month_cluster[month][cluster_name]) self.assertEqual( query_data.get("total", {}).get("capacity", {}).get("value"), total_capacity)
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_execute_sum_query(self): """Test that the sum query runs properly.""" query_params = {} handler = OCPReportQueryHandler(query_params, '', self.tenant, **{'report_type': 'cpu'}) 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_filter_by_infrastructure_ocp_on_aws(self): """Test that filter by infrastructure for ocp on aws.""" data_generator = OCPAWSReportDataGenerator(self.tenant, current_month_only=True) data_generator.add_data_to_tenant() # '?filter[resolution]=monthly&filter[time_scope_value]=-1&filter[time_scope_units]=month&filter[infrastructures]=aws' params = { 'filter': { 'resolution': 'monthly', 'time_scope_value': -1, 'time_scope_units': 'month', 'infrastructures': ['aws'] } } query_params = FakeQueryParameters(params, tenant=self.tenant) handler = OCPReportQueryHandler(query_params.mock_qp) query_data = handler.execute_query() for entry in query_data.get('data', []): 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_ocp_date_order_by_cost_desc(self): """Test that order of every other date matches the order of the `order_by` date.""" tested = False yesterday = self.dh.yesterday.date() url = f"?order_by[cost]=desc&order_by[date]={yesterday}&group_by[project]=*" query_params = self.mocked_query_params(url, OCPCostView) handler = OCPReportQueryHandler(query_params) query_output = handler.execute_query() data = query_output.get("data") proj_annotations = handler.annotations.get("project") cost_annotations = handler.report_annotations.get("cost_total") with tenant_context(self.tenant): expected = list( OCPCostSummaryByProjectP.objects.filter( usage_start=str(yesterday)).annotate( project=proj_annotations).values("project").annotate( cost=cost_annotations).order_by("-cost")) ranking_map = {} count = 1 for project in expected: ranking_map[project.get("project")] = count count += 1 for element in data: previous = 0 for project in element.get("projects"): project_name = project.get("project") # This if is cause some days may not have same projects. # however we want the projects that do match to be in the # same order if project_name in ranking_map.keys(): self.assertGreaterEqual(ranking_map[project_name], previous) previous = ranking_map[project_name] tested = True self.assertTrue(tested)