def node_with_abstract(self, user):
node_with_abstract = NodeFactory(title='Sambolera', creator=user, is_public=True)
node_with_abstract.set_description(
'Sambolera by Khadja Nin',
auth=Auth(user),
save=True)
return node_with_abstract
def test_fork_reverts_to_using_user_storage_default(self):
user = UserFactory()
user2 = UserFactory()
us = RegionFactory()
canada = RegionFactory()
user_settings = user.get_addon('osfstorage')
user_settings.default_region = us
user_settings.save()
user2_settings = user2.get_addon('osfstorage')
user2_settings.default_region = canada
user2_settings.save()
project = ProjectFactory(creator=user, is_public=True)
child = NodeFactory(parent=project, creator=user, is_public=True)
child_settings = child.get_addon('osfstorage')
child_settings.region_id = canada.id
child_settings.save()
fork = project.fork_node(Auth(user))
child_fork = models.Node.objects.get_children(fork).first()
assert fork.get_addon('osfstorage').region_id == us.id
assert fork.get_addon('osfstorage').user_settings == user.get_addon('osfstorage')
assert child_fork.get_addon('osfstorage').region_id == us.id
fork = project.fork_node(Auth(user2))
child_fork = models.Node.objects.get_children(fork).first()
assert fork.get_addon('osfstorage').region_id == canada.id
assert fork.get_addon('osfstorage').user_settings == user2.get_addon('osfstorage')
assert child_fork.get_addon('osfstorage').region_id == canada.id
def test__initiate_embargo_adds_admins_on_child_nodes(self):
project_admin = UserFactory()
project_non_admin = UserFactory()
child_admin = UserFactory()
child_non_admin = UserFactory()
grandchild_admin = UserFactory()
project = ProjectFactory(creator=project_admin)
project.add_contributor(project_non_admin, auth=Auth(project.creator), save=True)
child = NodeFactory(creator=child_admin, parent=project)
child.add_contributor(child_non_admin, auth=Auth(child.creator), save=True)
grandchild = NodeFactory(creator=grandchild_admin, parent=child) # noqa
registration = RegistrationFactory(project=project)
embargo = registration._initiate_embargo(
project.creator,
self.valid_embargo_end_date,
for_existing_registration=True
)
assert_in(project_admin._id, embargo.approval_state)
assert_in(child_admin._id, embargo.approval_state)
assert_in(grandchild_admin._id, embargo.approval_state)
assert_not_in(project_non_admin._id, embargo.approval_state)
assert_not_in(child_non_admin._id, embargo.approval_state)
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 attributes['tags'] == [str(each.name) for each in node.tags.all()]
assert attributes['current_user_can_comment'] == False
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)
def test_is_current_with_single_version(self):
node = NodeFactory()
page = NodeWikiPage(page_name='foo', node=node)
page.save()
node.wiki_pages_current['foo'] = page._id
node.wiki_pages_versions['foo'] = [page._id]
node.save()
assert page.is_current is True
def test_get_nodes_deleted_component(self):
node = NodeFactory(creator=self.project.creator, parent=self.project)
node.is_deleted = True
collector = rubeus.NodeFileCollector(
self.project, Auth(user=UserFactory())
)
nodes = collector._get_nodes(self.project)
assert_equal(len(nodes['children']), 0)
def test_collect_components_deleted(self):
node = NodeFactory(creator=self.project.creator, parent=self.project)
node.is_deleted = True
collector = rubeus.NodeFileCollector(
self.project, Auth(user=UserFactory())
)
nodes = collector._collect_components(self.project, visited=[])
assert_equal(len(nodes), 0)
def child_node_two(self, user, parent_project, institution):
child_node_two = NodeFactory(
parent=parent_project,
creator=user,
is_public=True)
child_node_two.affiliated_institutions.add(institution)
child_node_two.save()
return child_node_two
def great_grandchild_node_two(
self, user, grandchild_node_two,
institution
):
great_grandchild_node_two = NodeFactory(
parent=grandchild_node_two, creator=user, is_public=True)
great_grandchild_node_two.affiliated_institutions.add(institution)
great_grandchild_node_two.save()
return great_grandchild_node_two
def test_serialize_node_search_returns_only_visible_contributors(self):
node = NodeFactory()
non_visible_contributor = UserFactory()
node.add_contributor(non_visible_contributor, visible=False)
serialized_node = _serialize_node_search(node)
assert_equal(serialized_node['firstAuthor'], node.visible_contributors[0].family_name)
assert_equal(len(node.visible_contributors), 1)
assert_false(serialized_node['etal'])
class TestValidProject(OsfTestCase):
def setUp(self):
super(TestValidProject, self).setUp()
self.project = ProjectFactory()
self.node = NodeFactory()
self.auth = Auth(user=self.project.creator)
def test_populates_kwargs_node(self):
res = valid_project_helper(pid=self.project._id)
assert_equal(res['node'], self.project)
assert_is_none(res['parent'])
def test_populates_kwargs_node_and_parent(self):
res = valid_project_helper(pid=self.project._id, nid=self.node._id)
assert_equal(res['parent'], self.project)
assert_equal(res['node'], self.node)
def test_project_not_found(self):
with assert_raises(HTTPError) as exc_info:
valid_project_helper(pid='fakepid')
assert_equal(exc_info.exception.code, 404)
def test_project_deleted(self):
self.project.is_deleted = True
self.project.save()
with assert_raises(HTTPError) as exc_info:
valid_project_helper(pid=self.project._id)
assert_equal(exc_info.exception.code, 410)
def test_node_not_found(self):
with assert_raises(HTTPError) as exc_info:
valid_project_helper(pid=self.project._id, nid='fakenid')
assert_equal(exc_info.exception.code, 404)
def test_node_deleted(self):
self.node.is_deleted = True
self.node.save()
with assert_raises(HTTPError) as exc_info:
valid_project_helper(pid=self.project._id, nid=self.node._id)
assert_equal(exc_info.exception.code, 410)
def test_valid_project_as_factory_allow_retractions_is_retracted(self):
registration = RegistrationFactory(project=self.project)
registration.retraction = RetractionFactory()
registration.retraction.state = Sanction.UNAPPROVED
registration.retraction.save()
res = as_factory_allow_retractions(pid=registration._id)
assert_equal(res['node'], registration)
def test_collection_guid_not_found(self):
collection = CollectionFactory()
collection.collect_object(self.project, self.auth.user)
with assert_raises(HTTPError) as exc_info:
valid_project_helper(pid=collection._id, nid=collection._id)
assert_equal(exc_info.exception.code, 404)
def test_serialize_deleted(self):
node = NodeFactory()
info = serialize_node(node)
assert_false(info['deleted'])
node.is_deleted = True
info = serialize_node(node)
assert_true(info['deleted'])
node.is_deleted = False
info = serialize_node(node)
assert_false(info['deleted'])
def test_affiliated_component_with_affiliated_parent_not_returned(self, app, user, institution, public_node, institution_node_url):
# version < 2.2
component = NodeFactory(parent=public_node, is_public=True)
component.affiliated_institutions.add(institution)
component.save()
res = app.get(institution_node_url, auth=user.auth)
affiliated_node_ids = [node['id'] for node in res.json['data']]
assert res.status_code == 200
assert public_node._id in affiliated_node_ids
assert component._id not in affiliated_node_ids
def test_user_is_admin(self):
node = NodeFactory(creator=self.user)
res = self.app.post_json_api(
self.institution_nodes_url,
self.create_payload(node._id),
auth=self.user.auth
)
assert_equal(res.status_code, 201)
node.reload()
assert_in(self.institution, node.affiliated_institutions.all())
def test_a_public_component_from_home_page(self):
component = NodeFactory(title='Foobar Component', is_public=True)
# Searches a part of the name
res = self.app.get('/').maybe_follow()
component.reload()
form = res.forms['searchBar']
form['q'] = 'Foobar'
res = form.submit().maybe_follow()
# A link to the component is shown as a result
assert_in('Foobar Component', res)
def test_email_not_sent_to_parent_admins_on_submit(self, mock_mail, app, project, noncontrib, url, create_payload, second_admin):
component = NodeFactory(parent=project, creator=second_admin)
component.is_public = True
project.save()
url = '/{}nodes/{}/requests/'.format(API_BASE, component._id)
res = app.post_json_api(url, create_payload, auth=noncontrib.auth)
assert res.status_code == 201
assert component.admin_contributors.count() == 2
assert component.contributors.count() == 1
assert mock_mail.call_count == 1
def test_is_current_with_multiple_versions(self):
node = NodeFactory()
ver1 = NodeWikiPage(page_name='foo', node=node)
ver2 = NodeWikiPage(page_name='foo', node=node)
ver1.save()
ver2.save()
node.wiki_pages_current['foo'] = ver2._id
node.wiki_pages_versions['foo'] = [ver1._id, ver2._id]
node.save()
assert ver1.is_current is False
assert ver2.is_current is True
def test_affiliated_component_without_affiliated_parent_returned(self, app, user, institution, public_node, institution_node_url):
# version 2.2
node = ProjectFactory(is_public=True)
component = NodeFactory(parent=node, is_public=True)
component.affiliated_institutions.add(institution)
component.save()
url = '{}?version=2.2'.format(institution_node_url)
res = app.get(url, auth=user.auth)
affiliated_node_ids = [item['id'] for item in res.json['data']]
assert res.status_code == 200
assert node._id not in affiliated_node_ids
assert component._id in affiliated_node_ids
def test_serialize_node_for_logs(self):
node = NodeFactory()
d = node.serialize()
assert_equal(d['id'], node._primary_key)
assert_equal(d['category'], node.category_display)
assert_equal(d['node_type'], node.project_or_component)
assert_equal(d['url'], node.url)
assert_equal(d['title'], node.title)
assert_equal(d['api_url'], node.api_url)
assert_equal(d['is_public'], node.is_public)
assert_equal(d['is_registration'], node.is_registration)
def test_user_does_not_have_node(self):
node = NodeFactory()
res = self.app.post_json_api(
self.institution_nodes_url,
self.create_payload(node._id),
expect_errors=True,
auth=self.user.auth
)
assert_equal(res.status_code, 403)
node.reload()
assert_not_in(self.institution, node.affiliated_institutions.all())
def test_swapping_guids(self):
user = UserFactory()
node = NodeFactory()
user_guid = user.guids[0]
node_guid = node.guids[0]
user._id = node_guid._id
node._id = user_guid._id
assert node_guid._id == user._id
assert user_guid._id == node._id
def component_public(self, user_two, project_public):
component_public = NodeFactory(
parent=project_public,
title='Ultralight Beam',
creator=user_two,
is_public=True)
component_public.set_description(
'This is my part, nobody else speak',
auth=Auth(user_two),
save=True)
component_public.add_tag('trumpets', auth=Auth(user_two), save=True)
return component_public
def test_new_draft_registration_POST(self):
target = NodeFactory(creator=self.user)
payload = {
'schema_name': self.meta_schema.name,
'schema_version': self.meta_schema.schema_version
}
url = target.web_url_for('new_draft_registration')
res = self.app.post(url, payload, auth=self.user.auth)
assert_equal(res.status_code, http.FOUND)
target.reload()
draft = DraftRegistration.objects.get(branched_from=target)
assert_equal(draft.registration_schema, self.meta_schema)
def test_user_is_admin_but_not_affiliated(
self, app, url_institution_nodes, institution):
user = AuthUserFactory()
node = NodeFactory(creator=user)
res = app.post_json_api(
url_institution_nodes,
make_payload(node._id),
expect_errors=True, auth=user.auth
)
assert res.status_code == 403
node.reload()
assert institution not in node.affiliated_institutions.all()
def test_user_is_admin_but_not_affiliated(self):
user = AuthUserFactory()
node = NodeFactory(creator=user)
res = self.app.post_json_api(
self.institution_nodes_url,
self.create_payload(node._id),
expect_errors=True,
auth=user.auth
)
assert_equal(res.status_code, 403)
node.reload()
assert_not_in(self.institution, node.affiliated_institutions.all())
def child_node_one(
self, user, parent_project,
institution, parent_project_one
):
child_node_one = NodeFactory(
parent=parent_project,
title='Friend of {}'.format(
parent_project_one._id),
creator=user,
is_public=True)
child_node_one.affiliated_institutions.add(institution)
child_node_one.save()
return child_node_one
def test_user_with_nodes_and_permissions(self):
node = NodeFactory(creator=self.user)
res = self.app.post_json_api(
self.institution_nodes_url,
self.create_payload(node._id),
auth=self.user.auth
)
assert_equal(res.status_code, 201)
node_ids = [node_['id'] for node_ in res.json['data']]
assert_in(node._id, node_ids)
node.reload()
assert_in(self.institution, node.affiliated_institutions.all())
def test_only_add_existent_with_permissions(self):
node = NodeFactory(creator=self.user)
node.affiliated_institutions.add(self.institution)
node.save()
assert_in(self.institution, self.node1.affiliated_institutions.all())
assert_in(self.institution, node.affiliated_institutions.all())
res = self.app.post_json_api(
self.institution_nodes_url,
self.create_payload(node._id, self.node1._id),
auth=self.user.auth
)
assert_equal(res.status_code, 204)
def setUp(self):
super(TestNodeLinkedNodes, self).setUp()
self.user = AuthUserFactory()
self.auth = Auth(self.user)
self.linking_node = NodeFactory(creator=self.user)
self.linked_node = NodeFactory(creator=self.user)
self.linked_node2 = NodeFactory(creator=self.user)
self.public_node = NodeFactory(is_public=True, creator=self.user)
self.linking_node.add_pointer(self.linked_node, auth=self.auth)
self.linking_node.add_pointer(self.linked_node2, auth=self.auth)
self.linking_node.add_pointer(self.public_node, auth=self.auth)
self.linking_node.save()
self.url = '/{}nodes/{}/linked_nodes/'.format(API_BASE, self.linking_node._id)
self.node_ids = self.linking_node.linked_nodes.values_list('guids___id', flat=True)
def test_add_some_existant_others_not(self):
assert_in(self.institution, self.node1.affiliated_institutions.all())
node = NodeFactory(creator=self.user)
res = self.app.post_json_api(
self.institution_nodes_url,
self.create_payload(node._id, self.node1._id),
auth=self.user.auth
)
assert_equal(res.status_code, 201)
node.reload()
self.node1.reload()
assert_in(self.institution, self.node1.affiliated_institutions.all())
assert_in(self.institution, node.affiliated_institutions.all())
def node_two(self, user):
return NodeFactory(creator=user)
def node_private(self, user):
return NodeFactory(title='Classified', creator=user)
def node_one(self, user):
return NodeFactory(title='Ismael Lo: Tajabone', creator=user, is_public=True)
def other_node(self):
return NodeFactory()
def node_with_file(self):
node = NodeFactory()
file = create_test_file(node, node.creator)
file.save()
node.save()
return node
def child_node_one(self, user, parent_project, parent_project_one):
return NodeFactory(parent=parent_project,
title='Friend of {}'.format(parent_project_one._id),
creator=user)
def public_node(self, user):
return NodeFactory(is_public=True, creator=user)
def project(self, submitter):
return NodeFactory(creator=submitter)
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 attributes['tags'] == [
str(each.name) for each in node.tags.all()
]
assert attributes['current_user_can_comment'] == False
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)
def project_two(self):
return NodeFactory()
def resource(self, user):
return NodeFactory(creator=user, is_public=True)
class TestComponents(OsfTestCase):
def setUp(self):
super(TestComponents, self).setUp()
self.user = AuthUserFactory()
self.consolidate_auth = Auth(user=self.user)
self.project = ProjectFactory(creator=self.user)
self.project.add_contributor(contributor=self.user,
auth=self.consolidate_auth)
# A non-project componenet
self.component = NodeFactory(
category='hypothesis',
creator=self.user,
parent=self.project,
)
self.component.save()
self.component.set_privacy('public', self.consolidate_auth)
self.component.set_privacy('private', self.consolidate_auth)
self.project.save()
self.project_url = self.project.web_url_for('view_project')
def test_sees_parent(self):
res = self.app.get(self.component.url,
auth=self.user.auth).maybe_follow()
parent_title = res.html.find_all('h2', class_='node-parent-title')
assert_equal(len(parent_title), 1)
assert_in(self.project.title,
parent_title[0].text) # Bs4 will handle unescaping HTML here
def test_delete_project(self):
res = self.app.get(self.component.url + 'settings/',
auth=self.user.auth).maybe_follow()
assert_in('Delete {0}'.format(self.component.project_or_component),
res)
def test_cant_delete_project_if_not_admin(self):
non_admin = AuthUserFactory()
self.component.add_contributor(
non_admin,
permissions=['read', 'write'],
auth=self.consolidate_auth,
save=True,
)
res = self.app.get(self.component.url + 'settings/',
auth=non_admin.auth).maybe_follow()
assert_not_in('Delete {0}'.format(self.component.project_or_component),
res)
def test_can_configure_comments_if_admin(self):
res = self.app.get(
self.component.url + 'settings/',
auth=self.user.auth,
).maybe_follow()
assert_in('Commenting', res)
def test_cant_configure_comments_if_not_admin(self):
non_admin = AuthUserFactory()
self.component.add_contributor(
non_admin,
permissions=['read', 'write'],
auth=self.consolidate_auth,
save=True,
)
res = self.app.get(self.component.url + 'settings/',
auth=non_admin.auth).maybe_follow()
assert_not_in('Commenting', res)
def test_components_should_have_component_list(self):
res = self.app.get(self.component.url, auth=self.user.auth)
assert_in('Components', res)
def contributor_node(self, user, contributor):
contributor_node = NodeFactory(creator=contributor)
contributor_node.add_contributor(user, auth=Auth(contributor))
contributor_node.save()
return contributor_node
def child_node_two(self, user, parent_project):
return NodeFactory(parent=parent_project,
title='Lait Cafe au Choco',
creator=user)
def public_node(self):
return NodeFactory(is_public=True)
def grandchild_node_one(self, user, child_node_one):
return NodeFactory(parent=child_node_one, creator=user)
def private_node_two(self, user):
return NodeFactory(creator=user)
def great_grandchild_node_two(self, user, grandchild_node_two):
return NodeFactory(parent=grandchild_node_two, creator=user)
def admin_node(self, user):
return NodeFactory(creator=user)
def node_admin(self, user):
return NodeFactory(creator=user)
def node(self, greg):
return NodeFactory(creator=greg)
def node_contrib(self, user, user_two):
node_contrib = NodeFactory(creator=user_two)
node_contrib.add_contributor(user, auth=Auth(user_two))
node_contrib.save()
return node_contrib
def node_two(self, user):
return NodeFactory(title='Sambolera', creator=user, is_public=True)
def node_other(self):
return NodeFactory()
def component_private(self, user_one, project_public):
return NodeFactory(
parent=project_public,
description='',
title='Wavves',
creator=user_one)
def node_private(self, user):
return NodeFactory(creator=user)
def node_one(self, institution):
node_one = NodeFactory(is_public=True)
node_one.affiliated_institutions.add(institution)
node_one.save()
return node_one
def linking_node_source(self, user, auth, private_node, admin_node):
linking_node_source = NodeFactory(creator=user)
linking_node_source.add_pointer(private_node, auth=auth)
linking_node_source.add_pointer(admin_node, auth=auth)
return linking_node_source
def setUp(self):
super(TestResolveGuid, self).setUp()
self.node = NodeFactory()
class TestResolveGuid(OsfTestCase):
def setUp(self):
super(TestResolveGuid, self).setUp()
self.node = NodeFactory()
def test_resolve_guid(self):
res_guid = self.app.get(self.node.web_url_for('node_setting', _guid=True), auth=self.node.creator.auth)
res_full = self.app.get(self.node.web_url_for('node_setting'), auth=self.node.creator.auth)
assert res_guid.text == res_full.text
def test_resolve_guid_no_referent(self):
guid = Guid.load(self.node._id)
guid.referent = None
guid.save()
res = self.app.get(
self.node.web_url_for('node_setting', _guid=True),
auth=self.node.creator.auth,
expect_errors=True,
)
assert res.status_code == 404
@mock.patch('osf.models.node.Node.deep_url', None)
def test_resolve_guid_no_url(self):
res = self.app.get(
self.node.web_url_for('node_setting', _guid=True),
auth=self.node.creator.auth,
expect_errors=True,
)
assert res.status_code == 404
def test_resolve_guid_download_file(self):
pp = PreprintFactory(finish=True)
res = self.app.get(pp.url + 'download')
assert res.status_code == 302
assert '{}/v1/resources/{}/providers/{}{}?action=download&version=1&direct'.format(WATERBUTLER_URL, pp._id, pp.primary_file.provider, pp.primary_file.path) in res.location
res = self.app.get(pp.url + 'download/')
assert res.status_code == 302
assert '{}/v1/resources/{}/providers/{}{}?action=download&version=1&direct'.format(WATERBUTLER_URL, pp._id, pp.primary_file.provider, pp.primary_file.path) in res.location
res = self.app.get('/{}/download'.format(pp.primary_file.get_guid(create=True)._id))
assert res.status_code == 302
assert '{}/v1/resources/{}/providers/{}{}?action=download&version=1&direct'.format(WATERBUTLER_URL, pp._id, pp.primary_file.provider, pp.primary_file.path) in res.location
pp.primary_file.create_version(
creator=pp.creator,
location={u'folder': u'osf', u'object': u'deadbe', u'service': u'cloud'},
metadata={u'contentType': u'img/png', u'size': 9001}
)
pp.primary_file.save()
res = self.app.get(pp.url + 'download/')
assert res.status_code == 302
assert '{}/v1/resources/{}/providers/{}{}?action=download&version=2&direct'.format(WATERBUTLER_URL, pp._id, pp.primary_file.provider, pp.primary_file.path) in res.location
res = self.app.get(pp.url + 'download/?version=1')
assert res.status_code == 302
assert '{}/v1/resources/{}/providers/{}{}?action=download&version=1&direct'.format(WATERBUTLER_URL, pp._id, pp.primary_file.provider, pp.primary_file.path) in res.location
unpub_pp = PreprintFactory(project=self.node, is_published=False)
res = self.app.get(unpub_pp.url + 'download/?version=1', auth=unpub_pp.creator.auth)
assert res.status_code == 302
assert '{}/v1/resources/{}/providers/{}{}?action=download&version=1&direct'.format(WATERBUTLER_URL, unpub_pp._id, unpub_pp.primary_file.provider, unpub_pp.primary_file.path) in res.location
@mock.patch('website.settings.USE_EXTERNAL_EMBER', True)
@mock.patch('website.settings.EXTERNAL_EMBER_APPS', {
'preprints': {
'server': 'http://*****:*****@mock.patch('website.settings.USE_EXTERNAL_EMBER', True)
@mock.patch('website.settings.EXTERNAL_EMBER_APPS', {
'preprints': {
'server': 'http://localhost:4200',
'path': '/preprints/'
},
})
def test_resolve_guid_download_file_from_emberapp_preprints_unpublished(self):
# non-branded domains
provider = PreprintProviderFactory(_id='sockarxiv', name='Sockarxiv', reviews_workflow='pre-moderation')
# branded domains
branded_provider = PreprintProviderFactory(_id='spot', name='Spotarxiv', reviews_workflow='pre-moderation')
branded_provider.allow_submissions = False
branded_provider.domain = 'https://www.spotarxiv.com'
branded_provider.description = 'spots not dots'
branded_provider.domain_redirect_enabled = True
branded_provider.share_publish_type = 'Thesis'
branded_provider.save()
# test_provider_submitter_can_download_unpublished
submitter = AuthUserFactory()
pp = PreprintFactory(finish=True, provider=provider, is_published=False, creator=submitter)
pp.run_submit(submitter)
pp_branded = PreprintFactory(finish=True, provider=branded_provider, is_published=False, filename='preprint_file_two.txt', creator=submitter)
pp_branded.run_submit(submitter)
res = self.app.get('{}download'.format(pp.url), auth=submitter.auth)
assert res.status_code == 302
assert '{}/v1/resources/{}/providers/{}{}?action=download&version=1&direct'.format(WATERBUTLER_URL, pp._id, pp.primary_file.provider, pp.primary_file.path) in res.location
res = self.app.get('{}download'.format(pp_branded.url), auth=submitter.auth)
assert res.status_code == 302
# test_provider_super_user_can_download_unpublished
super_user = AuthUserFactory()
super_user.is_superuser = True
super_user.save()
res = self.app.get('{}download'.format(pp.url), auth=super_user.auth)
assert res.status_code == 302
assert '{}/v1/resources/{}/providers/{}{}?action=download&version=1&direct'.format(WATERBUTLER_URL, pp._id, pp.primary_file.provider, pp.primary_file.path) in res.location
res = self.app.get('{}download'.format(pp_branded.url), auth=super_user.auth)
assert res.status_code == 302
# test_provider_moderator_can_download_unpublished
moderator = AuthUserFactory()
provider.add_to_group(moderator, 'moderator')
provider.save()
res = self.app.get('{}download'.format(pp.url), auth=moderator.auth)
assert res.status_code == 302
assert '{}/v1/resources/{}/providers/{}{}?action=download&version=1&direct'.format(WATERBUTLER_URL, pp._id, pp.primary_file.provider, pp.primary_file.path) in res.location
branded_provider.add_to_group(moderator, 'moderator')
branded_provider.save()
res = self.app.get('{}download'.format(pp_branded.url), auth=moderator.auth)
assert res.status_code == 302
# test_provider_admin_can_download_unpublished
admin = AuthUserFactory()
provider.add_to_group(admin, ADMIN)
provider.save()
res = self.app.get('{}download'.format(pp.url), auth=admin.auth)
assert res.status_code == 302
assert '{}/v1/resources/{}/providers/{}{}?action=download&version=1&direct'.format(WATERBUTLER_URL, pp._id, pp.primary_file.provider, pp.primary_file.path) in res.location
branded_provider.add_to_group(admin, ADMIN)
branded_provider.save()
res = self.app.get('{}download'.format(pp_branded.url), auth=admin.auth)
assert res.status_code == 302
def test_resolve_guid_download_file_export(self):
pp = PreprintFactory(finish=True)
res = self.app.get(pp.url + 'download?format=asdf')
assert res.status_code == 302
assert '{}/export?format=asdf&url='.format(MFR_SERVER_URL) in res.location
assert '{}/v1/resources/{}/providers/{}{}%3Faction%3Ddownload'.format(quote(WATERBUTLER_URL), pp._id, pp.primary_file.provider, pp.primary_file.path) in res.location
res = self.app.get(pp.url + 'download/?format=asdf')
assert res.status_code == 302
assert '{}/export?format=asdf&url='.format(MFR_SERVER_URL) in res.location
assert '{}/v1/resources/{}/providers/{}{}%3Faction%3Ddownload'.format(quote(WATERBUTLER_URL), pp._id, pp.primary_file.provider, pp.primary_file.path) in res.location
res = self.app.get('/{}/download?format=asdf'.format(pp.primary_file.get_guid(create=True)._id))
assert res.status_code == 302
assert '{}/export?format=asdf&url='.format(MFR_SERVER_URL) in res.location
assert '{}/v1/resources/{}/providers/{}{}%3Faction%3Ddownload'.format(quote(WATERBUTLER_URL), pp._id, pp.primary_file.provider, pp.primary_file.path) in res.location
res = self.app.get('/{}/download/?format=asdf'.format(pp.primary_file.get_guid(create=True)._id))
assert res.status_code == 302
assert '{}/export?format=asdf&url='.format(MFR_SERVER_URL) in res.location
assert '{}/v1/resources/{}/providers/{}{}%3Faction%3Ddownload'.format(quote(WATERBUTLER_URL), pp._id, pp.primary_file.provider, pp.primary_file.path) in res.location
pp.primary_file.create_version(
creator=pp.creator,
location={u'folder': u'osf', u'object': u'deadbe', u'service': u'cloud'},
metadata={u'contentType': u'img/png', u'size': 9001}
)
pp.primary_file.save()
res = self.app.get(pp.url + 'download/?format=asdf')
assert res.status_code == 302
assert '{}/export?format=asdf&url='.format(MFR_SERVER_URL) in res.location
assert '{}/v1/resources/{}/providers/{}{}%3F'.format(quote(WATERBUTLER_URL), pp._id, pp.primary_file.provider, pp.primary_file.path) in res.location
quarams = res.location.split('%3F')[1].split('%26')
assert 'action%3Ddownload' in quarams
assert 'version%3D2' in quarams
assert 'direct' in quarams
res = self.app.get(pp.url + 'download/?format=asdf&version=1')
assert res.status_code == 302
assert '{}/export?format=asdf&url='.format(MFR_SERVER_URL) in res.location
assert '{}/v1/resources/{}/providers/{}{}%3F'.format(quote(WATERBUTLER_URL), pp._id, pp.primary_file.provider, pp.primary_file.path) in res.location
quarams = res.location.split('%3F')[1].split('%26')
assert 'action%3Ddownload' in quarams
assert 'version%3D1' in quarams
assert 'direct' in quarams
unpub_pp = PreprintFactory(project=self.node, is_published=False)
res = self.app.get(unpub_pp.url + 'download?format=asdf', auth=unpub_pp.creator.auth)
assert res.status_code == 302
assert res.status_code == 302
assert '{}/export?format=asdf&url='.format(MFR_SERVER_URL) in res.location
assert '{}/v1/resources/{}/providers/{}{}%3F'.format(quote(WATERBUTLER_URL), unpub_pp._id, unpub_pp.primary_file.provider, unpub_pp.primary_file.path) in res.location
quarams = res.location.split('%3F')[1].split('%26')
assert 'action%3Ddownload' in quarams
assert 'version%3D1' in quarams
assert 'direct' in quarams
def test_resolve_guid_download_file_export_same_format_optimization(self):
pp = PreprintFactory(filename='test.pdf', finish=True)
res = self.app.get(pp.url + 'download/?format=pdf')
assert res.status_code == 302
assert '{}/export?'.format(MFR_SERVER_URL) not in res.location
assert '{}/v1/resources/{}/providers/{}{}?action=download&version=1&direct'.format(WATERBUTLER_URL, pp._id, pp.primary_file.provider, pp.primary_file.path) in res.location
def test_resolve_guid_download_errors(self):
testfile = TestFile.get_or_create(self.node, 'folder/path')
testfile.name = 'asdf'
testfile.materialized_path = '/folder/path'
guid = testfile.get_guid(create=True)
testfile.save()
testfile.delete()
res = self.app.get('/{}/download'.format(guid), expect_errors=True)
assert res.status_code == 404
pp = PreprintFactory(is_published=False)
res = self.app.get(pp.url + 'download', expect_errors=True)
assert res.status_code == 404
pp.is_published = True
pp.save()
pp.is_public = False
pp.save()
non_contrib = AuthUserFactory()
res = self.app.get(pp.url + 'download', auth=non_contrib.auth, expect_errors=True)
assert res.status_code == 403
pp.deleted = timezone.now()
pp.save()
res = self.app.get(pp.url + 'download', auth=non_contrib.auth, expect_errors=True)
assert res.status_code == 410
