def test_get_tag_keys_filter_false(self):
"""Test that all tag keys are returned with no filter."""
query_params = {
'filter': {
'resolution': 'monthly',
'time_scope_value': -1,
'time_scope_units': 'month'
},
}
handler = OCPTagQueryHandler(query_params, None, self.tenant, **{})
with tenant_context(self.tenant):
usage_tag_keys = OCPUsageLineItemDailySummary.objects\
.annotate(tag_keys=JSONBObjectKeys('pod_labels'))\
.values('tag_keys')\
.annotate(tag_count=Count('tag_keys'))\
.all()
usage_tag_keys = [tag.get('tag_keys') for tag in usage_tag_keys]
storage_tag_keys = OCPStorageLineItemDailySummary.objects\
.annotate(tag_keys=JSONBObjectKeys('volume_labels'))\
.values('tag_keys')\
.annotate(tag_count=Count('tag_keys'))\
.all()
storage_tag_keys = [
tag.get('tag_keys') for tag in storage_tag_keys
]
tag_keys = list(set(usage_tag_keys + storage_tag_keys))
result = handler.get_tag_keys(filters=False)
self.assertEqual(sorted(result), sorted(tag_keys))
def test_get_tag_type_filter_storage(self):
"""Test that all storage tags are returned with storage type filter."""
query_params = {
'filter': {
'resolution': 'monthly',
'time_scope_value': -2,
'time_scope_units': 'month',
'type': 'storage'
},
}
query_string = '?filter[resolution]=monthly&' + \
'filter[time_scope_value]=-2&' + \
'filter[time_scope_units]=month&' + \
'filter[type]=storage&'
handler = OCPTagQueryHandler(query_params, query_string, self.tenant,
**{})
with tenant_context(self.tenant):
storage_tag_keys = OCPStorageLineItemDailySummary.objects\
.annotate(tag_keys=JSONBObjectKeys('volume_labels'))\
.values('tag_keys')\
.annotate(tag_count=Count('tag_keys'))\
.all()
storage_tag_keys = [
tag.get('tag_keys') for tag in storage_tag_keys
]
tag_keys = storage_tag_keys
result = handler.get_tag_keys(filters=False)
self.assertEqual(sorted(result), sorted(tag_keys))
def test_execute_query_with_wildcard_tag_filter(self):
"""Test that data is filtered to include entries with tag key."""
handler = OCPTagQueryHandler({'filter': {'type': 'pod'}}, '?filter[type]=pod', self.tenant)
tag_keys = handler.get_tag_keys()
filter_key = tag_keys[0]
with tenant_context(self.tenant):
totals = OCPUsageLineItemDailySummary.objects\
.filter(usage_start__gte=self.ten_days_ago)\
.filter(**{'pod_labels__has_key': filter_key})\
.aggregate(
**{
'usage': Sum('pod_usage_cpu_core_hours'),
'request': Sum('pod_request_cpu_core_hours'),
'limit': Sum('pod_limit_cpu_core_hours'),
'derived_cost': Sum('pod_charge_cpu_core_hours')
}
)
url = reverse('reports-openshift-cpu')
client = APIClient()
params = {f'filter[tag:{filter_key}]': '*'}
url = url + '?' + urlencode(params, quote_via=quote_plus)
response = client.get(url, **self.headers)
self.assertEqual(response.status_code, 200)
data = response.json()
data_totals = data.get('meta', {}).get('total', {})
for key in totals:
expected = round(float(totals[key]), 6)
result = data_totals.get(key, {}).get('value')
self.assertEqual(result, expected)
def test_execute_query_for_project(self):
"""Test that the execute query runs properly with project query."""
namespace = None
with tenant_context(self.tenant):
namespace_obj = OCPUsageLineItemDailySummary.objects\
.values('namespace')\
.first()
namespace = namespace_obj.get('namespace')
query_params = {
'filter': {
'resolution': 'daily',
'time_scope_value': -10,
'time_scope_units': 'day',
'project': namespace
},
}
query_string = '?filter[resolution]=daily&' + \
'filter[time_scope_value]=-10&' + \
'filter[time_scope_units]=day&' + \
'filter[project]={}'.format(namespace)
handler = OCPTagQueryHandler(query_params, query_string, self.tenant,
**{})
query_output = handler.execute_query()
self.assertIsNotNone(query_output.get('data'))
self.assertEqual(handler.time_scope_units, 'day')
self.assertEqual(handler.time_scope_value, -10)
def test_get_tag_group_by(self):
"""Test that tag based group bys work."""
handler = OCPTagQueryHandler('', {}, self.tenant)
tag_keys = handler.get_tag_keys(filters=False)
group_by_key = tag_keys[0]
group_by_value = 'group_by'
query_params = {
'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
}
)
group_by = handler._get_tag_group_by()
group = group_by[0]
expected = 'pod_labels__' + group_by_key
self.assertEqual(len(group_by), 1)
self.assertEqual(group[0], expected)
def get_tag_keys(request):
"""Get a list of tag keys to validate filters."""
tenant = get_tenant(request.user)
handler = OCPTagQueryHandler('', {}, tenant)
tags = handler.get_tag_keys(filters=False)
tags = [':'.join(['tag', tag]) for tag in tags]
return tags
def test_get_exclusions(self):
"""Test that exclusions are properly set."""
handler = OCPTagQueryHandler('', {}, self.tenant)
tag_keys = handler.get_tag_keys(filters=False)
group_by_key = tag_keys[0]
group_by_value = 'group_By'
query_params = {
'group_by': {group_by_key: [group_by_value]}
}
handler = OCPReportQueryHandler(
query_params,
'',
self.tenant,
**{
'report_type': 'cpu',
'tag_keys': tag_keys
}
)
exclusions = handler._get_exclusions()
expected = f"<Q: (AND: ('pod_labels__{group_by_key}__isnull', True))>"
self.assertEqual(repr(exclusions), expected)
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]}
}
handler = OCPReportQueryHandler(
query_params,
'',
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_get_tag_group_by_keys(self):
"""Test that group_by params with tag keys are returned."""
handler = OCPTagQueryHandler('', {}, self.tenant)
tag_keys = handler.get_tag_keys(filters=False)
key_of_interest = tag_keys[0]
query_params = {
'group_by': {
key_of_interest: ['']
}
}
handler = OCPReportQueryHandler(
query_params,
f'?filter[{key_of_interest}]=\'\'',
self.tenant,
**{
'report_type': 'cpu',
'tag_keys': tag_keys
}
)
results = handler.get_tag_group_by_keys()
self.assertEqual(results, [key_of_interest])
def test_get_tag_filter_keys(self):
"""Test that filter params with tag keys are returned."""
handler = OCPTagQueryHandler('', {}, self.tenant)
tag_keys = handler.get_tag_keys(filters=False)
key_of_interest = tag_keys[0]
query_params = {
'filter': {
'resolution': 'monthly',
'time_scope_value': -1,
'time_scope_units': 'month',
key_of_interest: ['']
}
}
handler = OCPReportQueryHandler(
query_params,
f'?filter[{key_of_interest}]=\'\'',
self.tenant,
**{
'report_type': 'cpu',
'tag_keys': tag_keys
}
)
results = handler.get_tag_filter_keys()
self.assertEqual(results, [key_of_interest])
def test_execute_query_no_query_parameters(self):
"""Test that the execute query runs properly with no query."""
query_params = {}
handler = OCPTagQueryHandler(query_params, '', self.tenant, **{})
query_output = handler.execute_query()
self.assertIsNotNone(query_output.get('data'))
self.assertEqual(handler.time_scope_units, 'month')
self.assertEqual(handler.time_scope_value, -1)
def test_execute_query_30_day_parameters(self):
"""Test that the execute query runs properly with 30 day query."""
query_params = {
'filter': {
'resolution': 'daily',
'time_scope_value': -30,
'time_scope_units': 'day'
},
}
query_string = '?filter[resolution]=daily&' + \
'filter[time_scope_value]=-30&' + \
'filter[time_scope_units]=day&'
handler = OCPTagQueryHandler(query_params, query_string, self.tenant,
**{})
query_output = handler.execute_query()
self.assertIsNotNone(query_output.get('data'))
self.assertEqual(handler.time_scope_units, 'day')
self.assertEqual(handler.time_scope_value, -30)
def test_execute_query_two_month_parameters(self):
"""Test that the execute query runs properly with two month query."""
query_params = {
'filter': {
'resolution': 'monthly',
'time_scope_value': -2,
'time_scope_units': 'month'
},
}
query_string = '?filter[resolution]=monthly&' + \
'filter[time_scope_value]=-2&' + \
'filter[time_scope_units]=month&'
handler = OCPTagQueryHandler(query_params, query_string, self.tenant,
**{})
query_output = handler.execute_query()
self.assertIsNotNone(query_output.get('data'))
self.assertEqual(handler.time_scope_units, 'month')
self.assertEqual(handler.time_scope_value, -2)
def test_execute_query_with_tag_group_by(self):
"""Test that data is grouped by tag key."""
handler = OCPTagQueryHandler({'filter': {'type': 'pod'}}, '?filter[type]=pod', self.tenant)
tag_keys = handler.get_tag_keys()
group_by_key = tag_keys[0]
url = reverse('reports-openshift-cpu')
client = APIClient()
params = {f'group_by[tag:{group_by_key}]': '*'}
url = url + '?' + urlencode(params, quote_via=quote_plus)
response = client.get(url, **self.headers)
self.assertEqual(response.status_code, 200)
data = response.json()
data = data.get('data', [])
expected_keys = ['date', group_by_key + 's']
for entry in data:
self.assertEqual(list(entry.keys()), expected_keys)
def test_execute_query_with_tag_filter(self):
"""Test that data is filtered by tag key."""
handler = OCPTagQueryHandler('', {}, self.tenant)
tag_keys = handler.get_tag_keys()
filter_key = tag_keys[0]
with tenant_context(self.tenant):
labels = OCPUsageLineItemDailySummary.objects\
.filter(usage_start__gte=self.ten_days_ago)\
.filter(pod_labels__has_key=filter_key)\
.values(*['pod_labels'])\
.all()
label_of_interest = labels[0]
filter_value = label_of_interest.get('pod_labels',
{}).get(filter_key)
totals = OCPUsageLineItemDailySummary.objects\
.filter(usage_start__gte=self.ten_days_ago)\
.filter(**{f'pod_labels__{filter_key}': filter_value})\
.aggregate(
**{
'usage': Sum('pod_usage_cpu_core_hours'),
'request': Sum('pod_request_cpu_core_hours'),
'limit': Sum('pod_limit_cpu_core_hours'),
'charge': Sum('pod_charge_cpu_core_hours')
}
)
url = reverse('reports-ocp-cpu')
client = APIClient()
params = {f'filter[tag:{filter_key}]': filter_value}
url = url + '?' + urlencode(params, quote_via=quote_plus)
response = client.get(url, **self.headers)
self.assertEqual(response.status_code, 200)
data = response.json()
data_totals = data.get('total')
for key in totals:
expected = round(float(totals[key]), 6)
result = data_totals.get(key)
self.assertEqual(result, expected)
