def to_representation(self, data, envelope='data'):
if isinstance(data, AbstractNode):
if data.is_registration:
serializer = RegistrationSerializer(data, context=self.context)
return RegistrationSerializer.to_representation(serializer, data)
serializer = NodeSerializer(data, context=self.context)
return NodeSerializer.to_representation(serializer, data)
if isinstance(data, OSFUser):
serializer = UserSerializer(data, context=self.context)
return UserSerializer.to_representation(serializer, data)
if isinstance(data, BaseFileNode):
serializer = FileSerializer(data, context=self.context)
return FileSerializer.to_representation(serializer, data)
if isinstance(data, Institution):
serializer = InstitutionSerializer(data, context=self.context)
return InstitutionSerializer.to_representation(serializer, data)
if isinstance(data, CollectedGuidMetadata):
serializer = CollectedMetaSerializer(data, context=self.context)
return CollectedMetaSerializer.to_representation(serializer, data)
return None
def test_old_date_formats_to_old_format(self):
req = make_drf_request_with_version(version='2.0')
setattr(self.node, 'last_logged', self.old_date)
data = NodeSerializer(self.node, context={'request': req}).data['data']
assert_equal(
datetime.strftime(self.old_date,self.old_format),
data['attributes']['date_modified']
)
def test_new_date_without_microseconds_formats_to_new_format(self):
req = make_drf_request_with_version(version='2.2')
setattr(self.node, 'last_logged', self.new_date_without_microseconds)
data = NodeSerializer(self.node, context={'request': req}).data['data']
assert_equal(
datetime.strftime(self.new_date_without_microseconds,
self.new_format),
data['attributes']['date_modified'])
def to_representation(self, data, envelope='data'):
if isinstance(data, AbstractNode):
if data.is_registration:
serializer = RegistrationSerializer(data, context=self.context)
return RegistrationSerializer.to_representation(
serializer, data)
serializer = NodeSerializer(data, context=self.context)
return NodeSerializer.to_representation(serializer, data)
if isinstance(data, User):
serializer = UserSerializer(data, context=self.context)
return UserSerializer.to_representation(serializer, data)
if isinstance(data, FileNode):
serializer = FileSerializer(data, context=self.context)
return FileSerializer.to_representation(serializer, data)
return None
def test_fork_serialization(self):
node = NodeFactory(creator=self.user)
fork = node.fork_node(auth=Auth(user=node.creator))
result = NodeSerializer(fork, context={'request': make_drf_request()}).data
data = result['data']
# Relationships
relationships = data['relationships']
forked_from = relationships['forked_from']['links']['related']['href']
assert_equal(
urlparse(forked_from).path,
'/{}nodes/{}/'.format(API_BASE, node._id)
)
def test_template_serialization(self):
node = NodeFactory(creator=self.user)
fork = node.use_as_template(auth=Auth(user=node.creator))
req = make_drf_request_with_version(version='2.0')
result = NodeSerializer(fork, context={'request': req}).data
data = result['data']
# Relationships
relationships = data['relationships']
templated_from = relationships['template_node']['links']['related'][
'href']
assert_equal(
urlparse(templated_from).path,
'/{}nodes/{}/'.format(API_BASE, node._id))
def to_representation(self, data, envelope="data"):
if isinstance(data, Node):
if data.is_registration:
serializer = RegistrationSerializer(data, context=self.context)
return RegistrationSerializer.to_representation(serializer, data)
serializer = NodeSerializer(data, context=self.context)
return NodeSerializer.to_representation(serializer, data)
if isinstance(data, User):
serializer = UserSerializer(data, context=self.context)
return UserSerializer.to_representation(serializer, data)
if isinstance(data, FileNode):
serializer = FileSerializer(data, context=self.context)
return FileSerializer.to_representation(serializer, data)
return None
def test_node_serialization(self):
parent = ProjectFactory(creator=self.user)
node = NodeFactory(creator=self.user, parent=parent)
req = make_drf_request_with_version(version='2.0')
result = NodeSerializer(node, context={'request': req}).data
data = result['data']
assert_equal(data['id'], node._id)
assert_equal(data['type'], 'nodes')
# Attributes
attributes = data['attributes']
assert_equal(attributes['title'], node.title)
assert_equal(attributes['description'], node.description)
assert_equal(attributes['public'], node.is_public)
assert_equal(attributes['tags'],
[str(each.name) for each in node.tags.all()])
assert_equal(attributes['current_user_can_comment'], False)
assert_equal(attributes['category'], node.category)
assert_equal(attributes['registration'], node.is_registration)
assert_equal(attributes['fork'], node.is_fork)
assert_equal(attributes['collection'], node.is_collection)
# Relationships
relationships = data['relationships']
assert_in('children', relationships)
assert_in('contributors', relationships)
assert_in('files', relationships)
assert_in('parent', relationships)
assert_in('affiliated_institutions', relationships)
parent_link = relationships['parent']['links']['related']['href']
assert_equal(
urlparse(parent_link).path,
'/{}nodes/{}/'.format(API_BASE, parent._id))
assert_in('registrations', relationships)
# Not a fork, so forked_from is removed entirely
assert_not_in('forked_from', relationships)
def get_current_user_permissions(self, obj):
return NodeSerializer.get_current_user_permissions(self, obj)
def test_node_links_bad_version_node_serializer(self):
req = make_drf_request_with_version(version='2.1')
data = NodeSerializer(self.node, context={'request': req}).data['data']
assert_not_in('node_links', data['relationships'])
def get_current_user_permissions(self, obj):
return NodeSerializer.get_current_user_permissions(self, obj)
def test_node_serializer(self, user):
# test_node_serialization
parent = ProjectFactory(creator=user)
node = NodeFactory(creator=user, parent=parent)
req = make_drf_request_with_version(version='2.0')
result = NodeSerializer(node, context={'request': req}).data
data = result['data']
assert data['id'] == node._id
assert data['type'] == 'nodes'
# Attributes
attributes = data['attributes']
assert attributes['title'] == node.title
assert attributes['description'] == node.description
assert attributes['public'] == node.is_public
assert set(attributes['tags']) == set(
node.tags.values_list('name', flat=True))
assert not attributes['current_user_can_comment']
assert attributes['category'] == node.category
assert attributes['registration'] == node.is_registration
assert attributes['fork'] == node.is_fork
assert attributes['collection'] == node.is_collection
# Relationships
relationships = data['relationships']
assert 'children' in relationships
assert 'contributors' in relationships
assert 'files' in relationships
assert 'parent' in relationships
assert 'affiliated_institutions' in relationships
assert 'registrations' in relationships
# Not a fork, so forked_from is removed entirely
assert 'forked_from' not in relationships
parent_link = relationships['parent']['links']['related']['href']
assert urlparse(parent_link).path == '/{}nodes/{}/'.format(
API_BASE, parent._id)
# test_fork_serialization
node = NodeFactory(creator=user)
fork = node.fork_node(auth=Auth(user))
req = make_drf_request_with_version(version='2.0')
result = NodeSerializer(fork, context={'request': req}).data
data = result['data']
# Relationships
relationships = data['relationships']
forked_from = relationships['forked_from']['links']['related']['href']
assert urlparse(forked_from).path == '/{}nodes/{}/'.format(
API_BASE, node._id)
# test_template_serialization
node = NodeFactory(creator=user)
fork = node.use_as_template(auth=Auth(user))
req = make_drf_request_with_version(version='2.0')
result = NodeSerializer(fork, context={'request': req}).data
data = result['data']
# Relationships
relationships = data['relationships']
templated_from = relationships['template_node']['links']['related'][
'href']
assert urlparse(templated_from).path == '/{}nodes/{}/'.format(
API_BASE, node._id)
