def test_extract_root_meta_invalid_meta():
def get_root_meta(resource, many):
return 'not a dict'
serializer = InvalidExtractRootMetaResourceSerializer()
with pytest.raises(AssertionError) as e_info:
JSONRenderer.extract_root_meta(serializer, {})
def test_extract_root_meta_invalid_meta():
def get_root_meta(resource, many):
return 'not a dict'
serializer = InvalidExtractRootMetaResourceSerializer()
with pytest.raises(AssertionError) as e_info:
JSONRenderer.extract_root_meta(serializer, {})
def test_extract_root_meta_invalid_meta():
def get_root_meta(obj):
return 'not a dict'
serializer = ResourceSerializer()
serializer.get_root_meta = get_root_meta
with pytest.raises(AssertionError) as e_info:
JSONRenderer.extract_root_meta(serializer, {}, {})
def test_extract_root_meta_invalid_meta():
def get_root_meta(obj):
return 'not a dict'
serializer = ResourceSerializer()
serializer.get_root_meta = get_root_meta
with pytest.raises(AssertionError) as e_info:
JSONRenderer.extract_root_meta(serializer, {}, {})
def test_simple_reverse_relation_included_renderer():
'''
Test renderer when a single reverse fk relation is passed.
'''
serializer = DummyTestSerializer(instance=Entry())
renderer = JSONRenderer()
rendered = renderer.render(serializer.data,
renderer_context={'view': DummyTestViewSet()})
assert rendered
def test_simple_reverse_relation_included_renderer():
'''
Test renderer when a single reverse fk relation is passed.
'''
serializer = DummyTestSerializer(instance=Entry())
renderer = JSONRenderer()
rendered = renderer.render(
serializer.data,
renderer_context={'view': DummyTestViewSet()})
assert rendered
def test_api_patch(fixture, admin_client, viewset, snapshot, minio_mock):
url = reverse("{0}-detail".format(viewset.base_name), args=[fixture.pk])
serializer = viewset.serializer_class(fixture)
renderer = JSONRenderer()
context = {"view": viewset}
data = renderer.render(serializer.data, renderer_context=context)
with CaptureQueriesContext(connection) as context:
response = admin_client.patch(url, data=json.loads(data))
assert_response(response, context, snapshot, request_payload=data)
def test_api_create(fixture, admin_client, viewset, snapshot):
url = reverse("{0}-list".format(viewset.base_name))
serializer = viewset.serializer_class(fixture)
renderer = JSONRenderer()
context = {"view": viewset}
data = renderer.render(serializer.data, renderer_context=context)
fixture.delete() # avoid constraint issues
with CaptureQueriesContext(connection) as context:
response = admin_client.post(url, data=json.loads(data))
assert_response(response, context, snapshot)
def test_extract_attributes():
fields = {
'id': serializers.Field(),
'username': serializers.Field(),
'deleted': serializers.ReadOnlyField(),
}
resource = {'id': 1, 'deleted': None, 'username': '******'}
expected = {'username': '******', 'deleted': None}
assert sorted(JSONRenderer.extract_attributes(
fields,
resource)) == sorted(expected), 'Regular fields should be extracted'
assert sorted(JSONRenderer.extract_attributes(fields, {})) == sorted(
{'username':
''}), 'Should not extract read_only fields on empty serializer'
def test_extract_attributes():
fields = {
'id': serializers.Field(),
'username': serializers.Field(),
'deleted': serializers.ReadOnlyField(),
}
resource = {'id': 1, 'deleted': None, 'username': '******'}
expected = {
'username': '******',
'deleted': None
}
assert sorted(JSONRenderer.extract_attributes(fields, resource)) == sorted(expected), 'Regular fields should be extracted'
assert sorted(JSONRenderer.extract_attributes(fields, {})) == sorted(
{'username': ''}), 'Should not extract read_only fields on empty serializer'
def test_extract_attributes():
fields = {
"id": serializers.Field(),
"username": serializers.Field(),
"deleted": serializers.ReadOnlyField(),
}
resource = {"id": 1, "deleted": None, "username": "******"}
expected = {"username": "******", "deleted": None}
assert sorted(JSONRenderer.extract_attributes(
fields,
resource)) == sorted(expected), "Regular fields should be extracted"
assert sorted(JSONRenderer.extract_attributes(fields, {})) == sorted(
{"username":
""}), "Should not extract read_only fields on empty serializer"
def test_build_json_resource_obj():
resource = {"username": "******", "version": "1.0.0"}
serializer = ResourceSerializer(data={"username": "******"})
serializer.is_valid()
resource_instance = serializer.save()
output = {
"type": "user",
"id": "1",
"attributes": {
"username": "******"
},
"meta": {
"version": "1.0.0"
},
}
assert (JSONRenderer.build_json_resource_obj(
get_serializer_fields(serializer),
resource,
resource_instance,
"user",
serializer,
) == output)
def test_extract_meta():
serializer = ResourceSerializer(data={'username': '******', 'version':'1.0.0'})
serializer.is_valid()
expected = {
'version': '1.0.0',
}
assert JSONRenderer.extract_meta(serializer, serializer.data) == expected
def test_extract_relation_instance(comment):
serializer = RelatedModelSerializer(instance=comment)
got = JSONRenderer.extract_relation_instance(
field=serializer.fields['blog'], resource_instance=comment
)
assert got == comment.entry.blog
def test_extract_meta():
serializer = ResourceSerializer(data={'username': '******', 'version': '1.0.0'})
serializer.is_valid()
expected = {
'version': '1.0.0',
}
assert JSONRenderer.extract_meta(serializer, serializer.data) == expected
def test_extract_root_meta_many():
def get_root_meta(obj):
return {'foo': 'meta-value'}
serializer = ResourceSerializer(many=True)
serializer.get_root_meta = get_root_meta
expected = {'foo': 'meta-value'}
assert JSONRenderer.extract_root_meta(serializer, {}, {}) == expected
def test_extract_meta():
serializer = ResourceSerializer(data={
"username": "******",
"version": "1.0.0"
})
serializer.is_valid()
expected = {
"version": "1.0.0",
}
assert JSONRenderer.extract_meta(serializer, serializer.data) == expected
def test_extract_root_meta_many():
def get_root_meta(obj):
return {
'foo': 'meta-value'
}
serializer = ResourceSerializer(many=True)
serializer.get_root_meta = get_root_meta
expected = {
'foo': 'meta-value'
}
assert JSONRenderer.extract_root_meta(serializer, {}, {}) == expected
def extract_relationships(fields, resource, resource_instance):
data = JSONRenderer.extract_relationships(fields, resource,
resource_instance)
# Do not alter RelationshipFields, which handle JSON API formatting
for field_name, field in six.iteritems(fields):
if isinstance(field, RelationshipField):
data.update({field_name: resource.get(field_name)})
# Remove embedded relationship data
for field in data:
if isinstance(field, RelationshipField):
ret = {}
for key in data[field]:
if key != 'data':
ret[key] = data[field][key]
data[field] = ret
return utils.format_keys(data)
def json(cls, *args, **kwargs):
"""Render a JSON POST request."""
serializer = cls.build(*args, **kwargs)
attributes = {}
relationships = {}
for key, value in serializer.initial_data.items():
if is_relation(value):
relationships[format_value(key)] = {"data": value}
else:
attributes[format_value(key)] = value
data = {"type": get_resource_type_from_serializer(serializer)}
if attributes:
data["attributes"] = attributes
if relationships:
data["relationships"] = relationships
return JSONRenderer().render({"data": data})
def build_json_resource_obj(fields, resource, resource_instance,
resource_name):
resource_data = [
('type', resource_name),
('id', encoding.force_text(resource_instance.pk)
if resource_instance else None),
('attributes', JSONRenderer.extract_attributes(fields, resource)),
]
# Use CustomJSONRenderer.extract_relationships, which removes embedded data
relationships = CustomJSONRenderer.extract_relationships(
fields, resource, resource_instance)
if relationships:
resource_data.append(('relationships', relationships))
# Add 'self' link if field is present and valid
if api_settings.URL_FIELD_NAME in resource and \
isinstance(fields[api_settings.URL_FIELD_NAME], relations.RelatedField):
resource_data.append(('links', {
'self': resource[api_settings.URL_FIELD_NAME]
}))
return OrderedDict(resource_data)
def test_build_json_resource_obj():
resource = {
'pk': 1,
'username': '******',
}
serializer = ResourceSerializer(data={'username': '******'})
serializer.is_valid()
resource_instance = serializer.save()
output = {
'type': 'user',
'id': '1',
'attributes': {
'username': '******'
},
}
assert JSONRenderer.build_json_resource_obj(
serializer.fields, resource, resource_instance, 'user') == output
def test_build_json_resource_obj():
resource = {
'pk': 1,
'username': '******',
}
serializer = ResourceSerializer(data={'username': '******'})
serializer.is_valid()
resource_instance = serializer.save()
output = {
'type': 'user',
'id': '1',
'attributes': {
'username': '******'
},
}
assert JSONRenderer.build_json_resource_obj(
serializer.fields, resource, resource_instance, 'user') == output
def test_build_json_resource_obj():
resource = {
"pk": 1,
"username": "******",
}
serializer = ResourceSerializer(data={"username": "******"})
serializer.is_valid()
resource_instance = serializer.save()
output = {
"type": "user",
"id": "1",
"attributes": {
"username": "******"
},
}
assert (JSONRenderer.build_json_resource_obj(serializer.fields, resource,
resource_instance,
"user") == output)
def test_extract_root_meta():
serializer = ExtractRootMetaResourceSerializer()
expected = {
'foo': 'meta-value',
}
assert JSONRenderer.extract_root_meta(serializer, {}) == expected
def test_extract_root_meta_many():
serializer = ExtractRootMetaResourceSerializer(many=True)
expected = {
'foo': 'meta-many-value'
}
assert JSONRenderer.extract_root_meta(serializer, {}) == expected
def test_extract_root_meta_invalid_meta():
serializer = InvalidExtractRootMetaResourceSerializer()
with pytest.raises(AssertionError):
JSONRenderer.extract_root_meta(serializer, {})
def render_dummy_test_serialized_view(view_class):
serializer = DummyTestSerializer(instance=Entry())
renderer = JSONRenderer()
return renderer.render(
serializer.data,
renderer_context={'view': view_class()})
def render_dummy_test_serialized_view(view_class, instance):
serializer = view_class.serializer_class(instance=instance)
renderer = JSONRenderer()
return renderer.render(serializer.data,
renderer_context={'view': view_class()})
def test_extract_root_meta():
serializer = ExtractRootMetaResourceSerializer()
expected = {
'foo': 'meta-value',
}
assert JSONRenderer.extract_root_meta(serializer, {}) == expected
def render_dummy_test_serialized_view(view_class, instance):
serializer = view_class.serializer_class(instance=instance)
renderer = JSONRenderer()
return renderer.render(
serializer.data,
renderer_context={'view': view_class()})
def test_extract_root_meta_many():
serializer = ExtractRootMetaResourceSerializer(many=True)
expected = {'foo': 'meta-many-value'}
assert JSONRenderer.extract_root_meta(serializer, {}) == expected
def render_dummy_test_serialized_view(view_class):
serializer = DummyTestSerializer(instance=Entry())
renderer = JSONRenderer()
return renderer.render(serializer.data,
renderer_context={'view': view_class()})
def test_extract_root_meta_invalid_meta():
serializer = InvalidExtractRootMetaResourceSerializer()
with pytest.raises(AssertionError):
JSONRenderer.extract_root_meta(serializer, {})
