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 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):
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_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
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)
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(TestPreprintProviderExportImport, self).setUp()
self.user = AuthUserFactory()
self.preprint_provider = PreprintProviderFactory()
self.request = RequestFactory().get('/fake_path')
self.view = views.ExportPreprintProvider()
self.view = setup_user_view(self.view, self.request, user=self.user)
self.view.kwargs = {'preprint_provider_id': self.preprint_provider.id}
self.import_request = RequestFactory().get('/fake_path')
self.import_view = views.ImportPreprintProvider()
self.import_view = setup_user_view(self.import_view, self.import_request, user=self.user)
self.preprint_provider.licenses_acceptable = [NodeLicense.objects.get(license_id='NONE')]
self.subject = SubjectFactory(provider=self.preprint_provider)
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_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 test_top_level_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.top_level_subjects) == set([subj_a, subj_b])
def test_public_project_pending_preprint_pre_moderation(self):
self.preprint.machine_state = 'pending'
provider = PreprintProviderFactory(reviews_workflow='pre-moderation')
self.preprint.provider = provider
self.preprint.save()
url = self.project_one.web_url_for('view_project')
# Admin - preprint
res = self.app.get(url, auth=self.admin.auth)
assert_in('{}'.format(self.preprint.provider.name), res.body)
assert_in('Pending\n', res.body)
assert_in('This preprint is not publicly available or searchable until approved by a moderator.', res.body)
# Write - preprint
res = self.app.get(url, auth=self.write_contrib.auth)
assert_in('{}'.format(self.preprint.provider.name), res.body)
assert_in('Pending\n', res.body)
assert_in('This preprint is not publicly available or searchable until approved by a moderator.', res.body)
# Read - preprint
res = self.app.get(url, auth=self.read_contrib.auth)
assert_in('{}'.format(self.preprint.provider.name), res.body)
assert_in('Pending\n', res.body)
assert_in('This preprint is not publicly available or searchable until approved by a moderator.', res.body)
# Noncontrib - preprint
res = self.app.get(url, auth=self.non_contrib.auth)
assert_in('{}'.format(self.preprint.provider.name), res.body)
assert_not_in('Pending\n', res.body)
assert_not_in('This preprint is not publicly available or searchable until approved by a moderator.', res.body)
# Unauthenticated - preprint
res = self.app.get(url)
assert_in('{}'.format(self.preprint.provider.name), res.body)
assert_not_in('Pending\n', res.body)
assert_not_in('This preprint is not publicly available or searchable until approved by a moderator.', res.body)
def preprint_provider_two(self):
return PreprintProviderFactory()
def providers(self):
return [
PreprintProviderFactory(
reviews_workflow='pre-moderation'
) for _ in range(5)]
def setUp(self):
super(TestPreprintProvider, self).setUp()
self.preprint = PreprintFactory(provider=None, is_published=False)
self.provider = PreprintProviderFactory(name='WWEArxiv')
def test_qatest_doesnt_make_dois(self):
preprint = PreprintFactory(is_published=True,
creator=self.user,
provider=PreprintProviderFactory())
preprint.node.add_tag('qatest', self.auth)
assert not request_identifiers(preprint)
def osf_provider(self):
return PreprintProviderFactory(_id='osf')
def provider_one(self):
return PreprintProviderFactory(name='Sockarxiv')
def provider(self):
return PreprintProviderFactory(
name='Lars Larson Snowmobiling Experience',
access_token='Snowmobiling'
)
def provider_three(self):
return PreprintProviderFactory(name='Mockarxiv')
def provider(self):
pp = PreprintProviderFactory(name='ModArxiv')
GroupHelper(pp).update_provider_auth_groups()
return pp
def setUp(self):
super(TestPreprintProviderSerializer, self).setUp()
self.preprint_provider = PreprintProviderFactory()
def provider(self):
pp = PreprintProviderFactory(name='ModArxiv')
pp.update_group_permissions()
return pp
def setUp(self):
self.admin = AuthUserFactory()
self.provider = PreprintProviderFactory()
self.project = ProjectFactory(creator=self.admin, is_public=True)
self.url = '/{}nodes/{}/preprints/?version=2.2&'.format(API_BASE, self.project._id)
super(TestNodePreprintIsValidList, self).setUp()
def provider_two(self):
return PreprintProviderFactory(name='Piratearxiv')
def preprint_provider():
return PreprintProviderFactory(name='Test 1')
def test_create_permissions(
self, 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(
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
def post_mod_provider(self, moderator):
ppp = PreprintProviderFactory(reviews_workflow='post-moderation')
ppp.get_group('moderator').user_set.add(moderator)
return ppp
def provider(self):
return PreprintProviderFactory(reviews_workflow='post-moderation')
def none_mod_provider(self):
return PreprintProviderFactory(reviews_workflow=None)
def provider(self):
return PreprintProviderFactory()
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
