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)
