def test_parse_int_list_accepted_none(self):
"""Tests parsing a list of int parameters where none of the values are acceptable."""
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.setlist('test', ['1', '2'])
self.assertRaises(BadParameter, rest_util.parse_int_list, request, 'test', accepted_values=[3])
def test_parse_string_list_accepted_none(self):
'''Tests parsing a list of string parameters where none of the values are acceptable.'''
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.setlist('test', ['value1', 'value2'])
self.assertRaises(BadParameter, rest_util.parse_string_list, request, 'test', accepted_values=['value'])
def test_parse_string_list(self):
"""Tests parsing a required list of string parameters that is provided via GET."""
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.setlist('test', ['value1', 'value2'])
self.assertListEqual(rest_util.parse_string_list(request, 'test'), ['value1', 'value2'])
def test_parse_string_list_accepted_partial(self):
"""Tests parsing a list of string parameters where only some values are acceptable."""
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.setlist('test', ['value1', 'value2'])
self.assertRaises(BadParameter, rest_util.parse_string_list, request, 'test', accepted_values=['value1'])
def test_filter_queryset(self):
"""Test search object filtering."""
view = ElasticListAPIView()
view.Meta.model = MagicMock()
view.Meta.model.field_has_raw.return_value = False
elasticfilter = ElasticFilter()
request = MagicMock()
# Set up the query terms for the test.
request.query_params = QueryDict('', mutable=True)
request.query_params.update(
{view.pagination_class.page_query_param: 'ignored',
'name': 'value',
'name__terms': '["value1","value2"]'}
)
result = \
elasticfilter.filter_queryset(request, Search(), view).to_dict()
EXPECTED = [{'terms': {u'name': ['value1', 'value2']}},
{'match': {u'name': 'value'}}]
for item in EXPECTED:
self.assertTrue(item in result['query']['bool']['must'])
def test_parse_int_list_accepted_partial(self):
'''Tests parsing a list of int parameters where only some values are acceptable.'''
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.setlist('test', ['1', '2'])
self.assertRaises(BadParameter, rest_util.parse_int_list, request, 'test', accepted_values=[1])
def test_parse_int_list_accepted_all(self):
'''Tests parsing a list of int parameters where all values are acceptable.'''
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.setlist('test', ['1', '2'])
self.assertListEqual(rest_util.parse_int_list(request, 'test', accepted_values=[1, 2]), [1, 2])
def test_parse_string_list_default(self):
'''Tests parsing a required list of string parameters that are provided via default value.'''
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.setlist('test', ['value1'])
self.assertEqual(rest_util.parse_string_list(request, 'test2', ['value2', 'value3']), ['value2', 'value3'])
def test_parse_int_list(self):
'''Tests parsing a required list of int parameters that is provided via GET.'''
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.setlist('test', ['1', '2'])
self.assertListEqual(rest_util.parse_int_list(request, 'test'), [1, 2])
def test_parse_string_list_optional(self):
'''Tests parsing an optional list of string parameters that are missing.'''
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.setlist('test', ['value1'])
self.assertListEqual(rest_util.parse_string_list(request, 'test2', required=False), [])
def test_filter_terms_regexp(self):
"""Test search object filtering using terms and regexp.
Because their values are dicts, these take a different code path than
"standard" match queries.
"""
view = ElasticListAPIView()
view.Meta.model = MagicMock()
view.Meta.model.field_has_raw.return_value = False
EXPECTED = [
{"regexp": {"this.is.a.nested.field": ".+12345666666666"}},
{"terms": {"_type": ["audit.http.request", "audit.http.response", "identity.*"]}},
]
elasticfilter = ElasticFilter()
request = MagicMock()
# Set up the query terms for the test.
request.query_params = QueryDict("", mutable=True)
request.query_params.update(
{
view.pagination_class.page_query_param: "ignored",
"terms": {"_type": ["audit.http.request", "audit.http.response", "identity.*"]},
"regexp": {"this.is.a.nested.field": ".+12345666666666"},
}
)
result = elasticfilter.filter_queryset(request, Search(), view).to_dict()
for item in EXPECTED:
self.assertTrue(item in result["query"]["bool"]["must"])
def test_parse_string_list_missing(self):
'''Tests parsing a required list of string parameters that are missing.'''
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.setlist('test', ['value1', 'value2'])
self.assertRaises(BadParameter, rest_util.parse_string_list, request, 'test2')
def test_parse_float_default(self):
'''Tests parsing a required float parameter that is provided via default value.'''
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.update({
'test': '10.1',
})
self.assertEqual(rest_util.parse_float(request, 'test2', 20.1), 20.1)
def test_parse_float_optional(self):
"""Tests parsing an optional float parameter that is missing."""
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.update({
'test': 'value1',
})
self.assertIsNone(rest_util.parse_float(request, 'test2', required=False))
def test_parse_duration_invalid(self):
"""Tests parsing a required ISO duration parameter that is formatted incorrectly."""
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.update({
'test': 'BAD',
})
self.assertRaises(BadParameter, rest_util.parse_duration, request, 'test')
def test_parse_duration(self):
'''Tests parsing a required ISO duration parameter that is provided via GET.'''
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.update({
'test': 'PT3H0M0S',
})
self.assertEqual(rest_util.parse_duration(request, 'test'), datetime.timedelta(0, 10800))
def test_parse_string_default(self):
'''Tests parsing an optional string parameter that is provided via default value.'''
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.update({
'test': 'value1',
})
self.assertEqual(rest_util.parse_string(request, 'test2', 'value2'), 'value2')
def test_has_params_partial(self):
'''Tests checking parameter presence when some are given.'''
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.update({
'test1': 'value1',
})
self.assertFalse(rest_util.has_params(request, 'test1', 'test2'))
def test_has_params_single(self):
'''Tests checking parameter presence when one is given.'''
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.update({
'test1': 'value1',
})
self.assertTrue(rest_util.has_params(request, 'test1'))
def test_parse_float_zero(self):
'''Tests parsing an optional float parameter zero instead of using the default value.'''
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.update({
'test': '0.0',
})
self.assertEqual(rest_util.parse_float(request, 'test', 10.1), 0.0)
def test_parse_datetime_optional(self):
'''Tests parsing an optional ISO datetime parameter that is missing.'''
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.update({
'test': 'value1',
})
self.assertIsNone(rest_util.parse_datetime(request, 'test2', required=False))
def test_parse_float_invalid(self):
'''Tests parsing a required float parameter that is not a valid number.'''
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.update({
'test': 'abc',
})
self.assertRaises(BadParameter, rest_util.parse_float, request, 'test')
def test_parse_datetime_missing_timezone(self):
'''Tests parsing an ISO datetime missing a timezone.'''
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.update({
'test': '2015-01-01T00:00:00',
})
self.assertRaises(BadParameter, rest_util.parse_datetime, request, 'test')
def test_parse_datetime_missing(self):
'''Tests parsing a required ISO datetime parameter that is missing.'''
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.update({
'test': '10',
})
self.assertRaises(BadParameter, rest_util.parse_datetime, request, 'test2')
def test_parse_duration_missing(self):
"""Tests parsing a required ISO duration parameter that is missing."""
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.update({
'test': '10',
})
self.assertRaises(BadParameter, rest_util.parse_duration, request, 'test2')
def test_parse_datetime_invalid(self):
'''Tests parsing a required ISO datetime parameter that is formatted incorrectly.'''
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.update({
'test': '20150101T00:00:00Z',
})
self.assertRaises(BadParameter, rest_util.parse_datetime, request, 'test')
def test_parse_bool_default(self):
'''Tests parsing an optional bool parameter that is provided via default value.'''
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.update({
'test': 'true',
})
self.assertFalse(rest_util.parse_bool(request, 'test2', False))
def test_parse_timestamp_datetime(self):
'''Tests parsing a valid ISO datetime.'''
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.update({
'test': '2015-01-01T00:00:00Z',
})
self.assertEqual(rest_util.parse_timestamp(request, 'test'), datetime.datetime(2015, 1, 1, tzinfo=timezone.utc))
def test_parse_float(self):
"""Tests parsing a required float parameter that is provided via GET."""
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.update({
'test': '10.1',
})
self.assertEqual(rest_util.parse_float(request, 'test'), 10.1)
def test_parse_int(self):
'''Tests parsing a required int parameter that is provided via GET.'''
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.update({
'test': '10',
})
self.assertEqual(rest_util.parse_int(request, 'test'), 10)
def test_parse_duration_missing(self):
"""Tests parsing a required ISO duration parameter that is missing."""
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.update({
'test': '10',
})
self.assertRaises(BadParameter, rest_util.parse_duration, request,
'test2')
def test_parse_duration_invalid(self):
"""Tests parsing a required ISO duration parameter that is formatted incorrectly."""
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.update({
'test': 'BAD',
})
self.assertRaises(BadParameter, rest_util.parse_duration, request,
'test')
def test_parse_string_missing(self):
"""Tests parsing a required string parameter that is missing."""
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.update({
'test': 'value1',
})
self.assertRaises(BadParameter, rest_util.parse_string, request,
'test2')
def test_parse_float_optional(self):
"""Tests parsing an optional float parameter that is missing."""
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.update({
'test': 'value1',
})
self.assertIsNone(
rest_util.parse_float(request, 'test2', required=False))
def test_parse_string_default(self):
'''Tests parsing an optional string parameter that is provided via default value.'''
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.update({
'test': 'value1',
})
self.assertEqual(rest_util.parse_string(request, 'test2', 'value2'),
'value2')
def test_has_params_all(self):
'''Tests checking parameter presence when all are given.'''
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.update({
'test1': 'value1',
'test2': None,
})
self.assertTrue(rest_util.has_params(request, 'test1', 'test2'))
def test_parse_datetime_missing(self):
'''Tests parsing a required ISO datetime parameter that is missing.'''
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.update({
'test': '10',
})
self.assertRaises(BadParameter, rest_util.parse_datetime, request,
'test2')
def test_parse_datetime_optional(self):
'''Tests parsing an optional ISO datetime parameter that is missing.'''
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.update({
'test': 'value1',
})
self.assertIsNone(
rest_util.parse_datetime(request, 'test2', required=False))
def test_filter_queryset_with_no_q_object(self):
request = MagicMock()
view = MagicMock()
queryset = MagicMock()
request.query_params = {}
res = FilterSupportingOrBackend().filter_queryset(request=request,
queryset=queryset,
view=view)
self.assertEqual(res, queryset)
def test_parse_datetime_invalid(self):
'''Tests parsing a required ISO datetime parameter that is formatted incorrectly.'''
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.update({
'test': '20150101T00:00:00Z',
})
self.assertRaises(BadParameter, rest_util.parse_datetime, request,
'test')
def test_parse_datetime_missing_timezone(self):
'''Tests parsing an ISO datetime missing a timezone.'''
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.update({
'test': '2015-01-01T00:00:00',
})
self.assertRaises(BadParameter, rest_util.parse_datetime, request,
'test')
def test_parse_datetime(self):
'''Tests parsing a valid ISO datetime.'''
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.update({
'test': '2015-01-01T00:00:00Z',
})
self.assertEqual(rest_util.parse_datetime(request, 'test'),
datetime.datetime(2015, 1, 1, tzinfo=timezone.utc))
def test_parse_duration(self):
'''Tests parsing a required ISO duration parameter that is provided via GET.'''
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.update({
'test': 'PT3H0M0S',
})
self.assertEqual(rest_util.parse_duration(request, 'test'),
datetime.timedelta(0, 10800))
def test_parse_int_list_accepted_all(self):
'''Tests parsing a list of int parameters where all values are acceptable.'''
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.setlist('test', ['1', '2'])
self.assertListEqual(
rest_util.parse_int_list(request, 'test', accepted_values=[1, 2]),
[1, 2])
def test_parse_string_list_default(self):
"""Tests parsing a required list of string parameters that are provided via default value."""
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.setlist('test', ['value1'])
self.assertEqual(
rest_util.parse_string_list(request, 'test2',
['value2', 'value3']),
['value2', 'value3'])
def test_parse_timestamp_duration(self, mock_now):
"""Tests parsing a valid ISO duration."""
mock_now.return_value = datetime.datetime(2015, 1, 1, 10, tzinfo=utc)
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.update({
'test': 'PT3H0M0S',
})
self.assertEqual(rest_util.parse_timestamp(request, 'test'),
datetime.datetime(2015, 1, 1, 7, tzinfo=utc))
def test_parse_int_accepted_all(self):
"""Tests parsing an int parameter where the value is acceptable."""
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.update({
'test': '1',
})
self.assertEqual(
rest_util.parse_int(request, 'test', accepted_values=[1, 2, 3]), 1)
def test_parse_string_list_accepted_all(self):
"""Tests parsing a list of string parameters where all values are acceptable."""
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.setlist('test', ['value1', 'value2'])
self.assertListEqual(
rest_util.parse_string_list(request,
'test',
accepted_values=['value1', 'value2']),
['value1', 'value2'])
def test_parse_string_list_accepted_none(self):
"""Tests parsing a list of string parameters where none of the values are acceptable."""
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.setlist('test', ['value1', 'value2'])
self.assertRaises(BadParameter,
rest_util.parse_string_list,
request,
'test',
accepted_values=['value'])
def test_parse_string_accepted_all(self):
"""Tests parsing a string parameter where the value is acceptable."""
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.update({
'test': 'value1',
})
self.assertEqual(
rest_util.parse_string(request, 'test',
accepted_values=['value1']), 'value1')
def test_parse_int_list_accepted_none(self):
'''Tests parsing a list of int parameters where none of the values are acceptable.'''
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.setlist('test', ['1', '2'])
self.assertRaises(BadParameter,
rest_util.parse_int_list,
request,
'test',
accepted_values=[3])
def test_parse_string_list_accepted_partial(self):
'''Tests parsing a list of string parameters where only some values are acceptable.'''
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.setlist('test', ['value1', 'value2'])
self.assertRaises(BadParameter,
rest_util.parse_string_list,
request,
'test',
accepted_values=['value1'])
def test_parse_int_list_accepted_partial(self):
"""Tests parsing a list of int parameters where only some values are acceptable."""
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.setlist('test', ['1', '2'])
self.assertRaises(BadParameter,
rest_util.parse_int_list,
request,
'test',
accepted_values=[1])
def test_parse_dict(self):
"""Tests parsing a dictionary."""
result = {
'name': 'value',
}
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.update({
'test': result,
})
self.assertDictEqual(rest_util.parse_dict(request, 'test'), result)
def test_filter_queryset_with_non_null_query_params(self, *args):
request = MagicMock()
view = MagicMock()
view.filterset_fields = (
'field1',
'field2',
'field3',
'field4',
'field5',
'field6',
'field7',
'field8',
'field9',
'field10',
'field11',
)
queryset = MagicMock()
queryset.model._meta.get_field = MagicMock()
queryset.model._meta.get_field().get_internal_type = MagicMock(
side_effect=[
'OtherRandowField',
'DateField',
'DateTimeField',
'DateField',
'DateField',
'DecimalField',
'FloatField',
'IntegerField',
'IntegerField',
'IntegerField',
'IntegerField',
]
)
request.query_params = OrderedDict(
[
('field12', 'value12'),
('field13__range', 'value13'),
('field6__range', 'value6'),
('field5__range', '5'),
('field1__range', '2017-11-28,2017-10-28'),
('field7__range', '2017-11-28,2017-10-28'),
('field8__range', '2017/11/28,2017/10/28'),
('field2__range', '21,22'),
('field3__range', '3.0,2.5'),
('field4__range', '4,6'),
('field9__range', ','),
('field10__range', '1,'),
('field11__range', ',1'),
]
)
res = FilterSupportingRangeBackend().filter_queryset(
request=request, queryset=queryset, view=view
)
self.assertNotEqual(res, queryset)
def test_parse_duration_default(self):
"""Tests parsing a required ISO duration parameter that is provided via default value."""
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.update({
'test': 'PT3H0M0S',
})
default_value = datetime.timedelta(0, 20800)
self.assertEqual(
rest_util.parse_duration(request, 'test2', default_value),
default_value)
def test_parse_datetime_default(self):
"""Tests parsing a required ISO datetime parameter that is provided via default value."""
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.update({
'test': '2015-01-01T00:00:00Z',
})
default_value = datetime.datetime(2015, 2, 10, tzinfo=utc)
self.assertEqual(
rest_util.parse_datetime(request, 'test2', default_value),
default_value)
def test_parse_float_valid(self):
"""Tests parsing a float parameter where the value is acceptable."""
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.update({
'test': '1.1',
})
self.assertEqual(
rest_util.parse_float(request,
'test',
accepted_values=[1.1, 2.2, 3.3]), 1.1)
def test_parse_string_accepted_none(self):
"""Tests parsing a string parameter where the value is not acceptable."""
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.update({
'test': 'value1',
})
self.assertRaises(BadParameter,
rest_util.parse_string,
request,
'test',
accepted_values=['value'])
def test_parse_float_accepted_none(self):
"""Tests parsing a float parameter where the value is not acceptable."""
request = MagicMock(Request)
request.query_params = QueryDict('', mutable=True)
request.query_params.update({
'test': '1.0',
})
self.assertRaises(BadParameter,
rest_util.parse_float,
request,
'test',
accepted_values=[5.0, 10.0])