def test_update_published(self, app, user):
unpublished = PreprintFactory(creator=user, is_published=False)
url = '/{}preprints/{}/'.format(API_BASE, unpublished._id)
payload = build_preprint_update_payload(unpublished._id, attributes={'is_published': True})
res = app.patch_json_api(url, payload, auth=user.auth)
unpublished.reload()
assert unpublished.is_published
def preprint(self, node_admin, provider):
preprint = PreprintFactory(
provider=provider,
is_published=False)
preprint.add_contributor(
node_admin, permissions=osf_permissions.ADMIN)
return preprint
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.node.is_public = False
pp.node.save()
non_contrib = AuthUserFactory()
res = self.app.get(pp.url + 'download', auth=non_contrib.auth, expect_errors=True)
assert res.status_code == 403
pp.node.is_deleted = True
pp.node.save()
res = self.app.get(pp.url + 'download', auth=non_contrib.auth, expect_errors=True)
assert res.status_code == 410
class TestPreprintConfirmationEmails(OsfTestCase):
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)
@mock.patch('website.mails.send_mail')
def test_creator_gets_email(self, send_mail):
self.preprint.set_published(True, auth=Auth(self.user), save=True)
send_mail.assert_called_with(
self.user.email,
mails.PREPRINT_CONFIRMATION_DEFAULT,
user=self.user,
node=self.preprint.node,
preprint=self.preprint
)
assert_equals(send_mail.call_count, 1)
self.preprint_branded.set_published(True, auth=Auth(self.user), save=True)
assert_equals(send_mail.call_count, 2)
def test_unregistered_contributor_detail_show_up_as_name_associated_with_preprint(
self,
app,
user,
preprint_published):
preprint_published.add_unregistered_contributor(
'Rheisen Dennis',
'*****@*****.**',
auth=Auth(user),
save=True)
unregistered_contributor = preprint_published.contributors[1]
url = '/{}preprints/{}/contributors/{}/'.format(
API_BASE, preprint_published._id, unregistered_contributor._id)
res = app.get(url, auth=user.auth, expect_errors=True)
assert res.status_code == 200
assert res.json['data']['embeds']['users']['data']['attributes']['full_name'] == 'Rheisen Dennis'
assert res.json['data']['attributes'].get(
'unregistered_contributor') == 'Rheisen Dennis'
preprint_two = PreprintFactory(creator=user, is_public=True)
preprint_two.add_unregistered_contributor(
'Nesiehr Sinned', '*****@*****.**', auth=Auth(user), save=True)
url = '/{}preprints/{}/contributors/{}/'.format(
API_BASE, preprint_two._id, unregistered_contributor._id)
res = app.get(url, auth=user.auth, expect_errors=True)
assert res.status_code == 200
assert res.json['data']['embeds']['users']['data']['attributes']['full_name'] == 'Rheisen Dennis'
assert res.json['data']['attributes'].get(
'unregistered_contributor') == 'Nesiehr Sinned'
def test_claim_user_registered_preprint_with_correct_password(self):
preprint = PreprintFactory(creator=self.referrer)
name, email = fake.name(), fake_email()
unreg_user = preprint.add_unregistered_contributor(
fullname=name,
email=email,
auth=Auth(user=self.referrer)
)
reg_user = AuthUserFactory() # NOTE: AuthUserFactory sets password as 'queenfan86'
url = unreg_user.get_claim_url(preprint._id)
# Follow to password re-enter page
res = self.app.get(url, auth=reg_user.auth).follow(auth=reg_user.auth)
# verify that the "Claim Account" form is returned
assert_in('Claim Contributor', res.body)
form = res.forms['claimContributorForm']
form['password'] = '******'
res = form.submit(auth=reg_user.auth)
preprint.reload()
unreg_user.reload()
# user is now a contributor to the project
assert_in(reg_user, preprint.contributors)
# the unregistered user (unreg_user) is removed as a contributor, and their
assert_not_in(unreg_user, preprint.contributors)
# unclaimed record for the project has been deleted
assert_not_in(preprint, unreg_user.unclaimed_records)
class TestPreprintConfirmationEmails(OsfTestCase):
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)
@mock.patch('website.mails.send_mail')
def test_creator_gets_email(self, send_mail):
self.preprint.set_published(True, auth=Auth(self.user), save=True)
domain = self.preprint.provider.domain or settings.DOMAIN
send_mail.assert_called_with(
self.user.email,
mails.REVIEWS_SUBMISSION_CONFIRMATION,
user=self.user,
mimetype='html',
provider_url='{}preprints/{}'.format(domain, self.preprint.provider._id),
domain=domain,
provider_contact_email=settings.OSF_CONTACT_EMAIL,
provider_support_email=settings.OSF_SUPPORT_EMAIL,
workflow=None,
reviewable=self.preprint,
is_creator=True,
provider_name=self.preprint.provider.name,
no_future_emails=[],
logo=settings.OSF_PREPRINTS_LOGO,
)
assert_equals(send_mail.call_count, 1)
self.preprint_branded.set_published(True, auth=Auth(self.user), save=True)
assert_equals(send_mail.call_count, 2)
def preprint(self, user, user_write_contrib):
preprint = PreprintFactory(creator=user)
preprint.add_contributor(
user_write_contrib,
permissions=permissions.WRITE,
visible=True, save=True)
return preprint
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 test_delete_preprint_primary_file(self):
user = UserFactory()
preprint = PreprintFactory(creator=user)
preprint.save()
file = preprint.files.all()[0]
with assert_raises(FileNodeIsPrimaryFile):
file.delete()
def setUp(self):
super(TestPreprintSpam, self).setUp()
self.user = AuthUserFactory()
self.auth = Auth(user=self.user)
self.node = ProjectFactory(creator=self.user, is_public=True)
self.preprint_one = PreprintFactory(creator=self.user, project=self.node)
self.preprint_two = PreprintFactory(creator=self.user, project=self.node, filename='preprint_file_two.txt')
def preprint_one(self, user, project_one, provider_one, subject_one):
preprint_one = PreprintFactory(
creator=user,
project=project_one,
provider=provider_one,
subjects=[[subject_one._id]])
preprint_one.original_publication_date = '2013-12-25 10:09:08.070605+00:00'
preprint_one.save()
return preprint_one
def preprint(self, user_admin_contrib, user_write_contrib, project, provider, subject):
preprint = PreprintFactory(
creator=user_admin_contrib,
filename='saor.pdf',
provider=provider,
subjects=[[subject._id]],
project=project,
is_published=True)
preprint.add_contributor(user_write_contrib, 'write', save=True)
return preprint
def test_move_preprint_primary_file_to_node(self):
user = UserFactory()
preprint = PreprintFactory(creator=user)
preprint.save()
to_move = preprint.files.all()[0]
assert_true(to_move.is_preprint_primary)
move_to = self.node_settings.get_root().append_folder('Cloud')
with assert_raises(FileNodeIsPrimaryFile):
moved = to_move.move_under(move_to, name='Tuna')
def preprint(self, user, contribs):
preprint = PreprintFactory(creator=user)
for contrib in contribs:
if contrib._id != user._id:
preprint.add_contributor(
contrib,
permissions=permissions.WRITE,
visible=True,
save=True
)
return preprint
def test_copy_node_file_to_preprint(self):
user = UserFactory()
preprint = PreprintFactory(creator=user)
preprint.save()
to_copy = self.node_settings.get_root().append_file('Carp')
copy_to = preprint.root_folder
copied = to_copy.copy_under(copy_to)
assert_equal(copied.parent, copy_to)
assert_equal(copied.target, preprint)
def test_gets(
self, app, user_one, user_two, preprint,
project_public, project_private):
# test_authorized_in_gets_200
url = '/{}users/{}/preprints/'.format(API_BASE, user_one._id)
res = app.get(url, auth=user_one.auth)
assert res.status_code == 200
assert res.content_type == 'application/vnd.api+json'
# test_anonymous_gets_200
url = '/{}users/{}/preprints/'.format(API_BASE, user_one._id)
res = app.get(url)
assert res.status_code == 200
assert res.content_type == 'application/vnd.api+json'
# test_get_preprints_logged_in
url = '/{}users/{}/preprints/'.format(API_BASE, user_one._id)
res = app.get(url, auth=user_one.auth)
node_json = res.json['data']
ids = [each['id'] for each in node_json]
assert preprint._id in ids
assert project_public._id not in ids
assert project_private._id not in ids
# test_get_projects_not_logged_in
url = '/{}users/{}/preprints/'.format(API_BASE, user_one._id)
res = app.get(url)
node_json = res.json['data']
ids = [each['id'] for each in node_json]
assert preprint._id in ids
assert project_public._id not in ids
assert project_private._id not in ids
# test_get_projects_logged_in_as_different_user
url = '/{}users/{}/preprints/'.format(API_BASE, user_one._id)
res = app.get(url, auth=user_two.auth)
node_json = res.json['data']
ids = [each['id'] for each in node_json]
assert preprint._id in ids
assert project_public._id not in ids
assert project_private._id not in ids
abandoned_preprint = PreprintFactory(creator=user_one, finish=False)
abandoned_preprint.machine_state = 'initial'
abandoned_preprint.save()
url = '/{}users/{}/preprints/'.format(API_BASE, user_one._id)
res = app.get(url, auth=user_one.auth)
actual = [result['id'] for result in res.json['data']]
assert abandoned_preprint._id not in actual
def none_mod_preprint(self, admin, write_contrib, none_mod_provider):
preprint = PreprintFactory(
creator=admin,
provider=none_mod_provider,
)
preprint.save()
preprint.add_contributor(
contributor=write_contrib,
permissions='write',
save=True
)
return preprint
def none_mod_preprint(self, admin, write_contrib, none_mod_provider):
preprint = PreprintFactory(
creator=admin,
provider=none_mod_provider,
)
preprint.save()
preprint.node.add_contributor(
contributor=write_contrib,
permissions=permissions.DEFAULT_CONTRIBUTOR_PERMISSIONS,
save=True
)
return preprint
class TestPreprintFactory(OsfTestCase):
def setUp(self):
super(TestPreprintFactory, self).setUp()
self.user = AuthUserFactory()
self.auth = Auth(user=self.user)
self.preprint = PreprintFactory(creator=self.user)
self.preprint.save()
def test_is_preprint(self):
assert_true(self.preprint.node.is_preprint)
def test_preprint_is_public(self):
assert_true(self.preprint.node.is_public)
def auto_withdrawable_pre_mod_preprint(self, admin, write_contrib, pre_mod_provider):
pre = PreprintFactory(
creator=admin,
provider=pre_mod_provider,
is_published=False,
machine_state='pending'
)
pre.save()
pre.add_contributor(
contributor=write_contrib,
permissions='write',
save=True
)
return pre
def test_move_preprint_primary_file_within_preprint(self):
user = UserFactory()
preprint = PreprintFactory(creator=user)
preprint.save()
folder = OsfStorageFolder(name='foofolder', target=preprint)
folder.save()
to_move = preprint.files.all()[0]
assert_true(to_move.is_preprint_primary)
moved = to_move.move_under(folder, name='Tuna')
assert preprint.primary_file == to_move
assert to_move.parent == folder
assert folder.target == preprint
def test_identifier_preprint_detail_datacite_doi(self, app, user):
""" Make sure dois with the temporary category legacy_doi show up
with the category doi for now, until the proper migration happens
"""
preprint = PreprintFactory(set_doi=False)
doi_value = '10.123/datacitedoi/woo'
preprint.set_identifier_value(category='legacy_doi', value=doi_value)
identifier = preprint.identifiers.filter(category='legacy_doi').first()
url = '/{}identifiers/{}/'.format(API_BASE, identifier._id)
res = app.get(url, auth=user.auth)
attributes = res.json['data']['attributes']
assert attributes['category'] == 'doi'
assert attributes['value'] == doi_value
def preprint_unpublished(
self,
user_admin_contrib,
user_write_contrib,
provider_one,
project_public,
subject):
preprint = PreprintFactory(creator=user_admin_contrib,
filename='mgla.pdf',
provider=provider_one,
subjects=[[subject._id]],
project=project_public,
is_published=False)
preprint.add_contributor(user_write_contrib, 'write', save=True)
return preprint
def setUp(self):
super(TestPreprintFactory, self).setUp()
self.user = AuthUserFactory()
self.auth = Auth(user=self.user)
self.preprint = PreprintFactory(creator=self.user)
self.preprint.save()
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()
self.preprint.node.add_tag('preprint', self.auth, save=False)
self.preprint.node.add_tag('spoderman', self.auth, save=False)
self.preprint.node.add_unregistered_contributor('BoJack Horseman', '*****@*****.**', Auth(self.preprint.node.creator))
self.preprint.node.add_contributor(self.user, visible=False)
self.preprint.node.save()
self.preprint.node.creator.given_name = u'ZZYZ'
if len(self.preprint.node.creator.fullname.split(' ')) > 2:
# Prevent unexpected keys ('suffix', 'additional_name')
self.preprint.node.creator.fullname = 'David Davidson'
self.preprint.node.creator.middle_names = ''
self.preprint.node.creator.suffix = ''
self.preprint.node.creator.save()
self.preprint.set_subjects([[SubjectFactory()._id]], auth=Auth(self.preprint.node.creator), save=False)
def preprint_unpublished(
self,
user_admin_contrib,
provider_one,
project_public,
user_write_contrib,
subject):
preprint = PreprintFactory(creator=user_admin_contrib,
filename='mgla.pdf',
provider=provider_one,
subjects=[[subject._id]],
project=project_public,
is_published=False,
machine_state=DefaultStates.INITIAL.value)
preprint.add_contributor(user_write_contrib, permissions='write', save=True)
return preprint
def setUp(self):
super(TestPreprintCitationContentChicago, self).setUp()
self.admin_contributor = AuthUserFactory()
self.published_preprint = PreprintFactory(
title='A Study of Coffee',
creator=self.admin_contributor)
self.published_preprint.save()
self.admin_contributor.given_name = 'Grapes'
self.admin_contributor.middle_names = ' Coffee Beans '
self.admin_contributor.family_name = 'McGee'
self.admin_contributor.save()
self.published_preprint_url = '/{}preprints/{}/citation/chicago-author-date/'.format(
API_BASE, self.published_preprint._id)
self.second_contrib = AuthUserFactory()
self.second_contrib.given_name = 'Darla'
self.second_contrib.middle_names = 'Texas Toast'
self.second_contrib.family_name = 'Jenkins'
self.second_contrib.suffix = 'Junior'
self.second_contrib.save()
self.third_contrib = AuthUserFactory()
self.third_contrib.given_name = 'Lilith'
self.third_contrib.middle_names = 'Radar'
self.third_contrib.family_name = 'Schematics'
self.third_contrib.save()
def setUp(self):
super(TestSetPreprintFile, self).setUp()
self.user = AuthUserFactory()
self.auth = Auth(user=self.user)
self.read_write_user = AuthUserFactory()
self.read_write_user_auth = Auth(user=self.read_write_user)
self.project = ProjectFactory(creator=self.user)
self.file = OsfStorageFile.create(
node=self.project,
path='/panda.txt',
name='panda.txt',
materialized_path='/panda.txt')
self.file.save()
self.file_two = OsfStorageFile.create(
node=self.project,
path='/pandapanda.txt',
name='pandapanda.txt',
materialized_path='/pandapanda.txt')
self.file_two.save()
self.project.add_contributor(self.read_write_user, permissions=[permissions.WRITE])
self.project.save()
self.preprint = PreprintFactory(project=self.project, finish=False)
def setUp(self):
super(TestPreprintServicePermissions, 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, is_published=False)
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_update_published_makes_node_public(
self, app, user):
unpublished = PreprintFactory(creator=user, is_published=False)
assert not unpublished.node.is_public
url = '/{}preprints/{}/'.format(API_BASE, unpublished._id)
payload = build_preprint_update_payload(
unpublished._id, attributes={'is_published': True})
app.patch_json_api(url, payload, auth=user.auth)
unpublished.node.reload()
assert unpublished.node.is_public
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 preprint_unpublished(
self,
user_admin_contrib,
provider_one,
project_public,
subject):
return PreprintFactory(creator=user_admin_contrib,
filename='mgla.pdf',
provider=provider_one,
subjects=[[subject._id]],
project=project_public,
is_published=False)
def test_format_subjects_for_preprint(self):
subject = SubjectFactory()
subject_1 = SubjectFactory(parent=subject)
subject_2 = SubjectFactory(parent=subject)
subjects = [[subject._id, subject_1._id], [subject._id, subject_2._id]]
preprint = PreprintFactory(subjects=subjects,
project=self.node,
is_published=True)
formatted_subjects = metadata.format_subjects(preprint)
assert len(formatted_subjects) == Subject.objects.all().count()
def setUp(self):
super(TestUserPreprints, self).setUp()
self.user_one = AuthUserFactory()
self.user_two = AuthUserFactory()
self.preprint = PreprintFactory(title="Preprint User One",
creator=self.user_one)
self.public_project = ProjectFactory(title="Public Project User One",
is_public=True,
creator=self.user_one)
self.private_project = ProjectFactory(title="Private Project User One",
is_public=False,
creator=self.user_one)
def preprint_three(self, user, project_three, provider_three, subject_one,
subject_two):
preprint_three = PreprintFactory(creator=user,
project=project_three,
filename='darn_reason.txt',
provider=provider_three,
subjects=[[subject_one._id],
[subject_two._id]])
preprint_three.date_created = '2013-12-11 10:09:08.070605+00:00'
preprint_three.date_published = '2013-12-11 10:09:08.070605+00:00'
preprint_three.original_publication_date = '2013-12-11 10:09:08.070605+00:00'
preprint_three.is_published = False
preprint_three.save()
return preprint_three
class TestPreprintDeleteView(AdminTestCase):
def setUp(self):
super(TestPreprintDeleteView, self).setUp()
self.user = AuthUserFactory()
self.preprint = PreprintFactory(creator=self.user)
self.request = RequestFactory().post('/fake_path')
self.plain_view = views.PreprintDeleteView
self.view = setup_log_view(self.plain_view(),
self.request,
guid=self.preprint._id)
self.url = reverse('preprints:remove',
kwargs={'guid': self.preprint._id})
def test_remove_preprint(self):
count = AdminLogEntry.objects.count()
self.view.post(self.request)
self.preprint.refresh_from_db()
assert self.preprint.deleted is not None
assert AdminLogEntry.objects.count() == count + 1
def test_restore_preprint(self):
self.view.post(self.request)
self.preprint.refresh_from_db()
assert self.preprint.deleted is not None
count = AdminLogEntry.objects.count()
self.view.post(self.request)
self.preprint.reload()
assert self.preprint.deleted is None
assert AdminLogEntry.objects.count() == count + 1
class TestPreprintDeleteView(AdminTestCase):
def setUp(self):
super(TestPreprintDeleteView, self).setUp()
self.user = AuthUserFactory()
self.preprint = PreprintFactory(creator=self.user)
self.request = RequestFactory().post('/fake_path')
self.plain_view = views.PreprintDeleteView
self.view = setup_log_view(self.plain_view(), self.request,
guid=self.preprint._id)
self.url = reverse('preprints:remove', kwargs={'guid': self.preprint._id})
def test_get_object(self):
obj = self.view.get_object()
assert isinstance(obj, Preprint)
def test_get_context(self):
res = self.view.get_context_data(object=self.preprint)
assert 'guid' in res
assert res.get('guid') == self.preprint._id
def test_remove_preprint(self):
count = AdminLogEntry.objects.count()
self.view.delete(self.request)
self.preprint.refresh_from_db()
assert self.preprint.deleted is not None
assert AdminLogEntry.objects.count() == count + 1
def test_restore_preprint(self):
self.view.delete(self.request)
self.preprint.refresh_from_db()
assert self.preprint.deleted is not None
count = AdminLogEntry.objects.count()
self.view.delete(self.request)
self.preprint.reload()
assert self.preprint.deleted is None
assert AdminLogEntry.objects.count() == count + 1
def test_no_user_permissions_raises_error(self):
guid = self.preprint._id
request = RequestFactory().get(self.url)
request.user = self.user
with pytest.raises(PermissionDenied):
self.plain_view.as_view()(request, guid=guid, user_id=self.user)
def test_correct_view_permissions(self):
user = AuthUserFactory()
guid = self.preprint._id
change_permission = Permission.objects.get(codename='delete_preprint')
view_permission = Permission.objects.get(codename='view_preprint')
user.user_permissions.add(change_permission)
user.user_permissions.add(view_permission)
user.save()
request = RequestFactory().get(self.url)
request.user = user
response = self.plain_view.as_view()(request, guid=guid)
assert response.status_code == 200
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 preprint_two(self, user, project_two, provider_two, subject_two):
preprint_two = PreprintFactory(creator=user,
project=project_two,
filename='howto_reason.txt',
provider=provider_two,
subjects=[[subject_two._id]])
preprint_two.date_created = '2013-12-11 10:09:08.070605+00:00'
preprint_two.date_published = '2013-12-11 10:09:08.070605+00:00'
preprint_two.original_publication_date = '2013-12-11 10:09:08.070605+00:00'
preprint_two.save()
return preprint_two
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)
class TestPreprintIdentifiers(OsfTestCase):
def setUp(self):
super(TestPreprintIdentifiers, self).setUp()
self.user = AuthUserFactory()
self.auth = Auth(user=self.user)
self.preprint = PreprintFactory(is_published=False, creator=self.user)
@mock.patch('website.preprints.tasks.get_and_set_preprint_identifiers.si')
def test_identifiers_task_called_on_publish(self, mock_get_and_set_identifiers):
assert self.preprint.identifiers.count() == 0
self.preprint.set_published(True, auth=self.auth, save=True)
assert mock_get_and_set_identifiers.called
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 preprint_unpublished(
self,
user_admin_contrib,
provider_one,
project_public,
subject):
return PreprintFactory(creator=user_admin_contrib,
filename='mgla.pdf',
provider=provider_one,
subjects=[[subject._id]],
project=project_public,
is_published=False,
machine_state=DefaultStates.INITIAL.value)
def test_change_preprint_provider_subjects_custom_taxonomies(
self, plain_view, preprint_user, provider_one, provider_two,
subject_one):
""" Testing that subjects are changed when providers are changed between two custom taxonomies.
"""
subject_two = SubjectFactory(
provider=provider_two, bepress_subject=subject_one.bepress_subject)
preprint = PreprintFactory(subjects=[[subject_one._id]],
provider=provider_one,
creator=preprint_user)
request = RequestFactory().post(reverse('preprints:preprint',
kwargs={'guid': preprint._id}),
data={'provider': provider_two.id})
request.user = preprint_user
response = plain_view.as_view()(request, guid=preprint._id)
assert response.status_code == 302
preprint.refresh_from_db()
assert preprint.provider == provider_two
assert subject_two in preprint.subjects.all()
def preprint(
self, admin_contrib, write_contrib, read_contrib,
preprint_provider):
preprint = PreprintFactory(
creator=admin_contrib,
provider=preprint_provider)
preprint.node.add_contributor(write_contrib, auth=Auth(admin_contrib))
preprint.node.add_contributor(
read_contrib,
auth=Auth(admin_contrib),
permissions=['read'])
preprint.node.save()
return preprint
def test_change_preprint_provider_subjects_from_osf(
self, plain_view, preprint_user, provider_one, provider_osf,
subject_osf):
""" Testing that subjects are changed when a provider is changed from osf using the bepress subject id of the new subject.
"""
subject_two = SubjectFactory(provider=provider_one,
bepress_subject=subject_osf)
preprint = PreprintFactory(subjects=[[subject_osf._id]],
provider=provider_osf,
creator=preprint_user)
request = RequestFactory().post(reverse('preprints:preprint',
kwargs={'guid': preprint._id}),
data={'provider': provider_one.id})
request.user = preprint_user
response = plain_view.as_view()(request, guid=preprint._id)
assert response.status_code == 302
preprint.refresh_from_db()
assert preprint.provider == provider_one
assert subject_two in preprint.subjects.all()
def test_state_changes(self):
user = AuthUserFactory()
preprint = PreprintFactory(provider__reviews_workflow='pre-moderation', is_published=False)
assert preprint.machine_state == DefaultStates.INITIAL.value
preprint.run_submit(user)
assert preprint.machine_state == DefaultStates.PENDING.value
preprint.run_accept(user, 'comment')
assert preprint.machine_state == DefaultStates.ACCEPTED.value
from_db = PreprintService.objects.get(id=preprint.id)
assert from_db.machine_state == DefaultStates.ACCEPTED.value
preprint.run_reject(user, 'comment')
assert preprint.machine_state == DefaultStates.REJECTED.value
from_db.refresh_from_db()
assert from_db.machine_state == DefaultStates.REJECTED.value
preprint.run_accept(user, 'comment')
assert preprint.machine_state == DefaultStates.ACCEPTED.value
from_db.refresh_from_db()
assert from_db.machine_state == DefaultStates.ACCEPTED.value
def preprint_with_contributor(self, mergee):
preprint = PreprintFactory()
preprint.add_contributor(mergee,
permissions=WRITE,
visible=False,
save=True)
preprint.save()
return preprint
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_update_published_does_not_send_contributor_added_for_inactive_users(
self):
unpublished = PreprintFactory(creator=self.user, is_published=False)
unpublished.node.add_unregistered_contributor(fullname=fake.name(),
email=fake.email(),
auth=Auth(self.user),
save=True)
url = '/{}preprints/{}/'.format(API_BASE, unpublished._id)
payload = build_preprint_update_payload(
unpublished._id, attributes={'is_published': True})
with capture_signals() as captured:
res = self.app.patch_json_api(url, payload, auth=self.user.auth)
# Signal not sent, because contributor is not registered
assert_false(captured[contributor_added])
class TestPreprintConfirmHamSpamViews(AdminTestCase):
def setUp(self):
super(TestPreprintConfirmHamSpamViews, self).setUp()
self.request = RequestFactory().post('/fake_path')
self.user = AuthUserFactory()
self.preprint = PreprintFactory(creator=self.user)
def test_confirm_preprint_as_ham(self):
view = views.PreprintConfirmHamView()
view = setup_log_view(view, self.request, guid=self.preprint._id)
view.delete(self.request)
self.preprint.refresh_from_db()
assert self.preprint.spam_status == 4
def test_confirm_preprint_as_spam(self):
assert self.preprint.is_public
view = views.PreprintConfirmSpamView()
view = setup_log_view(view, self.request, guid=self.preprint._id)
view.delete(self.request)
self.preprint.refresh_from_db()
assert self.preprint.spam_status == 2
assert not self.preprint.is_public
class TestPreprintSpam(OsfTestCase):
def setUp(self):
super(TestPreprintSpam, self).setUp()
self.user = AuthUserFactory()
self.auth = Auth(user=self.user)
self.node = ProjectFactory(creator=self.user, is_public=True)
self.preprint_one = PreprintFactory(creator=self.user,
project=self.node)
self.preprint_two = PreprintFactory(creator=self.user,
project=self.node,
filename='preprint_file_two.txt')
@mock.patch.object(settings, 'SPAM_CHECK_ENABLED', True)
def test_preprints_get_marked_as_spammy_if_node_is_spammy(self):
with mock.patch('osf.models.node.Node._get_spam_content',
mock.Mock(return_value='some content!')):
with mock.patch('osf.models.node.Node.do_check_spam',
mock.Mock(return_value=True)):
self.node.check_spam(self.user, None, None)
self.preprint_one.reload()
self.preprint_two.reload()
assert_true(self.preprint_one.is_spammy)
assert_true(self.preprint_two.is_spammy)
def test_delete_from_share(self, mock_share):
preprint = PreprintFactory()
update_share(preprint)
data = json.loads(mock_share.calls[-1].request.body.decode())
graph = data['data']['attributes']['data']['@graph']
share_preprint = next(n for n in graph if n['@type'] == 'preprint')
assert not share_preprint['is_deleted']
preprint.date_withdrawn = datetime.now()
update_share(preprint)
data = json.loads(mock_share.calls[-1].request.body.decode())
graph = data['data']['attributes']['data']['@graph']
share_preprint = next(n for n in graph if n['@type'] == 'preprint')
assert not share_preprint['is_deleted']
preprint.spam_status = SpamStatus.SPAM
update_share(preprint)
data = json.loads(mock_share.calls[-1].request.body.decode())
graph = data['data']['attributes']['data']['@graph']
share_preprint = next(n for n in graph if n['@type'] == 'preprint')
assert share_preprint['is_deleted']
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.node.is_public = False
pp.node.save()
non_contrib = AuthUserFactory()
res = self.app.get(pp.url + 'download',
auth=non_contrib.auth,
expect_errors=True)
assert res.status_code == 403
pp.node.is_deleted = True
pp.node.save()
res = self.app.get(pp.url + 'download',
auth=non_contrib.auth,
expect_errors=True)
# assert res.status_code == 410
# This will throw an unauthorized error before it reaches deleted
assert res.status_code == 403
def post_mod_preprint(self, admin, write_contrib, post_mod_provider):
post = PreprintFactory(
creator=admin,
provider=post_mod_provider,
)
post.save()
post.add_contributor(contributor=write_contrib,
permissions='write',
save=True)
return post
def none_mod_preprint(self, admin, write_contrib, none_mod_provider):
preprint = PreprintFactory(
creator=admin,
provider=none_mod_provider,
)
preprint.save()
preprint.add_contributor(contributor=write_contrib,
permissions=permissions.WRITE,
save=True)
return 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 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_correct_doi_client_called(self):
osf_preprint = PreprintFactory(is_published=True,
creator=self.user,
provider=PreprintProviderFactory())
assert isinstance(osf_preprint.get_doi_client(), CrossRefClient)
ecsarxiv_preprint = PreprintFactory(
is_published=True,
creator=self.user,
provider=PreprintProviderFactory(_id='ecsarxiv'))
assert isinstance(ecsarxiv_preprint.get_doi_client(),
ECSArXivCrossRefClient)
