def provider_two():
provider = PreprintProviderFactory(name='Spotarxiv')
provider.allow_submissions = False
provider.domain = 'https://www.spotarxiv.com'
provider.description = 'spots not dots'
provider.domain_redirect_enabled = True
provider._id = 'spot'
provider.share_publish_type = 'Thesis'
provider.save()
return provider
def preprint():
node_license = NodeLicense.objects.get(name='CC-By Attribution 4.0 International')
user = AuthUserFactory()
provider = PreprintProviderFactory()
provider.doi_prefix = '10.31219'
provider.save()
license_details = {
'id': node_license.license_id,
'year': '2017',
'copyrightHolders': ['Jeff Hardy', 'Matt Hardy']
}
preprint = PreprintFactory(provider=provider, article_doi='10.31219/FK2osf.io/test!', is_published=True, license_details=license_details)
preprint.license.node_license.url = 'https://creativecommons.org/licenses/by/4.0/legalcode'
return preprint
def setUp(self):
super(TestOnPreprintUpdatedTask, self).setUp()
self.user = AuthUserFactory()
if len(self.user.fullname.split(' ')) > 2:
# Prevent unexpected keys ('suffix', 'additional_name')
self.user.fullname = 'David Davidson'
self.user.middle_names = ''
self.user.suffix = ''
self.user.save()
self.auth = Auth(user=self.user)
self.preprint = PreprintFactory()
thesis_provider = PreprintProviderFactory(share_publish_type='Thesis')
self.thesis = PreprintFactory(provider=thesis_provider)
for pp in [self.preprint, self.thesis]:
pp.node.add_tag('preprint', self.auth, save=False)
pp.node.add_tag('spoderman', self.auth, save=False)
pp.node.add_unregistered_contributor('BoJack Horseman',
'*****@*****.**',
Auth(pp.node.creator))
pp.node.add_contributor(self.user, visible=False)
pp.node.save()
pp.node.creator.given_name = u'ZZYZ'
if len(pp.node.creator.fullname.split(' ')) > 2:
# Prevent unexpected keys ('suffix', 'additional_name')
pp.node.creator.fullname = 'David Davidson'
pp.node.creator.middle_names = ''
pp.node.creator.suffix = ''
pp.node.creator.save()
pp.set_subjects([[SubjectFactory()._id]],
auth=Auth(pp.node.creator))
def create_fake_project(creator, n_users, privacy, n_components, name, n_tags,
presentation_name, is_registration, is_preprint,
preprint_provider):
auth = Auth(user=creator)
project_title = name if name else fake.science_sentence()
if is_preprint:
provider = None
if preprint_provider:
try:
provider = models.PreprintProvider.objects.get(_id=provider)
except models.PreprintProvider.DoesNotExist:
pass
if not provider:
provider = PreprintProviderFactory(name=fake.science_word())
privacy = 'public'
mock_change_identifier = mock.patch(
'website.identifiers.client.EzidClient.update_identifier')
mock_change_identifier.start()
mock_change_identifier_preprints = mock.patch(
'website.identifiers.client.CrossRefClient.update_identifier')
mock_change_identifier_preprints.start()
project = PreprintFactory(title=project_title,
description=fake.science_paragraph(),
creator=creator,
provider=provider)
node = project.node
elif is_registration:
project = RegistrationFactory(title=project_title,
description=fake.science_paragraph(),
creator=creator)
node = project
else:
project = ProjectFactory(title=project_title,
description=fake.science_paragraph(),
creator=creator)
node = project
node.set_privacy(privacy)
for _ in range(n_users):
contrib = create_fake_user()
node.add_contributor(contrib, auth=auth)
if isinstance(n_components, int):
for _ in range(n_components):
NodeFactory(parent=node,
title=fake.science_sentence(),
description=fake.science_paragraph(),
creator=creator)
elif isinstance(n_components, list):
render_generations_from_node_structure_list(node, creator,
n_components)
for _ in range(n_tags):
node.add_tag(fake.science_word(), auth=auth)
if presentation_name is not None:
node.add_tag(presentation_name, auth=auth)
node.add_tag('poster', auth=auth)
node.save()
project.save()
logger.info('Created project: {0}'.format(node.title))
return project
def setUp(self):
super(TestPreprintIsPublishedDetail, self).setUp()
self.admin = AuthUserFactory()
self.write_contrib = AuthUserFactory()
self.non_contrib = AuthUserFactory()
self.public_project = ProjectFactory(creator=self.admin,
is_public=True)
self.public_project.add_contributor(self.write_contrib,
permissions=['read', 'write'],
save=True)
self.subject = SubjectFactory()
self.provider = PreprintProviderFactory()
self.file_one_public_project = test_utils.create_test_file(
self.public_project, self.admin, 'mgla.pdf')
self.unpublished_preprint = PreprintFactory(
creator=self.admin,
filename='mgla.pdf',
provider=self.provider,
subjects=[[self.subject._id]],
project=self.public_project,
is_published=False)
self.url = '/{}preprints/{}/'.format(API_BASE,
self.unpublished_preprint._id)
def test_change_preprint_provider_form(self, plain_view, preprint):
new_provider = PreprintProviderFactory()
plain_view.kwargs = {'guid': preprint._id}
form_data = {'provider': new_provider.id}
form = ChangeProviderForm(data=form_data, instance=preprint)
plain_view().form_valid(form)
assert preprint.provider == new_provider
def test_change_preprint_provider_form(self):
new_provider = PreprintProviderFactory()
self.view.kwargs = {'guid': self.preprint._id}
form_data = {'provider': new_provider.id}
form = ChangeProviderForm(data=form_data, instance=self.preprint)
self.view().form_valid(form)
nt.assert_equal(self.preprint.provider, new_provider)
def setUp(self):
self.admin = AuthUserFactory()
self.provider_one = PreprintProviderFactory()
self.provider_two = self.provider_one
self.published_project = ProjectFactory(creator=self.admin, is_public=True)
self.public_project = ProjectFactory(creator=self.admin, is_public=True)
self.url = '/{}preprints/?version=2.2&'.format(API_BASE)
super(TestPreprintIsPublishedList, self).setUp()
def setUp(self):
super(TestPreprintProviderChangeForm, self).setUp()
self.user = AuthUserFactory()
self.preprint_provider = PreprintProviderFactory()
self.request = RequestFactory().get('/fake_path')
self.request.user = self.user
self.view = views.PreprintProviderChangeForm()
self.view = setup_form_view(self.view, self.request, form=PreprintProviderForm())
self.parent_1 = SubjectFactory(provider=PreprintProviderFactory(_id='osf'))
self.child_1 = SubjectFactory(parent=self.parent_1)
self.child_2 = SubjectFactory(parent=self.parent_1)
self.grandchild_1 = SubjectFactory(parent=self.child_1)
self.view.kwargs = {'preprint_provider_id': self.preprint_provider.id}
def setUp(self):
super(TestPreprintCreate, self).setUp()
self.user = AuthUserFactory()
self.other_user = AuthUserFactory()
self.private_project = ProjectFactory(creator=self.user)
self.public_project = ProjectFactory(creator=self.user, is_public=True)
self.public_project.add_contributor(self.other_user, permissions=permissions.DEFAULT_CONTRIBUTOR_PERMISSIONS, save=True)
self.subject = SubjectFactory()
self.provider = PreprintProviderFactory()
self.user_two = AuthUserFactory()
self.file_one_public_project = test_utils.create_test_file(self.public_project, self.user, 'millionsofdollars.pdf')
self.file_one_private_project = test_utils.create_test_file(self.private_project, self.user, 'woowoowoo.pdf')
self.url = '/{}preprints/'.format(API_BASE)
def setUp(self):
super(TestPreprintProviderLicenses, self).setUp()
self.provider = PreprintProviderFactory()
self.licenses = NodeLicense.objects.all()
self.license1 = self.licenses[0]
self.license2 = self.licenses[1]
self.license3 = self.licenses[2]
self.url = '/{}preprint_providers/{}/licenses/'.format(API_BASE, self.provider._id)
def test_get_doi_for_preprint(self):
new_provider = PreprintProviderFactory()
preprint = PreprintFactory(provider=new_provider)
ideal_doi = '{}osf.io/{}'.format(settings.DOI_NAMESPACE, preprint._id)
doi, metadata = get_doi_and_metadata_for_object(preprint)
assert doi == ideal_doi
def setUp(self):
super(TestPreprintProviderSubjects, self).setUp()
self.lawless_preprint_provider = PreprintProviderFactory()
self.ruled_preprint_provider = PreprintProviderFactory()
self.ruled_preprint_provider.subjects_acceptable = self.create_subject_rules()
self.ruled_preprint_provider.save()
self.lawless_url = '/{}preprint_providers/{}/taxonomies/?page[size]=15&'.format(API_BASE, self.lawless_preprint_provider._id)
self.ruled_url = '/{}preprint_providers/{}/taxonomies/?page[size]=15&'.format(API_BASE, self.ruled_preprint_provider._id)
def setUp(self):
super(TestPreprintConfirmationEmails, self).setUp()
self.user = AuthUserFactory()
self.write_contrib = AuthUserFactory()
self.project = ProjectFactory(creator=self.user)
self.project.add_contributor(self.write_contrib, permissions=[permissions.WRITE])
self.preprint = PreprintFactory(project=self.project, provider=PreprintProviderFactory(_id='osf'), is_published=False)
self.preprint_branded = PreprintFactory(creator=self.user, is_published=False)
def setUp(self):
super(TestPreprintBannerView, self).setUp()
self.admin = AuthUserFactory()
self.provider_one = PreprintProviderFactory()
self.provider_two = PreprintProviderFactory()
self.project_one = ProjectFactory(creator=self.admin, is_public=True)
self.project_two = ProjectFactory(creator=self.admin, is_public=True)
self.project_three = ProjectFactory(creator=self.admin, is_public=True)
self.subject_one = SubjectFactory()
self.subject_two = SubjectFactory()
self.file_one = test_utils.create_test_file(self.project_one, self.admin, 'mgla.pdf')
self.file_two = test_utils.create_test_file(self.project_two, self.admin, 'saor.pdf')
self.published_preprint = PreprintFactory(creator=self.admin, filename='mgla.pdf', provider=self.provider_one, subjects=[[self.subject_one._id]], project=self.project_one, is_published=True)
self.unpublished_preprint = PreprintFactory(creator=self.admin, filename='saor.pdf', provider=self.provider_two, subjects=[[self.subject_two._id]], project=self.project_two, is_published=False)
def preprint():
node_license = NodeLicense.objects.get(
name='CC-By Attribution 4.0 International')
user = AuthUserFactory()
provider = PreprintProviderFactory()
provider.doi_prefix = '10.31219'
provider.save()
license_details = {
'id': node_license.license_id,
'year': '2017',
'copyrightHolders': ['Jeff Hardy', 'Matt Hardy']
}
preprint = PreprintFactory(provider=provider,
article_doi='10.31219/FK2osf.io/test!',
is_published=True,
license_details=license_details)
preprint.license.node_license.url = 'https://creativecommons.org/licenses/by/4.0/legalcode'
return preprint
def test_metadata_for_preprint_has_correct_structure(self):
provider = PreprintProviderFactory()
license = NodeLicense.objects.get(
name="CC-By Attribution 4.0 International")
license_details = {
'id': license.license_id,
'year': '2017',
'copyrightHolders': ['Jeff Hardy', 'Matt Hardy']
}
preprint = PreprintFactory(provider=provider,
project=self.node,
is_published=True,
license_details=license_details)
metadata_xml = metadata.datacite_metadata_for_preprint(
preprint,
doi=preprint.get_identifier('doi').value,
pretty_print=True)
root = lxml.etree.fromstring(metadata_xml)
xsi_location = '{http://www.w3.org/2001/XMLSchema-instance}schemaLocation'
expected_location = 'http://datacite.org/schema/kernel-4 http://schema.datacite.org/meta/kernel-4/metadata.xsd'
assert root.attrib[xsi_location] == expected_location
identifier = root.find('{%s}identifier' % metadata.NAMESPACE)
assert identifier.attrib['identifierType'] == 'DOI'
assert identifier.text == preprint.get_identifier('doi').value
creators = root.find('{%s}creators' % metadata.NAMESPACE)
assert len(creators.getchildren()) == len(
self.node.visible_contributors)
subjects = root.find('{%s}subjects' % metadata.NAMESPACE)
assert subjects.getchildren()
publisher = root.find('{%s}publisher' % metadata.NAMESPACE)
assert publisher.text == provider.name
pub_year = root.find('{%s}publicationYear' % metadata.NAMESPACE)
assert pub_year.text == str(preprint.date_published.year)
dates = root.find('{%s}dates' % metadata.NAMESPACE).getchildren()[0]
assert dates.text == preprint.modified.isoformat()
assert dates.attrib['dateType'] == 'Updated'
alternate_identifier = root.find('{%s}alternateIdentifiers' %
metadata.NAMESPACE).getchildren()[0]
assert alternate_identifier.text == settings.DOMAIN + preprint._id
assert alternate_identifier.attrib['alternateIdentifierType'] == 'URL'
descriptions = root.find('{%s}descriptions' %
metadata.NAMESPACE).getchildren()[0]
assert descriptions.text == preprint.node.description
rights = root.find('{%s}rightsList' %
metadata.NAMESPACE).getchildren()[0]
assert rights.text == preprint.license.name
class TestDeletePreprintProvider(AdminTestCase):
def setUp(self):
super(TestDeletePreprintProvider, self).setUp()
self.user = AuthUserFactory()
self.preprint_provider = PreprintProviderFactory()
self.request = RequestFactory().get('/fake_path')
self.view = views.DeletePreprintProvider()
self.view = setup_user_view(self.view, self.request, user=self.user)
self.view.kwargs = {'preprint_provider_id': self.preprint_provider.id}
def test_cannot_delete_if_preprints_present(self):
preprint = PreprintFactory()
self.preprint_provider.preprint_services.add(preprint)
self.preprint_provider.save()
redirect = self.view.delete(self.request)
nt.assert_equal(
redirect.url, '/preprint_providers/{}/cannot_delete/'.format(
self.preprint_provider.id))
nt.assert_equal(redirect.status_code, 302)
def test_delete_provider_with_no_preprints(self):
redirect = self.view.delete(self.request)
nt.assert_equal(redirect.url, '/preprint_providers/')
nt.assert_equal(redirect.status_code, 302)
def test_get_with_no_preprints(self):
res = self.view.get(self.request)
nt.assert_equal(res.status_code, 200)
def test_cannot_get_if_preprints_present(self):
preprint = PreprintFactory()
self.preprint_provider.preprint_services.add(preprint)
self.preprint_provider.save()
redirect = self.view.get(self.request)
nt.assert_equal(
redirect.url, '/preprint_providers/{}/cannot_delete/'.format(
self.preprint_provider.id))
nt.assert_equal(redirect.status_code, 302)
def setUp(self):
super(TestPreprintSaveShareHook, self).setUp()
self.admin = AuthUserFactory()
self.auth = Auth(user=self.admin)
self.provider = PreprintProviderFactory(name='Lars Larson Snowmobiling Experience')
self.project = ProjectFactory(creator=self.admin, is_public=True)
self.subject = SubjectFactory()
self.subject_two = SubjectFactory()
self.file = api_test_utils.create_test_file(self.project, self.admin, 'second_place.pdf')
self.preprint = PreprintFactory(creator=self.admin, filename='second_place.pdf', provider=self.provider, subjects=[[self.subject._id]], project=self.project, is_published=False)
def setUp(self):
super(TestPreprintProviderHighlightedSubjects, self).setUp()
self.provider = PreprintProviderFactory()
self.subj_a = SubjectFactory(provider=self.provider, text='A')
self.subj_aa = SubjectFactory(provider=self.provider,
text='AA',
parent=self.subj_a,
highlighted=True)
self.url = '/{}preprint_providers/{}/taxonomies/highlighted/'.format(
API_BASE, self.provider._id)
def create_fake_project(creator, n_users, privacy, n_components, name, n_tags,
presentation_name, is_registration, is_preprint,
preprint_provider):
auth = Auth(user=creator)
project_title = name if name else fake.science_sentence()
if is_preprint:
provider = None
if preprint_provider:
try:
provider = models.PreprintProvider.find_one(
Q('_id', 'eq', provider))
except NoResultsFound:
pass
if not provider:
provider = PreprintProviderFactory(name=fake.science_word())
privacy = 'public'
project = PreprintFactory(title=project_title,
description=fake.science_paragraph(),
creator=creator,
provider=provider)
node = project.node
elif is_registration:
project = RegistrationFactory(title=project_title,
description=fake.science_paragraph(),
creator=creator)
node = project
else:
project = ProjectFactory(title=project_title,
description=fake.science_paragraph(),
creator=creator)
node = project
node.set_privacy(privacy)
for _ in range(n_users):
contrib = create_fake_user()
node.add_contributor(contrib, auth=auth)
if isinstance(n_components, int):
for _ in range(n_components):
NodeFactory(project=node,
title=fake.science_sentence(),
description=fake.science_paragraph(),
creator=creator)
elif isinstance(n_components, list):
render_generations_from_node_structure_list(node, creator,
n_components)
for _ in range(n_tags):
node.add_tag(fake.science_word(), auth=auth)
if presentation_name is not None:
node.add_tag(presentation_name, auth=auth)
node.add_tag('poster', auth=auth)
node.save()
project.save()
logger.info('Created project: {0}'.format(node.title))
return project
def test_create_permissions(self, mock_ezid, app, url, preprint, node_admin, moderator):
assert preprint.machine_state == 'initial'
submit_payload = self.create_payload(preprint._id, trigger='submit')
# Unauthorized user can't submit
res = app.post_json_api(url, submit_payload, expect_errors=True)
assert res.status_code == 401
# A random user can't submit
some_rando = AuthUserFactory()
res = app.post_json_api(url, submit_payload, auth=some_rando.auth, expect_errors=True)
assert res.status_code == 403
# Node admin can submit
res = app.post_json_api(url, submit_payload, auth=node_admin.auth)
assert res.status_code == 201
preprint.refresh_from_db()
assert preprint.machine_state == 'pending'
assert not preprint.is_published
accept_payload = self.create_payload(preprint._id, trigger='accept', comment='This is good.')
# Unauthorized user can't accept
res = app.post_json_api(url, accept_payload, expect_errors=True)
assert res.status_code == 401
# A random user can't accept
res = app.post_json_api(url, accept_payload, auth=some_rando.auth, expect_errors=True)
assert res.status_code == 403
# Moderator from another provider can't accept
another_moderator = AuthUserFactory()
another_moderator.groups.add(GroupHelper(PreprintProviderFactory()).get_group('moderator'))
res = app.post_json_api(url, accept_payload, auth=another_moderator.auth, expect_errors=True)
assert res.status_code == 403
# Node admin can't accept
res = app.post_json_api(url, accept_payload, auth=node_admin.auth, expect_errors=True)
assert res.status_code == 403
# Still unchanged after all those tries
preprint.refresh_from_db()
assert preprint.machine_state == 'pending'
assert not preprint.is_published
# Moderator can accept
res = app.post_json_api(url, accept_payload, auth=moderator.auth)
assert res.status_code == 201
preprint.refresh_from_db()
assert preprint.machine_state == 'accepted'
assert preprint.is_published
# Check if "get_and_set_preprint_identifiers" is called once.
assert mock_ezid.call_count == 1
def setUp(self):
self.user = AuthUserFactory()
self.user.is_superuser = True
self.user.save()
self.preprint_provider = PreprintProviderFactory()
self.request = RequestFactory().get('/fake_path')
self.view = views.ShareSourcePreprintProvider()
self.view = setup_user_view(self.view, self.request, user=self.user)
self.view.kwargs = {'preprint_provider_id': self.preprint_provider.id}
def setUp(self):
super(TestDeletePreprintProvider, self).setUp()
self.user = AuthUserFactory()
self.preprint_provider = PreprintProviderFactory()
self.request = RequestFactory().get('/fake_path')
self.view = views.DeletePreprintProvider()
self.view = setup_user_view(self.view, self.request, user=self.user)
self.view.kwargs = {'preprint_provider_id': self.preprint_provider.id}
def setUp(self):
super(TestPreprintProviderDisplay, self).setUp()
self.user = AuthUserFactory()
self.preprint_provider = PreprintProviderFactory()
self.request = RequestFactory().get('/fake_path')
self.view = views.PreprintProviderDisplay()
self.view = setup_user_view(self.view, self.request, user=self.user)
self.view.kwargs = {'preprint_provider_id': self.preprint_provider.id}
def setUp(self):
super(TestCreatePreprintProvider, self).setUp()
self.user = AuthUserFactory()
self.preprint_provider = PreprintProviderFactory()
self.request = RequestFactory().get('/fake_path')
self.request.user = self.user
self.view = views.CreatePreprintProvider()
self.view = setup_form_view(self.view, self.request, form=PreprintProviderForm())
self.view.kwargs = {'preprint_provider_id': self.preprint_provider.id}
def test_resolve_guid_download_file_from_emberapp_preprints(self):
provider = PreprintProviderFactory(_id='sockarxiv', name='Sockarxiv')
pp = PreprintFactory(finish=True, provider=provider)
assert pp.url.startswith('/preprints/sockarxiv')
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
def test_all_subjects(self):
subj_a = SubjectFactory(provider=self.provider, text='A')
subj_b = SubjectFactory(provider=self.provider, text='B')
subj_aa = SubjectFactory(provider=self.provider, text='AA', parent=subj_a)
subj_ab = SubjectFactory(provider=self.provider, text='AB', parent=subj_a)
subj_ba = SubjectFactory(provider=self.provider, text='BA', parent=subj_b)
subj_bb = SubjectFactory(provider=self.provider, text='BB', parent=subj_b)
subj_aaa = SubjectFactory(provider=self.provider, text='AAA', parent=subj_aa)
some_other_provider = PreprintProviderFactory(name='asdfArxiv')
subj_asdf = SubjectFactory(provider=some_other_provider)
assert set(self.provider.all_subjects) == set([subj_a, subj_b, subj_aa, subj_ab, subj_ba, subj_bb, subj_aaa])
class TestDeletePreprintProvider(AdminTestCase):
def setUp(self):
super(TestDeletePreprintProvider, self).setUp()
self.user = AuthUserFactory()
self.preprint_provider = PreprintProviderFactory()
self.request = RequestFactory().get('/fake_path')
self.view = views.DeletePreprintProvider()
self.view = setup_user_view(self.view, self.request, user=self.user)
self.view.kwargs = {'preprint_provider_id': self.preprint_provider.id}
def test_cannot_delete_if_preprints_present(self):
preprint = PreprintFactory()
self.preprint_provider.preprint_services.add(preprint)
self.preprint_provider.save()
redirect = self.view.delete(self.request)
nt.assert_equal(redirect.url, '/preprint_providers/{}/cannot_delete/'.format(self.preprint_provider.id))
nt.assert_equal(redirect.status_code, 302)
def test_delete_provider_with_no_preprints(self):
redirect = self.view.delete(self.request)
nt.assert_equal(redirect.url, '/preprint_providers/')
nt.assert_equal(redirect.status_code, 302)
def test_get_with_no_preprints(self):
res = self.view.get(self.request)
nt.assert_equal(res.status_code, 200)
def test_cannot_get_if_preprints_present(self):
preprint = PreprintFactory()
self.preprint_provider.preprint_services.add(preprint)
self.preprint_provider.save()
redirect = self.view.get(self.request)
nt.assert_equal(redirect.url, '/preprint_providers/{}/cannot_delete/'.format(self.preprint_provider.id))
nt.assert_equal(redirect.status_code, 302)
def setUp(self):
self.user = AuthUserFactory()
# all the same provider
self.provider = PreprintProviderFactory(name='Sockarxiv')
self.provider_two = self.provider
self.provider_three = self.provider
# all different projects
self.project = ProjectFactory(creator=self.user)
self.project_two = ProjectFactory(creator=self.user)
self.project_three = ProjectFactory(creator=self.user)
self.url = '/{}preprint_providers/{}/preprints/?version=2.2&'.format(
API_BASE, self.provider._id)
super(TestPreprintProviderPreprintsListFiltering, self).setUp()
def test_project_made_public(self):
assert_false(self.project.is_public)
self.preprint.set_primary_file(self.file, auth=self.auth, save=True)
assert_false(self.project.is_public)
with assert_raises(ValueError):
self.preprint.set_published(True, auth=self.auth, save=True)
self.preprint.provider = PreprintProviderFactory()
self.preprint.set_subjects([[SubjectFactory()._id]], auth=self.auth)
self.project.reload()
assert_false(self.project.is_public)
self.preprint.set_published(True, auth=self.auth, save=True)
self.project.reload()
assert_true(self.project.is_public)
def setUp(self):
super(TestGetSubjectDescendants, self).setUp()
self.user = AuthUserFactory()
self.preprint_provider = PreprintProviderFactory()
self.parent_1 = SubjectFactory()
self.child_1 = SubjectFactory(parent=self.parent_1)
self.child_2 = SubjectFactory(parent=self.parent_1)
self.grandchild_1 = SubjectFactory(parent=self.child_1)
self.request = RequestFactory().get('/?parent_id={}'.format(self.parent_1.id))
self.view = views.GetSubjectDescendants()
self.view = setup_user_view(self.view, self.request, user=self.user)
class TestShareSourcePreprintProvider(AdminTestCase):
def setUp(self):
self.user = AuthUserFactory()
self.user.is_superuser = True
self.user.save()
self.preprint_provider = PreprintProviderFactory()
self.request = RequestFactory().get('/fake_path')
self.view = views.ShareSourcePreprintProvider()
self.view = setup_user_view(self.view, self.request, user=self.user)
self.view.kwargs = {'preprint_provider_id': self.preprint_provider.id}
@mock.patch.object(views.ShareSourcePreprintProvider, 'share_post')
def test_update_share_token_and_source(self, share_resp):
token = 'tokennethbranagh'
source_name = 'sir'
share_resp.return_value = {
'data': {
'attributes': {
'longTitle': source_name,
},
},
'included': [{
'attributes': {
'token': token,
},
'type': 'ShareUser',
}]
}
self.view.get(self.request)
self.preprint_provider.refresh_from_db()
assert self.preprint_provider.access_token == token
assert self.preprint_provider.share_source == source_name
def setUp(self):
super(TestPreprintProviderSpecificSubjects, self).setUp()
self.provider_1 = PreprintProviderFactory()
self.provider_2 = PreprintProviderFactory()
self.root_subject_1 = SubjectFactory(text='R1',
provider=self.provider_1)
self.parent_subject_1 = SubjectFactory(text='P1',
provider=self.provider_1,
parent=self.root_subject_1)
self.child_subject_1 = SubjectFactory(text='C1',
provider=self.provider_1,
parent=self.parent_subject_1)
self.root_subject_2 = SubjectFactory(text='R2',
provider=self.provider_2)
self.parent_subject_2 = SubjectFactory(text='P2',
provider=self.provider_2,
parent=self.root_subject_2)
self.child_subject_2 = SubjectFactory(text='C2',
provider=self.provider_2,
parent=self.parent_subject_2)
self.url_1 = '/{}preprint_providers/{}/taxonomies/?page[size]=15&'.format(
API_BASE, self.provider_1._id)
self.url_2 = '/{}preprint_providers/{}/taxonomies/?page[size]=15&'.format(
API_BASE, self.provider_2._id)
class TestShareSourcePreprintProvider(AdminTestCase):
def setUp(self):
self.user = AuthUserFactory()
self.user.is_superuser = True
self.user.save()
self.preprint_provider = PreprintProviderFactory()
self.request = RequestFactory().get('/fake_path')
self.view = views.ShareSourcePreprintProvider()
self.view = setup_user_view(self.view, self.request, user=self.user)
self.view.kwargs = {'preprint_provider_id': self.preprint_provider.id}
@mock.patch.object(views.ShareSourcePreprintProvider, 'share_post')
def test_update_share_token_and_source(self, share_resp):
token = 'tokennethbranagh'
source_name = 'sir'
share_resp.return_value = {
'data': {
'attributes': {
'longTitle': source_name,
},
},
'included': [{
'attributes': {
'token': token,
},
'type': 'ShareUser',
}]
}
self.view.get(self.request)
self.preprint_provider.refresh_from_db()
assert self.preprint_provider.access_token == token
assert self.preprint_provider.share_source == source_name
def setUp(self):
super(TestPreprintCreate, self).setUp()
self.user = AuthUserFactory()
self.other_user = AuthUserFactory()
self.private_project = ProjectFactory(creator=self.user)
self.public_project = ProjectFactory(creator=self.user, is_public=True)
self.public_project.add_contributor(
self.other_user,
permissions=permissions.DEFAULT_CONTRIBUTOR_PERMISSIONS,
save=True)
self.subject = SubjectFactory()
self.provider = PreprintProviderFactory()
self.user_two = AuthUserFactory()
self.url = '/{}preprints/'.format(API_BASE)
def setUp(self):
super(TestPreprintBannerView, self).setUp()
self.admin = AuthUserFactory()
self.write_contrib = AuthUserFactory()
self.read_contrib = AuthUserFactory()
self.non_contrib = AuthUserFactory()
self.provider_one = PreprintProviderFactory()
self.project_one = ProjectFactory(creator=self.admin, is_public=True)
self.project_one.add_contributor(self.write_contrib, ['write', 'read'])
self.project_one.add_contributor(self.read_contrib, ['read'])
self.subject_one = SubjectFactory()
self.preprint = PreprintFactory(creator=self.admin, filename='mgla.pdf', provider=self.provider_one, subjects=[[self.subject_one._id]], project=self.project_one, is_published=True)
self.preprint.add_contributor(self.write_contrib, 'write')
self.preprint.add_contributor(self.read_contrib, 'read')
def test_implicit_admins_can_see_project_status(self):
project = ProjectFactory(creator=self.admin)
component = NodeFactory(creator=self.admin, parent=project)
project.add_contributor(self.write_contrib, ['read', 'write', 'admin'])
project.save()
preprint = PreprintFactory(creator=self.admin, filename='mgla.pdf', provider=self.provider_one, subjects=[[self.subject_one._id]], project=component, is_published=True)
preprint.machine_state = 'pending'
provider = PreprintProviderFactory(reviews_workflow='post-moderation')
preprint.provider = provider
preprint.save()
url = component.web_url_for('view_project')
res = self.app.get(url, auth=self.write_contrib.auth)
assert_in('{}'.format(preprint.provider.name), res.body)
assert_in('Pending\n', res.body)
assert_in('This preprint is publicly available and searchable but is subject to removal by a moderator.', res.body)
def setUp(self):
self.user = AuthUserFactory()
self.subject1 = SubjectFactory()
self.subject2 = SubjectFactory()
self.subject3 = SubjectFactory()
self.subject1_1 = SubjectFactory(parent=self.subject1)
self.subject2_1 = SubjectFactory(parent=self.subject2)
self.subject3_1 = SubjectFactory(parent=self.subject3)
self.subject1_1_1 = SubjectFactory(parent=self.subject1_1)
self.preprint_provider = PreprintProviderFactory()
self.request = RequestFactory().get('/fake_path')
self.view = views.ProcessCustomTaxonomy()
self.view = setup_user_view(self.view, self.request, user=self.user)
class TestPreprintCreate(ApiTestCase):
def setUp(self):
super(TestPreprintCreate, self).setUp()
self.user = AuthUserFactory()
self.other_user = AuthUserFactory()
self.private_project = ProjectFactory(creator=self.user)
self.public_project = ProjectFactory(creator=self.user, is_public=True)
self.public_project.add_contributor(
self.other_user,
permissions=permissions.DEFAULT_CONTRIBUTOR_PERMISSIONS,
save=True)
self.subject = SubjectFactory()
self.provider = PreprintProviderFactory()
self.user_two = AuthUserFactory()
self.url = '/{}preprints/'.format(API_BASE)
def publish_preprint(self, preprint, user, expect_errors=False):
preprint_file = test_utils.create_test_preprint_file(
preprint, user, 'coffee_manuscript.pdf')
update_payload = build_preprint_update_payload(preprint._id, preprint_file._id)
res = self.app.patch_json_api(
self.url + '{}/'.format(preprint._id),
update_payload,
auth=user.auth,
expect_errors=expect_errors
)
return res
def test_create_preprint_with_supplemental_public_project(self):
public_project_payload = build_preprint_create_payload(
self.public_project._id, self.provider._id)
res = self.app.post_json_api(
self.url,
public_project_payload,
auth=self.user.auth)
data = res.json['data']
preprint = Preprint.load(data['id'])
assert_equal(res.status_code, 201)
assert_equal(data['attributes']['is_published'], False)
assert preprint.node == self.public_project
def test_create_preprint_with_supplemental_private_project(self):
private_project_payload = build_preprint_create_payload(
self.private_project._id,
self.provider._id,
attrs={
'subjects': [
[
SubjectFactory()._id]],
})
res = self.app.post_json_api(
self.url,
private_project_payload,
auth=self.user.auth)
assert_equal(res.status_code, 201)
self.private_project.reload()
assert_false(self.private_project.is_public)
preprint = Preprint.load(res.json['data']['id'])
res = self.publish_preprint(preprint, self.user)
preprint.reload()
assert_equal(res.status_code, 200)
self.private_project.reload()
assert_false(self.private_project.is_public)
assert_true(preprint.is_public)
assert_true(preprint.is_published)
def test_non_authorized_user_on_supplemental_node(self):
public_project_payload = build_preprint_create_payload(
self.public_project._id, self.provider._id)
res = self.app.post_json_api(
self.url,
public_project_payload,
auth=self.user_two.auth,
expect_errors=True)
assert_equal(res.status_code, 403)
def test_write_user_on_supplemental_node(self):
assert_in(self.other_user, self.public_project.contributors)
public_project_payload = build_preprint_create_payload(
self.public_project._id, self.provider._id)
res = self.app.post_json_api(
self.url,
public_project_payload,
auth=self.other_user.auth,
expect_errors=True)
# Users can create a preprint with a supplemental node that they have write perms to
assert_equal(res.status_code, 201)
def test_read_user_on_supplemental_node(self):
self.public_project.set_permissions(self.other_user, ['read'], save=True)
assert_in(self.other_user, self.public_project.contributors)
public_project_payload = build_preprint_create_payload(
self.public_project._id, self.provider._id)
res = self.app.post_json_api(
self.url,
public_project_payload,
auth=self.other_user.auth,
expect_errors=True)
assert_equal(res.status_code, 403)
def test_file_is_not_in_node(self):
file_one_project = test_utils.create_test_file(
self.public_project, self.user, 'openupthatwindow.pdf')
assert_equal(file_one_project.target, self.public_project)
wrong_project_payload = build_preprint_create_payload(
self.public_project._id, self.provider._id, file_one_project._id)
res = self.app.post_json_api(
self.url,
wrong_project_payload,
auth=self.user.auth,
expect_errors=True)
assert_equal(res.status_code, 400)
# File which is targeted towards the project instead of the preprint is invalid
assert_equal(
res.json['errors'][0]['detail'],
'This file is not a valid primary file for this preprint.')
def test_already_has_supplemental_node_on_another_preprint(self):
preprint = PreprintFactory(creator=self.user, project=self.public_project)
already_preprint_payload = build_preprint_create_payload(
preprint.node._id, preprint.provider._id)
res = self.app.post_json_api(
self.url,
already_preprint_payload,
auth=self.user.auth,
expect_errors=True)
# One preprint per provider per node constraint has been lifted
assert_equal(res.status_code, 201)
def test_read_write_user_already_a_preprint_with_same_provider(
self):
assert_in(self.other_user, self.public_project.contributors)
preprint = PreprintFactory(creator=self.user, project=self.public_project)
already_preprint_payload = build_preprint_create_payload(
preprint.node._id, preprint.provider._id)
res = self.app.post_json_api(
self.url,
already_preprint_payload,
auth=self.other_user.auth,
expect_errors=True)
assert_equal(res.status_code, 201)
def test_publish_preprint_fails_with_no_primary_file(self):
no_file_payload = build_preprint_create_payload(
node_id=self.public_project._id,
provider_id=self.provider._id,
file_id=None,
attrs={
'is_published': True,
'subjects': [[SubjectFactory()._id]],
}
)
res = self.app.post_json_api(
self.url,
no_file_payload,
auth=self.user.auth,
expect_errors=True)
assert_equal(res.status_code, 400)
assert_equal(
res.json['errors'][0]['detail'],
'A valid primary_file must be set before publishing a preprint.')
def test_publish_preprint_fails_with_invalid_primary_file(self):
no_file_payload = build_preprint_create_payload(
node_id=self.public_project._id,
provider_id=self.provider._id,
attrs={
'subjects': [[SubjectFactory()._id]],
}
)
res = self.app.post_json_api(
self.url,
no_file_payload,
auth=self.user.auth,
expect_errors=True)
assert_equal(res.status_code, 201)
preprint = Preprint.load(res.json['data']['id'])
update_payload = build_preprint_update_payload(preprint._id, 'fakefileid')
res = self.app.patch_json_api(
self.url + '{}/'.format(preprint._id),
update_payload,
auth=self.user.auth,
expect_errors=True
)
assert_equal(res.status_code, 400)
assert_equal(
res.json['errors'][0]['detail'],
'A valid primary_file must be set before publishing a preprint.')
def test_no_provider_given(self):
no_providers_payload = build_preprint_create_payload()
res = self.app.post_json_api(
self.url,
no_providers_payload,
auth=self.user.auth,
expect_errors=True)
assert_equal(res.status_code, 400)
assert_equal(
res.json['errors'][0]['detail'],
'You must specify a valid provider to create a preprint.')
def test_invalid_provider_given(self):
wrong_provider_payload = build_preprint_create_payload(
provider_id='jobbers')
res = self.app.post_json_api(
self.url,
wrong_provider_payload,
auth=self.user.auth,
expect_errors=True)
assert_equal(res.status_code, 400)
assert_equal(
res.json['errors'][0]['detail'],
'You must specify a valid provider to create a preprint.')
def test_file_not_osfstorage(self):
public_project_payload = build_preprint_create_payload(
provider_id=self.provider._id)
res = self.app.post_json_api(
self.url,
public_project_payload,
auth=self.user.auth,
expect_errors=True)
preprint = Preprint.load(res.json['data']['id'])
assert_equal(res.status_code, 201)
github_file = test_utils.create_test_preprint_file(
preprint, self.user, 'coffee_manuscript.pdf')
github_file.recast(GithubFile._typedmodels_type)
github_file.save()
update_payload = build_preprint_update_payload(preprint._id, github_file._id)
res = self.app.patch_json_api(
self.url + '{}/'.format(preprint._id),
update_payload,
auth=self.user.auth,
expect_errors=True
)
assert_equal(res.status_code, 400)
assert_equal(
res.json['errors'][0]['detail'],
'This file is not a valid primary file for this preprint.')
def test_preprint_contributor_signal_sent_on_creation(self):
# Signal sent but bails out early without sending email
with capture_signals() as mock_signals:
payload = build_preprint_create_payload(
provider_id=self.provider._id)
res = self.app.post_json_api(
self.url, payload, auth=self.user.auth)
assert_equal(res.status_code, 201)
assert_true(len(mock_signals.signals_sent()) == 1)
assert_in(
project_signals.contributor_added,
mock_signals.signals_sent())
def test_create_preprint_with_deleted_node_should_fail(self):
self.public_project.is_deleted = True
self.public_project.save()
public_project_payload = build_preprint_create_payload(
self.public_project._id, self.provider._id)
res = self.app.post_json_api(
self.url,
public_project_payload,
auth=self.user.auth,
expect_errors=True)
assert_equal(res.status_code, 400)
assert_equal(res.json['errors'][0]['detail'],
'Cannot attach a deleted project to a preprint.')
def test_create_preprint_with_no_permissions_to_node(self):
project = ProjectFactory()
public_project_payload = build_preprint_create_payload(
project._id, self.provider._id)
res = self.app.post_json_api(
self.url,
public_project_payload,
auth=self.user.auth,
expect_errors=True)
assert_equal(res.status_code, 403)
def test_create_preprint_adds_log_if_published(self):
public_project_payload = build_preprint_create_payload(
provider_id=self.provider._id,
)
res = self.app.post_json_api(
self.url,
public_project_payload,
auth=self.user.auth)
assert_equal(res.status_code, 201)
preprint = Preprint.load(res.json['data']['id'])
res = self.publish_preprint(preprint, self.user)
log = preprint.logs.latest()
assert_equal(log.action, 'published')
assert_equal(log.params.get('preprint'), preprint._id)
@mock.patch('osf.models.preprint.update_or_enqueue_on_preprint_updated')
def test_create_preprint_from_project_published_hits_update(
self, mock_on_preprint_updated):
private_project_payload = build_preprint_create_payload(
self.private_project._id,
self.provider._id)
res = self.app.post_json_api(
self.url,
private_project_payload,
auth=self.user.auth)
assert_false(mock_on_preprint_updated.called)
preprint = Preprint.load(res.json['data']['id'])
self.publish_preprint(preprint, self.user)
assert_true(mock_on_preprint_updated.called)
@mock.patch('osf.models.preprint.update_or_enqueue_on_preprint_updated')
def test_create_preprint_from_project_unpublished_does_not_hit_update(
self, mock_on_preprint_updated):
private_project_payload = build_preprint_create_payload(
self.private_project._id,
self.provider._id)
self.app.post_json_api(
self.url,
private_project_payload,
auth=self.user.auth)
assert not mock_on_preprint_updated.called
@mock.patch('osf.models.preprint.update_or_enqueue_on_preprint_updated')
def test_setting_is_published_with_moderated_provider_fails(
self, mock_on_preprint_updated):
self.provider.reviews_workflow = 'pre-moderation'
self.provider.save()
public_project_payload = build_preprint_create_payload(
self.public_project._id,
self.provider._id,
)
res = self.app.post_json_api(
self.url,
public_project_payload,
auth=self.user.auth,
expect_errors=True)
assert res.status_code == 201
preprint = Preprint.load(res.json['data']['id'])
res = self.publish_preprint(preprint, self.user, expect_errors=True)
assert res.status_code == 409
assert not mock_on_preprint_updated.called
class TestPreprintCreate(ApiTestCase):
def setUp(self):
super(TestPreprintCreate, self).setUp()
self.user = AuthUserFactory()
self.other_user = AuthUserFactory()
self.private_project = ProjectFactory(creator=self.user)
self.public_project = ProjectFactory(creator=self.user, is_public=True)
self.public_project.add_contributor(
self.other_user,
permissions=permissions.DEFAULT_CONTRIBUTOR_PERMISSIONS,
save=True)
self.subject = SubjectFactory()
self.provider = PreprintProviderFactory()
self.user_two = AuthUserFactory()
self.file_one_public_project = test_utils.create_test_file(
self.public_project, self.user, 'millionsofdollars.pdf')
self.file_one_private_project = test_utils.create_test_file(
self.private_project, self.user, 'woowoowoo.pdf')
self.url = '/{}preprints/'.format(API_BASE)
def test_create_preprint_from_public_project(self):
public_project_payload = build_preprint_create_payload(
self.public_project._id, self.provider._id, self.file_one_public_project._id)
res = self.app.post_json_api(
self.url,
public_project_payload,
auth=self.user.auth)
assert_equal(res.status_code, 201)
def test_create_preprint_from_private_project(self):
private_project_payload = build_preprint_create_payload(
self.private_project._id,
self.provider._id,
self.file_one_private_project._id,
attrs={
'subjects': [
[
SubjectFactory()._id]],
'is_published': True})
res = self.app.post_json_api(
self.url,
private_project_payload,
auth=self.user.auth)
self.private_project.reload()
assert_equal(res.status_code, 201)
assert_true(self.private_project.is_public)
def test_non_authorized_user(self):
public_project_payload = build_preprint_create_payload(
self.public_project._id, self.provider._id, self.file_one_public_project._id)
res = self.app.post_json_api(
self.url,
public_project_payload,
auth=self.user_two.auth,
expect_errors=True)
assert_equal(res.status_code, 403)
def test_read_write_user_not_admin(self):
assert_in(self.other_user, self.public_project.contributors)
public_project_payload = build_preprint_create_payload(
self.public_project._id, self.provider._id, self.file_one_public_project._id)
res = self.app.post_json_api(
self.url,
public_project_payload,
auth=self.other_user.auth,
expect_errors=True)
assert_equal(res.status_code, 403)
def test_file_is_not_in_node(self):
wrong_project_payload = build_preprint_create_payload(
self.public_project._id, self.provider._id, self.file_one_private_project._id)
res = self.app.post_json_api(
self.url,
wrong_project_payload,
auth=self.user.auth,
expect_errors=True)
assert_equal(res.status_code, 400)
assert_equal(
res.json['errors'][0]['detail'],
'This file is not a valid primary file for this preprint.')
def test_already_a_preprint_with_conflicting_provider(self):
preprint = PreprintFactory(creator=self.user)
file_one_preprint = test_utils.create_test_file(
preprint.node, self.user, 'openupthatwindow.pdf')
already_preprint_payload = build_preprint_create_payload(
preprint.node._id, preprint.provider._id, file_one_preprint._id)
res = self.app.post_json_api(
self.url,
already_preprint_payload,
auth=self.user.auth,
expect_errors=True)
assert_equal(res.status_code, 409)
assert_in(
'Only one preprint per provider can be submitted for a node.',
res.json['errors'][0]['detail'])
def test_read_write_user_already_a_preprint_with_conflicting_provider(
self):
assert_in(self.other_user, self.public_project.contributors)
preprint = PreprintFactory(creator=self.user)
preprint.node.add_contributor(
self.other_user,
permissions=permissions.DEFAULT_CONTRIBUTOR_PERMISSIONS,
save=True)
file_one_preprint = test_utils.create_test_file(
preprint.node, self.user, 'openupthatwindow.pdf')
already_preprint_payload = build_preprint_create_payload(
preprint.node._id, self.provider._id, file_one_preprint._id)
res = self.app.post_json_api(
self.url,
already_preprint_payload,
auth=self.other_user.auth,
expect_errors=True)
assert_equal(res.status_code, 403)
def test_publish_preprint_fails_with_no_primary_file(self):
no_file_payload = build_preprint_create_payload(
node_id=self.public_project._id,
provider_id=self.provider._id,
file_id=None,
attrs={
'is_published': True,
'subjects': [[SubjectFactory()._id]],
}
)
res = self.app.post_json_api(
self.url,
no_file_payload,
auth=self.user.auth,
expect_errors=True)
assert_equal(res.status_code, 400)
assert_equal(
res.json['errors'][0]['detail'],
'A valid primary_file must be set before publishing a preprint.')
def test_publish_preprint_fails_with_invalid_primary_file(self):
no_file_payload = build_preprint_create_payload(
node_id=self.public_project._id,
provider_id=self.provider._id,
file_id='totallynotanid',
attrs={
'is_published': True,
'subjects': [[SubjectFactory()._id]],
}
)
res = self.app.post_json_api(
self.url,
no_file_payload,
auth=self.user.auth,
expect_errors=True)
assert_equal(res.status_code, 400)
assert_equal(
res.json['errors'][0]['detail'],
'A valid primary_file must be set before publishing a preprint.')
def test_no_provider_given(self):
no_providers_payload = build_preprint_create_payload(
self.public_project._id, self.provider._id, self.file_one_public_project._id)
del no_providers_payload['data']['relationships']['provider']
res = self.app.post_json_api(
self.url,
no_providers_payload,
auth=self.user.auth,
expect_errors=True)
assert_equal(res.status_code, 400)
assert_equal(
res.json['errors'][0]['detail'],
'You must specify a valid provider to create a preprint.')
def test_invalid_provider_given(self):
wrong_provider_payload = build_preprint_create_payload(
self.public_project._id, 'jobbers', self.file_one_public_project._id)
res = self.app.post_json_api(
self.url,
wrong_provider_payload,
auth=self.user.auth,
expect_errors=True)
assert_equal(res.status_code, 400)
assert_equal(
res.json['errors'][0]['detail'],
'You must specify a valid provider to create a preprint.')
def test_request_id_does_not_match_request_url_id(self):
public_project_payload = build_preprint_create_payload(
self.private_project._id, self.provider._id, self.file_one_public_project._id)
res = self.app.post_json_api(
self.url,
public_project_payload,
auth=self.user.auth,
expect_errors=True)
assert_equal(res.status_code, 400)
assert_equal(
res.json['errors'][0]['detail'],
'This file is not a valid primary file for this preprint.')
def test_file_not_osfstorage(self):
github_file = self.file_one_public_project
github_file.recast(GithubFile._typedmodels_type)
github_file.save()
public_project_payload = build_preprint_create_payload(
self.public_project._id, self.provider._id, github_file._id)
res = self.app.post_json_api(
self.url,
public_project_payload,
auth=self.user.auth,
expect_errors=True)
assert_equal(res.status_code, 400)
assert_equal(
res.json['errors'][0]['detail'],
'This file is not a valid primary file for this preprint.')
def test_preprint_contributor_signal_not_sent_on_creation(self):
with capture_signals() as mock_signals:
public_project_payload = build_preprint_create_payload(
self.public_project._id, self.provider._id, self.file_one_public_project._id)
res = self.app.post_json_api(
self.url, public_project_payload, auth=self.user.auth)
assert_equal(res.status_code, 201)
assert_not_in(
project_signals.contributor_added,
mock_signals.signals_sent())
def test_create_preprint_with_deleted_node_should_fail(self):
self.public_project.is_deleted = True
self.public_project.save()
public_project_payload = build_preprint_create_payload(
self.public_project._id, self.provider._id, self.file_one_public_project._id)
res = self.app.post_json_api(
self.url,
public_project_payload,
auth=self.user.auth,
expect_errors=True)
assert_equal(res.status_code, 400)
assert_equal(res.json['errors'][0]['detail'],
'Cannot create a preprint from a deleted node.')
def test_create_preprint_adds_log_if_published(self):
public_project_payload = build_preprint_create_payload(
self.public_project._id,
self.provider._id,
self.file_one_public_project._id,
{
'is_published': True,
'subjects': [[SubjectFactory()._id]],
}
)
res = self.app.post_json_api(
self.url,
public_project_payload,
auth=self.user.auth)
assert_equal(res.status_code, 201)
preprint_id = res.json['data']['id']
preprint = PreprintService.load(preprint_id)
log = preprint.node.logs.latest()
assert_equal(log.action, 'preprint_initiated')
assert_equal(log.params.get('preprint'), preprint_id)
@mock.patch('website.preprints.tasks.on_preprint_updated.si')
def test_create_preprint_from_project_published_hits_update(
self, mock_on_preprint_updated):
private_project_payload = build_preprint_create_payload(
self.private_project._id,
self.provider._id,
self.file_one_private_project._id,
attrs={
'subjects': [
[
SubjectFactory()._id]],
'is_published': True})
res = self.app.post_json_api(
self.url,
private_project_payload,
auth=self.user.auth)
assert mock_on_preprint_updated.called
@mock.patch('website.preprints.tasks.on_preprint_updated.si')
def test_create_preprint_from_project_unpublished_does_not_hit_update(
self, mock_on_preprint_updated):
private_project_payload = build_preprint_create_payload(
self.private_project._id,
self.provider._id,
self.file_one_private_project._id,
attrs={
'subjects': [
[
SubjectFactory()._id]],
'is_published': False})
res = self.app.post_json_api(
self.url,
private_project_payload,
auth=self.user.auth)
assert not mock_on_preprint_updated.called
@mock.patch('website.preprints.tasks.on_preprint_updated.si')
def test_setting_is_published_with_moderated_provider_fails(
self, mock_on_preprint_updated):
self.provider.reviews_workflow = 'pre-moderation'
self.provider.save()
public_project_payload = build_preprint_create_payload(
self.public_project._id,
self.provider._id,
self.file_one_public_project._id,
{
'is_published': True,
'subjects': [[SubjectFactory()._id]],
}
)
res = self.app.post_json_api(
self.url,
public_project_payload,
auth=self.user.auth,
expect_errors=True)
assert res.status_code == 409
assert not mock_on_preprint_updated.called
def post_mod_provider(self, moderator):
ppp = PreprintProviderFactory(reviews_workflow='post-moderation')
ppp.get_group('moderator').user_set.add(moderator)
return ppp
class TestPreprintProviderLicenses(ApiTestCase):
def setUp(self):
super(TestPreprintProviderLicenses, self).setUp()
self.provider = PreprintProviderFactory()
self.licenses = NodeLicense.objects.all()
self.license1 = self.licenses[0]
self.license2 = self.licenses[1]
self.license3 = self.licenses[2]
self.url = '/{}preprint_providers/{}/licenses/'.format(API_BASE, self.provider._id)
def test_preprint_provider_has_no_acceptable_licenses_and_no_default(self):
self.provider.licenses_acceptable = []
self.provider.default_license = None
self.provider.save()
res = self.app.get(self.url)
assert_equal(res.status_code, 200)
assert_equal(res.json['links']['meta']['total'], len(self.licenses))
def test_preprint_provider_has_a_default_license_but_no_acceptable_licenses(self):
self.provider.licenses_acceptable = []
self.provider.default_license = self.license2
self.provider.save()
res = self.app.get(self.url)
assert_equal(res.status_code, 200)
assert_equal(res.json['links']['meta']['total'], len(self.licenses))
assert_equal(self.license2._id, res.json['data'][0]['id'])
def test_prerint_provider_has_acceptable_licenses_but_no_default(self):
self.provider.licenses_acceptable.add(self.license1, self.license2)
self.provider.default_license = None
self.provider.save()
res = self.app.get(self.url)
assert_equal(res.status_code, 200)
assert_equal(res.json['links']['meta']['total'], 2)
license_ids = [item['id'] for item in res.json['data']]
assert_in(self.license1._id, license_ids)
assert_in(self.license2._id, license_ids)
assert_not_in(self.license3._id, license_ids)
def test_preprint_provider_has_both_acceptable_and_default_licenses(self):
self.provider.licenses_acceptable.add(self.license1, self.license3)
self.provider.default_license = self.license3
self.provider.save()
res = self.app.get(self.url)
assert_equal(res.status_code, 200)
assert_equal(res.json['links']['meta']['total'], 2)
license_ids = [item['id'] for item in res.json['data']]
assert_in(self.license1._id, license_ids)
assert_in(self.license3._id, license_ids)
assert_not_in(self.license2._id, license_ids)
assert_equal(self.license3._id, license_ids[0])
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
class TestPreprintProviderSubjects(ApiTestCase):
def create_subject_rules(self):
'''
Subject Hierarchy
+-----------------------------+
| |
| +-------->B+----->F |
| | |
| A+----------->C |
| | |
| +-------->D+----->G |
| |
| H+------>I+----->J |
| | |
| +----->K |
| |
| L+------>M+----->N |
| | |
| +------->E |
| |
| O |
+-----------------------------+
'''
self.subA = SubjectFactory(text='A')
self.subB = SubjectFactory(text='B', parent=self.subA)
self.subC = SubjectFactory(text='C', parent=self.subA)
self.subD = SubjectFactory(text='D', parent=self.subA)
self.subF = SubjectFactory(text='F', parent=self.subB)
self.subG = SubjectFactory(text='G', parent=self.subD)
self.subH = SubjectFactory(text='H')
self.subI = SubjectFactory(text='I', parent=self.subH)
self.subJ = SubjectFactory(text='J', parent=self.subI)
self.subK = SubjectFactory(text='K', parent=self.subI)
self.subL = SubjectFactory(text='L')
self.subM = SubjectFactory(text='M', parent=self.subL)
self.subE = SubjectFactory(text='E', parent=self.subM)
self.subN = SubjectFactory(text='N', parent=self.subM)
self.subO = SubjectFactory(text='O')
rules = [
([self.subA._id, self.subB._id], False),
([self.subA._id, self.subD._id], True),
([self.subH._id, self.subI._id, self.subJ._id], True),
([self.subL._id], True)
]
# This should allow: A, B, D, G, H, I, J, L, M, N and E
# This should not allow: C, F, K, O
return rules
def setUp(self):
super(TestPreprintProviderSubjects, self).setUp()
self.lawless_preprint_provider = PreprintProviderFactory()
self.ruled_preprint_provider = PreprintProviderFactory()
self.ruled_preprint_provider.subjects_acceptable = self.create_subject_rules()
self.ruled_preprint_provider.save()
self.lawless_url = '/{}preprint_providers/{}/taxonomies/?page[size]=15&'.format(API_BASE, self.lawless_preprint_provider._id)
self.ruled_url = '/{}preprint_providers/{}/taxonomies/?page[size]=15&'.format(API_BASE, self.ruled_preprint_provider._id)
def test_no_rules_grabs_all(self):
res = self.app.get(self.lawless_url)
assert_equal(res.status_code, 200)
assert_equal(res.json['links']['meta']['total'], 15)
def test_rules_only_grab_acceptable_subjects(self):
res = self.app.get(self.ruled_url)
assert_equal(res.status_code, 200)
assert_equal(res.json['links']['meta']['total'], 11)
def test_no_rules_with_null_parent_filter(self):
res = self.app.get(self.lawless_url + 'filter[parents]=null')
assert_equal(res.status_code, 200)
assert_equal(res.json['links']['meta']['total'], 4)
def test_rules_enforced_with_null_parent_filter(self):
res = self.app.get(self.ruled_url + 'filter[parents]=null')
assert_equal(res.status_code, 200)
assert_equal(res.json['links']['meta']['total'], 3)
texts = [item['attributes']['text'] for item in res.json['data']]
assert_in('A', texts)
assert_in('H', texts)
assert_in('L', texts)
assert_not_in('O', texts)
def test_no_rules_with_parents_filter(self):
res = self.app.get(self.lawless_url + 'filter[parents]={}'.format(self.subB._id))
assert_equal(res.status_code, 200)
assert_equal(res.json['links']['meta']['total'], 1)
assert_equal(res.json['data'][0]['attributes']['text'], 'F')
res = self.app.get(self.lawless_url + 'filter[parents]={}'.format(self.subI._id))
assert_equal(res.status_code, 200)
assert_equal(res.json['links']['meta']['total'], 2)
res = self.app.get(self.lawless_url + 'filter[parents]={}'.format(self.subM._id))
assert_equal(res.status_code, 200)
assert_equal(res.json['links']['meta']['total'], 2)
def test_rules_enforced_with_parents_filter(self):
res = self.app.get(self.ruled_url + 'filter[parents]={}'.format(self.subB._id))
assert_equal(res.status_code, 200)
assert_equal(res.json['links']['meta']['total'], 0)
texts = [item['attributes']['text'] for item in res.json['data']]
assert_not_in('F', texts)
res = self.app.get(self.ruled_url + 'filter[parents]={}'.format(self.subI._id))
assert_equal(res.status_code, 200)
assert_equal(res.json['links']['meta']['total'], 1)
texts = [item['attributes']['text'] for item in res.json['data']]
assert_in('J', texts)
assert_not_in('K', texts)
res = self.app.get(self.ruled_url + 'filter[parents]={}'.format(self.subM._id))
assert_equal(res.status_code, 200)
assert_equal(res.json['links']['meta']['total'], 2)
texts = [item['attributes']['text'] for item in res.json['data']]
assert_in('N', texts)
assert_in('E', texts)
def test_no_rules_with_parent_filter(self):
res = self.app.get(self.lawless_url + 'filter[parent]={}'.format(self.subB._id))
assert_equal(res.status_code, 200)
assert_equal(res.json['links']['meta']['total'], 1)
assert_equal(res.json['data'][0]['attributes']['text'], 'F')
res = self.app.get(self.lawless_url + 'filter[parent]={}'.format(self.subI._id))
assert_equal(res.status_code, 200)
assert_equal(res.json['links']['meta']['total'], 2)
res = self.app.get(self.lawless_url + 'filter[parent]={}'.format(self.subM._id))
assert_equal(res.status_code, 200)
assert_equal(res.json['links']['meta']['total'], 2)
def test_rules_enforced_with_parent_filter(self):
res = self.app.get(self.ruled_url + 'filter[parent]={}'.format(self.subB._id))
assert_equal(res.status_code, 200)
assert_equal(res.json['links']['meta']['total'], 0)
texts = [item['attributes']['text'] for item in res.json['data']]
assert_not_in('F', texts)
res = self.app.get(self.ruled_url + 'filter[parent]={}'.format(self.subI._id))
assert_equal(res.status_code, 200)
assert_equal(res.json['links']['meta']['total'], 1)
texts = [item['attributes']['text'] for item in res.json['data']]
assert_in('J', texts)
assert_not_in('K', texts)
res = self.app.get(self.ruled_url + 'filter[parent]={}'.format(self.subM._id))
assert_equal(res.status_code, 200)
assert_equal(res.json['links']['meta']['total'], 2)
texts = [item['attributes']['text'] for item in res.json['data']]
assert_in('N', texts)
assert_in('E', texts)
def test_no_rules_with_grandparent_filter(self):
res = self.app.get(self.lawless_url + 'filter[parents]={}'.format(self.subA._id))
assert_equal(res.status_code, 200)
assert_equal(res.json['links']['meta']['total'], 3)
def test_rules_enforced_with_grandparent_filter(self):
res = self.app.get(self.ruled_url + 'filter[parents]={}'.format(self.subA._id))
assert_equal(res.status_code, 200)
assert_equal(res.json['links']['meta']['total'], 2)
texts = [item['attributes']['text'] for item in res.json['data']]
assert_in('B', texts)
assert_in('D', texts)
assert_not_in('C', texts)
def provider(self):
pp = PreprintProviderFactory(name='ModArxiv')
pp.update_group_permissions()
return pp
def provider(self, user):
provider = PreprintProviderFactory()
provider.add_to_group(user, 'moderator')
return provider
def preprint_provider(self, cc0_license, no_license):
preprint_provider = PreprintProviderFactory()
preprint_provider.licenses_acceptable = [cc0_license, no_license]
preprint_provider.save()
return preprint_provider
