def test_get_fields_with_include_fields_and_request_fields(self):
include = ['permissions']
expected = set(UserSerializer().get_fields().keys()) | set(include)
serializer = UserSerializer(include_fields=include,
request_fields={'permissions': {}})
self.assertEqual(set(serializer.fields.keys()), expected)
self.assertEqual(serializer.request_fields['permissions'], {})
def test_get_fields_with_include_all_and_exclude(self):
expected = six.iterkeys(UserSerializer().get_all_fields())
serializer = UserSerializer(
include_fields='*',
exclude_fields=['id']
)
self.assertEqual(list(six.iterkeys(serializer.fields)), list(expected))
def test_get_fields_with_include_fields(self):
include = ['permissions']
expected = set(
six.iterkeys(UserSerializer().get_fields())
) | set(include)
serializer = UserSerializer(
include_fields=include
)
self.assertEqual(set(six.iterkeys(serializer.fields)), expected)
def test_get_fields_with_exclude_fields(self):
exclude = ['id']
expected = set(
six.iterkeys(UserSerializer().get_fields())
) - set(exclude)
serializer = UserSerializer(
exclude_fields=exclude,
)
self.assertEqual(set(six.iterkeys(serializer.fields)), expected)
def test_data_with_included_has_one(self):
request_fields = {'location': {}}
serializer = UserSerializer(
self.fixture.users,
many=True,
envelope=True,
request_fields=request_fields,
)
self.assertEqual(
serializer.data, {
'locations': [{
'id': 1,
'name': '0'
}, {
'id': 2,
'name': '1'
}, {
'id': 3,
'name': '2'
}],
'users': [{
'location': 1,
'id': 1,
'name': '0'
}, {
'location': 1,
'id': 2,
'name': '1'
}, {
'location': 2,
'id': 3,
'name': '2'
}, {
'location': 3,
'id': 4,
'name': '3'
}]
})
serializer = UserSerializer(
self.fixture.users[0],
envelope=True,
request_fields=request_fields,
)
self.assertEqual(
serializer.data, {
'locations': [{
'id': 1,
'name': '0'
}],
'user': {
'location': 1,
'id': 1,
'name': '0'
}
})
def test_data_with_nested_exclude(self):
request_fields = {'groups': {'name': False}}
serializer = UserSerializer(self.fixture.users,
many=True,
request_fields=request_fields,
sideload=True)
self.assertEqual(
serializer.data, {
'groups': [{
'id': 1
}, {
'id': 2
}],
'users': [{
'location': 1,
'id': 1,
'groups': [1, 2],
'name': '0'
}, {
'location': 1,
'id': 2,
'groups': [1, 2],
'name': '1'
}, {
'location': 2,
'id': 3,
'groups': [1, 2],
'name': '2'
}, {
'location': 3,
'id': 4,
'groups': [1, 2],
'name': '3'
}]
})
def test_get_fields_with_only_fields_and_include_fields(self):
expected = ['id', 'name']
serializer = UserSerializer(
only_fields=expected,
include_fields=['permissions']
)
self.assertEqual(list(six.iterkeys(serializer.fields)), expected)
def test_data_with_included_field(self):
request_fields = {
'last_name': True
}
serializer = UserSerializer(
self.fixture.users,
many=True,
sideload=True, # pending deprecation 1.6
request_fields=request_fields,
)
self.assertEqual(serializer.data, {
'users': [
OrderedDict(
[('id', 1), ('name', '0'),
('location', 1), ('last_name', '0')]),
OrderedDict(
[('id', 2), ('name', '1'),
('location', 1), ('last_name', '1')]),
OrderedDict(
[('id', 3), ('name', '2'),
('location', 2), ('last_name', '2')]),
OrderedDict(
[('id', 4), ('name', '3'),
('location', 3), ('last_name', '3')])
]
})
def test_wrong_include(self):
"""Test wrong GET param."""
request = RequestFactory()
request = request.get('/users/?include[]=UNEXPECTED')
serializer = UserSerializer(context={'request': request})
with self.assertRaises(ValidationError):
serializer.fields # noqa
def test_request_is_none(self):
"""Test serializer without request."""
serializer = UserSerializer()
fields = serializer.fields
self.assertSetEqual(
set(fields.keys()),
{'id', 'first_name', 'last_name', 'username'},
)
def test_get_fields_with_only_fields_and_request_fields(self):
expected = ['id', 'permissions']
serializer = UserSerializer(
only_fields=expected,
request_fields={
'permissions': {}
}
)
self.assertEqual(list(six.iterkeys(serializer.fields)), expected)
self.assertEqual(serializer.request_fields['permissions'], {})
def test_data_without_envelope(self):
serializer = UserSerializer(
self.fixture.users,
many=True,
)
self.assertEqual(serializer.data, [
OrderedDict([('id', 1), ('name', '0'), ('location', 1)]),
OrderedDict([('id', 2), ('name', '1'), ('location', 1)]),
OrderedDict([('id', 3), ('name', '2'), ('location', 2)]),
OrderedDict([('id', 4), ('name', '3'), ('location', 3)])
])
def test_request_without_include(self):
"""Test serializer without request."""
request = RequestFactory()
request = request.get('/users/')
serializer = UserSerializer(context={'request': request})
fields = serializer.fields
self.assertSetEqual(
set(fields.keys()),
{'id', 'first_name', 'last_name', 'username'},
)
def test_self_nested(self):
"""Test self include."""
request = RequestFactory()
request = request.get('/users/?include[]=may_know_users')
serializer = UserSerializer(context={'request': request})
fields = serializer.fields
self.assertIn(
'may_know_users',
fields.keys(),
)
def test_data(self):
serializer = UserSerializer(self.fixture.users,
many=True,
sideload=True)
self.assertEqual(
serializer.data, {
'users': [
OrderedDict([('id', 1), ('name', '0'), ('location', 1)]),
OrderedDict([('id', 2), ('name', '1'), ('location', 1)]),
OrderedDict([('id', 3), ('name', '2'), ('location', 2)]),
OrderedDict([('id', 4), ('name', '3'), ('location', 3)])
]
})
def test_post_processors(self):
@register_post_processor
def test_post_processor(data):
data['post_processed'] = True
return data
serializer = UserSerializer(
self.fixture.users,
many=True,
envelope=True,
request_fields={'groups': {}},
)
data = serializer.data
self.assertTrue(data.get('post_processed'))
def test_data_with_excluded_field(self):
request_fields = {'location': False}
serializer = UserSerializer(self.fixture.users,
many=True,
request_fields=request_fields,
sideload=True)
self.assertEqual(
serializer.data, {
'users': [
OrderedDict([('id', 1), ('name', '0')]),
OrderedDict([('id', 2), ('name', '1')]),
OrderedDict([('id', 3), ('name', '2')]),
OrderedDict([('id', 4), ('name', '3')])
]
})
def test_include_field_many_false(self):
"""Test field serializer with `many=False`."""
request = RequestFactory()
request = request.get('/users/?include[]=profile')
serializer = UserSerializer(context={'request': request})
fields = serializer.fields
self.assertSetEqual(
set(fields.keys()),
{'id', 'first_name', 'last_name', 'username', 'profile'},
)
self.assertIsInstance(
fields['profile'],
ProfileSerializer,
)
def test_data_with_nested_include(self):
request_fields = {'groups': {'permissions': True}}
serializer = UserSerializer(
self.fixture.users,
many=True,
envelope=True,
request_fields=request_fields,
)
expected = {
'users': [{
'id': 1,
'name': '0',
'groups': [1, 2],
'location': 1
}, {
'id': 2,
'name': '1',
'groups': [1, 2],
'location': 1
}, {
'id': 3,
'name': '2',
'groups': [1, 2],
'location': 2
}, {
'id': 4,
'name': '3',
'groups': [1, 2],
'location': 3
}],
'groups': [{
'id': 1,
'name': '0',
'permissions': [1]
}, {
'id': 2,
'name': '1',
'permissions': [2]
}]
}
self.assertEqual(serializer.data, expected)
def test_include_field_many_true(self):
"""Test field serializer with `many=True`."""
request = RequestFactory()
request = request.get('/users/?include[]=groups')
serializer = UserSerializer(context={'request': request})
fields = serializer.fields
self.assertSetEqual(
set(fields.keys()),
{'id', 'first_name', 'last_name', 'username', 'groups'},
)
self.assertIsInstance(
fields['groups'],
ListSerializer,
)
self.assertIsInstance(
fields['groups'].child,
GroupSerializer,
)
class UserList(CreateAPI, ListAPI):
model = User
ordering = ["pk"]
serializer = UserSerializer(only=[
"username",
"date_joined",
"email",
])
permissions = [PublicEndpoint]
filter_fields = [
"email",
"date_joined__gte",
"date_joined__lte",
]
search_fields = [
"email",
"username",
]
sort_fields = [
"id",
"date_joined",
]
def test_get_name_proxies_to_child(self):
serializer = UserSerializer(many=True)
self.assertTrue(isinstance(serializer, DynamicListSerializer))
self.assertEqual(serializer.get_name(), 'user')
self.assertEqual(serializer.get_plural_name(), 'users')
def test_get_name_proxies_to_child(self):
serializer = UserSerializer(many=True)
self.assertTrue(isinstance(serializer, DynamicListSerializer))
self.assertEqual(serializer.get_name(), 'user')
self.assertEqual(serializer.get_plural_name(), 'users')
def test_get_fields_with_only_fields(self):
expected = ['id', 'last_name']
serializer = UserSerializer(only_fields=expected)
self.assertEqual(list(six.iterkeys(serializer.fields)), expected)
def test_data_with_included_has_many(self):
request_fields = {'groups': {}}
expected = {
'users': [{
'id': 1,
'name': '0',
'groups': [1, 2],
'location': 1
}, {
'id': 2,
'name': '1',
'groups': [1, 2],
'location': 1
}, {
'id': 3,
'name': '2',
'groups': [1, 2],
'location': 2
}, {
'id': 4,
'name': '3',
'groups': [1, 2],
'location': 3
}],
'groups': [{
'id': 1,
'name': '0'
}, {
'id': 2,
'name': '1'
}]
}
serializer = UserSerializer(
self.fixture.users,
many=True,
envelope=True,
request_fields=request_fields,
)
self.assertEqual(serializer.data, expected)
request_fields = {'members': {}}
expected = {
'users': [{
'id': 1,
'name': '0',
'location': 1
}, {
'id': 2,
'name': '1',
'location': 1
}, {
'id': 3,
'name': '2',
'location': 2
}, {
'id': 4,
'name': '3',
'location': 3
}],
'groups': [{
'id': 1,
'name': '0',
'members': [1, 2, 3, 4]
}, {
'id': 2,
'name': '1',
'members': [1, 2, 3, 4]
}]
}
serializer = GroupSerializer(
self.fixture.groups,
many=True,
envelope=True,
request_fields=request_fields,
)
self.assertEqual(serializer.data, expected)
def test_get_fields_with_include_all(self):
expected = iter(UserSerializer().get_all_fields().keys())
serializer = UserSerializer(
include_fields='*'
)
self.assertEqual(list(iter(serializer.fields.keys())), list(expected))
async def test_serializer_is_valid_empty_data(client: TestClient):
with pytest.raises(ValidationError, match="Bad Request") as exc_info:
UserSerializer(data="").is_valid()
assert json.loads(exc_info.value.text) == {
"error": "No data provided"
}, "Wrong error caught"