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)