def setUp(self):
super(ApiSearchTestCase, self).setUp()
self.user = AuthUserFactory()
self.user_one = AuthUserFactory(fullname='Kanye Omari West')
self.user_one.schools = [{
'degree': 'English',
'institution': 'Chicago State University'
}]
self.user_one.jobs = [{
'title': 'Producer',
'institution': 'GOOD Music, Inc.'
}]
self.user_one.save()
self.user_two = AuthUserFactory(fullname='Chance The Rapper')
self.project = ProjectFactory(title='The Life of Pablo', creator=self.user_one, is_public=True)
self.project.set_description('Name one genius who ain\'t crazy', auth=Auth(self.user_one), save=True)
self.project.add_tag('Yeezus', auth=Auth(self.user_one), save=True)
self.project_two = ProjectFactory(title='Graduation', creator=self.user_one, is_public=True)
self.private_project = ProjectFactory(title='Coloring Book', creator=self.user_two)
self.component = NodeFactory(parent=self.project, title='Ultralight Beam', creator=self.user_two, is_public=True)
self.component.set_description('This is my part, nobody else speak', auth=Auth(self.user_two), save=True)
self.component.add_tag('trumpets', auth=Auth(self.user_two), save=True)
self.component_two = NodeFactory(parent=self.project, title='Highlights', creator=self.user_one, is_public=True)
self.private_component = NodeFactory(parent=self.project, title='Wavves', creator=self.user_one)
self.file = utils.create_test_file(self.component, self.user_one, filename='UltralightBeam.mp3')
self.file_two = utils.create_test_file(self.component_two, self.user_one, filename='Highlights.mp3')
self.private_file = utils.create_test_file(self.private_component, self.user_one, filename='Wavves.mp3')
def user():
user = UserFactory()
quickfiles_node = QuickFilesNode.objects.get_for_user(user)
create_test_file(quickfiles_node, user)
inst = InstitutionFactory()
user.affiliated_institutions.add(inst)
return user
def test_cannot_set_primary_file(self, app, user, preprint, url):
# test_write_contrib_cannot_set_primary_file
read_write_contrib = AuthUserFactory()
preprint.node.add_contributor(
read_write_contrib,
permissions=['read', 'write'],
auth=Auth(user), save=True)
new_file = test_utils.create_test_file(
preprint.node, user, filename='lovechild_reason.pdf')
data = {
'data': {
'type': 'primary_file',
'id': preprint._id,
'attributes': {},
'relationships': {
'primary_file': {
'data': {
'type': 'file',
'id': new_file._id
}
}
}
}
}
res = app.patch_json_api(
url, data,
auth=read_write_contrib.auth,
expect_errors=True)
assert res.status_code == 403
# test_noncontrib_cannot_set_primary_file
non_contrib = AuthUserFactory()
new_file = test_utils.create_test_file(
preprint.node, user, filename='flowerchild_nik.pdf')
data = {
'data': {
'type': 'primary_file',
'id': preprint._id,
'attributes': {},
'relationships': {
'primary_file': {
'data': {
'type': 'file',
'id': new_file._id
}
}
}
}
}
res = app.patch_json_api(
url, data,
auth=non_contrib.auth,
expect_errors=True)
assert res.status_code == 403
def setUp(self):
super(TestFileFiltering, self).setUp()
self.user = AuthUserFactory()
self.node = ProjectFactory(creator=self.user)
self.file1 = api_utils.create_test_file(
self.node, self.user, filename='file1')
self.file2 = api_utils.create_test_file(
self.node, self.user, filename='file2')
self.file3 = api_utils.create_test_file(
self.node, self.user, filename='file3')
self.file4 = api_utils.create_test_file(
self.node, self.user, filename='file4')
def test_quickfiles_moves_files_on_merge(self, user, quickfiles):
create_test_file(quickfiles, user, filename='Guerrillas_of_Destiny.pdf')
other_user = factories.UserFactory()
other_quickfiles = QuickFilesNode.objects.get(creator=other_user)
create_test_file(other_quickfiles, user, filename='Young_Bucks.pdf')
user.merge_user(other_user)
user.save()
stored_files = OsfStorageFile.objects.all().prefetch_related('node')
assert stored_files.count() == 2
for stored_file in stored_files:
assert stored_file.node == quickfiles
def setUp(self):
assert self.admin, 'Subclasses of PreprintIsValidListMixin must define self.admin'
assert self.project, 'Subclasses of PreprintIsValidListMixin must define self.project'
assert self.provider, 'Subclasses of PreprintIsValidListMixin must define self.provider'
assert self.url, 'Subclasses of PreprintIsValidListMixin must define self.url'
self.app = JSONAPITestApp()
self.write_contrib = AuthUserFactory()
self.non_contrib = AuthUserFactory()
self.subject = SubjectFactory()
self.project.add_contributor(self.write_contrib, permissions=permissions.DEFAULT_CONTRIBUTOR_PERMISSIONS, save=True)
test_utils.create_test_file(self.project, self.admin, 'saor.pdf')
self.preprint = PreprintFactory(creator=self.admin, filename='saor.pdf', provider=self.provider, subjects=[[self.subject._id]], project=self.project, is_published=True)
def test_can_rename_file_in_quickfiles_node(self):
quickfiles_node = QuickFilesNode.objects.get_for_user(self.user)
quickfiles_file = create_test_file(quickfiles_node, self.user, filename='road_dogg.mp3')
quickfiles_folder = OsfStorageFolder.objects.get(node=quickfiles_node)
dest_folder = OsfStorageFolder.objects.get(node=self.project)
new_name = 'JesseJames.mp3'
res = self.send_hook(
'osfstorage_move_hook',
{'nid': quickfiles_node._id},
payload={
'action': 'rename',
'source': quickfiles_file._id,
'node': quickfiles_node._id,
'user': self.user._id,
'name': quickfiles_file.name,
'destination': {
'parent': quickfiles_folder._id,
'node': quickfiles_node._id,
'name': new_name,
}
},
method='post_json',
expect_errors=True,
)
quickfiles_file.reload()
assert_equal(res.status_code, 200)
assert_equal(quickfiles_file.name, new_name)
def test_search_serializer_mixed_model(self):
user = AuthUserFactory()
project = ProjectFactory(creator=user, is_public=True)
component = NodeFactory(parent=project, creator=user, is_public=True)
file_component = utils.create_test_file(component, user)
context = {'request': make_drf_request_with_version(version='2.0')}
schema = RegistrationSchema.objects.filter(
name='Replication Recipe (Brandt et al., 2013): Post-Completion',
schema_version=LATEST_SCHEMA_VERSION).first()
# test_search_serializer_mixed_model_project
result = SearchSerializer(project, context=context).data
assert result['data']['type'] == 'nodes'
# test_search_serializer_mixed_model_component
result = SearchSerializer(component, context=context).data
assert result['data']['type'] == 'nodes'
# test_search_serializer_mixed_model_registration
with mock_archive(project, autocomplete=True, autoapprove=True, schema=schema) as registration:
result = SearchSerializer(registration, context=context).data
assert result['data']['type'] == 'registrations'
# test_search_serializer_mixed_model_file
result = SearchSerializer(file_component, context=context).data
assert result['data']['type'] == 'files'
# test_search_serializer_mixed_model_user
result = SearchSerializer(user, context=context).data
assert result['data']['type'] == 'users'
def test_disabled_users_quickfiles_file_detail_gets_410(self, app, quickfiles_node, user):
file_node = api_utils.create_test_file(quickfiles_node, user, create_guid=True)
url_with_guid = '/{}files/{}/'.format(
API_BASE, file_node.get_guid()._id
)
url_with_id = '/{}files/{}/'.format(API_BASE, file_node._id)
res = app.get(url_with_id)
assert res.status_code == 200
res = app.get(url_with_guid, auth=user.auth)
assert res.status_code == 200
user.is_disabled = True
user.save()
res = app.get(url_with_id, expect_errors=True)
assert res.json['errors'][0]['detail'] == 'This user has been deactivated and their' \
' quickfiles are no longer available.'
assert res.status_code == 410
res = app.get(url_with_guid, expect_errors=True)
assert res.json['errors'][0]['detail'] == 'This user has been deactivated and their' \
' quickfiles are no longer available.'
assert res.status_code == 410
def test_download_file(self):
file = create_test_file(node=self.node, user=self.user)
folder = self.node_settings.get_root().append_folder('Folder')
base_url = '/download/{}/'
# Test download works with path
url = base_url.format(file._id)
redirect = self.app.get(url, auth=self.user.auth)
assert redirect.status_code == 302
# Test download works with guid
url = base_url.format(file.get_guid()._id)
redirect = self.app.get(url, auth=self.user.auth)
assert redirect.status_code == 302
# Test nonexistant file 404's
url = base_url.format('FakeGuid')
redirect = self.app.get(url, auth=self.user.auth, expect_errors=True)
assert redirect.status_code == 404
# Test folder 400's
url = base_url.format(folder._id)
redirect = self.app.get(url, auth=self.user.auth, expect_errors=True)
assert redirect.status_code == 400
def test_migrate_file_root_comment(self):
test_file = create_test_file(node=self.project, user=self.project.creator)
comment = self._set_up_comment_with_target(root_target=test_file, target=test_file)
update_comment_targets_to_guids()
comment.reload()
assert_equal(comment.root_target, test_file.get_guid())
assert_equal(comment.target, test_file.get_guid())
def _set_up_private_project_with_comment(self):
self.private_project = ProjectFactory.create(is_public=False, creator=self.user, comment_level='private')
self.private_project.add_contributor(self.contributor, save=True)
self.file = test_utils.create_test_file(self.private_project, self.user)
self.comment = CommentFactory(node=self.private_project, target=self.file.get_guid(), user=self.user)
self.private_url = '/{}comments/{}/'.format(API_BASE, self.comment._id)
self.payload = self._set_up_payload(self.comment._id)
def _set_up_registration_with_comment(self):
self.registration = RegistrationFactory(creator=self.user, comment_level='private')
self.registration_file = test_utils.create_test_file(self.registration, self.user)
self.registration_comment = CommentFactory(node=self.registration, target=self.registration_file.get_guid(), user=self.user)
self.comment_url = '/{}comments/{}/'.format(API_BASE, self.registration_comment._id)
reply_target = Guid.load(self.registration_comment._id)
self.registration_comment_reply = CommentFactory(node=self.registration, target=reply_target, user=self.user)
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, public=True)
self.public_project.add_contributor(self.other_user, permissions=[permissions.DEFAULT_CONTRIBUTOR_PERMISSIONS], save=True)
self.subject = SubjectFactory()
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_download_file_with_token(self, mock_get_client):
cas_base_url = 'http://accounts.test.test'
client = cas.CasClient(cas_base_url)
mock_get_client.return_value = client
base_url = '/download/{}/'
file = create_test_file(node=self.node, user=self.user)
responses.add(
responses.Response(
responses.GET,
'{}/oauth2/profile'.format(cas_base_url),
body=json.dumps({'id': '{}'.format(self.user._id)}),
status=200,
)
)
download_url = base_url.format(file.get_guid()._id)
token = ApiOAuth2PersonalTokenFactory(owner=self.user)
headers = {
'Authorization': str('Bearer {}'.format(token.token_id))
}
redirect = self.app.get(download_url, headers=headers)
assert mock_get_client.called
assert settings.WATERBUTLER_URL in redirect.location
assert redirect.status_code == 302
def test_public_node_non_contributor_commenter_can_delete_file_comment(self):
project = ProjectFactory(is_public=True, comment_level='public')
test_file = test_utils.create_test_file(project, project.creator)
comment = CommentFactory(node=project, target=test_file.get_guid(), user=self.non_contributor)
url = '/{}comments/{}/'.format(API_BASE, comment._id)
res = self.app.delete_json_api(url, auth=self.non_contributor.auth)
assert_equal(res.status_code, 204)
def test_migrate_file_comment_reply(self):
test_file = create_test_file(node=self.project, user=self.project.creator)
comment = self._set_up_comment_with_target(root_target=test_file, target=test_file)
reply = self._set_up_comment_with_target(root_target=test_file, target=comment)
update_comment_targets_to_guids()
reply.reload()
assert_equal(reply.root_target, test_file.get_guid())
assert_equal(reply.target, Guid.load(comment._id))
def _set_up_public_project_file_comment_reports(self):
self.public_project = ProjectFactory.build(is_public=True, creator=self.user)
self.public_project.add_contributor(contributor=self.contributor, save=True)
self.public_file = test_utils.create_test_file(self.public_project, self.user)
self.public_comment = CommentFactory.build(node=self.public_project, target=self.public_file, user=self.contributor)
self.public_comment.reports = {self.user._id: {'category': 'spam', 'text': 'This is spam'}}
self.public_comment.save()
self.public_url = '/{}comments/{}/reports/{}/'.format(API_BASE, self.public_comment._id, self.user._id)
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 test_public_node_non_contributor_commenter_can_update_file_comment(self):
project = ProjectFactory(is_public=True)
test_file = test_utils.create_test_file(project, project.creator)
comment = CommentFactory(node=project, target=test_file.get_guid(), user=self.non_contributor)
url = '/{}comments/{}/'.format(API_BASE, comment._id)
payload = self._set_up_payload(comment._id)
res = self.app.put_json_api(url, payload, auth=self.non_contributor.auth)
assert_equal(res.status_code, 200)
assert_equal(payload['data']['attributes']['content'], res.json['data']['attributes']['content'])
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_already_a_preprint(self):
preprint = PreprintFactory(creator=self.user)
file_one_preprint = test_utils.create_test_file(preprint, self.user, 'openupthatwindow.pdf')
already_preprint_payload = build_preprint_create_payload(preprint._id, self.subject._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_equal(res.json['errors'][0]['detail'], 'This node already stored as a preprint, use the update method instead.')
def test_public_node_logged_in_non_contributor_reporter_can_delete_report_detail(self):
project = ProjectFactory(is_public=True, comment_level='public')
test_file = test_utils.create_test_file(project, self.user)
comment = CommentFactory.build(node=project, target=test_file, user=project.creator)
comment.reports = {self.non_contributor._id: {'category': 'spam', 'text': 'This is spam'}}
comment.save()
url = '/{}comments/{}/reports/{}/'.format(API_BASE, comment._id, self.non_contributor._id)
res = self.app.delete_json_api(url, auth=self.non_contributor.auth)
assert_equal(res.status_code, 204)
def setUp(self):
super(TestFileTagging, self).setUp()
self.user = AuthUserFactory()
self.node = ProjectFactory(creator=self.user)
self.file1 = api_utils.create_test_file(self.node, self.user, filename="file1")
self.payload = {
"data": {"type": "files", "id": self.file1._id, "attributes": {"checkout": None, "tags": ["goofy"]}}
}
self.url = "/{}files/{}/".format(API_BASE, self.file1._id)
def test_node_files_osfstorage_cannot_filter_by_last_touched(self):
yesterday_stamp = datetime.datetime.utcnow() - datetime.timedelta(
days=1)
self.file = api_utils.create_test_file(self.project, self.user)
url = '/{}nodes/{}/files/osfstorage/?filter[last_touched][gt]={}'.format(
API_BASE, self.project._id, yesterday_stamp.isoformat())
res = self.app.get(url, auth=self.user.auth, expect_errors=True)
assert_equal(res.status_code, 400)
assert_equal(len(res.json['errors']), 1)
def test_public_node_non_contributor_commenter_can_delete_file_comment(
self):
project = ProjectFactory(is_public=True, comment_level='public')
test_file = test_utils.create_test_file(project, project.creator)
comment = CommentFactory(node=project,
target=test_file.get_guid(),
user=self.non_contributor)
url = '/{}comments/{}/'.format(API_BASE, comment._id)
res = self.app.delete_json_api(url, auth=self.non_contributor.auth)
assert_equal(res.status_code, 204)
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(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_node_files_osfstorage_cannot_filter_by_last_touched(self):
yesterday_stamp = datetime.datetime.utcnow() - datetime.timedelta(days=1)
self.file = api_utils.create_test_file(self.project, self.user)
url = '/{}nodes/{}/files/osfstorage/?filter[last_touched][gt]={}'.format(API_BASE,
self.project._id,
yesterday_stamp.isoformat())
res = self.app.get(url, auth=self.user.auth, expect_errors=True)
assert_equal(res.status_code, 400)
assert_equal(len(res.json['errors']), 1)
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 setUp(self):
super(PreprintIsPublishedListMixin, self).setUp()
assert self.admin, 'Subclasses of PreprintIsPublishedMixin must define self.admin'
assert self.provider_one, 'Subclasses of PreprintIsPublishedMixin must define self.provider_one'
assert self.provider_two, 'Subclasses of PreprintIsPublishedMixin must define self.provider_two'
assert self.published_project, 'Subclasses of PreprintIsPublishedMixin must define self.published_project'
assert self.public_project, 'Subclasses of PreprintIsPublishedMixin must define self.public_project'
assert self.url, 'Subclasses of PreprintIsPublishedMixin must define self.url'
self.write_contrib = AuthUserFactory()
self.non_contrib = AuthUserFactory()
self.public_project.add_contributor(self.write_contrib, permissions=permissions.DEFAULT_CONTRIBUTOR_PERMISSIONS, save=True)
self.subject = SubjectFactory()
self.file_one_public_project = test_utils.create_test_file(self.public_project, self.admin, 'mgla.pdf')
self.file_one_published_project = test_utils.create_test_file(self.published_project, self.admin, 'saor.pdf')
self.unpublished_preprint = PreprintFactory(creator=self.admin, filename='mgla.pdf', provider=self.provider_one, subjects=[[self.subject._id]], project=self.public_project, is_published=False)
self.published_preprint = PreprintFactory(creator=self.admin, filename='saor.pdf', provider=self.provider_two, subjects=[[self.subject._id]], project=self.published_project, is_published=True)
def test_public_node_non_contributor_commenter_cannot_update_own_file_comment_if_comment_level_private(self):
project = ProjectFactory(is_public=True)
test_file = test_utils.create_test_file(project, project.creator)
comment = CommentFactory(node=project, target=test_file.get_guid(), user=self.non_contributor)
project.comment_level = 'private'
project.save()
url = '/{}comments/{}/'.format(API_BASE, comment._id)
payload = self._set_up_payload(comment._id)
res = self.app.put_json_api(url, payload, 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 setUp(self):
super(PreprintIsPublishedListMixin, self).setUp()
assert self.admin, 'Subclasses of PreprintIsPublishedMixin must define self.admin'
assert self.provider_one, 'Subclasses of PreprintIsPublishedMixin must define self.provider_one'
assert self.provider_two, 'Subclasses of PreprintIsPublishedMixin must define self.provider_two'
assert self.published_project, 'Subclasses of PreprintIsPublishedMixin must define self.published_project'
assert self.public_project, 'Subclasses of PreprintIsPublishedMixin must define self.public_project'
assert self.url, 'Subclasses of PreprintIsPublishedMixin must define self.url'
self.write_contrib = AuthUserFactory()
self.non_contrib = AuthUserFactory()
self.public_project.add_contributor(self.write_contrib, permissions=permissions.DEFAULT_CONTRIBUTOR_PERMISSIONS, save=True)
self.subject = SubjectFactory()
self.file_one_public_project = test_utils.create_test_file(self.public_project, self.admin, 'mgla.pdf')
self.file_one_published_project = test_utils.create_test_file(self.published_project, self.admin, 'saor.pdf')
self.unpublished_preprint = PreprintFactory(creator=self.admin, filename='mgla.pdf', provider=self.provider_one, subjects=[[self.subject._id]], project=self.public_project, is_published=False)
self.published_preprint = PreprintFactory(creator=self.admin, filename='saor.pdf', provider=self.provider_two, subjects=[[self.subject._id]], project=self.published_project, is_published=True)
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_migrate_file_comment_reply(self):
test_file = create_test_file(node=self.project,
user=self.project.creator)
comment = self._set_up_comment_with_target(root_target=test_file,
target=test_file)
reply = self._set_up_comment_with_target(root_target=test_file,
target=comment)
update_comment_targets_to_guids()
reply.reload()
assert_equal(reply.root_target, test_file.get_guid())
assert_equal(reply.target, Guid.load(comment._id))
def test_public_node_non_contributor_commenter_cannot_update_own_file_comment_if_comment_level_private(self):
project = ProjectFactory(is_public=True)
test_file = test_utils.create_test_file(project, project.creator)
comment = CommentFactory(node=project, target=test_file.get_guid(), user=self.non_contributor)
project.comment_level = 'private'
project.save()
url = '/{}comments/{}/'.format(API_BASE, comment._id)
payload = self._set_up_payload(comment._id)
res = self.app.put_json_api(url, payload, 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_timestamp_check_return_status_6(self):
"""
[IN & Testdata]
BaseFileNode : Exist & BaseFileNode.is_deleted = True
RdmFileTimestamptokenVerifyResult : Exist & RdmFileTimestamptokenVerifyResult.timestamp_token = null
provider = 'osfstorage'
[OUT]
FILE_NOT_EXISTS_TIME_STAMP_TOKEN_CHECK_FILE_NOT_FOUND = 6
FILE_NOT_EXISTS_TIME_STAMP_TOKEN_CHECK_FILE_NOT_FOUND_MSG = 'FILE missing(Unverify)'
"""
provider = 'osfstorage'
self.node_settings = self.project.get_addon(provider)
## create file_node(BaseFileNode record)
filename = 'test_file_timestamp_check'
file_node = create_test_file(node=self.node,
user=self.user,
filename=filename)
file_node.delete()
## create tmp_dir
current_datetime = datetime.datetime.now(pytz.timezone('Asia/Tokyo'))
current_datetime_str = current_datetime.strftime('%Y%m%d%H%M%S%f')
tmp_dir = '/tmp/tmp_{}_{}_{}'.format(self.user._id, file_node._id,
current_datetime_str)
os.mkdir(tmp_dir)
## create tmp_file (file_node)
tmp_file = os.path.join(tmp_dir, filename)
## verify timestamptoken
verifyCheck = TimeStampTokenVerifyCheck()
verifyCheck.timestamp_check(self.user._id, file_node._id,
self.node._id, provider,
os.path.join('/',
filename), tmp_file, tmp_dir)
ret = verifyCheck.timestamp_check(self.user._id, file_node._id,
self.node._id, provider,
os.path.join('/', filename),
tmp_file, tmp_dir)
shutil.rmtree(tmp_dir)
## check timestamp_check func response
nt.assert_equal(ret['verify_result'], 6)
nt.assert_equal(ret['verify_result_title'], 'FILE missing(Unverify)')
## check rdmfiletimestamptokenverifyresult record
rdmfiletimestamptokenverifyresult = RdmFileTimestamptokenVerifyResult.objects.get(
file_id=file_node._id)
osfuser_id = Guid.objects.get(_id=self.user._id).object_id
nt.assert_equal(
rdmfiletimestamptokenverifyresult.inspection_result_status, 6)
nt.assert_equal(rdmfiletimestamptokenverifyresult.validation_user,
osfuser_id)
def test_deleted_file_return_410(self, app, node, user):
deleted_file = api_utils.create_test_file(node, user, create_guid=True)
guid = deleted_file.get_guid()._id
assert guid
url = '/{}files/{}/'.format(API_BASE, guid)
res = app.get(url, auth=user.auth)
assert res.status_code == 200
deleted_file.delete(user=user, save=True)
res = app.get(url, auth=user.auth, expect_errors=True)
assert res.status_code == 410
def _set_up_private_project_with_comment(self):
self.private_project = ProjectFactory.create(is_public=False,
creator=self.user,
comment_level='private')
self.private_project.add_contributor(self.contributor, save=True)
self.file = test_utils.create_test_file(self.private_project,
self.user)
self.comment = CommentFactory(node=self.private_project,
target=self.file.get_guid(),
user=self.user)
self.private_url = '/{}comments/{}/'.format(API_BASE, self.comment._id)
self.payload = self._set_up_payload(self.comment._id)
def test_timestamp_check_return_status_1(self):
"""
TIME_STAMP_TOKEN_CHECK_SUCCESS = 1
TIME_STAMP_TOKEN_CHECK_SUCCESS_MSG = 'OK'
"""
provider = 'osfstorage'
self.node_settings = self.project.get_addon(provider)
## create file_node(BaseFileNode record)
filename = 'test_file_timestamp_check'
file_node = create_test_file(node=self.node,
user=self.user,
filename=filename)
## create tmp_dir
current_datetime = datetime.datetime.now(pytz.timezone('Asia/Tokyo'))
current_datetime_str = current_datetime.strftime('%Y%m%d%H%M%S%f')
tmp_dir = '/tmp/tmp_{}_{}_{}'.format(self.user._id, file_node._id,
current_datetime_str)
os.mkdir(tmp_dir)
## create tmp_file (file_node)
tmp_file = os.path.join(tmp_dir, filename)
with open(tmp_file, 'wb') as fout:
fout.write('test_file_timestamp_check_context')
## add timestamp
addTimestamp = AddTimestamp()
addTimestamp.add_timestamp(self.user._id, file_node._id,
self.node._id, provider,
os.path.join('/',
filename), tmp_file, tmp_dir)
## verify timestamptoken
verifyCheck = TimeStampTokenVerifyCheck()
ret = verifyCheck.timestamp_check(self.user._id, file_node._id,
self.node._id, provider,
os.path.join('/', filename),
tmp_file, tmp_dir)
shutil.rmtree(tmp_dir)
## check timestamp_check func response
nt.assert_equal(ret['verify_result'], 1)
nt.assert_equal(ret['verify_result_title'], 'OK')
## check rdmfiletimestamptokenverifyresult record
rdmfiletimestamptokenverifyresult = RdmFileTimestamptokenVerifyResult.objects.get(
file_id=file_node._id)
osfuser_id = Guid.objects.get(_id=self.user._id).object_id
nt.assert_equal(
rdmfiletimestamptokenverifyresult.inspection_result_status, 1)
nt.assert_equal(rdmfiletimestamptokenverifyresult.validation_user,
osfuser_id)
def test_download_count(self):
# Keen does not allow same day requests so we have to do some time traveling to my birthday
with mock.patch('django.utils.timezone.now', return_value=datetime.datetime(1991, 9, 25).replace(tzinfo=pytz.utc)):
node = ProjectFactory()
file = api_utils.create_test_file(
node, node.creator, filename='file_one')
utils.update_analytics(node, file, 0, 'download')
query_date = datetime.date(1991, 9, 25)
event = DownloadCountSummary().get_events(query_date)
assert event[0]['files']['total'] == 1
def setUp(self):
super(TestFileSerializer, self).setUp()
self.user = factories.UserFactory()
self.node = factories.NodeFactory(creator=self.user)
self.file = utils.create_test_file(self.node, self.user)
self.date_created = self.file.versions.first().date_created
self.date_modified = self.file.versions.last().date_created
self.date_created_tz_aware = self.date_created.replace(tzinfo=utc)
self.date_modified_tz_aware = self.date_modified.replace(tzinfo=utc)
self.new_format = '%Y-%m-%dT%H:%M:%S.%fZ'
def setUp(self):
super(TestFileSerializer, self).setUp()
self.user = factories.UserFactory()
self.node = factories.NodeFactory(creator=self.user)
self.file = utils.create_test_file(self.node, self.user)
self.date_created = self.file.versions[0].date_created
self.date_modified = self.file.versions[-1].date_created
self.date_created_tz_aware = self.date_created.replace(tzinfo=utc)
self.date_modified_tz_aware = self.date_modified.replace(tzinfo=utc)
self.new_format = '%Y-%m-%dT%H:%M:%S.%fZ'
def test_quickfiles_moves_files_on_triple_merge_with_name_conflict(
self, user, quickfiles):
name = 'Woo.pdf'
other_user = factories.UserFactory()
third_user = factories.UserFactory()
create_test_file(quickfiles, user, filename=name)
create_test_file(QuickFilesNode.objects.get(creator=other_user),
other_user,
filename=name)
create_test_file(QuickFilesNode.objects.get(creator=third_user),
third_user,
filename=name)
user.merge_user(other_user)
user.save()
user.merge_user(third_user)
user.save()
actual_filenames = list(OsfStorageFile.objects.all().values_list(
'name', flat=True))
expected_filenames = ['Woo.pdf', 'Woo (1).pdf', 'Woo (2).pdf']
assert_items_equal(actual_filenames, expected_filenames)
def test_public_node_non_contrib_commenter_can_update_file_comment(
self, app, non_contrib, set_up_payload):
project = ProjectFactory(is_public=True)
test_file = test_utils.create_test_file(project, project.creator)
comment = CommentFactory(node=project,
target=test_file.get_guid(),
user=non_contrib)
url = '/{}comments/{}/'.format(API_BASE, comment._id)
payload = set_up_payload(comment._id)
res = app.put_json_api(url, payload, auth=non_contrib.auth)
assert res.status_code == 200
assert payload['data']['attributes']['content'] == res.json['data'][
'attributes']['content']
def test_can_move_file_out_of_quickfiles_node(self):
quickfiles_node = QuickFilesNode.objects.get_for_user(self.user)
create_test_file(quickfiles_node, self.user, filename='slippery.mp3')
quickfiles_folder = OsfStorageFolder.objects.get(node=quickfiles_node)
dest_folder = OsfStorageFolder.objects.get(node=self.project)
res = self.send_hook(
'osfstorage_move_hook',
{'nid': quickfiles_node._id},
payload={
'source': quickfiles_folder._id,
'node': quickfiles_node._id,
'user': self.user._id,
'destination': {
'parent': dest_folder._id,
'node': self.project._id,
'name': dest_folder.name,
}
},
method='post_json',
)
assert_equal(res.status_code, 200)
def _set_up_public_project_file_comment_reports(self):
self.public_project = ProjectFactory.build(is_public=True, creator=self.user)
self.public_project.add_contributor(contributor=self.contributor, save=True)
self.public_file = test_utils.create_test_file(self.public_project, self.user)
self.public_comment = CommentFactory.build(node=self.public_project, target=self.public_file, user=self.contributor)
self.public_comment.reports = {self.user._id: {
'category': 'spam',
'text': 'This is spam',
'date': datetime.utcnow(),
'retracted': False,
}}
self.public_comment.save()
self.public_url = '/{}comments/{}/reports/{}/'.format(API_BASE, self.public_comment._id, self.user._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 test_node_has_correct_unread_file_comments_count(self):
contributor = AuthUserFactory()
self.public_project.add_contributor(contributor=contributor, auth=Auth(self.user))
test_file = test_utils.create_test_file(self.public_project, self.user)
comment = CommentFactory(node=self.public_project, target=test_file, user=contributor, page='files')
comment.node.commented_files[comment.root_target._id] = 1
self.public_project.save()
res = self.app.get(self.public_url + '?related_counts=True', auth=self.user.auth)
unread = res.json['data']['relationships']['comments']['links']['related']['meta']['unread']
unread_comments_total = unread['total']
unread_comments_files = unread['files']
assert_equal(unread_comments_total, 1)
assert_equal(unread_comments_files, 1)
def _set_up_registration_with_comment(self):
self.registration = RegistrationFactory(creator=self.user,
comment_level='private')
self.registration_file = test_utils.create_test_file(
self.registration, self.user)
self.registration_comment = CommentFactory(
node=self.registration,
target=self.registration_file.get_guid(),
user=self.user)
self.comment_url = '/{}comments/{}/'.format(
API_BASE, self.registration_comment._id)
reply_target = Guid.load(self.registration_comment._id)
self.registration_comment_reply = CommentFactory(
node=self.registration, target=reply_target, user=self.user)
def _set_up_public_project_comment_reports(self, comment_level='public'):
self.public_project = ProjectFactory.create(is_public=True, creator=self.user, comment_level=comment_level)
self.public_project.add_contributor(contributor=self.contributor, save=True)
self.public_file = test_utils.create_test_file(self.public_project, self.user)
self.public_comment = CommentFactory.build(node=self.public_project, target=self.public_file.get_guid(), user=self.contributor)
self.public_comment.reports = self.public_comment.reports or {}
self.public_comment.reports[self.user._id] = {
'category': 'spam',
'text': 'This is spam',
'date': timezone.now(),
'retracted': False,
}
self.public_comment.save()
self.public_url = '/{}comments/{}/reports/'.format(API_BASE, self.public_comment._id)
def test_quickfiles_moves_errors_after_max_renames(self, user, quickfiles):
create_test_file(quickfiles, user, filename='Woo (1).pdf')
create_test_file(quickfiles, user, filename='Woo (2).pdf')
other_user = factories.UserFactory()
create_test_file(QuickFilesNode.objects.get(creator=other_user), other_user, filename='Woo (1).pdf')
with pytest.raises(MaxRetriesError):
user.merge_user(other_user)
def test_public_node_non_contributor_commenter_can_update_file_comment(
self):
project = ProjectFactory(is_public=True)
test_file = test_utils.create_test_file(project, project.creator)
comment = CommentFactory(node=project,
target=test_file.get_guid(),
user=self.non_contributor)
url = '/{}comments/{}/'.format(API_BASE, comment._id)
payload = self._set_up_payload(comment._id)
res = self.app.put_json_api(url,
payload,
auth=self.non_contributor.auth)
assert_equal(res.status_code, 200)
assert_equal(payload['data']['attributes']['content'],
res.json['data']['attributes']['content'])
def setUp(self):
super(TestNodeFileLogDetail, self).setUp()
self.user_one = AuthUserFactory()
self.user_two = AuthUserFactory()
self.node = ProjectFactory(creator=self.user_one)
self.node.add_contributor(self.user_two)
self.component = NodeFactory(parent=self.node, creator=self.user_one)
self.file = api_utils.create_test_file(node=self.component,
user=self.user_one)
self.node.add_log(
'osf_storage_file_moved',
auth=Auth(self.user_one),
params={
'node': self.node._id,
'project': self.node.parent_id,
'path': self.file.materialized_path,
'source': {
'materialized': self.file.materialized_path,
'addon': 'osfstorage',
'node': {
'_id': self.component._id,
'url': self.component.url,
'title': self.component.title,
}
},
'destination': {
'materialized': self.file.materialized_path,
'addon': 'osfstorage',
'node': {
'_id': self.node._id,
'url': self.node.url,
'title': self.node.title,
}
}
},
)
self.node.save()
self.node_logs_url = '/{}nodes/{}/logs/'.format(
API_BASE, self.node._id)
self.component_logs_url = '/{}nodes/{}/logs/'.format(
API_BASE, self.component._id)
def setUp(self):
super(TestSearchSerializer, self).setUp()
self.user = AuthUserFactory()
self.project = ProjectFactory(creator=self.user, is_public=True)
self.component = NodeFactory(parent=self.project, creator=self.user, is_public=True)
self.file = utils.create_test_file(self.component, self.user)
ensure_schemas()
self.schema = MetaSchema.find_one(
Q('name', 'eq', 'Replication Recipe (Brandt et al., 2013): Post-Completion') &
Q('schema_version', 'eq', LATEST_SCHEMA_VERSION)
)
with mock_archive(self.project, autocomplete=True, autoapprove=True, schema=self.schema) as registration:
self.registration = registration
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_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 setUp(self):
super(TestFileTagging, self).setUp()
self.user = AuthUserFactory()
self.node = ProjectFactory(creator=self.user)
self.file1 = api_utils.create_test_file(
self.node, self.user, filename='file1')
self.payload = {
"data": {
"type": "files",
"id": self.file1._id,
"attributes": {
"checkout": None,
"tags": ["goofy"]
}
}
}
self.url = '/{}files/{}/'.format(API_BASE, self.file1._id)
def test_add_log_timestamptoken(self, mock_perform):
from osf.models import RdmFileTimestamptokenVerifyResult, NodeLog
from api_tests.utils import create_test_file
from website.views import userkey_generation
result_list1_count = RdmFileTimestamptokenVerifyResult.objects.filter(project_id=self.node._id).count()
nodelog_count1 = NodeLog.objects.all().count()
path = 'pizza'
url = self.node.api_url_for('create_waterbutler_log')
userkey_generation(self.user._id)
file_node = create_test_file(node=self.node, user=self.user, filename=path)
file_node._path = '/' + path
file_node.save()
metadata = {
'path': path,
'provider': 'osfstorage',
'name': path,
'materialized': '/' + path,
'extra': {
'version': 1
}
}
payload = self.build_payload(metadata=metadata)
logging.info('---test_add_log_timestamptoken.payload: {}'.format(payload))
nlogs = self.node.logs.count()
self.app.put_json(url, payload, headers={'Content-Type': 'application/json'})
self.node.reload()
assert_equal(self.node.logs.count(), nlogs + 1)
nodelog_count2 = NodeLog.objects.all().count()
assert_equal(nodelog_count1 + 1, nodelog_count2)
result_list2 = RdmFileTimestamptokenVerifyResult.objects.filter(project_id=self.node._id)
assert_true(mock_perform.called, 'perform not called')
## tearDown
import os
from api.base import settings as api_settings
from osf.models import RdmUserKey
rdmuserkey_pvt_key = RdmUserKey.objects.get(guid=self.user.id, key_kind=api_settings.PRIVATE_KEY_VALUE)
pvt_key_path = os.path.join(api_settings.KEY_SAVE_PATH, rdmuserkey_pvt_key.key_name)
os.remove(pvt_key_path)
rdmuserkey_pvt_key.delete()
rdmuserkey_pub_key = RdmUserKey.objects.get(guid=self.user.id, key_kind=api_settings.PUBLIC_KEY_VALUE)
pub_key_path = os.path.join(api_settings.KEY_SAVE_PATH, rdmuserkey_pub_key.key_name)
os.remove(pub_key_path)
rdmuserkey_pub_key.delete()
def test_public_node_non_contrib_commenter_cannot_update_own_file_comment_if_comment_level_private(
self, app, non_contrib, set_up_payload):
project = ProjectFactory(is_public=True)
test_file = test_utils.create_test_file(project, project.creator)
comment = CommentFactory(node=project,
target=test_file.get_guid(),
user=non_contrib)
project.comment_level = 'private'
project.save()
url = '/{}comments/{}/'.format(API_BASE, comment._id)
payload = set_up_payload(comment._id)
res = app.put_json_api(url,
payload,
auth=non_contrib.auth,
expect_errors=True)
assert res.status_code == 403
assert res.json['errors'][0][
'detail'] == exceptions.PermissionDenied.default_detail
