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