def test_get_tag_type_filter_storage(self):
"""Test that all storage tags are returned with storage type filter."""
# '?filter[time_scope_units]=month&filter[time_scope_value]=-2&filter[resolution]=monthly&filter[type]=storage'
params = {
'filter': {
'resolution': 'monthly',
'time_scope_value': -2,
'time_scope_units': 'month',
'type': 'storage'
}
}
query_params = FakeQueryParameters(params, tenant=self.tenant)
handler = OCPTagQueryHandler(query_params.mock_qp)
with tenant_context(self.tenant):
storage_tag_keys = OCPUsageLineItemDailySummary.objects\
.annotate(tag_keys=JSONBObjectKeys('volume_labels'))\
.values('tag_keys')\
.distinct()\
.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_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 _obtain_tag_keys(self):
"""
Collect the available tag keys for the customer.
Returns:
(List) - List of available tag keys objects
(List) - List of enabled tag keys strings
"""
url = (
"?filter[time_scope_units]=month&filter[time_scope_value]=-1"
"&filter[resolution]=monthly&key_only=True&filter[enabled]=False")
tag_request = self.factory.get(url)
tag_request.user = self.request.user
query_params = QueryParameters(tag_request, OCPTagView)
handler = OCPTagQueryHandler(query_params)
query_output = handler.execute_query()
avail_data = query_output.get("data")
all_tags_set = set(avail_data)
enabled = []
with schema_context(self.schema):
enabled_tags = OCPEnabledTagKeys.objects.all()
enabled = [enabled_tag.key for enabled_tag in enabled_tags]
all_tags_set.update(enabled)
return all_tags_set, enabled
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_post_settings_ocp_tag_enabled(self):
"""Test setting OCP tags as enabled."""
url = (
"?filter[time_scope_units]=month&filter[time_scope_value]=-1"
"&filter[resolution]=monthly&key_only=True&filter[enabled]=False")
query_params = self.mocked_query_params(url, OCPTagView)
handler = OCPTagQueryHandler(query_params)
query_output = handler.execute_query()
tag = query_output.get("data")[0]
body = {
"api": {
"settings": {
"openshift": {
"tag-management": {
"enabled": [tag]
}
}
}
}
}
response = self.post_settings(body)
self.assertEqual(response.status_code, status.HTTP_200_OK)
response = self.get_settings()
self.assertEqual(response.status_code, status.HTTP_200_OK)
duallist = self.get_duallist_from_response(response)
enabled = duallist.get("initialValue")
self.assertIn(tag, enabled)
def test_get_tag_keys_filter_true(self):
"""Test that not all tag keys are returned with a filter."""
url = ("?filter[time_scope_units]=month&filter[time_scope_value]=-2"
"&filter[resolution]=monthly&filter[enabled]=false")
query_params = self.mocked_query_params(url, OCPTagView)
handler = OCPTagQueryHandler(query_params)
with tenant_context(self.tenant):
usage_tag_keys = (OCPUsageLineItemDailySummary.objects.filter(
usage_start__lte=self.dh.this_month_start).annotate(
tag_keys=JSONBObjectKeys("pod_labels")).values(
"tag_keys").distinct().all())
usage_tag_keys = [tag.get("tag_keys") for tag in usage_tag_keys]
storage_tag_keys = (OCPUsageLineItemDailySummary.objects.filter(
usage_start__lte=self.dh.this_month_start).annotate(
tag_keys=JSONBObjectKeys("volume_labels")).values(
"tag_keys").distinct().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=True)
self.assertEqual(sorted(result), sorted(tag_keys))
def test_get_tag_type_filter_pod(self):
"""Test that all usage tags are returned with pod type filter."""
query_params = {
'filter': {
'resolution': 'monthly',
'time_scope_value': -2,
'time_scope_units': 'month',
'type': 'pod'
},
}
query_string = '?filter[resolution]=monthly&' + \
'filter[time_scope_value]=-2&' + \
'filter[time_scope_units]=month&' + \
'filter[type]=pod&'
handler = OCPTagQueryHandler(query_params, query_string, self.tenant,
**{})
with tenant_context(self.tenant):
usage_tag_keys = OCPUsageLineItemDailySummary.objects\
.annotate(tag_keys=JSONBObjectKeys('pod_labels'))\
.values('tag_keys')\
.distinct()\
.all()
usage_tag_keys = [tag.get('tag_keys') for tag in usage_tag_keys]
tag_keys = usage_tag_keys
result = handler.get_tag_keys(filters=False)
self.assertEqual(sorted(result), sorted(tag_keys))
def test_get_tag_values_for_value_filter_partial_match(self):
"""Test that the execute query runs properly with value query."""
key = "version"
value = "a"
url = f"/version/?filter[value]={value}"
query_params = self.mocked_query_params(url, OCPTagView)
# the mocked query parameters dont include the key from the url so it needs to be added
query_params.kwargs = {"key": key}
handler = OCPTagQueryHandler(query_params)
with tenant_context(self.tenant):
storage_tags = (OCPTagsValues.objects.filter(
key__exact=key,
value__icontains=value).values("value").distinct().all())
storage_values = [tag.get("value") for tag in storage_tags]
usage_tags = (OCPTagsValues.objects.filter(
key__exact=key,
value__icontains=value).values("value").distinct().all())
usage_values = [tag.get("value") for tag in usage_tags]
# remove duplicates from the values
tag_values = list(dict.fromkeys(storage_values + usage_values))
expected = {"key": key, "values": tag_values}
result = handler.get_tag_values()
self.assertEqual(result[0].get("key"), expected.get("key"))
self.assertEqual(sorted(result[0].get("values")),
sorted(expected.get("values")))
def test_get_tag_keys_filter_false(self):
"""Test that all tag keys are returned with no filter."""
url = '?filter[time_scope_units]=month&filter[time_scope_value]=-2&filter[resolution]=monthly'
query_params = self.mocked_query_params(url, OCPTagView)
handler = OCPTagQueryHandler(query_params)
with tenant_context(self.tenant):
usage_tag_keys = (
OCPUsageLineItemDailySummary.objects.annotate(
tag_keys=JSONBObjectKeys('pod_labels')
)
.values('tag_keys')
.distinct()
.all()
)
usage_tag_keys = [tag.get('tag_keys') for tag in usage_tag_keys]
storage_tag_keys = (
OCPUsageLineItemDailySummary.objects.annotate(
tag_keys=JSONBObjectKeys('volume_labels')
)
.values('tag_keys')
.distinct()
.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_set_access_filters_with_list(self):
"""Test that the execute query runs properly with value query and an RBAC restriction on cluster."""
key = "app"
value = "b"
url = f"/app/?filter[value]={value}"
query_params = self.mocked_query_params(url, OCPTagView)
# the mocked query parameters dont include the key from the url so it needs to be added
query_params.kwargs = {"key": key}
handler = OCPTagQueryHandler(query_params)
access = ["my-ocp-cluster-2"]
filt = [
{
"field": "report_period__cluster_id",
"operation": "icontains",
"composition_key": "cluster_filter"
},
{
"field": "report_period__cluster_alias",
"operation": "icontains",
"composition_key": "cluster_filter"
},
]
filters = QueryFilterCollection()
handler.set_access_filters(access, filt, filters)
expected = []
expected.append(
QueryFilter(field="report_period__cluster_id",
operation="icontains",
parameter=["my-ocp-cluster-2"]))
expected.append(
QueryFilter(field="report_period__cluster_alias",
operation="icontains",
parameter=["my-ocp-cluster-2"]))
self.assertEqual(filters._filters, expected)
def test_execute_query_10_day_parameters_only_keys(self):
"""Test that the execute query runs properly with 10 day query."""
url = "?filter[time_scope_units]=day&filter[time_scope_value]=-10&filter[resolution]=daily&key_only=True"
query_params = self.mocked_query_params(url, OCPTagView)
handler = OCPTagQueryHandler(query_params)
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_execute_query_month_parameters(self):
"""Test that the execute query runs properly with single month query."""
url = '?filter[time_scope_units]=month&filter[time_scope_value]=-1&filter[resolution]=monthly'
query_params = self.mocked_query_params(url, OCPTagView)
handler = OCPTagQueryHandler(query_params)
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."""
url = '?filter[time_scope_units]=day&filter[time_scope_value]=-30&filter[resolution]=daily'
query_params = self.mocked_query_params(url, OCPTagView)
handler = OCPTagQueryHandler(query_params)
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_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, 'day')
self.assertEqual(handler.time_scope_value, -10)
def test_execute_query_no_query_parameters(self):
"""Test that the execute query runs properly with no query."""
# '?'
handler = OCPTagQueryHandler(
FakeQueryParameters({}, tenant=self.tenant).mock_qp)
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_execute_query_two_month_parameters(self):
"""Test that the execute query runs properly with two month query."""
url = "?filter[time_scope_units]=month&filter[time_scope_value]=-2&filter[resolution]=monthly"
query_params = self.mocked_query_params(url, OCPTagView)
handler = OCPTagQueryHandler(query_params)
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_no_query_parameters(self):
"""Test that the execute query runs properly with no query."""
url = "?"
query_params = self.mocked_query_params(url, OCPTagView)
handler = OCPTagQueryHandler(query_params)
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_filter_keys(self):
"""Test that filter params with tag keys are returned."""
url = "?"
query_params = self.mocked_query_params(url, OCPTagView)
handler = OCPTagQueryHandler(query_params)
tag_keys = handler.get_tag_keys(filters=False)
url = f"?filter[tag:{tag_keys[0]}]=*"
query_params = self.mocked_query_params(url, OCPCpuView)
handler = OCPReportQueryHandler(query_params)
results = handler.get_tag_filter_keys()
self.assertEqual(results, ["tag:" + tag_keys[0]])
def test_get_tag_group_by_keys(self):
"""Test that group_by params with tag keys are returned."""
url = "?"
query_params = self.mocked_query_params(url, OCPTagView)
handler = OCPTagQueryHandler(query_params)
tag_keys = handler.get_tag_keys(filters=False)
group_by_key = tag_keys[0]
url = f"?group_by[tag:{group_by_key}]=*"
query_params = self.mocked_query_params(url, OCPCpuView)
handler = OCPReportQueryHandler(query_params)
results = handler.get_tag_group_by_keys()
self.assertEqual(results, ["tag:" + group_by_key])
def test_get_tag_type_filter_storage(self):
"""Test that all storage tags are returned with storage type filter."""
url = "?filter[time_scope_units]=month&filter[time_scope_value]=-2&filter[resolution]=monthly&filter[type]=storage" # noqa: E501
query_params = self.mocked_query_params(url, OCPTagView)
handler = OCPTagQueryHandler(query_params)
with tenant_context(self.tenant):
tag_keys = list(
OCPStorageVolumeLabelSummary.objects.values_list(
"key", flat=True).distinct().all())
result = handler.get_tag_keys(filters=False)
self.assertEqual(sorted(result), sorted(tag_keys))
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")
url = f"?filter[time_scope_units]=day&filter[time_scope_value]=-10&filter[resolution]=daily&filter[project]={namespace}" # noqa: E501
query_params = self.mocked_query_params(url, OCPTagView)
handler = OCPTagQueryHandler(query_params)
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_cluster_filter(self):
"""Test that tags from a cluster are returned with the cluster filter."""
url = "?filter[cluster]=OCP-on-AWS&filter[type]=storage" # noqa: E501
query_params = self.mocked_query_params(url, OCPTagView)
handler = OCPTagQueryHandler(query_params)
with tenant_context(self.tenant):
storage_tag_keys = (OCPStorageVolumeLabelSummary.objects.filter(
report_period__cluster_id__contains="OCP-on-AWS").values(
"key").distinct().all())
tag_keys = [tag.get("key") for tag in storage_tag_keys]
result = handler.get_tag_keys()
self.assertEqual(sorted(result), sorted(tag_keys))
def test_get_tag_group_by_keys(self):
"""Test that group_by params with tag keys are returned."""
# '?'
query_params = FakeQueryParameters({}, tenant=self.tenant)
handler = OCPTagQueryHandler(query_params.mock_qp)
tag_keys = handler.get_tag_keys(filters=False)
params = {'group_by': {tag_keys[0]: ['*']}}
query_params = FakeQueryParameters(params,
report_type='cpu',
tag_keys=tag_keys,
tenant=self.tenant)
handler = OCPReportQueryHandler(query_params.mock_qp)
results = handler.get_tag_group_by_keys()
self.assertEqual(results, [tag_keys[0]])
def test_get_exclusions(self):
"""Test that exclusions are properly set."""
url = '?'
query_params = self.mocked_query_params(url, OCPTagView)
handler = OCPTagQueryHandler(query_params)
tag_keys = handler.get_tag_keys(filters=False)
group_by_key = tag_keys[0]
group_by_value = 'group_By'
url = f'?group_by[tag:{group_by_key}]={group_by_value}'
query_params = self.mocked_query_params(url, OCPCpuView)
handler = OCPReportQueryHandler(query_params)
exclusions = handler._get_exclusions()
expected = f"<Q: (AND: ('pod_labels__{group_by_key}__isnull', True))>"
self.assertEqual(repr(exclusions), expected)
def test_get_settings_ocp_tag_enabled(self):
"""Test that a GET settings call returns expected format."""
response = self.get_settings()
self.assertEqual(response.status_code, status.HTTP_200_OK)
duallist = self.get_duallist_from_response(response)
all_keys = duallist.get("options")
self.assertIsNotNone(all_keys)
all_key_values = [key_obj.get("value") for key_obj in all_keys]
url = (
"?filter[time_scope_units]=month&filter[time_scope_value]=-1"
"&filter[resolution]=monthly&key_only=True&filter[enabled]=False")
query_params = self.mocked_query_params(url, OCPTagView)
handler = OCPTagQueryHandler(query_params)
query_output = handler.execute_query()
tag = query_output.get("data")[0]
self.assertIn(tag, all_key_values)
def test_execute_query_two_month_parameters(self):
"""Test that the execute query runs properly with two month query."""
# '?filter[time_scope_units]=month&filter[time_scope_value]=-2&filter[resolution]=monthly'
params = {
'filter': {
'resolution': 'monthly',
'time_scope_value': -2,
'time_scope_units': 'month'
}
}
query_params = FakeQueryParameters(params, tenant=self.tenant)
handler = OCPTagQueryHandler(query_params.mock_qp)
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_30_day_parameters(self):
"""Test that the execute query runs properly with 30 day query."""
# '?filter[time_scope_units]=day&filter[time_scope_value]=-30&filter[resolution]=daily'
params = {
'filter': {
'resolution': 'daily',
'time_scope_value': -30,
'time_scope_units': 'day'
}
}
query_params = FakeQueryParameters(params, tenant=self.tenant)
handler = OCPTagQueryHandler(query_params.mock_qp)
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_get_tag_group_by(self):
"""Test that tag based group bys work."""
url = "?"
query_params = self.mocked_query_params(url, OCPTagView)
handler = OCPTagQueryHandler(query_params)
tag_keys = handler.get_tag_keys(filters=False)
group_by_key = tag_keys[0]
group_by_value = "group_by"
url = f"?group_by[tag:{group_by_key}]={group_by_value}"
query_params = self.mocked_query_params(url, OCPCpuView)
handler = OCPReportQueryHandler(query_params)
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 test_get_tag_type_filter_storage(self):
"""Test that all storage tags are returned with storage type filter."""
url = "?filter[time_scope_units]=month&filter[time_scope_value]=-2&filter[resolution]=monthly&filter[type]=storage" # noqa: E501
query_params = self.mocked_query_params(url, OCPTagView)
handler = OCPTagQueryHandler(query_params)
with tenant_context(self.tenant):
storage_tag_keys = (OCPUsageLineItemDailySummary.objects.annotate(
tag_keys=JSONBObjectKeys("volume_labels")).values(
"tag_keys").distinct().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))
