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)
