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,
osf_contact_email=settings.OSF_CONTACT_EMAIL)
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)
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)
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)
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)
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.s')
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
class TestPreprintSaveShareHook(OsfTestCase):
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)
@mock.patch('website.preprints.tasks.on_preprint_updated.s')
def test_save_unpublished_not_called(self, mock_on_preprint_updated):
self.preprint.save()
assert not mock_on_preprint_updated.called
@mock.patch('website.preprints.tasks.on_preprint_updated.s')
def test_save_published_called(self, mock_on_preprint_updated):
self.preprint.set_published(True, auth=self.auth, save=True)
assert mock_on_preprint_updated.called
# This covers an edge case where a preprint is forced back to unpublished
# that it sends the information back to share
@mock.patch('website.preprints.tasks.on_preprint_updated.s')
def test_save_unpublished_called_forced(self, mock_on_preprint_updated):
self.preprint.set_published(True, auth=self.auth, save=True)
self.preprint.published = False
self.preprint.save(**{'force_update': True})
assert_equal(mock_on_preprint_updated.call_count, 2)
@mock.patch('website.preprints.tasks.on_preprint_updated.s')
def test_save_published_called(self, mock_on_preprint_updated):
self.preprint.set_published(True, auth=self.auth, save=True)
assert mock_on_preprint_updated.called
@mock.patch('website.preprints.tasks.on_preprint_updated.s')
def test_save_published_subject_change_called(self,
mock_on_preprint_updated):
self.preprint.is_published = True
self.preprint.set_subjects([[self.subject_two._id]],
auth=self.auth,
save=True)
assert mock_on_preprint_updated.called
@mock.patch('website.preprints.tasks.on_preprint_updated.s')
def test_save_unpublished_subject_change_not_called(
self, mock_on_preprint_updated):
self.preprint.set_subjects([[self.subject_two._id]],
auth=self.auth,
save=True)
assert not mock_on_preprint_updated.called
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
class TestPreprintSaveShareHook(OsfTestCase):
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)
@mock.patch('website.preprints.tasks.on_preprint_updated.s')
def test_save_unpublished_not_called(self, mock_on_preprint_updated):
self.preprint.save()
assert not mock_on_preprint_updated.called
@mock.patch('website.preprints.tasks.on_preprint_updated.s')
def test_save_published_called(self, mock_on_preprint_updated):
self.preprint.set_published(True, auth=self.auth, save=True)
assert mock_on_preprint_updated.called
# This covers an edge case where a preprint is forced back to unpublished
# that it sends the information back to share
@mock.patch('website.preprints.tasks.on_preprint_updated.s')
def test_save_unpublished_called_forced(self, mock_on_preprint_updated):
self.preprint.set_published(True, auth=self.auth, save=True)
self.preprint.published = False
self.preprint.save(**{'force_update': True})
assert_equal(mock_on_preprint_updated.call_count, 2)
@mock.patch('website.preprints.tasks.on_preprint_updated.s')
def test_save_published_called(self, mock_on_preprint_updated):
self.preprint.set_published(True, auth=self.auth, save=True)
assert mock_on_preprint_updated.called
@mock.patch('website.preprints.tasks.on_preprint_updated.s')
def test_save_published_subject_change_called(self, mock_on_preprint_updated):
self.preprint.is_published = True
self.preprint.set_subjects([[self.subject_two._id]], auth=self.auth, save=True)
assert mock_on_preprint_updated.called
@mock.patch('website.preprints.tasks.on_preprint_updated.s')
def test_save_unpublished_subject_change_not_called(self, mock_on_preprint_updated):
self.preprint.set_subjects([[self.subject_two._id]], auth=self.auth, save=True)
assert not mock_on_preprint_updated.called
@mock.patch('website.preprints.tasks.requests')
@mock.patch('website.project.tasks.settings.SHARE_URL', 'ima_real_website')
def test_send_to_share_is_true(self, mock_requests):
self.preprint.provider.access_token = 'Snowmobiling'
self.preprint.provider.save()
on_preprint_updated(self.preprint._id)
assert mock_requests.post.called
class TestPreprintSaveShareHook(OsfTestCase):
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)
@mock.patch('website.preprints.tasks.on_preprint_updated.si')
def test_save_unpublished_not_called(self, mock_on_preprint_updated):
self.preprint.save()
assert not mock_on_preprint_updated.called
@mock.patch('website.preprints.tasks.on_preprint_updated.si')
def test_save_published_called(self, mock_on_preprint_updated):
self.preprint.set_published(True, auth=self.auth, save=True)
assert mock_on_preprint_updated.called
# This covers an edge case where a preprint is forced back to unpublished
# that it sends the information back to share
@mock.patch('website.preprints.tasks.on_preprint_updated.si')
def test_save_unpublished_called_forced(self, mock_on_preprint_updated):
self.preprint.set_published(True, auth=self.auth, save=True)
self.preprint.published = False
self.preprint.save(**{'force_update': True})
assert_equal(mock_on_preprint_updated.call_count, 2)
@mock.patch('website.preprints.tasks.on_preprint_updated.si')
def test_save_published_called(self, mock_on_preprint_updated):
self.preprint.set_published(True, auth=self.auth, save=True)
assert mock_on_preprint_updated.called
@mock.patch('website.preprints.tasks.on_preprint_updated.si')
def test_save_published_subject_change_called(self,
mock_on_preprint_updated):
self.preprint.is_published = True
self.preprint.set_subjects([[self.subject_two._id]], auth=self.auth)
assert mock_on_preprint_updated.called
assert {
'old_subjects': [self.subject.id]
} in mock_on_preprint_updated.call_args
@mock.patch('website.preprints.tasks.on_preprint_updated.si')
def test_save_unpublished_subject_change_not_called(
self, mock_on_preprint_updated):
self.preprint.set_subjects([[self.subject_two._id]], auth=self.auth)
assert not mock_on_preprint_updated.called
@mock.patch('website.preprints.tasks.requests')
@mock.patch('website.preprints.tasks.settings.SHARE_URL',
'ima_real_website')
def test_send_to_share_is_true(self, mock_requests):
self.preprint.provider.access_token = 'Snowmobiling'
self.preprint.provider.save()
on_preprint_updated(self.preprint._id)
assert mock_requests.post.called
@mock.patch('website.preprints.tasks.on_preprint_updated.si')
def test_node_contributor_changes_updates_preprints_share(
self, mock_on_preprint_updated):
# A user is added as a contributor
self.preprint.is_published = True
self.preprint.save()
assert mock_on_preprint_updated.call_count == 1
user = AuthUserFactory()
node = self.preprint.node
node.preprint_file = self.file
node.add_contributor(contributor=user, auth=self.auth)
assert mock_on_preprint_updated.call_count == 2
node.move_contributor(contributor=user, index=0, auth=self.auth)
assert mock_on_preprint_updated.call_count == 3
data = [{
'id': self.admin._id,
'permission': 'admin',
'visible': True
}, {
'id': user._id,
'permission': 'write',
'visible': False
}]
node.manage_contributors(data, auth=self.auth, save=True)
assert mock_on_preprint_updated.call_count == 4
node.update_contributor(user, 'read', True, auth=self.auth, save=True)
assert mock_on_preprint_updated.call_count == 5
node.remove_contributor(contributor=user, auth=self.auth)
assert mock_on_preprint_updated.call_count == 6
@mock.patch('website.preprints.tasks.settings.SHARE_URL', 'a_real_url')
@mock.patch('website.preprints.tasks._async_update_preprint_share.delay')
@mock.patch('website.preprints.tasks.requests')
def test_call_async_update_on_500_failure(self, requests, mock_async):
self.preprint.provider.access_token = 'Snowmobiling'
requests.post.return_value = MockShareResponse(501)
update_preprint_share(self.preprint)
assert mock_async.called
@mock.patch('website.preprints.tasks.settings.SHARE_URL', 'a_real_url')
@mock.patch('website.preprints.tasks.send_desk_share_preprint_error')
@mock.patch('website.preprints.tasks._async_update_preprint_share.delay')
@mock.patch('website.preprints.tasks.requests')
def test_no_call_async_update_on_400_failure(self, requests, mock_async,
mock_mail):
self.preprint.provider.access_token = 'Snowmobiling'
requests.post.return_value = MockShareResponse(400)
update_preprint_share(self.preprint)
assert not mock_async.called
assert mock_mail.called
class TestSetPreprintFile(OsfTestCase):
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)
@assert_logs(NodeLog.MADE_PUBLIC, 'project')
@assert_logs(NodeLog.PREPRINT_INITIATED, 'project', -2)
def test_is_preprint_property_new_file_to_published(self):
assert_false(self.project.is_preprint)
self.preprint.set_primary_file(self.file, auth=self.auth, save=True)
self.project.reload()
assert_false(self.project.is_preprint)
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_preprint)
self.preprint.set_published(True, auth=self.auth, save=True)
self.project.reload()
assert_true(self.project.is_preprint)
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 test_add_primary_file(self):
self.preprint.set_primary_file(self.file, auth=self.auth, save=True)
assert_equal(self.project.preprint_file, self.file)
assert_equal(type(self.project.preprint_file), type(self.file))
@assert_logs(NodeLog.PREPRINT_FILE_UPDATED, 'project')
def test_change_primary_file(self):
self.preprint.set_primary_file(self.file, auth=self.auth, save=True)
assert_equal(self.project.preprint_file, self.file)
self.preprint.set_primary_file(self.file_two,
auth=self.auth,
save=True)
assert_equal(self.project.preprint_file._id, self.file_two._id)
def test_add_invalid_file(self):
with assert_raises(AttributeError):
self.preprint.set_primary_file('inatlanta',
auth=self.auth,
save=True)
def test_deleted_file_creates_orphan(self):
self.preprint.set_primary_file(self.file, auth=self.auth, save=True)
self.file.is_deleted = True
self.file.save()
assert_true(self.project.is_preprint_orphan)
def test_preprint_created_date(self):
self.preprint.set_primary_file(self.file, auth=self.auth, save=True)
assert_equal(self.project.preprint_file._id, self.file._id)
assert (self.preprint.created)
assert_not_equal(self.project.created, self.preprint.created)
def test_non_admin_update_file(self):
self.preprint.set_primary_file(self.file, auth=self.auth, save=True)
assert_equal(self.project.preprint_file._id, self.file._id)
with assert_raises(PermissionsError):
self.preprint.set_primary_file(self.file_two,
auth=self.read_write_user_auth,
save=True)
assert_equal(self.project.preprint_file._id, self.file._id)
class TestPreprintServicePermissions(OsfTestCase):
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_nonadmin_cannot_set_subjects(self):
initial_subjects = list(self.preprint.subjects.all())
with assert_raises(PermissionsError):
self.preprint.set_subjects([[SubjectFactory()._id]],
auth=Auth(self.write_contrib))
self.preprint.reload()
assert_equal(initial_subjects, list(self.preprint.subjects.all()))
def test_nonadmin_cannot_set_file(self):
initial_file = self.preprint.primary_file
file = OsfStorageFile.create(node=self.project,
path='/panda.txt',
name='panda.txt',
materialized_path='/panda.txt')
file.save()
with assert_raises(PermissionsError):
self.preprint.set_primary_file(file,
auth=Auth(self.write_contrib),
save=True)
self.preprint.reload()
self.preprint.node.reload()
assert_equal(initial_file._id, self.preprint.primary_file._id)
def test_nonadmin_cannot_publish(self):
assert_false(self.preprint.is_published)
with assert_raises(PermissionsError):
self.preprint.set_published(True,
auth=Auth(self.write_contrib),
save=True)
assert_false(self.preprint.is_published)
def test_admin_can_set_subjects(self):
initial_subjects = list(self.preprint.subjects.all())
self.preprint.set_subjects([[SubjectFactory()._id]],
auth=Auth(self.user))
self.preprint.reload()
assert_not_equal(initial_subjects, list(self.preprint.subjects.all()))
def test_admin_can_set_file(self):
initial_file = self.preprint.primary_file
file = OsfStorageFile.create(node=self.project,
path='/panda.txt',
name='panda.txt',
materialized_path='/panda.txt')
file.save()
self.preprint.set_primary_file(file, auth=Auth(self.user), save=True)
self.preprint.reload()
self.preprint.node.reload()
assert_not_equal(initial_file._id, self.preprint.primary_file._id)
assert_equal(file._id, self.preprint.primary_file._id)
def test_admin_can_publish(self):
assert_false(self.preprint.is_published)
self.preprint.set_published(True, auth=Auth(self.user), save=True)
assert_true(self.preprint.is_published)
def test_admin_cannot_unpublish(self):
assert_false(self.preprint.is_published)
self.preprint.set_published(True, auth=Auth(self.user), save=True)
assert_true(self.preprint.is_published)
with assert_raises(ValueError) as e:
self.preprint.set_published(False, auth=Auth(self.user), save=True)
assert_in('Cannot unpublish', e.exception.message)
class TestSetPreprintFile(OsfTestCase):
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)
@assert_logs(NodeLog.MADE_PUBLIC, 'project')
@assert_logs(NodeLog.PREPRINT_INITIATED, 'project', -2)
def test_is_preprint_property_new_file_to_published(self):
assert_false(self.project.is_preprint)
self.preprint.set_primary_file(self.file, auth=self.auth, save=True)
self.project.reload()
assert_false(self.project.is_preprint)
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, save=True)
self.project.reload()
assert_false(self.project.is_preprint)
self.preprint.set_published(True, auth=self.auth, save=True)
self.project.reload()
assert_true(self.project.is_preprint)
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, save=True)
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 test_add_primary_file(self):
self.preprint.set_primary_file(self.file, auth=self.auth, save=True)
assert_equal(self.project.preprint_file, self.file)
assert_equal(type(self.project.preprint_file), type(self.file))
@assert_logs(NodeLog.PREPRINT_FILE_UPDATED, 'project')
def test_change_primary_file(self):
self.preprint.set_primary_file(self.file, auth=self.auth, save=True)
assert_equal(self.project.preprint_file, self.file)
self.preprint.set_primary_file(self.file_two, auth=self.auth, save=True)
assert_equal(self.project.preprint_file._id, self.file_two._id)
def test_add_invalid_file(self):
with assert_raises(AttributeError):
self.preprint.set_primary_file('inatlanta', auth=self.auth, save=True)
def test_deleted_file_creates_orphan(self):
self.preprint.set_primary_file(self.file, auth=self.auth, save=True)
self.file.is_deleted = True
self.file.save()
assert_true(self.project.is_preprint_orphan)
def test_preprint_created_date(self):
self.preprint.set_primary_file(self.file, auth=self.auth, save=True)
assert_equal(self.project.preprint_file._id, self.file._id)
assert(self.preprint.date_created)
assert_not_equal(self.project.date_created, self.preprint.date_created)
def test_non_admin_update_file(self):
self.preprint.set_primary_file(self.file, auth=self.auth, save=True)
assert_equal(self.project.preprint_file._id, self.file._id)
with assert_raises(PermissionsError):
self.preprint.set_primary_file(self.file_two, auth=self.read_write_user_auth, save=True)
assert_equal(self.project.preprint_file._id, self.file._id)
class TestPreprintServicePermissions(OsfTestCase):
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_nonadmin_cannot_set_subjects(self):
initial_subjects = list(self.preprint.subjects.all())
with assert_raises(PermissionsError):
self.preprint.set_subjects([[SubjectFactory()._id]], auth=Auth(self.write_contrib), save=True)
self.preprint.reload()
assert_equal(initial_subjects, list(self.preprint.subjects.all()))
def test_nonadmin_cannot_set_file(self):
initial_file = self.preprint.primary_file
file = OsfStorageFile.create(
node=self.project,
path='/panda.txt',
name='panda.txt',
materialized_path='/panda.txt')
file.save()
with assert_raises(PermissionsError):
self.preprint.set_primary_file(file, auth=Auth(self.write_contrib), save=True)
self.preprint.reload()
self.preprint.node.reload()
assert_equal(initial_file._id, self.preprint.primary_file._id)
def test_nonadmin_cannot_publish(self):
assert_false(self.preprint.is_published)
with assert_raises(PermissionsError):
self.preprint.set_published(True, auth=Auth(self.write_contrib), save=True)
assert_false(self.preprint.is_published)
def test_admin_can_set_subjects(self):
initial_subjects = list(self.preprint.subjects.all())
self.preprint.set_subjects([[SubjectFactory()._id]], auth=Auth(self.user), save=True)
self.preprint.reload()
assert_not_equal(initial_subjects, list(self.preprint.subjects.all()))
def test_admin_can_set_file(self):
initial_file = self.preprint.primary_file
file = OsfStorageFile.create(
node=self.project,
path='/panda.txt',
name='panda.txt',
materialized_path='/panda.txt')
file.save()
self.preprint.set_primary_file(file, auth=Auth(self.user), save=True)
self.preprint.reload()
self.preprint.node.reload()
assert_not_equal(initial_file._id, self.preprint.primary_file._id)
assert_equal(file._id, self.preprint.primary_file._id)
def test_admin_can_publish(self):
assert_false(self.preprint.is_published)
self.preprint.set_published(True, auth=Auth(self.user), save=True)
assert_true(self.preprint.is_published)
def test_admin_cannot_unpublish(self):
assert_false(self.preprint.is_published)
self.preprint.set_published(True, auth=Auth(self.user), save=True)
assert_true(self.preprint.is_published)
with assert_raises(ValueError) as e:
self.preprint.set_published(False, auth=Auth(self.user), save=True)
assert_in('Cannot unpublish', e.exception.message)
class TestPreprintSaveShareHook(OsfTestCase):
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)
@mock.patch('website.preprints.tasks.on_preprint_updated.si')
def test_save_unpublished_not_called(self, mock_on_preprint_updated):
self.preprint.save()
assert not mock_on_preprint_updated.called
@mock.patch('website.preprints.tasks.on_preprint_updated.si')
def test_save_published_called(self, mock_on_preprint_updated):
self.preprint.set_published(True, auth=self.auth, save=True)
assert mock_on_preprint_updated.called
# This covers an edge case where a preprint is forced back to unpublished
# that it sends the information back to share
@mock.patch('website.preprints.tasks.on_preprint_updated.si')
def test_save_unpublished_called_forced(self, mock_on_preprint_updated):
self.preprint.set_published(True, auth=self.auth, save=True)
self.preprint.published = False
self.preprint.save(**{'force_update': True})
assert_equal(mock_on_preprint_updated.call_count, 2)
@mock.patch('website.preprints.tasks.on_preprint_updated.si')
def test_save_published_called(self, mock_on_preprint_updated):
self.preprint.set_published(True, auth=self.auth, save=True)
assert mock_on_preprint_updated.called
@mock.patch('website.preprints.tasks.on_preprint_updated.si')
def test_save_published_subject_change_called(self, mock_on_preprint_updated):
self.preprint.is_published = True
self.preprint.set_subjects([[self.subject_two._id]], auth=self.auth)
assert mock_on_preprint_updated.called
call_args, call_kwargs = mock_on_preprint_updated.call_args
assert call_kwargs.get('old_subjects') == [self.subject.id]
@mock.patch('website.preprints.tasks.on_preprint_updated.si')
def test_save_unpublished_subject_change_not_called(self, mock_on_preprint_updated):
self.preprint.set_subjects([[self.subject_two._id]], auth=self.auth)
assert not mock_on_preprint_updated.called
@mock.patch('website.preprints.tasks.requests')
@mock.patch('website.preprints.tasks.settings.SHARE_URL', 'ima_real_website')
def test_send_to_share_is_true(self, mock_requests):
self.preprint.provider.access_token = 'Snowmobiling'
self.preprint.provider.save()
on_preprint_updated(self.preprint._id)
assert mock_requests.post.called
@mock.patch('osf.models.preprint_service.update_or_enqueue_on_preprint_updated')
def test_node_contributor_changes_updates_preprints_share(self, mock_on_preprint_updated):
# A user is added as a contributor
self.preprint.is_published = True
self.preprint.save()
assert mock_on_preprint_updated.call_count == 1
user = AuthUserFactory()
node = self.preprint.node
node.preprint_file = self.file
node.add_contributor(contributor=user, auth=self.auth)
assert mock_on_preprint_updated.call_count == 2
node.move_contributor(contributor=user, index=0, auth=self.auth)
assert mock_on_preprint_updated.call_count == 3
data = [{'id': self.admin._id, 'permission': 'admin', 'visible': True},
{'id': user._id, 'permission': 'write', 'visible': False}]
node.manage_contributors(data, auth=self.auth, save=True)
assert mock_on_preprint_updated.call_count == 4
node.update_contributor(user, 'read', True, auth=self.auth, save=True)
assert mock_on_preprint_updated.call_count == 5
node.remove_contributor(contributor=user, auth=self.auth)
assert mock_on_preprint_updated.call_count == 6
@mock.patch('website.preprints.tasks.settings.SHARE_URL', 'a_real_url')
@mock.patch('website.preprints.tasks._async_update_preprint_share.delay')
@mock.patch('website.preprints.tasks.requests')
def test_call_async_update_on_500_failure(self, requests, mock_async):
self.preprint.provider.access_token = 'Snowmobiling'
requests.post.return_value = MockShareResponse(501)
update_preprint_share(self.preprint)
assert mock_async.called
@mock.patch('website.preprints.tasks.settings.SHARE_URL', 'a_real_url')
@mock.patch('website.preprints.tasks.send_desk_share_preprint_error')
@mock.patch('website.preprints.tasks._async_update_preprint_share.delay')
@mock.patch('website.preprints.tasks.requests')
def test_no_call_async_update_on_400_failure(self, requests, mock_async, mock_mail):
self.preprint.provider.access_token = 'Snowmobiling'
requests.post.return_value = MockShareResponse(400)
update_preprint_share(self.preprint)
assert not mock_async.called
assert mock_mail.called
