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))