def test_access_add_account_filter(self):
"""Test that if no group_by or filter is present a filter of accounts is added."""
fake_uri = "filter[region]=*"
test_access = {
"aws.account": {
"read": ["account1", "account2"]
},
"aws.organizational_unit": {
"read": ["*"]
}
}
fake_request = Mock(
spec=HttpRequest,
user=Mock(access=test_access,
customer=Mock(schema_name="acct10001")),
GET=Mock(urlencode=Mock(return_value=fake_uri)),
)
fake_view = Mock(
spec=ReportView,
provider=self.FAKE.word(),
query_handler=Mock(provider=Provider.PROVIDER_AWS),
report=self.FAKE.word(),
serializer=Mock,
tag_handler=[],
)
params = QueryParameters(fake_request, fake_view)
self.assertEqual(params.get_access("account"),
["account1", "account2"])
self.assertEqual(params.get_filter("region"), "*")
def test_partial_access_ocp_all_no_azure_access(self):
"""Test set access returns account numbers."""
self.test_read_access = {
"aws.account": {
"read": ["999999999"]
},
"azure.subscription_guid": {
"read": []
}
}
fake_request = Mock(
spec=HttpRequest,
user=Mock(access=self.test_read_access,
customer=Mock(schema_name="acct10001")),
GET=Mock(urlencode=Mock(return_value="")),
)
fake_view = Mock(
spec=ReportView,
provider=Provider.OCP_ALL,
query_handler=Mock(provider=Provider.OCP_ALL),
report=self.FAKE.word(),
serializer=Mock,
tag_handler=[],
)
with patch("reporting.models.OCPAllCostLineItemDailySummary.objects",
return_value=[]):
params = QueryParameters(fake_request, fake_view)
self.assertEqual(params.get_filter("account"), ["999999999"])
def test_partial_access_ocp_all_partial_azure_access(self):
"""Test set access returns account numbers."""
guid = uuid4()
self.test_read_access = {
"aws.account": {"read": ["*"]},
"aws.organizational_unit": {"read": ["*"]},
"azure.subscription_guid": {"read": [str(guid)]},
}
fake_request = Mock(
spec=HttpRequest,
user=Mock(access=self.test_read_access, customer=Mock(schema_name="acct10001")),
GET=Mock(urlencode=Mock(return_value="")),
)
fake_view = Mock(
spec=ReportView,
provider=Provider.OCP_ALL,
query_handler=Mock(provider=Provider.OCP_ALL),
report=self.FAKE.word(),
serializer=Mock,
tag_handler=[],
)
with patch("reporting.models.OCPAllCostLineItemDailySummary.objects") as mock_object:
mock_object.filter.return_value.values_list.return_value.distinct.return_value = ["999999999"]
params = QueryParameters(fake_request, fake_view)
self.assertEqual(sorted(params.get_filter("account")), sorted(["999999999", str(guid)]))
def test_has_filter_no_filter(self):
"""Test the default filter query parameters."""
fake_request = Mock(spec=HttpRequest,
user=Mock(
access=None,
customer=Mock(schema_name=self.FAKE.word())),
GET=Mock(urlencode=Mock(return_value='')))
fake_view = Mock(spec=ReportView,
provider=self.FAKE.word(),
query_handler=Mock(provider=self.provider),
report=self.FAKE.word(),
serializer=Mock,
tag_handler=[])
params = QueryParameters(fake_request, fake_view)
self.assertEqual(params.get_filter('time_scope_units'), 'day')
self.assertEqual(params.get_filter('time_scope_value'), '-10')
self.assertEqual(params.get_filter('resolution'), 'daily')
def test_access_add_account_filter(self):
"""Test that if no group_by or filter is present a filter of accounts is added."""
fake_uri = 'filter[region]=*'
test_access = {'aws.account': {'read': ['account1', 'account2']}}
fake_request = Mock(spec=HttpRequest,
user=Mock(access=test_access,
customer=Mock(schema_name='acct10001')),
GET=Mock(urlencode=Mock(return_value=fake_uri)))
fake_view = Mock(spec=ReportView,
provider=self.FAKE.word(),
query_handler=Mock(provider='AWS'),
report=self.FAKE.word(),
serializer=Mock,
tag_handler=[])
params = QueryParameters(fake_request, fake_view)
self.assertEqual(params.get_filter('account'),
['account1', 'account2'])
self.assertEqual(params.get_filter('region'), '*')
def test_has_start_end_dates_filter_no_filter(self):
"""Test the default filter query parameters with start and end dates."""
fake_uri = "start_date=2021-04-01&" "end_date=2021-04-13"
fake_request = Mock(
spec=HttpRequest,
user=Mock(access=None, customer=Mock(schema_name=self.FAKE.word())),
GET=Mock(urlencode=Mock(return_value=fake_uri)),
)
fake_view = Mock(
spec=ReportView,
provider=self.FAKE.word(),
query_handler=Mock(provider=self.provider),
report=self.FAKE.word(),
serializer=Mock,
tag_handler=[],
)
params = QueryParameters(fake_request, fake_view)
self.assertIsNone(params.get_filter("time_scope_units"))
self.assertIsNone(params.get_filter("time_scope_value"))
self.assertEqual(params.get_filter("resolution"), "daily")
def get(self, request, **kwargs):
"""Get Report Data.
This method is responsible for passing request data to the reporting APIs.
Args:
request (Request): The HTTP request object
Returns:
(Response): The report in a Response object
"""
LOG.debug(f"API: {request.path} USER: {request.user.username}")
key = kwargs.get("key")
if key and not self.validate_key(key):
raise Http404
try:
params = QueryParameters(request=request, caller=self, **kwargs)
except ValidationError as exc:
return Response(data=exc.detail,
status=status.HTTP_400_BAD_REQUEST)
if key and params.get("key_only"):
LOG.debug("Invalid query parameter 'key_only'.")
error = {"details": "Invalid query parameter 'key_only'."}
raise ValidationError(error)
if not key and params.get_filter("value"):
LOG.debug("Invalid query parameter 'value'.")
error = {"details": "Invalid query parameter 'value'."}
raise ValidationError(error)
handler = self.query_handler(params)
output = handler.execute_query()
if key:
lizt = []
for dikt in output.get("data"):
if isinstance(dikt.get("values"), list):
for val in dikt.get("values"):
lizt.append(val)
else:
lizt.append(dikt.get("values"))
output["data"] = lizt
max_rank = handler.max_rank
paginator = get_paginator(params.parameters.get("filter", {}),
max_rank)
paginated_result = paginator.paginate_queryset(output, request)
LOG.debug(f"DATA: {output}")
return paginator.get_paginated_response(paginated_result)
def test_update_query_parameters_filtered_intersection(self):
"""Test that a filter by cluster filtered list is replaced with only the intersection of cluster."""
fake_uri = ('filter[cluster]=cluster1&' 'filter[cluster]=cluster3')
test_access = {'openshift.cluster': {'read': ['cluster1', 'cluster2']}}
fake_request = Mock(spec=HttpRequest,
user=Mock(access=test_access,
customer=Mock(schema_name='acct10001')),
GET=Mock(urlencode=Mock(return_value=fake_uri)))
fake_view = Mock(spec=ReportView,
provider=self.FAKE.word(),
query_handler=Mock(provider='OCP'),
report=self.FAKE.word(),
serializer=Mock,
tag_handler=[])
params = QueryParameters(fake_request, fake_view)
self.assertEqual(params.get_filter('cluster'), ['cluster1'])
def test_has_filter_no_resolution(self):
"""Test the default filter parameters when resolution is undefined."""
fake_uri = ('filter[time_scope_units]=month&'
'filter[time_scope_value]=-1')
fake_request = Mock(spec=HttpRequest,
user=Mock(
access=None,
customer=Mock(schema_name=self.FAKE.word())),
GET=Mock(urlencode=Mock(return_value=fake_uri)))
fake_view = Mock(spec=ReportView,
provider=self.FAKE.word(),
query_handler=Mock(provider=self.provider),
report=self.FAKE.word(),
serializer=Mock,
tag_handler=[])
params = QueryParameters(fake_request, fake_view)
self.assertEqual(params.get_filter('resolution'), 'monthly')
def test_update_query_parameters_add_subscription_guid_filter_obj(self):
"""Test that if no group_by or filter is present a filter of subscription_guids is added."""
guid1 = uuid4()
guid2 = uuid4()
test_access = {'azure.subscription_guid': {'read': [guid1, guid2]}}
fake_request = Mock(spec=HttpRequest,
user=Mock(access=test_access,
customer=Mock(schema_name='acct10001')),
GET=Mock(urlencode=Mock(return_value='')))
fake_view = Mock(spec=ReportView,
provider=self.FAKE.word(),
query_handler=Mock(provider='AZURE'),
report=self.FAKE.word(),
serializer=Mock,
tag_handler=[])
params = QueryParameters(fake_request, fake_view)
self.assertEqual(params.get_filter('subscription_guid'),
[guid1, guid2])
def test_get_set_filter(self):
"""Test that set() assigns the provided value and get() retrieves it."""
fake_request = Mock(
spec=HttpRequest,
user=Mock(access=None,
customer=Mock(schema_name=self.FAKE.word())),
GET=Mock(urlencode=Mock(return_value=self.fake_uri)))
fake_view = Mock(spec=ReportView,
provider=self.FAKE.word(),
query_handler=Mock(provider=self.provider),
report=self.FAKE.word(),
serializer=Mock,
tag_handler=[])
params = QueryParameters(fake_request, fake_view)
key = self.FAKE.word()
value = self.FAKE.word()
params.set_filter(**{key: value})
self.assertEqual(params.get_filter(key), value)
def test_update_query_parameters_filtered_intersection(self):
"""Test that a filter by cluster filtered list is replaced with only the intersection of cluster."""
fake_uri = "filter[cluster]=cluster1&" "filter[cluster]=cluster3"
test_access = {"openshift.cluster": {"read": ["cluster1", "cluster2"]}}
fake_request = Mock(
spec=HttpRequest,
user=Mock(access=test_access, customer=Mock(schema_name="acct10001")),
GET=Mock(urlencode=Mock(return_value=fake_uri)),
)
fake_view = Mock(
spec=ReportView,
provider=self.FAKE.word(),
query_handler=Mock(provider=Provider.PROVIDER_OCP),
report=self.FAKE.word(),
serializer=Mock,
tag_handler=[],
)
params = QueryParameters(fake_request, fake_view)
self.assertEqual(params.get_filter("cluster"), ["cluster1"])
