def create_fake_project(creator, n_users, privacy, n_components, name, n_tags,
presentation_name, is_registration, is_preprint,
preprint_providers):
auth = Auth(user=creator)
project_title = name if name else fake.science_sentence()
if is_preprint:
providers_to_add = []
if preprint_providers:
providers = preprint_providers.split(',')
for provider in providers:
try:
preprint_provider = models.PreprintProvider.find_one(
Q('_id', 'eq', provider))
except NoResultsFound:
preprint_provider = PreprintProviderFactory(name=provider)
providers_to_add.append(preprint_provider)
privacy = 'public'
project = PreprintFactory(title=project_title,
description=fake.science_paragraph(),
creator=creator,
providers=providers_to_add)
elif is_registration:
project = RegistrationFactory(title=project_title,
description=fake.science_paragraph(),
creator=creator)
else:
project = ProjectFactory(title=project_title,
description=fake.science_paragraph(),
creator=creator)
project.set_privacy(privacy)
for _ in range(n_users):
contrib = create_fake_user()
project.add_contributor(contrib, auth=auth)
if isinstance(n_components, int):
for _ in range(n_components):
NodeFactory(project=project,
title=fake.science_sentence(),
description=fake.science_paragraph(),
creator=creator)
elif isinstance(n_components, list):
render_generations_from_node_structure_list(project, creator,
n_components)
for _ in range(n_tags):
project.add_tag(fake.science_word(), auth=auth)
if presentation_name is not None:
project.add_tag(presentation_name, auth=auth)
project.add_tag('poster', auth=auth)
project.save()
logger.info('Created project: {0}'.format(project.title))
return project
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)
class TestPreprintProviders(OsfTestCase):
def setUp(self):
super(TestPreprintProviders, self).setUp()
self.preprint = PreprintFactory(providers=[])
self.provider = PreprintProviderFactory(name='WWEArxiv')
def test_add_provider(self):
assert_not_equal(self.preprint.provider, self.provider)
self.preprint.provider = self.provider
self.preprint.save()
self.preprint.reload()
assert_equal(self.preprint.provider, self.provider)
def test_remove_provider(self):
self.preprint.provider = None
self.preprint.save()
self.preprint.reload()
assert_equal(self.preprint.provider, None)
class TestPreprintFiltering(ApiTestCase):
def setUp(self):
super(TestPreprintFiltering, self).setUp()
self.user = AuthUserFactory()
self.provider = PreprintProviderFactory(name='wwe')
self.preprint = PreprintFactory(creator=self.user, providers=[self.provider])
self.preprint.add_tag('nature boy', Auth(self.user), save=False)
self.preprint.add_tag('ric flair', Auth(self.user), save=False)
self.preprint.save()
self.provider_two = PreprintProviderFactory(name='wcw')
self.preprint_two = PreprintFactory(creator=self.user, filename='woo.txt', providers=[self.provider_two])
self.preprint_two.add_tag('nature boy', Auth(self.user), save=False)
self.preprint_two.add_tag('woo', Auth(self.user), save=False)
self.preprint_two.save()
self.preprint_three = PreprintFactory(creator=self.user, filename='stonecold.txt', providers=[self.provider])
self.preprint_three.add_tag('stone', Auth(self.user), save=False)
self.preprint_two.add_tag('cold', Auth(self.user), save=False)
self.preprint_three.save()
def tearDown(self):
super(TestPreprintFiltering, self).tearDown()
Node.remove()
def test_filtering_tags(self):
# both preprint and preprint_two have nature boy
url = '/{}preprints/?filter[tags]={}'.format(API_BASE, 'nature boy')
res = self.app.get(url, auth=self.user.auth)
reg_json = res.json['data']
ids = [each['id'] for each in reg_json]
assert_in(self.preprint._id, ids)
assert_in(self.preprint_two._id, ids)
assert_not_in(self.preprint_three._id, ids)
# filtering two tags
# preprint has both tags; preprint_two only has one
url = '/{}preprints/?filter[tags]={}&filter[tags]={}'.format(API_BASE, 'nature boy', 'ric flair')
res = self.app.get(url, auth=self.user.auth)
reg_json = res.json['data']
ids = [each['id'] for each in reg_json]
assert_in(self.preprint._id, ids)
assert_not_in(self.preprint_two._id, ids)
assert_not_in(self.preprint_three._id, ids)
def test_filter_by_doi(self):
url = '/{}preprints/?filter[doi]={}'.format(API_BASE, self.preprint.preprint_doi)
res = self.app.get(url, auth=self.user.auth)
data = res.json['data']
assert_equal(len(data), 1)
for result in data:
assert_equal(self.preprint._id, result['id'])
def create_fake_project(creator, n_users, privacy, n_components, name, n_tags, presentation_name, is_registration, is_preprint, preprint_providers):
auth = Auth(user=creator)
project_title = name if name else fake.science_sentence()
if is_preprint:
providers_to_add = []
if preprint_providers:
providers = preprint_providers.split(',')
for provider in providers:
try:
preprint_provider = models.PreprintProvider.find_one(Q('_id', 'eq', provider))
except NoResultsFound:
preprint_provider = PreprintProviderFactory(name=provider)
providers_to_add.append(preprint_provider)
privacy = 'public'
project = PreprintFactory(title=project_title, description=fake.science_paragraph(), creator=creator, providers=providers_to_add)
elif is_registration:
project = RegistrationFactory(title=project_title, description=fake.science_paragraph(), creator=creator)
else:
project = ProjectFactory(title=project_title, description=fake.science_paragraph(), creator=creator)
project.set_privacy(privacy)
for _ in range(n_users):
contrib = create_fake_user()
project.add_contributor(contrib, auth=auth)
if isinstance(n_components, int):
for _ in range(n_components):
NodeFactory(project=project, title=fake.science_sentence(), description=fake.science_paragraph(),
creator=creator)
elif isinstance(n_components, list):
render_generations_from_node_structure_list(project, creator, n_components)
for _ in range(n_tags):
project.add_tag(fake.science_word(), auth=auth)
if presentation_name is not None:
project.add_tag(presentation_name, auth=auth)
project.add_tag('poster', auth=auth)
project.save()
logger.info('Created project: {0}'.format(project.title))
return project
class TestPreprintUpdateLicense(ApiTestCase):
def setUp(self):
super(TestPreprintUpdateLicense, self).setUp()
ensure_licenses()
self.admin_contributor = AuthUserFactory()
self.rw_contributor = AuthUserFactory()
self.read_contributor = AuthUserFactory()
self.non_contributor = AuthUserFactory()
self.preprint_provider = PreprintProviderFactory()
self.preprint = PreprintFactory(creator=self.admin_contributor, provider=self.preprint_provider)
self.preprint.node.add_contributor(self.rw_contributor, auth=Auth(self.admin_contributor))
self.preprint.node.add_contributor(self.read_contributor, auth=Auth(self.admin_contributor), permissions=['read'])
self.preprint.node.save()
self.cc0_license = NodeLicense.find_one(Q('name', 'eq', 'CC0 1.0 Universal'))
self.mit_license = NodeLicense.find_one(Q('name', 'eq', 'MIT License'))
self.no_license = NodeLicense.find_one(Q('name', 'eq', 'No license'))
self.preprint_provider.licenses_acceptable = [self.cc0_license, self.no_license]
self.preprint_provider.save()
self.url = '/{}preprints/{}/'.format(API_BASE, self.preprint._id)
def make_payload(self, node_id, license_id=None, license_year=None, copyright_holders=None):
attributes = {}
if license_year and copyright_holders:
attributes = {
'license_record': {
'year': license_year,
'copyright_holders': copyright_holders
}
}
elif license_year:
attributes = {
'license_record': {
'year': license_year
}
}
elif copyright_holders:
attributes = {
'license_record': {
'copyright_holders': copyright_holders
}
}
return {
'data': {
'id': node_id,
'attributes': attributes,
'relationships': {
'license': {
'data': {
'type': 'licenses',
'id': license_id
}
}
}
}
} if license_id else {
'data': {
'id': node_id,
'attributes': attributes
}
}
def make_request(self, url, data, auth=None, expect_errors=False):
return self.app.patch_json_api(url, data, auth=auth, expect_errors=expect_errors)
def test_admin_can_update_license(self):
data = self.make_payload(
node_id=self.preprint._id,
license_id=self.cc0_license._id
)
assert_equal(self.preprint.license, None)
res = self.make_request(self.url, data, auth=self.admin_contributor.auth)
assert_equal(res.status_code, 200)
self.preprint.reload()
assert_equal(self.preprint.license.node_license, self.cc0_license)
assert_equal(self.preprint.license.year, None)
assert_equal(self.preprint.license.copyright_holders, [])
# check logs
log = self.preprint.node.logs[-1]
assert_equal(log.action, 'preprint_license_updated')
assert_equal(log.params.get('preprint'), self.preprint._id)
def test_admin_can_update_license_record(self):
data = self.make_payload(
node_id=self.preprint._id,
license_id=self.no_license._id,
license_year='2015',
copyright_holders=['Bojack Horseman, Princess Carolyn']
)
assert_equal(self.preprint.license, None)
res = self.make_request(self.url, data, auth=self.admin_contributor.auth)
assert_equal(res.status_code, 200)
self.preprint.reload()
assert_equal(self.preprint.license.node_license, self.no_license)
assert_equal(self.preprint.license.year, '2015')
assert_equal(self.preprint.license.copyright_holders, ['Bojack Horseman, Princess Carolyn'])
def test_rw_contributor_cannot_update_license(self):
data = self.make_payload(
node_id=self.preprint._id,
license_id=self.cc0_license._id
)
res = self.make_request(self.url, data, auth=self.rw_contributor.auth, expect_errors=True)
assert_equal(res.status_code, 403)
assert_equal(res.json['errors'][0]['detail'], 'User must be an admin to update a preprint.')
def test_read_contributor_cannot_update_license(self):
data = self.make_payload(
node_id=self.preprint._id,
license_id=self.cc0_license._id
)
res = self.make_request(self.url, data, auth=self.read_contributor.auth, expect_errors=True)
assert_equal(res.status_code, 403)
assert_equal(res.json['errors'][0]['detail'], 'You do not have permission to perform this action.')
def test_non_contributor_cannot_update_license(self):
data = self.make_payload(
node_id=self.preprint._id,
license_id=self.cc0_license._id
)
res = self.make_request(self.url, data, auth=self.non_contributor.auth, expect_errors=True)
assert_equal(res.status_code, 403)
assert_equal(res.json['errors'][0]['detail'], 'You do not have permission to perform this action.')
def test_unauthenticated_user_cannot_update_license(self):
data = self.make_payload(
node_id=self.preprint._id,
license_id=self.cc0_license._id
)
res = self.make_request(self.url, data, expect_errors=True)
assert_equal(res.status_code, 401)
assert_equal(res.json['errors'][0]['detail'], 'Authentication credentials were not provided.')
def test_update_preprint_with_invalid_license_for_provider(self):
data = self.make_payload(
node_id=self.preprint._id,
license_id=self.mit_license._id
)
assert_equal(self.preprint.license, None)
res = self.make_request(self.url, data, auth=self.admin_contributor.auth, expect_errors=True)
assert_equal(res.status_code, 403)
assert_equal(res.json['errors'][0]['detail'], 'Invalid license chosen for {}'.format(self.preprint_provider.name))
def test_update_preprint_with_existing_license_year_attribute_only(self):
self.preprint.set_preprint_license(
{
'id': self.no_license.id,
'year': '2014',
'copyrightHolders': ['Diane', 'Mr. Peanut Butter']
},
Auth(self.admin_contributor),
)
self.preprint.save()
assert_equal(self.preprint.license.node_license, self.no_license)
assert_equal(self.preprint.license.year, '2014')
assert_equal(self.preprint.license.copyright_holders, ['Diane', 'Mr. Peanut Butter'])
data = self.make_payload(
node_id=self.preprint._id,
license_year='2015'
)
res = self.make_request(self.url, data, auth=self.admin_contributor.auth)
assert_equal(res.status_code, 200)
self.preprint.license.reload()
assert_equal(self.preprint.license.node_license, self.no_license)
assert_equal(self.preprint.license.year, '2015')
assert_equal(self.preprint.license.copyright_holders, ['Diane', 'Mr. Peanut Butter'])
def test_update_preprint_with_existing_license_copyright_holders_attribute_only(self):
self.preprint.set_preprint_license(
{
'id': self.no_license.id,
'year': '2014',
'copyrightHolders': ['Diane', 'Mr. Peanut Butter']
},
Auth(self.admin_contributor),
)
self.preprint.save()
assert_equal(self.preprint.license.node_license, self.no_license)
assert_equal(self.preprint.license.year, '2014')
assert_equal(self.preprint.license.copyright_holders, ['Diane', 'Mr. Peanut Butter'])
data = self.make_payload(
node_id=self.preprint._id,
copyright_holders=['Bojack Horseman', 'Princess Carolyn']
)
res = self.make_request(self.url, data, auth=self.admin_contributor.auth)
assert_equal(res.status_code, 200)
self.preprint.license.reload()
assert_equal(self.preprint.license.node_license, self.no_license)
assert_equal(self.preprint.license.year, '2014')
assert_equal(self.preprint.license.copyright_holders, ['Bojack Horseman', 'Princess Carolyn'])
def test_update_preprint_with_existing_license_relationship_only(self):
self.preprint.set_preprint_license(
{
'id': self.no_license.id,
'year': '2014',
'copyrightHolders': ['Diane', 'Mr. Peanut Butter']
},
Auth(self.admin_contributor),
)
self.preprint.save()
assert_equal(self.preprint.license.node_license, self.no_license)
assert_equal(self.preprint.license.year, '2014')
assert_equal(self.preprint.license.copyright_holders, ['Diane', 'Mr. Peanut Butter'])
data = self.make_payload(
node_id=self.preprint._id,
license_id=self.cc0_license._id
)
res = self.make_request(self.url, data, auth=self.admin_contributor.auth)
assert_equal(res.status_code, 200)
self.preprint.license.reload()
assert_equal(self.preprint.license.node_license, self.cc0_license)
assert_equal(self.preprint.license.year, '2014')
assert_equal(self.preprint.license.copyright_holders, ['Diane', 'Mr. Peanut Butter'])
def test_update_preprint_with_existing_license_relationship_and_attributes(self):
self.preprint.set_preprint_license(
{
'id': self.no_license.id,
'year': '2014',
'copyrightHolders': ['Diane', 'Mr. Peanut Butter']
},
Auth(self.admin_contributor),
save=True
)
assert_equal(self.preprint.license.node_license, self.no_license)
assert_equal(self.preprint.license.year, '2014')
assert_equal(self.preprint.license.copyright_holders, ['Diane', 'Mr. Peanut Butter'])
data = self.make_payload(
node_id=self.preprint._id,
license_id=self.cc0_license._id,
license_year='2015',
copyright_holders=['Bojack Horseman', 'Princess Carolyn']
)
res = self.make_request(self.url, data, auth=self.admin_contributor.auth)
assert_equal(res.status_code, 200)
self.preprint.license.reload()
assert_equal(self.preprint.license.node_license, self.cc0_license)
assert_equal(self.preprint.license.year, '2015')
assert_equal(self.preprint.license.copyright_holders, ['Bojack Horseman', 'Princess Carolyn'])
def test_update_preprint_license_without_required_year_in_payload(self):
data = self.make_payload(
node_id=self.preprint._id,
license_id=self.no_license._id,
copyright_holders=['Rick', 'Morty']
)
res = self.make_request(self.url, data, auth=self.admin_contributor.auth, expect_errors=True)
assert_equal(res.status_code, 400)
assert_equal(res.json['errors'][0]['detail'], 'year must be specified for this license')
def test_update_preprint_license_without_required_copyright_holders_in_payload_(self):
data = self.make_payload(
node_id=self.preprint._id,
license_id=self.no_license._id,
license_year='1994'
)
res = self.make_request(self.url, data, auth=self.admin_contributor.auth, expect_errors=True)
assert_equal(res.status_code, 400)
assert_equal(res.json['errors'][0]['detail'], 'copyrightHolders must be specified for this license')
def test_update_preprint_license_does_not_change_project_license(self):
self.preprint.node.set_node_license(
{
'id': self.no_license.id,
'year': '2015',
'copyrightHolders': ['Simba', 'Mufasa']
},
auth=Auth(self.admin_contributor)
)
self.preprint.node.save()
assert_equal(self.preprint.node.node_license.node_license, self.no_license)
data = self.make_payload(
node_id=self.preprint._id,
license_id=self.cc0_license._id
)
res = self.make_request(self.url, data, auth=self.admin_contributor.auth)
assert_equal(res.status_code, 200)
self.preprint.reload()
assert_equal(self.preprint.license.node_license, self.cc0_license)
assert_equal(self.preprint.node.node_license.node_license, self.no_license)
def test_update_preprint_license_without_change_does_not_add_log(self):
self.preprint.set_preprint_license(
{
'id': self.no_license.id,
'year': '2015',
'copyrightHolders': ['Kim', 'Kanye']
},
auth=Auth(self.admin_contributor),
save=True
)
before_num_logs = len(self.preprint.node.logs)
before_update_log = self.preprint.node.logs[-1]
data = self.make_payload(
node_id=self.preprint._id,
license_id=self.no_license._id,
license_year='2015',
copyright_holders=['Kanye', 'Kim']
)
res = self.make_request(self.url, data, auth=self.admin_contributor.auth)
self.preprint.node.reload()
after_num_logs = len(self.preprint.node.logs)
after_update_log = self.preprint.node.logs[-1]
assert_equal(res.status_code, 200)
assert_equal(before_num_logs, after_num_logs)
assert_equal(before_update_log._id, after_update_log._id)
class TestPreprintRelationshipPreprintProvider(ApiTestCase):
def setUp(self):
super(TestPreprintRelationshipPreprintProvider, self).setUp()
self.user = AuthUserFactory()
self.read_write_user = AuthUserFactory()
self.preprint = PreprintFactory(creator=self.user, providers=None)
self.preprint.add_contributor(self.read_write_user)
self.preprint.save()
self.preprint_provider_one = PreprintProviderFactory()
self.preprint_provider_two = PreprintProviderFactory()
self.preprint_preprint_providers_url = self.create_url(self.preprint._id)
def create_url(self, preprint_id):
return '/{0}preprints/{1}/relationships/preprint_providers/'.format(API_BASE, preprint_id)
def create_payload(self, *preprint_provider_ids):
data = []
for provider_id in preprint_provider_ids:
data.append({'type': 'preprint_providers', 'id': provider_id})
return {'data': data}
def test_add_preprint_providers(self):
assert_equal(self.preprint.preprint_providers, None)
res = self.app.post_json_api(
self.preprint_preprint_providers_url,
self.create_payload(self.preprint_provider_one._id, self.preprint_provider_two._id),
auth=self.user.auth
)
assert_equal(res.status_code, 201)
# check the relationship
self.preprint.reload()
assert_in(self.preprint_provider_one, self.preprint.preprint_providers)
assert_in(self.preprint_provider_two, self.preprint.preprint_providers)
def test_add_through_patch_one_provider_while_removing_other(self):
self.preprint.preprint_providers = [self.preprint_provider_one]
self.preprint.save()
assert_in(self.preprint_provider_one, self.preprint.preprint_providers)
assert_not_in(self.preprint_provider_two, self.preprint.preprint_providers)
res = self.app.patch_json_api(
self.preprint_preprint_providers_url,
self.create_payload(self.preprint_provider_two._id),
auth=self.user.auth
)
assert_equal(res.status_code, 200)
self.preprint.reload()
assert_not_in(self.preprint_provider_one, self.preprint.preprint_providers)
assert_in(self.preprint_provider_two, self.preprint.preprint_providers)
def test_add_through_post_to_preprint_with_provider(self):
self.preprint.preprint_providers = [self.preprint_provider_one]
self.preprint.save()
assert_in(self.preprint_provider_one, self.preprint.preprint_providers)
assert_not_in(self.preprint_provider_two, self.preprint.preprint_providers)
res = self.app.post_json_api(
self.preprint_preprint_providers_url,
self.create_payload(self.preprint_provider_two._id),
auth=self.user.auth
)
assert_equal(res.status_code, 201)
self.preprint.reload()
assert_in(self.preprint_provider_one, self.preprint.preprint_providers)
assert_in(self.preprint_provider_two, self.preprint.preprint_providers)
def test_add_provider_with_no_permissions(self):
new_user = AuthUserFactory()
new_user.save()
res = self.app.post_json_api(
self.preprint_preprint_providers_url,
self.create_payload(self.preprint_provider_one._id),
auth=new_user.auth,
expect_errors=True,
)
assert_equal(res.status_code, 403)
def test_delete_nothing(self):
res = self.app.delete_json_api(
self.preprint_preprint_providers_url,
self.create_payload(),
auth=self.user.auth
)
assert_equal(res.status_code, 204)
def test_remove_providers(self):
self.preprint.preprint_providers = [self.preprint_provider_one]
self.preprint.save()
assert_in(self.preprint_provider_one, self.preprint.preprint_providers)
res = self.app.put_json_api(
self.preprint_preprint_providers_url,
self.create_payload(),
auth=self.user.auth
)
assert_equal(res.status_code, 200)
self.preprint.reload()
assert_equal(self.preprint.preprint_providers, [])
def test_remove_providers_with_no_auth(self):
res = self.app.put_json_api(
self.preprint_preprint_providers_url,
self.create_payload(),
expect_errors=True
)
assert_equal(res.status_code, 401)
def test_using_post_making_no_changes_returns_204(self):
self.preprint.preprint_providers = [self.preprint_provider_one]
self.preprint.save()
assert_in(self.preprint_provider_one, self.preprint.preprint_providers)
res = self.app.post_json_api(
self.preprint_preprint_providers_url,
self.create_payload(self.preprint_provider_one._id),
auth=self.user.auth
)
assert_equal(res.status_code, 204)
self.preprint.reload()
assert_in(self.preprint_provider_one, self.preprint.preprint_providers)
def test_delete_user_is_admin(self):
self.preprint.preprint_providers = [self.preprint_provider_one]
self.preprint.save()
assert_in(self.preprint_provider_one, self.preprint.preprint_providers)
res = self.app.delete_json_api(
self.preprint_preprint_providers_url,
self.create_payload(self.preprint_provider_one._id),
auth=self.user.auth
)
assert_equal(res.status_code, 204)
self.preprint.reload()
assert_not_in(self.preprint_provider_one, self.preprint.preprint_providers)
def test_delete_provider_user_is_read_write(self):
self.preprint.preprint_providers = [self.preprint_provider_one]
self.preprint.save()
assert_in(self.preprint_provider_one, self.preprint.preprint_providers)
res = self.app.delete_json_api(
self.preprint_preprint_providers_url,
self.create_payload(self.preprint_provider_one._id),
auth=self.read_write_user.auth,
expect_errors=True
)
assert_equal(res.status_code, 403)
self.preprint.reload()
assert_in(self.preprint_provider_one, self.preprint.preprint_providers)
def test_add_provider_user_is_read_write(self):
self.preprint.preprint_providers = []
self.preprint.preprint_providers.append(self.preprint_provider_one)
self.preprint.save()
assert_in(self.preprint_provider_one, self.preprint.preprint_providers)
res = self.app.post_json_api(
self.preprint_preprint_providers_url,
self.create_payload(self.preprint_provider_two._id),
auth=self.read_write_user.auth,
expect_errors=True
)
assert_equal(res.status_code, 403)
self.preprint.reload()
assert_in(self.preprint_provider_one, self.preprint.preprint_providers)
def test_change_provider_user_is_read_write(self):
self.preprint.preprint_providers = []
self.preprint.preprint_providers.append(self.preprint_provider_one)
self.preprint.save()
assert_in(self.preprint_provider_one, self.preprint.preprint_providers)
res = self.app.put_json_api(
self.preprint_preprint_providers_url,
self.create_payload(self.preprint_provider_two._id),
auth=self.read_write_user.auth,
expect_errors=True
)
assert_equal(res.status_code, 403)
self.preprint.reload()
assert_in(self.preprint_provider_one, self.preprint.preprint_providers)
def test_get_relationship_information(self):
res = self.app.get(self.preprint_preprint_providers_url,auth=self.user.auth)
assert_equal(res.status_code, 200)
def test_invalid_relationship_type(self):
invalid_type_payload = self.create_payload(self.preprint_provider_one._id)
invalid_type_payload['data'][0]['type'] = 'socks'
res = self.app.put_json_api(
self.preprint_preprint_providers_url,
invalid_type_payload,
auth=self.user.auth,
expect_errors=True
)
assert_equal(res.status_code, 409)
def test_provider_does_not_exist(self):
res = self.app.post_json_api(
self.preprint_preprint_providers_url,
self.create_payload('nope nope nope'),
auth=self.user.auth,
expect_errors=True
)
assert_equal(res.status_code, 404)
class TestPreprintRelationshipPreprintProvider(ApiTestCase):
def setUp(self):
super(TestPreprintRelationshipPreprintProvider, self).setUp()
self.user = AuthUserFactory()
self.read_write_user = AuthUserFactory()
self.preprint = PreprintFactory(creator=self.user, providers=None)
self.preprint.add_contributor(self.read_write_user)
self.preprint.save()
self.preprint_provider_one = PreprintProviderFactory()
self.preprint_provider_two = PreprintProviderFactory()
self.preprint_preprint_providers_url = self.create_url(self.preprint._id)
def create_url(self, preprint_id):
return '/{0}preprints/{1}/relationships/preprint_providers/'.format(API_BASE, preprint_id)
def create_payload(self, *preprint_provider_ids):
data = []
for provider_id in preprint_provider_ids:
data.append({'type': 'preprint_providers', 'id': provider_id})
return {'data': data}
def test_add_preprint_providers(self):
assert_equal(self.preprint.preprint_providers, None)
res = self.app.post_json_api(
self.preprint_preprint_providers_url,
self.create_payload(self.preprint_provider_one._id, self.preprint_provider_two._id),
auth=self.user.auth
)
assert_equal(res.status_code, 201)
# check the relationship
self.preprint.reload()
assert_in(self.preprint_provider_one, self.preprint.preprint_providers)
assert_in(self.preprint_provider_two, self.preprint.preprint_providers)
def test_add_preprint_providers_permission_denied(self):
noncontrib = AuthUserFactory()
assert_equal(self.preprint.preprint_providers, None)
res = self.app.post_json_api(
self.preprint_preprint_providers_url,
self.create_payload(self.preprint_provider_one._id, self.preprint_provider_two._id),
auth=noncontrib.auth,
expect_errors=True
)
assert_equal(res.status_code, 403)
def test_add_through_patch_one_provider_while_removing_other(self):
self.preprint.preprint_providers = [self.preprint_provider_one]
self.preprint.save()
assert_in(self.preprint_provider_one, self.preprint.preprint_providers)
assert_not_in(self.preprint_provider_two, self.preprint.preprint_providers)
res = self.app.patch_json_api(
self.preprint_preprint_providers_url,
self.create_payload(self.preprint_provider_two._id),
auth=self.user.auth
)
assert_equal(res.status_code, 200)
self.preprint.reload()
assert_not_in(self.preprint_provider_one, self.preprint.preprint_providers)
assert_in(self.preprint_provider_two, self.preprint.preprint_providers)
def test_add_through_post_to_preprint_with_provider(self):
self.preprint.preprint_providers = [self.preprint_provider_one]
self.preprint.save()
assert_in(self.preprint_provider_one, self.preprint.preprint_providers)
assert_not_in(self.preprint_provider_two, self.preprint.preprint_providers)
res = self.app.post_json_api(
self.preprint_preprint_providers_url,
self.create_payload(self.preprint_provider_two._id),
auth=self.user.auth
)
assert_equal(res.status_code, 201)
self.preprint.reload()
assert_in(self.preprint_provider_one, self.preprint.preprint_providers)
assert_in(self.preprint_provider_two, self.preprint.preprint_providers)
def test_add_provider_with_no_permissions(self):
new_user = AuthUserFactory()
new_user.save()
res = self.app.post_json_api(
self.preprint_preprint_providers_url,
self.create_payload(self.preprint_provider_one._id),
auth=new_user.auth,
expect_errors=True,
)
assert_equal(res.status_code, 403)
def test_delete_nothing(self):
res = self.app.delete_json_api(
self.preprint_preprint_providers_url,
self.create_payload(),
auth=self.user.auth
)
assert_equal(res.status_code, 204)
def test_remove_providers(self):
self.preprint.preprint_providers = [self.preprint_provider_one]
self.preprint.save()
assert_in(self.preprint_provider_one, self.preprint.preprint_providers)
res = self.app.put_json_api(
self.preprint_preprint_providers_url,
self.create_payload(),
auth=self.user.auth
)
assert_equal(res.status_code, 200)
self.preprint.reload()
assert_equal(self.preprint.preprint_providers, [])
def test_remove_providers_with_no_auth(self):
res = self.app.put_json_api(
self.preprint_preprint_providers_url,
self.create_payload(),
expect_errors=True
)
assert_equal(res.status_code, 401)
def test_using_post_making_no_changes_returns_204(self):
self.preprint.preprint_providers = [self.preprint_provider_one]
self.preprint.save()
assert_in(self.preprint_provider_one, self.preprint.preprint_providers)
res = self.app.post_json_api(
self.preprint_preprint_providers_url,
self.create_payload(self.preprint_provider_one._id),
auth=self.user.auth
)
assert_equal(res.status_code, 204)
self.preprint.reload()
assert_in(self.preprint_provider_one, self.preprint.preprint_providers)
def test_delete_user_is_admin(self):
self.preprint.preprint_providers = [self.preprint_provider_one]
self.preprint.save()
assert_in(self.preprint_provider_one, self.preprint.preprint_providers)
res = self.app.delete_json_api(
self.preprint_preprint_providers_url,
self.create_payload(self.preprint_provider_one._id),
auth=self.user.auth
)
assert_equal(res.status_code, 204)
self.preprint.reload()
assert_not_in(self.preprint_provider_one, self.preprint.preprint_providers)
def test_delete_provider_user_is_read_write(self):
self.preprint.preprint_providers = [self.preprint_provider_one]
self.preprint.save()
assert_in(self.preprint_provider_one, self.preprint.preprint_providers)
res = self.app.delete_json_api(
self.preprint_preprint_providers_url,
self.create_payload(self.preprint_provider_one._id),
auth=self.read_write_user.auth,
expect_errors=True
)
assert_equal(res.status_code, 403)
self.preprint.reload()
assert_in(self.preprint_provider_one, self.preprint.preprint_providers)
def test_add_provider_user_is_read_write(self):
self.preprint.preprint_providers = []
self.preprint.preprint_providers.append(self.preprint_provider_one)
self.preprint.save()
assert_in(self.preprint_provider_one, self.preprint.preprint_providers)
res = self.app.post_json_api(
self.preprint_preprint_providers_url,
self.create_payload(self.preprint_provider_two._id),
auth=self.read_write_user.auth,
expect_errors=True
)
assert_equal(res.status_code, 403)
self.preprint.reload()
assert_in(self.preprint_provider_one, self.preprint.preprint_providers)
def test_change_provider_user_is_read_write(self):
self.preprint.preprint_providers = []
self.preprint.preprint_providers.append(self.preprint_provider_one)
self.preprint.save()
assert_in(self.preprint_provider_one, self.preprint.preprint_providers)
res = self.app.put_json_api(
self.preprint_preprint_providers_url,
self.create_payload(self.preprint_provider_two._id),
auth=self.read_write_user.auth,
expect_errors=True
)
assert_equal(res.status_code, 403)
self.preprint.reload()
assert_in(self.preprint_provider_one, self.preprint.preprint_providers)
def test_get_relationship_information(self):
res = self.app.get(self.preprint_preprint_providers_url,auth=self.user.auth)
assert_equal(res.status_code, 200)
def test_invalid_relationship_type(self):
invalid_type_payload = self.create_payload(self.preprint_provider_one._id)
invalid_type_payload['data'][0]['type'] = 'socks'
res = self.app.put_json_api(
self.preprint_preprint_providers_url,
invalid_type_payload,
auth=self.user.auth,
expect_errors=True
)
assert_equal(res.status_code, 409)
def test_provider_does_not_exist(self):
res = self.app.post_json_api(
self.preprint_preprint_providers_url,
self.create_payload('nope nope nope'),
auth=self.user.auth,
expect_errors=True
)
assert_equal(res.status_code, 404)
